@gaialabs/core 0.2.0 → 0.2.1

package/dist/index.d.mts

@@ -1,174 +1,135 @@
-import { SupabaseClient } from '@supabase/supabase-js';
+import { SupabaseClient } from "@supabase/supabase-js";
 
+//#region src/rom/state.d.ts
 /**
  * Lightweight ROM state placeholder used during early development.
  * This stub will be expanded as the ROM extraction pipeline matures.
  */
 declare class RomState {
-    readonly cgram: Uint8Array<ArrayBuffer>;
-    readonly vram: Uint8Array<ArrayBuffer>;
-    /**
-     * Create ROM state from scene metadata.
-     * Parameters are currently unused but kept for future implementation.
-     */
-    static fromScene(_baseDir: string, _root: unknown, _metaFile: string, _id: number): Promise<RomState>;
+  readonly cgram: Uint8Array<ArrayBuffer>;
+  readonly vram: Uint8Array<ArrayBuffer>;
+  /**
+       * Create ROM state from scene metadata.
+       * Parameters are currently unused but kept for future implementation.
+       */
+  static fromScene(_baseDir: string, _root: unknown, _metaFile: string, _id: number): Promise<RomState>;
 }
 /**
  * Utility helpers for working with RomState.
  */
 declare class RomStateUtils {
-    /** Create an empty ROM state */
-    static createEmpty(): RomState;
-    /** Clear all data in the given ROM state */
-    static clear(state: RomState): void;
+  /** Create an empty ROM state */
+  static createEmpty(): RomState;
+  /** Clear all data in the given ROM state */
+  static clear(state: RomState): void;
 }
-
+//#endregion
+//#region src/assembly/Stack.d.ts
 /**
  * Represents the stack for the 65816 processor
  */
 declare class Stack {
-    bytes: Uint8Array;
-    location: number;
-    constructor();
-    /**
-     * Push a byte onto the stack
-     */
-    push(value: number): void;
-    /**
-     * Push a 16-bit value onto the stack (little-endian)
-     */
-    pushUInt16(value: number): void;
-    /**
-     * Pop a byte from the stack
-     */
-    popByte(): number;
-    /**
-     * Pop a 16-bit value from the stack (little-endian)
-     */
-    popUInt16(): number;
-    /**
-     * Reset the stack to initial state
-     */
-    reset(): void;
-}
-
-/**
- * Manages the 65816 processor registers and status flags
- */
-declare class Registers {
-    value: Record<string, number>;
-    stack: Stack;
-    constructor();
-}
-
-declare class MapExt<K, V> extends Map<K, V> {
-    constructor();
-    tryAdd(key: K, value: V): boolean;
-    setFlag(key: K, flag: number, value?: boolean): void;
-    clearFlag(key: K, flag: number): void;
-}
-/**
- * Manages CPU processor state during ROM analysis
- * Converted from GaiaLib/Rom/Extraction/ProcessorStateManager.cs
- */
-declare class ProcessorStateManager {
-    readonly stackPositions: MapExt<number, number>;
-    private readonly _buckets;
-    get(key: string): MapExt<number, number>;
-    /**
-     * Hydrate processor registers with stored state
-     * Uses Registers from gaia-core/assembly for processor state management
-     */
-    hydrateRegisters(position: number, reg: Registers): void;
-    getStackPosition(location: number): number | undefined;
-    setStackPosition(location: number, value: number): void;
-    tryAddStackPosition(location: number, value: number): boolean;
-}
-
-/**
- * Provides low-level ROM data reading functionality
- * Converted from GaiaLib/Rom/Extraction/RomDataReader.cs
- */
-declare class RomDataReader {
-    readonly romData: Uint8Array;
-    position: number;
-    constructor(romData: Uint8Array);
-    readByte(): number;
-    readSByte(): number;
-    readUShort(): number;
-    readShort(): number;
-    readAddress(): number;
-    readInt(): number;
-    peekByte(): number;
-    peekShort(): number;
-    peekAddress(): number;
-}
-
+  bytes: Uint8Array;
+  location: number;
+  constructor();
+  /**
+       * Push a byte onto the stack
+       */
+  push(value: number): void;
+  /**
+       * Push a 16-bit value onto the stack (little-endian)
+       */
+  pushUInt16(value: number): void;
+  /**
+       * Pop a byte from the stack
+       */
+  popByte(): number;
+  /**
+       * Pop a 16-bit value from the stack (little-endian)
+       */
+  popUInt16(): number;
+  /**
+       * Reset the stack to initial state
+       */
+  reset(): void;
+}
+//#endregion
+//#region src/types/addressing.d.ts
 /**
  * Address type classifications
  * Converted from GaiaLib/Enum/AddressType.cs
  */
 declare enum AddressType {
-    Unknown = "Unknown",
-    Bank = "Bank",
-    Offset = "Offset",
-    Address = "Address",
-    WBank = "WBank",
-    Relative = "Relative"
+  Unknown = "Unknown",
+  Bank = "Bank",
+  Offset = "Offset",
+  Address = "Address",
+  WBank = "WBank",
+  Relative = "Relative",
+  Location = "Location",
 }
 /**
  * Address space types
  * Converted from GaiaLib/Types/Address.cs
  */
 declare enum AddressSpace {
-    None = "None",
-    ROM = "ROM",
-    WRAM = "WRAM",
-    SRAM = "SRAM",
-    System = "System"
+  None = "None",
+  ROM = "ROM",
+  WRAM = "WRAM",
+  SRAM = "SRAM",
+  System = "System",
+}
+declare enum MemoryMapMode {
+  Lo = "Lo",
+  Hi = "Hi",
+  ExHi = "ExHi",
 }
 /**
  * SNES address structure
  * Converted from GaiaLib/Types/Address.cs
  */
 declare class Address {
-    offset: number;
-    bank: number;
-    static readonly UPPER_BANK = 32768;
-    static readonly DATA_BANK_FLAG = 64;
-    static readonly FAST_BANK_FLAG = 128;
-    constructor(bank: number, offset: number);
-    get isROM(): boolean;
-    get isCodeBank(): boolean;
-    get space(): AddressSpace;
-    toInt(): number;
-    toString(): string;
-    static fromInt(addr: number): Address;
-    static typeFromCode(code: string): AddressType;
-    static codeFromType(type: AddressType): string | null;
-}
-
+  offset: number;
+  bank: number;
+  mode: MemoryMapMode;
+  static readonly UPPER_BANK = 32768;
+  static readonly DATA_BANK_FLAG = 64;
+  static readonly FAST_BANK_FLAG = 128;
+  constructor(bank: number, offset: number, mode: MemoryMapMode);
+  get isROM(): boolean;
+  get isCodeBank(): boolean;
+  toInt(): number;
+  static fromInt(value: number, mode: MemoryMapMode): Address;
+  static resolveBank(value: number, mode: MemoryMapMode): number;
+  toString(): string;
+  static typeFromCode(code: string): AddressType;
+  static codeFromType(type: AddressType): string | null;
+}
+//#endregion
+//#region src/types/members.d.ts
 /**
  * Member type definitions for data structures
  * Converted from GaiaLib/Enum/MemberType.cs
  */
 declare enum MemberType {
-    Byte = "Byte",
-    Word = "Word",
-    Offset = "Offset",
-    Address = "Address",
-    Binary = "Binary",
-    Code = "Code"
+  Byte = "Byte",
+  Word = "Word",
+  Offset = "Offset",
+  Address = "Address",
+  Binary = "Binary",
+  Code = "Code",
+  Location = "Location",
 }
-
+//#endregion
+//#region src/types/processor.d.ts
 /**
  * Processor register type definitions
  * Converted from GaiaLib/Enum/RegisterType.cs
  */
 declare enum RegisterType {
-    M = "M",
-    X = "X",
-    B = "B"
+  M = "M",
+  X = "X",
+  B = "B",
 }
 /**
  * Status flags for 65816 processor
@@ -185,198 +146,207 @@ declare enum RegisterType {
  * c = Carry
  */
 declare enum StatusFlags {
-    /**
-     * Clear before starting addition or subtraction.
-     * Arithmetic overflow:
-     * [addition - carry out of high bit:]
-     * 0 = no carry
-     * 1 = carry
-     * [subtraction - borrow required to subtract:]
-     * 0 = borrow required
-     * 1 = no borrow required
-     * [Logic:]
-     * receives bit shifted or rotated out;
-     * source of bit rotated in
-     */
-    Carry = 1,
-    /**
-     * Indicates zero or non-zero result:
-     * 0 = non-zero result
-     * 1 = zero result
-     */
-    Zero = 2,
-    /**
-     * Enables or disables processor's IRQ interrupt line:
-     * Set to disable interrupts by masking the IRQ line
-     * Clear to enable IRQ interrupts
-     */
-    IrqDisable = 4,
-    /**
-     * Determines mode for add/subtract (not increment/decrement, though):
-     * Set to force decimal operation (BCD)
-     * Clear to return to binary operation
-     */
-    DecimalMode = 8,
-    IndexMode = 16,
-    AccumulatorMode = 32,
-    /**
-     * Clear to reverse "set-overflow" hardware input.
-     * Indicates invalid carry into high bit of arithmetic
-     * result (two's-complement overflow):
-     * 0 = two's-complement result ok
-     * 1 = error if two's-complement arithmetic
-     */
-    Overflow = 64,
-    /**
-     * Reflects most significant bit of result
-     * (the sign of a two's-complement binary number):
-     * 0 = high bit clear (positive result)
-     * 1 = high bit set (negative result)
-     */
-    Negative = 128
-}
-
+  /**
+       * Clear before starting addition or subtraction.
+       * Arithmetic overflow:
+       * [addition - carry out of high bit:]
+       * 0 = no carry
+       * 1 = carry
+       * [subtraction - borrow required to subtract:]
+       * 0 = borrow required
+       * 1 = no borrow required
+       * [Logic:]
+       * receives bit shifted or rotated out;
+       * source of bit rotated in
+       */
+  Carry = 1,
+  /**
+       * Indicates zero or non-zero result:
+       * 0 = non-zero result
+       * 1 = zero result
+       */
+  Zero = 2,
+  /**
+       * Enables or disables processor's IRQ interrupt line:
+       * Set to disable interrupts by masking the IRQ line
+       * Clear to enable IRQ interrupts
+       */
+  IrqDisable = 4,
+  /**
+       * Determines mode for add/subtract (not increment/decrement, though):
+       * Set to force decimal operation (BCD)
+       * Clear to return to binary operation
+       */
+  DecimalMode = 8,
+  IndexMode = 16,
+  AccumulatorMode = 32,
+  /**
+       * Clear to reverse "set-overflow" hardware input.
+       * Indicates invalid carry into high bit of arithmetic
+       * result (two's-complement overflow):
+       * 0 = two's-complement result ok
+       * 1 = error if two's-complement arithmetic
+       */
+  Overflow = 64,
+  /**
+       * Reflects most significant bit of result
+       * (the sign of a two's-complement binary number):
+       * 0 = high bit clear (positive result)
+       * 1 = high bit set (negative result)
+       */
+  Negative = 128,
+}
+//#endregion
+//#region src/types/resources.d.ts
 /**
  * Binary resource type definitions
  * Converted from GaiaLib/Enum/BinType.cs
  */
 declare enum BinType {
-    Bitmap = "Bitmap",
-    Tilemap = "Tilemap",
-    Tileset = "Tileset",
-    Palette = "Palette",
-    Sound = "Sound",
-    Music = "Music",
-    Unknown = "Unknown",
-    Meta17 = "Meta17",
-    Spritemap = "Spritemap",
-    Assembly = "Assembly",
-    Patch = "Patch",
-    Transform = "Transform"
-}
-
+  Bitmap = "Bitmap",
+  Tilemap = "Tilemap",
+  Tileset = "Tileset",
+  Palette = "Palette",
+  Sound = "Sound",
+  Music = "Music",
+  Unknown = "Unknown",
+  Meta17 = "Meta17",
+  Spritemap = "Spritemap",
+  Assembly = "Assembly",
+  Patch = "Patch",
+  Transform = "Transform",
+}
+//#endregion
+//#region src/types/transforms.d.ts
 /**
  * Transform type definitions
  * Converted from GaiaLib/Enum/XformType.cs
  */
 declare enum XformType {
-    Lookup = "Lookup",
-    Replace = "Replace"
+  Lookup = "Lookup",
+  Replace = "Replace",
 }
 /**
  * Transform definition
  * Converted from GaiaLib/Types/XformDef.cs
  */
 interface XformDef {
-    type: XformType;
-    key?: string;
-    value?: string;
-    keyIx?: number;
-    valueIx?: number;
-}
-
+  type: XformType;
+  key?: string;
+  value?: string;
+  keyIx?: number;
+  valueIx?: number;
+}
+//#endregion
+//#region src/database/files.d.ts
 declare class DbFile {
-    name: string;
-    type: string;
-    start: number;
-    end: number;
-    compressed?: boolean;
-    upper?: boolean;
-    group?: string;
-    scene?: string;
-    constructor(data: Partial<DbFile>);
+  name: string;
+  type: string;
+  start: number;
+  end: number;
+  compressed?: boolean;
+  upper?: boolean;
+  group?: string;
+  scene?: string;
+  constructor(data: Partial<DbFile>);
 }
 declare class DbFileType {
-    name: string;
-    extension: string;
-    type: string;
-    isPatch: boolean;
-    isBlock: boolean;
-    header: number;
-    constructor(data: Partial<DbFileType>);
+  name: string;
+  extension: string;
+  type: string;
+  isPatch: boolean;
+  isBlock: boolean;
+  header: number;
+  constructor(data: Partial<DbFileType>);
 }
-
+//#endregion
+//#region src/database/parts.d.ts
 /**
  * Database part definition
  * Converted from GaiaLib/Database/DbPart.cs
  */
 declare class DbPart {
-    name: string;
-    start: number;
-    end: number;
-    type: string;
-    bank?: number;
-    order?: number;
-    constructor(data: Partial<DbPart>);
-}
-
+  name: string;
+  start: number;
+  end: number;
+  type: string;
+  bank?: number;
+  order?: number;
+  constructor(data: Partial<DbPart>);
+}
+//#endregion
+//#region src/database/transforms.d.ts
 declare class DbTransform {
-    key: string;
-    value: string;
-    constructor(data: Partial<DbTransform>);
+  key: string;
+  value: string;
+  constructor(data: Partial<DbTransform>);
 }
-
+//#endregion
+//#region src/database/blocks.d.ts
 /**
  * Database block definition
  * Converted from GaiaLib/Database/DbBlock.cs
  */
 declare class DbBlock {
-    name: string;
-    movable: boolean;
-    group?: string;
-    scene?: string;
-    parts: DbPart[];
-    transforms?: DbTransform[];
-    postProcess?: string;
-    constructor(data: Partial<DbBlock>);
-}
-
+  name: string;
+  movable: boolean;
+  group?: string;
+  scene?: string;
+  parts: DbPart[];
+  transforms?: DbTransform[];
+  postProcess?: string;
+  order?: number;
+  constructor(data: Partial<DbBlock>);
+}
+//#endregion
+//#region src/types/compression.d.ts
 /**
  * Interface for compression providers
  */
 interface ICompressionProvider {
-    /**
-     * Expand (decompress) data
-     * @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: Uint8Array, srcPosition?: number, srcLen?: number): Uint8Array;
-    /**
-     * Compact (compress) data
-     * @param srcData Source data to compress
-     * @returns Compressed data
-     */
-    compact(srcData: Uint8Array): Uint8Array;
-}
-
+  /**
+       * Expand (decompress) data
+       * @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: Uint8Array, srcPosition?: number, srcLen?: number): Uint8Array;
+  /**
+       * Compact (compress) data
+       * @param srcData Source data to compress
+       * @returns Compressed data
+       */
+  compact(srcData: Uint8Array): Uint8Array;
+}
+//#endregion
+//#region src/types/files.d.ts
 /**
  * Chunk file for ROM processing
  * Converted from GaiaLib/Types/ChunkFile.cs
  */
 declare class ChunkFile {
-    name: string;
-    size: number;
-    location: number;
-    type: DbFileType;
-    parts?: AsmBlock[];
-    includes?: Set<string>;
-    includeLookup?: Map<string, AsmBlock>;
-    bank?: number;
-    compressed?: boolean;
-    upper?: boolean;
-    rawData?: Uint8Array | null;
-    textData?: string;
-    transforms?: {
-        key: string;
-        value: string;
-    }[];
-    postProcess?: string;
-    mnemonics: Record<number, string>;
-    group?: string;
-    scene?: string;
-    constructor(name: string, size: number, location: number, type: DbFileType);
+  name: string;
+  size: number;
+  location: number;
+  type: DbFileType;
+  parts?: AsmBlock[];
+  includes?: Set<string>;
+  includeLookup?: Map<string, AsmBlock>;
+  bank?: number;
+  compressed?: boolean;
+  upper?: boolean;
+  rawData?: Uint8Array | null;
+  textData?: string;
+  transforms?: {
+    key: string;
+    value: string;
+  }[];
+  postProcess?: string;
+  mnemonics: Record<number, string>;
+  group?: string;
+  scene?: string;
+  constructor(name: string, size: number, location: number, type: DbFileType);
 }
 declare function createChunkFileFromDbFile(rom: Uint8Array, compression: ICompressionProvider, dbFile: DbFile, fileType: DbFileType): ChunkFile;
 declare function createChunkFileFromDbBlock(block: DbBlock, fileType: DbFileType): ChunkFile;
@@ -384,1642 +354,1752 @@ declare function createChunkFileFromDbBlock(block: DbBlock, fileType: DbFileType
  * Chunk file utilities
  */
 declare class ChunkFileUtils {
-    /**
-     * Rebase blocks to a new location
-     */
-    static rebase(chunkFile: ChunkFile, newLocation?: number): void;
-    /**
-     * Calculate the total size of all blocks
-     */
-    static calculateSize(chunkFile: ChunkFile): number;
-    /**
-   * Check if a location is outside this block and return the part (matches C# IsOutside)
-   * Returns [isOutside, part] where part is the part containing the location
-   */
-    static isOutsideWithPart(root: ChunkFile[], block: ChunkFile, location: number): [boolean, ChunkFile | null, AsmBlock | null];
-    /**
-     * Check if a location is inside this block and return the part (matches C# IsInside)
-     * Returns [isInside, part] where part is the part containing the location
-     */
-    static isInsideWithPart(block: ChunkFile, location: number): [boolean, AsmBlock | null];
-    /**
-     * Check if a location is outside this block (shorthand version)
-     */
-    static isOutside(block: ChunkFile, location: number): boolean;
-    /**
-     * Check if a location is inside this block (shorthand version)
-     */
-    static isInside(block: ChunkFile, location: number): boolean;
-    /**
-     * Get all included blocks
-     */
-    static getIncludes(chunkFile: ChunkFile): ChunkFile[];
-}
-
+  /**
+       * Rebase blocks to a new location
+       */
+  static rebase(chunkFile: ChunkFile, newLocation?: number): void;
+  /**
+       * Calculate the total size of all blocks
+       */
+  static calculateSize(chunkFile: ChunkFile): number;
+  /**
+     * Check if a location is outside this block and return the part (matches C# IsOutside)
+     * Returns [isOutside, part] where part is the part containing the location
+     */
+  static isOutsideWithPart(root: ChunkFile[], block: ChunkFile, location: number): [boolean, ChunkFile | null, AsmBlock | null];
+  /**
+       * Check if a location is inside this block and return the part (matches C# IsInside)
+       * Returns [isInside, part] where part is the part containing the location
+       */
+  static isInsideWithPart(block: ChunkFile, location: number): [boolean, AsmBlock | null];
+  /**
+       * Check if a location is outside this block (shorthand version)
+       */
+  static isOutside(block: ChunkFile, location: number): boolean;
+  /**
+       * Check if a location is inside this block (shorthand version)
+       */
+  static isInside(block: ChunkFile, location: number): boolean;
+  /**
+       * Get all included blocks
+       */
+  static getIncludes(chunkFile: ChunkFile): ChunkFile[];
+}
+//#endregion
+//#region src/database/cop.d.ts
 /**
  * COP instruction definition
  * Converted from GaiaLib/Database/CopDef.cs
  */
 declare class CopDef {
-    id: number;
-    name: string;
-    size: number;
-    parts: string[];
-    halt: boolean;
-    constructor(data: Partial<CopDef>);
-}
-
+  id: number;
+  name: string;
+  size: number;
+  parts: string[];
+  halt: boolean;
+  constructor(data: Partial<CopDef>);
+}
+//#endregion
+//#region src/database/opcode.d.ts
 declare class OpCode {
-    code: number;
-    mnem: string;
-    mode: string;
-    constructor(code: number, mnem: string, mode: string);
+  code: number;
+  mnem: string;
+  mode: string;
+  constructor(code: number, mnem: string, mode: string);
 }
-
+//#endregion
+//#region src/types/assembly.d.ts
 /**
  * Represents a single assembly operation/instruction
  */
 declare class Op extends OpCode {
-    location: number;
-    operands: unknown[];
-    size: number;
-    copDef?: CopDef;
-    constructor(code: OpCode, location?: number, operands?: unknown[], size?: number);
+  location: number;
+  operands: unknown[];
+  size: number;
+  copDef?: CopDef;
+  constructor(code: OpCode, location?: number, operands?: unknown[], size?: number);
 }
 /**
  * Represents a block of assembly code or data
  */
 declare class AsmBlock {
-    label?: string;
-    location: number;
-    size: number;
-    isString: boolean;
-    objList: any[];
-    structName?: string;
-    bank?: number;
-    includes?: Set<{
-        block: ChunkFile;
-        part: AsmBlock;
-    }>;
-    constructor(location?: number, size?: number, isString?: boolean, label?: string, structName?: string, bank?: number);
+  label?: string;
+  location: number;
+  size: number;
+  isString: boolean;
+  objList: any[];
+  structName?: string;
+  bank?: number;
+  includes?: Set<{
+    block: ChunkFile;
+    part: AsmBlock;
+  }>;
+  constructor(location?: number, size?: number, isString?: boolean, label?: string, structName?: string, bank?: number);
 }
 /**
  * Database part utilities
  */
 declare class AsmBlockUtils {
-    /**
-     * Check if a location is inside this part
-     */
-    static isInside(part: AsmBlock, location: number): boolean;
-    /**
-     * Check if a location is outside this part
-     */
-    static isOutside(part: AsmBlock, location: number): boolean;
-}
-
+  /**
+       * Check if a location is inside this part
+       */
+  static isInside(part: AsmBlock, location: number): boolean;
+  /**
+       * Check if a location is outside this part
+       */
+  static isOutside(part: AsmBlock, location: number): boolean;
+}
+//#endregion
+//#region src/types/bitstream.d.ts
 /**
  * Bit stream for reading/writing binary data at bit level
  * Converted from GaiaLib/Types/BitStream.cs
  */
 declare class BitStream {
-    private static readonly NIBBLE_MASK;
-    private static readonly NIBBLE_PERFECT_POSITION;
-    private data;
-    private position;
-    private bitFlag;
-    private writeSample;
-    constructor(data: Uint8Array, position?: number);
-    get dataArray(): Uint8Array;
-    get currentPosition(): number;
-    set currentPosition(value: number);
-    /**
-     * Read a byte from the stream
-     * @returns The byte read, or -1 if the end of the data has been reached
-     */
-    readByte(): number;
-    /**
-     * Read a ushort from the stream (ignores the current bit flag)
-     * @returns The short read, or -1 if the end of the data has been reached
-     */
-    readShort(): number;
-    /**
-     * Read a bit from the stream
-     * @returns True if the current bit at bitFlag is set, false otherwise
-     */
-    readBit(): boolean;
-    /**
-     * Read a nibble from the stream
-     * @returns The nibble read, or -1 if the end of the data has been reached
-     */
-    readNibble(): number;
-    /**
-     * Write a bit to the stream
-     * @param set True if the current bit should be set, false otherwise
-     */
-    writeBit(set: boolean): void;
-    /**
-     * Write a byte to the stream
-     * @param value The byte to write
-     */
-    writeByte(value: number): void;
-    /**
-     * Write a nibble to the stream
-     * @param value The nibble to write
-     */
-    writeNibble(value: number): void;
-    flush(): void;
-}
-
+  private static readonly NIBBLE_MASK;
+  private static readonly NIBBLE_PERFECT_POSITION;
+  private data;
+  private position;
+  private bitFlag;
+  private writeSample;
+  constructor(data: Uint8Array, position?: number);
+  get dataArray(): Uint8Array;
+  get currentPosition(): number;
+  set currentPosition(value: number);
+  /**
+       * Read a byte from the stream
+       * @returns The byte read, or -1 if the end of the data has been reached
+       */
+  readByte(): number;
+  /**
+       * Read a ushort from the stream (ignores the current bit flag)
+       * @returns The short read, or -1 if the end of the data has been reached
+       */
+  readShort(): number;
+  /**
+       * Read a bit from the stream
+       * @returns True if the current bit at bitFlag is set, false otherwise
+       */
+  readBit(): boolean;
+  /**
+       * Read a nibble from the stream
+       * @returns The nibble read, or -1 if the end of the data has been reached
+       */
+  readNibble(): number;
+  /**
+       * Write a bit to the stream
+       * @param set True if the current bit should be set, false otherwise
+       */
+  writeBit(set: boolean): void;
+  /**
+       * Write a byte to the stream
+       * @param value The byte to write
+       */
+  writeByte(value: number): void;
+  /**
+       * Write a nibble to the stream
+       * @param value The nibble to write
+       */
+  writeNibble(value: number): void;
+  flush(): void;
+}
+//#endregion
+//#region src/types/compression-registry.d.ts
 /**
  * Registry for compression providers
  * Allows registration of compression implementations by string ID
  */
 declare class CompressionRegistry {
-    private static providers;
-    /**
-     * Register a compression provider
-     * @param id String identifier for the compression type
-     * @param factory Factory function that creates the compression provider
-     */
-    static register(id: string, factory: () => ICompressionProvider): void;
-    /**
-     * Get a compression provider by ID
-     * @param id String identifier for the compression type
-     * @returns Compression provider instance
-     */
-    static get(id: string): ICompressionProvider;
-    /**
-     * Check if a compression provider is registered
-     * @param id String identifier for the compression type
-     * @returns True if provider is registered
-     */
-    static has(id: string): boolean;
-    /**
-     * Get list of registered provider IDs
-     * @returns Array of registered provider IDs
-     */
-    static getRegisteredIds(): string[];
-    /**
-     * Clear all registered providers (mainly for testing)
-     */
-    static clear(): void;
-}
-
+  private static providers;
+  /**
+       * Register a compression provider
+       * @param id String identifier for the compression type
+       * @param factory Factory function that creates the compression provider
+       */
+  static register(id: string, factory: () => ICompressionProvider): void;
+  /**
+       * Get a compression provider by ID
+       * @param id String identifier for the compression type
+       * @returns Compression provider instance
+       */
+  static get(id: string): ICompressionProvider;
+  /**
+       * Check if a compression provider is registered
+       * @param id String identifier for the compression type
+       * @returns True if provider is registered
+       */
+  static has(id: string): boolean;
+  /**
+       * Get list of registered provider IDs
+       * @returns Array of registered provider IDs
+       */
+  static getRegisteredIds(): string[];
+  /**
+       * Clear all registered providers (mainly for testing)
+       */
+  static clear(): void;
+}
+//#endregion
+//#region src/types/constants.d.ts
 /**
  * ROM processing constants
  * Converted from GaiaLib/Types/RomProcessingConstants.cs
  */
 declare class RomProcessingConstants {
-    static readonly PAGE_SIZE = 32768;
-    static readonly SNES_HEADER_SIZE = 80;
-    static readonly DICTIONARIES: string[];
-    static readonly DICT_COMMANDS: number[];
-    static readonly END_CHARS: number[];
-    static readonly WHITESPACE: string[];
-    static readonly OPERATORS: string[];
-    static readonly COMMA_SPACE: string[];
-    static readonly ADDRESS_SPACE: string[];
-    static readonly SYMBOL_SPACE: string[];
-    static readonly LABEL_SPACE: string[];
-    static readonly OBJECT_SPACE: string[];
-    static readonly COP_SPLIT_CHARS: string[];
-    static readonly WHITESPACE_REGEX: RegExp;
-    static readonly COMMA_SPACE_REGEX: RegExp;
-    static readonly SYMBOL_SPACE_REGEX: RegExp;
-    static readonly LABEL_SPACE_REGEX: RegExp;
-    static readonly OBJECT_SPACE_REGEX: RegExp;
-    static readonly ADDRESS_SPACE_REGEX: RegExp;
-    static readonly COP_SPLIT_REGEX: RegExp;
-    static readonly COMMA_SPACE_TRIM_REGEX: RegExp;
-    /**
-     * Gets the size of an object for processing purposes
-     * @param obj The object to get the size for
-     * @returns Size in bytes
-     * @throws Error when unable to determine size
-     */
-    static getSize(obj: unknown): number;
+  static readonly PAGE_SIZE = 32768;
+  static readonly SNES_HEADER_SIZE = 80;
+  static readonly DICTIONARIES: string[];
+  static readonly DICT_COMMANDS: number[];
+  static readonly END_CHARS: number[];
+  static readonly WHITESPACE: string[];
+  static readonly OPERATORS: string[];
+  static readonly COMMA_SPACE: string[];
+  static readonly ADDRESS_SPACE: string[];
+  static readonly SYMBOL_SPACE: string[];
+  static readonly LABEL_SPACE: string[];
+  static readonly OBJECT_SPACE: string[];
+  static readonly COP_SPLIT_CHARS: string[];
+  static readonly WHITESPACE_REGEX: RegExp;
+  static readonly COMMA_SPACE_REGEX: RegExp;
+  static readonly SYMBOL_SPACE_REGEX: RegExp;
+  static readonly LABEL_SPACE_REGEX: RegExp;
+  static readonly OBJECT_SPACE_REGEX: RegExp;
+  static readonly ADDRESS_SPACE_REGEX: RegExp;
+  static readonly COP_SPLIT_REGEX: RegExp;
+  static readonly COMMA_SPACE_TRIM_REGEX: RegExp;
+  /**
+       * Gets the size of an object for processing purposes
+       * @param obj The object to get the size for
+       * @returns Size in bytes
+       * @throws Error when unable to determine size
+       */
+  static getSize(obj: unknown): number;
 }
 /**
  * BlockReader specific constants
  */
 declare class BlockReaderConstants {
-    static readonly REF_SEARCH_MAX_RANGE = 416;
-    static readonly BANK_MASK_CHECK = 64;
-    static readonly BYTE_DELIMITER_THRESHOLD = 256;
-    static readonly BANK_HIGH_MEMORY_1 = 126;
-    static readonly BANK_HIGH_MEMORY_2 = 127;
-    static readonly POINTER_CHARACTERS: string[];
-    static readonly WIDE_STRING_TYPE = "WideString";
-    static readonly BINARY_TYPE = "Binary";
-    static readonly CODE_TYPE = "Code";
-    static readonly LOCATION_FORMAT = "loc_{0:X6}";
-    static readonly TYPE_NAME_FORMAT = "{0}_{1:X6}";
-    static readonly OFFSET_FORMAT = "+{0:X}";
-    static readonly MARKER_FORMAT = "+M";
-    static readonly NEGATIVE_OFFSET_FORMAT = "-{0:X}";
-    static readonly NEGATIVE_MARKER_FORMAT = "-M";
-}
-
+  static readonly REF_SEARCH_MAX_RANGE = 416;
+  static readonly BANK_MASK_CHECK = 64;
+  static readonly BYTE_DELIMITER_THRESHOLD = 256;
+  static readonly BANK_HIGH_MEMORY_1 = 126;
+  static readonly BANK_HIGH_MEMORY_2 = 127;
+  static readonly POINTER_CHARACTERS: string[];
+  static readonly WIDE_STRING_TYPE = "WideString";
+  static readonly BINARY_TYPE = "Binary";
+  static readonly CODE_TYPE = "Code";
+  static readonly LOCATION_FORMAT = "loc_{0:X6}";
+  static readonly TYPE_NAME_FORMAT = "{0}_{1:X6}";
+  static readonly OFFSET_FORMAT = "+{0:X}";
+  static readonly MARKER_FORMAT = "+M";
+  static readonly NEGATIVE_OFFSET_FORMAT = "-{0:X}";
+  static readonly NEGATIVE_MARKER_FORMAT = "-M";
+}
+//#endregion
+//#region src/types/location.d.ts
 /**
  * Location wrapper for additional metadata
  * Converted from GaiaLib/Types/LocationWrapper.cs
  */
 declare class LocationWrapper {
-    location: number;
-    type: AddressType;
-    constructor(location: number, type: AddressType);
+  location: number;
+  type: AddressType;
+  constructor(location: number, type: AddressType);
 }
-
+//#endregion
+//#region src/database/strings.d.ts
 /**
  * Database string command definition
  * Converted from GaiaLib/Database/DbStringCommand.cs
  */
 declare class DbStringCommand {
-    id: number;
-    name: string;
-    types: MemberType[];
-    delimiter?: number;
-    halt: boolean;
-    constructor(data: Partial<DbStringCommand>);
+  id: number;
+  name: string;
+  types: MemberType[];
+  delimiter?: number;
+  halt: boolean;
+  constructor(data: Partial<DbStringCommand>);
 }
 /**
  * Database string layer definition
  * Converted from GaiaLib/Database/DbStringLayer.cs
  */
 interface DbStringLayer {
-    base: number;
-    map: string[];
+  base: number;
+  map: string[];
+}
+declare class DbStringDictionary {
+  base: number;
+  range: number;
+  command: number;
+  name: string;
+  suffix: string;
+  entries: string[];
+  constructor(data: Partial<DbStringDictionary>);
 }
 /**
  * Database string type definition
  * Converted from GaiaLib/Database/DbStringType.cs
  */
 declare class DbStringType {
-    name: string;
-    delimiter: string;
-    terminator: number;
-    shiftType?: string;
-    characterMap: string[];
-    commands: Record<string, DbStringCommand>;
-    commandLookup: Record<number, DbStringCommand>;
-    layers: DbStringLayer[];
-    greedyTerminator: boolean;
-    constructor(data: Partial<DbStringType>);
+  name: string;
+  delimiter: string;
+  terminator: number;
+  shiftType?: string;
+  characterMap: string[];
+  commands: Record<string, DbStringCommand>;
+  commandLookup: Record<number, DbStringCommand>;
+  layers: DbStringLayer[];
+  greedyTerminator: boolean;
+  dictionaries: Record<string, DbStringDictionary>;
+  constructor(data: Partial<DbStringType>);
 }
 /**
  * String type utilities
  */
 declare class DbStringTypeUtils {
-    private static readonly shiftDownFunctions;
-    private static readonly shiftUpFunctions;
-    static getShiftDown(shiftType?: string): (x: number) => number;
-    static getShiftUp(shiftType?: string): (x: number) => number;
+  private static readonly shiftDownFunctions;
+  private static readonly shiftUpFunctions;
+  static getShiftDown(shiftType?: string): (x: number) => number;
+  static getShiftUp(shiftType?: string): (x: number) => number;
 }
-
+//#endregion
+//#region src/types/strings.d.ts
 /**
  * String marker for positioning
  * Converted from GaiaLib/Types/StringMarker.cs
  */
 interface StringMarker {
-    offset: number;
+  offset: number;
 }
 /**
  * String wrapper with type and location information
  * Converted from GaiaLib/Types/StringWrapper.cs
  */
 interface StringWrapper {
-    string: string;
-    type: DbStringType;
-    marker: number;
-    location: number;
+  string: string;
+  type: DbStringType;
+  marker: number;
+  location: number;
+  fixedSize: number;
 }
 /**
  * String entry (commented out in original C# code)
  * Converted from GaiaLib/Types/StringEntry.cs
  */
 interface StringEntry {
-    block: AsmBlock;
-    index: number;
-    size: number;
-    data: Uint8Array;
+  block: AsmBlock;
+  index: number;
+  size: number;
+  data: Uint8Array;
 }
 /**
  * String size comparer utility
  * Converted from GaiaLib/Types/StringSizeComparer.cs
  */
 declare class StringSizeComparer {
-    /**
-     * Compare two strings by length
-     */
-    static compare(a: string, b: string): number;
-    /**
-     * Compare two StringWrapper objects by string length
-     */
-    static compareWrappers(a: StringWrapper, b: StringWrapper): number;
-}
-
+  /**
+       * Compare two strings by length
+       */
+  static compare(a: string, b: string): number;
+  /**
+       * Compare two StringWrapper objects by string length
+       */
+  static compareWrappers(a: StringWrapper, b: StringWrapper): number;
+}
+//#endregion
+//#region src/types/structs.d.ts
 /**
  * Structure definition
  * Converted from GaiaLib/Types/StructDef.cs
  */
 interface StructDef {
-    name: string;
-    parts: unknown[];
-}
-
-/**
- * Table entry definition
- * Converted from GaiaLib/Types/TableEntry.cs
- */
-interface TableEntry {
-    location: number;
-    object: unknown;
-}
-/**
- * Creates a new TableEntry
- */
-declare function createTableEntry(location: number, object?: unknown): TableEntry;
-
+  name: string;
+  parts: unknown[];
+}
+//#endregion
+//#region src/types/tables.d.ts
+declare class TableEntry {
+  location: number;
+  object: unknown;
+  constructor(location: number);
+}
+//#endregion
+//#region src/types/operands.d.ts
 declare class TypedNumber {
-    value: number;
-    size: number;
-    constructor(value: number, size: number);
+  value: number;
+  size: number;
+  constructor(value: number, size: number);
 }
 declare class Byte extends TypedNumber {
-    constructor(value: number);
+  constructor(value: number);
 }
 declare class Word extends TypedNumber {
-    constructor(value: number);
+  constructor(value: number);
 }
 declare class Long extends TypedNumber {
-    constructor(value: number);
+  constructor(value: number);
 }
-
+//#endregion
+//#region src/assembly/Registers.d.ts
+/**
+ * Manages the 65816 processor registers and status flags
+ */
+declare class Registers {
+  value: Record<string, number>;
+  stack: Stack;
+  mode: MemoryMapMode;
+  constructor(mode: MemoryMapMode);
+}
+//#endregion
+//#region src/rom/extraction/processor.d.ts
+declare class MapExt<K, V> extends Map<K, V> {
+  constructor();
+  tryAdd(key: K, value: V): boolean;
+  setFlag(key: K, flag: number, value?: boolean): void;
+  clearFlag(key: K, flag: number): void;
+}
+/**
+ * Manages CPU processor state during ROM analysis
+ * Converted from GaiaLib/Rom/Extraction/ProcessorStateManager.cs
+ */
+declare class ProcessorStateManager {
+  readonly stackPositions: MapExt<number, number>;
+  private readonly _buckets;
+  get(key: string): MapExt<number, number>;
+  /**
+       * Hydrate processor registers with stored state
+       * Uses Registers from gaia-core/assembly for processor state management
+       */
+  hydrateRegisters(position: number, reg: Registers): void;
+  getStackPosition(location: number): number | undefined;
+  setStackPosition(location: number, value: number): void;
+  tryAddStackPosition(location: number, value: number): boolean;
+}
+//#endregion
+//#region src/rom/extraction/reader.d.ts
+/**
+ * Provides low-level ROM data reading functionality
+ * Converted from GaiaLib/Rom/Extraction/RomDataReader.cs
+ */
+declare class RomDataReader {
+  readonly romData: Uint8Array;
+  position: number;
+  constructor(romData: Uint8Array);
+  readByte(): number;
+  readSByte(): number;
+  readUShort(): number;
+  readShort(): number;
+  readAddress(): number;
+  readInt(): number;
+  peekByte(): number;
+  peekShort(): number;
+  peekAddress(): number;
+}
+//#endregion
+//#region src/database/entrypoints.d.ts
 /**
  * Database entry point definition
  * Converted from GaiaLib/Database/DbEntryPoint.cs
  */
 interface DbEntryPoint {
-    location: number;
-    name: string;
+  location: number;
+  name: string;
 }
-
+//#endregion
+//#region src/database/paths.d.ts
 /**
  * Database path configuration
  * Converted from GaiaLib/Database/DbPath.cs
  */
 interface DbPath {
-    folder: string;
-    extension: string;
+  folder: string;
+  extension: string;
 }
 /**
  * Creates a default DbPath
  */
 declare function createDbPath(folder?: string, extension?: string): DbPath;
-
+//#endregion
+//#region src/database/config.d.ts
 /**
  * Database configuration
  * Converted from GaiaLib/Database/DbConfig.cs
  */
 interface DbConfig {
-    sfxLocation: number;
-    sfxCount: number;
-    compression: string;
-    entryPoints: DbEntryPoint[];
-    paths: Record<BinType, DbPath>;
+  sfxLocation: number;
+  sfxCount: number;
+  compression: string;
+  entryPoints: DbEntryPoint[];
+  paths: Record<BinType, DbPath>;
+  memoryMode: MemoryMapMode;
 }
-
+//#endregion
+//#region src/database/structs.d.ts
 /**
  * Database structure definition
  * Converted from GaiaLib/Database/DbStruct.cs
  */
 declare class DbStruct {
-    name: string;
-    types?: string[];
-    parent?: string;
-    delimiter?: number;
-    discriminator?: number;
-    constructor(data: Partial<DbStruct>);
-}
-
+  name: string;
+  types?: string[];
+  parent?: string;
+  delimiter?: number;
+  discriminator?: number;
+  constructor(data: Partial<DbStruct>);
+}
+//#endregion
+//#region src/database/addressingMode.d.ts
 declare class DbAddressingMode {
-    name: string;
-    shorthand: string;
-    operands: string[];
-    size: number;
-    formatString?: string;
-    parseRegex?: string;
-    instructions: Record<string, number>;
-    constructor(data: Partial<DbAddressingMode>);
-}
-
+  name: string;
+  shorthand: string;
+  operands: string[];
+  size: number;
+  formatString?: string;
+  parseRegex?: string;
+  instructions: Record<string, number>;
+  constructor(data: Partial<DbAddressingMode>);
+}
+//#endregion
+//#region src/database/assets.d.ts
 interface DbAsset {
-    index: number;
-    type: string;
-    file: string;
-    scene: string;
-    meta: any;
-}
-
+  index: number;
+  type: string;
+  file: string;
+  scene: string;
+  meta: any;
+}
+//#endregion
+//#region src/database/scenes.d.ts
 declare class DbScene {
-    name: string;
-    id: number;
-    description?: string;
-    assets: DbAsset[];
-    constructor(data: Partial<DbScene>);
-}
-
+  name: string;
+  id: number;
+  description?: string;
+  assets: DbAsset[];
+  constructor(data: Partial<DbScene>);
+}
+//#endregion
+//#region src/database/groups.d.ts
 declare class DbGroup {
-    name: string;
-    prefix: string;
-    description?: string;
-    scenes: Record<string, DbScene>;
-    constructor(data: Partial<DbGroup>);
-}
-
+  name: string;
+  prefix: string;
+  description?: string;
+  scenes: Record<string, DbScene>;
+  constructor(data: Partial<DbGroup>);
+}
+//#endregion
+//#region src/database/modules.d.ts
 interface DbGameRomModule {
-    mnemonics: Record<number, string>;
-    overrides: Record<number, Record<string, number>>;
-    rewrites: Record<string, number>;
-    blocks: Record<string, Record<string, Partial<DbBlock>>>;
-    files: Record<string, Record<string, Record<string, Partial<DbFile>>>>;
-    config: DbConfig;
-    labels: DbLabel[];
-    structs: Record<string, DbStruct>;
-    copdef: Record<string, Partial<CopDef>>;
-    strings: Record<string, Partial<DbStringType>>;
-    transforms: Record<string, Partial<DbTransform>[]>;
-    addrModes: Record<string, Partial<DbAddressingMode>>;
-    groups: Record<string, Partial<DbGroup>>;
-    fileTypes: Record<string, Partial<DbFileType>>;
+  mnemonics: Record<number, string>;
+  overrides: Record<number, Record<string, number>>;
+  rewrites: Record<string, number>;
+  blocks: Record<string, Record<string, Partial<DbBlock>>>;
+  files: Record<string, Record<string, Record<string, Partial<DbFile>>>>;
+  config: DbConfig;
+  labels: DbLabel[];
+  structs: Record<string, DbStruct>;
+  copdef: Record<string, Partial<CopDef>>;
+  strings: Record<string, Partial<DbStringType>>;
+  transforms: Record<string, Partial<DbTransform>[]>;
+  addrModes: Record<string, Partial<DbAddressingMode>>;
+  groups: Record<string, Partial<DbGroup>>;
+  fileTypes: Record<string, Partial<DbFileType>>;
 }
 interface DbBaseRomModule extends DbGameRomModule {
-    baseRomFiles: ChunkFile[];
+  baseRomFiles: ChunkFile[];
 }
-
+//#endregion
+//#region src/database/root.d.ts
 /**
  * Main database root class
  * Converted from GaiaLib/Database/DbRoot.cs
  */
 interface DbRoot {
-    copDef: Record<number, CopDef>;
-    copLookup: Record<string, CopDef>;
-    mnemonics: Record<number, string>;
-    structs: Record<string, DbStruct>;
-    stringTypes: Record<string, DbStringType>;
-    stringDelimiters: string[];
-    files: DbFile[];
-    config: DbConfig;
-    blocks: DbBlock[];
-    overrides: Record<number, Record<string, number>>;
-    labels: Record<number, string>;
-    rewrites: Record<number, number>;
-    entryPoints: DbEntryPoint[];
-    opCodes: Record<number, OpCode>;
-    opLookup: Record<string, OpCode[]>;
-    addrLookup: Record<string, DbAddressingMode>;
-    compression: ICompressionProvider;
-    baseRomFiles?: ChunkFile[];
-    projectFiles?: ChunkFile[];
-    groups: Record<string, DbGroup>;
-    scenes: Record<number, DbScene>;
-    fileTypes: Record<string, DbFileType>;
-    fileExtLookup: Record<string, DbFileType>;
+  copDef: Record<number, CopDef>;
+  copLookup: Record<string, CopDef>;
+  mnemonics: Record<number, string>;
+  structs: Record<string, DbStruct>;
+  stringTypes: Record<string, DbStringType>;
+  stringDelimiters: string[];
+  files: DbFile[];
+  config: DbConfig;
+  blocks: DbBlock[];
+  overrides: Record<number, Record<string, any>>;
+  labels: Record<number, string>;
+  rewrites: Record<number, number>;
+  entryPoints: DbEntryPoint[];
+  opCodes: Record<number, OpCode>;
+  opLookup: Record<string, OpCode[]>;
+  addrLookup: Record<string, DbAddressingMode>;
+  compression: ICompressionProvider;
+  baseRomFiles?: ChunkFile[];
+  projectFiles?: ChunkFile[];
+  groups: Record<string, DbGroup>;
+  scenes: Record<number, DbScene>;
+  fileTypes: Record<string, DbFileType>;
+  fileExtLookup: Record<string, DbFileType>;
 }
 /**
  * Database root utilities
  */
 declare class DbRootUtils {
-    /**
-     * JSON serialization options
-     */
-    /**
-     * Load database from a single file
-     */
-    static fromFolder(folderPath: string, systemPath: string): Promise<DbRoot>;
-    /**
-     * Load database from folder structure
-     */
-    static gameModuleFromFolder(folderPath: string, systemPath: string): Promise<DbGameRomModule>;
-    static fromGameModule(module: DbGameRomModule): DbRoot;
-    static applyFolder(root: DbRoot, folderPath: string, sourceFiles?: ChunkFile[]): Promise<ChunkFile[]>;
-    static extractAllContent(root: DbRoot, romPath: string, outPath: string): Promise<void>;
-    static rebuildAllContent(root: DbRoot, inPath: string[], outPath: string): Promise<void>;
-}
-
+  /**
+       * JSON serialization options
+       */
+  /**
+       * Load database from a single file
+       */
+  static fromFolder(folderPath: string, systemPath: string): Promise<DbRoot>;
+  /**
+       * Load database from folder structure
+       */
+  static gameModuleFromFolder(folderPath: string, systemPath: string): Promise<DbGameRomModule>;
+  static fromGameModule(module: DbGameRomModule): DbRoot;
+  static applyFolder(root: DbRoot, folderPath: string, sourceFiles?: ChunkFile[]): Promise<ChunkFile[]>;
+  static extractAllContent(root: DbRoot, romPath: string, outPath: string): Promise<void>;
+  static rebuildAllContent(root: DbRoot, inPath: string[], outPath: string): Promise<void>;
+}
+//#endregion
+//#region src/database/labels.d.ts
 /**
  * Database label definition
  * Converted from GaiaLib/Database/DbLabel.cs
  */
 interface DbLabel {
-    location: number;
-    label: string;
+  location: number;
+  label: string;
 }
-
+//#endregion
+//#region src/database/mnemonics.d.ts
 /**
  * Database mnemonic definition
  * Converted from GaiaLib/Database/DbMnemonic.cs
  */
 interface DbMnemonic {
-    key: number;
-    value: string;
-    metadata?: string;
+  key: number;
+  value: string;
+  metadata?: string;
 }
-
+//#endregion
+//#region src/database/overrides.d.ts
 declare class DbOverride {
-    location: number;
-    register: string;
-    value: number;
-    constructor(values: Partial<DbOverride>);
+  location: number;
+  register: string;
+  value: number;
+  constructor(values: Partial<DbOverride>);
 }
-
+//#endregion
+//#region src/database/rewrites.d.ts
 /**
  * Database rewrite rule definition
  * Converted from GaiaLib/Database/DbRewrite.cs
  */
 interface DbRewrite {
-    location: number;
-    value: number;
+  location: number;
+  value: number;
 }
-
+//#endregion
+//#region src/database/sfx.d.ts
 /**
  * Database sound effect definition
  * Converted from GaiaLib/Database/DbSfx.cs
  */
 interface DbSfx {
-    location: number;
-    size: number;
-    names: string[];
+  location: number;
+  size: number;
+  names: string[];
 }
-
+//#endregion
+//#region src/rom/extraction/references.d.ts
 /**
  * Manages references, chunks, and markers during ROM analysis
  * Converted from GaiaLib/Rom/Extraction/ReferenceManager.cs
  */
 declare class ReferenceManager {
-    readonly structTable: Map<number, string>;
-    readonly markerTable: Map<number, number>;
-    readonly nameTable: Map<number, string>;
-    private readonly root;
-    constructor(root: DbRoot);
-    tryGetStruct(location: number): {
-        found: boolean;
-        chunkType?: string;
-    };
-    tryAddStruct(location: number, chunkType: string): boolean;
-    containsStruct(location: number): boolean;
-    tryGetName(location: number): {
-        found: boolean;
-        referenceName?: string;
-    };
-    tryAddName(location: number, referenceName: string): boolean;
-    tryGetMarker(location: number): {
-        found: boolean;
-        offset?: number;
-    };
-    setMarker(location: number, offset: number): void;
-    createBranchLabel(location: number): string;
-    createTypeName(type: string, location: number): string;
-    createFallbackName(location: number): string;
-    /**
-     * Finds a reference location by its assigned name.
-     */
-    findLocationByName(name: string): number | undefined;
-    resolveName(location: number, type: AddressType, isBranch: boolean): string;
-    findClosestReference(location: number): string | null;
-    private processRewrite;
-    private processClosestMatch;
-}
-
+  readonly structTable: Map<number, string>;
+  readonly markerTable: Map<number, number>;
+  readonly nameTable: Map<number, string>;
+  private readonly root;
+  constructor(root: DbRoot);
+  tryGetStruct(location: number): {
+    found: boolean;
+    chunkType?: string;
+  };
+  tryAddStruct(location: number, chunkType: string): boolean;
+  containsStruct(location: number): boolean;
+  tryGetName(location: number): {
+    found: boolean;
+    referenceName?: string;
+  };
+  tryAddName(location: number, referenceName: string): boolean;
+  tryGetMarker(location: number): {
+    found: boolean;
+    offset?: number;
+  };
+  setMarker(location: number, offset: number): void;
+  createBranchLabel(location: number): string;
+  createTypeName(type: string, location: number): string;
+  createFallbackName(location: number): string;
+  /**
+       * Finds a reference location by its assigned name.
+       */
+  findLocationByName(name: string): number | undefined;
+  resolveName(location: number, type: AddressType, isBranch: boolean): string;
+  findClosestReference(location: number): string | null;
+  private processRewrite;
+  private processClosestMatch;
+}
+//#endregion
+//#region src/rom/extraction/strings.d.ts
 /**
  * Reads and processes strings from ROM data
  * Converted from GaiaLib/Rom/Extraction/StringReader.cs
  */
 declare class StringReader {
-    static readonly STRING_REFERENCE_CHARACTERS: string[];
-    private readonly _blockReader;
-    private readonly _romDataReader;
-    constructor(blockReader: BlockReader);
-    private resolveCommand;
-    parseString(stringType: DbStringType): StringWrapper;
-    /**
-     * Handles character shifting based on string type
-     * This is a simplified implementation of the shift logic
-     */
-    private shiftDown;
-    resolveString(sw: StringWrapper, isBranch: boolean): void;
+  static readonly STRING_REFERENCE_CHARACTERS: string[];
+  private readonly _blockReader;
+  private readonly _romDataReader;
+  constructor(blockReader: BlockReader);
+  private resolveCommand;
+  parseString(stringType: DbStringType, fixedSize: number): StringWrapper;
+  resolveString(sw: StringWrapper, isBranch: boolean): void;
 }
-
+//#endregion
+//#region src/rom/extraction/asm.d.ts
 /**
  * Parses assembly instructions from ROM data, handling different addressing modes
  * and maintaining CPU register state during analysis.
  * Converted from GaiaLib/Rom/Extraction/AsmReader.cs
  */
 declare class AsmReader {
-    private static readonly STATUS_OP_MASK;
-    private static readonly STATUS_OP_VALUE;
-    private static readonly ACCUMULATOR_OP_MASK;
-    private static readonly ACCUMULATOR_OP_VALUE;
-    static readonly VARIABLE_SIZE_INDICATOR = -2;
-    private readonly _blockReader;
-    private readonly _transformProcessor;
-    private readonly _addressingModeHandler;
-    private readonly _romDataReader;
-    constructor(blockReader: BlockReader);
-    parseAsm(reg: Registers): Op;
-    clearDestinationRegister(code: OpCode, reg: Registers): void;
-    private initializeOperation;
-    private calculateInstructionSize;
-}
-
+  private static readonly STATUS_OP_MASK;
+  private static readonly STATUS_OP_VALUE;
+  private static readonly ACCUMULATOR_OP_MASK;
+  private static readonly ACCUMULATOR_OP_VALUE;
+  static readonly VARIABLE_SIZE_INDICATOR = -2;
+  private readonly _blockReader;
+  private readonly _transformProcessor;
+  private readonly _addressingModeHandler;
+  private readonly _romDataReader;
+  constructor(blockReader: BlockReader);
+  parseAsm(reg: Registers): Op;
+  clearDestinationRegister(code: OpCode, reg: Registers): void;
+  private initializeOperation;
+  private calculateInstructionSize;
+}
+//#endregion
+//#region src/rom/extraction/parser.d.ts
 /**
  * Handles parsing of different data types from ROM
  * Converted from GaiaLib/Rom/Extraction/TypeParser.cs
  */
 declare class TypeParser {
-    private readonly _blockReader;
-    private readonly _romDataReader;
-    private readonly _stringReader;
-    private readonly _stringTypes;
-    private readonly _referenceManager;
-    constructor(blockReader: BlockReader);
-    parseType(typeName: string, reg: Registers | null, depth: number, bank?: number): unknown;
-    private tryParseMemberType;
-    private parseWordSafe;
-    private parseBinary;
-    private parseLocation;
-    private parseCode;
-}
-
+  private readonly _blockReader;
+  private readonly _romDataReader;
+  private readonly _stringReader;
+  private readonly _stringTypes;
+  private readonly _referenceManager;
+  constructor(blockReader: BlockReader);
+  parseType(typeName: string, reg: Registers | null, depth: number, bank?: number): unknown;
+  private tryParseMemberType;
+  private parseWordSafe;
+  private parseBinary;
+  private parseLocation;
+  private parseCode;
+}
+//#endregion
+//#region src/rom/extraction/blocks.d.ts
 /**
  * Central class for reading and analyzing ROM blocks
  * Converted from GaiaLib/Rom/Extraction/BlockReader.cs
  */
 declare class BlockReader {
-    private static readonly REF_SEARCH_MAX_RANGE;
-    private static readonly BANK_MASK_CHECK;
-    private static readonly BYTE_DELIMITER_THRESHOLD;
-    private static readonly BANK_HIGH_MEMORY_1;
-    private static readonly BANK_HIGH_MEMORY_2;
-    private static readonly POINTER_CHARACTERS;
-    private static readonly LOCATION_REGEX;
-    readonly _root: DbRoot;
-    readonly _stringReader: StringReader;
-    readonly _asmReader: AsmReader;
-    readonly _typeParser: TypeParser;
-    readonly _romDataReader: RomDataReader;
-    readonly _stateManager: ProcessorStateManager;
-    readonly _referenceManager: ReferenceManager;
-    _partEnd: number;
-    _currentChunk: ChunkFile | null;
-    _currentAsmBlock: AsmBlock | null;
-    _enrichedChunks: ChunkFile[];
-    constructor(romData: Uint8Array, root: DbRoot);
-    /**
-     * Processes predefined overrides for registers and bank notes
-     */
-    private initializeOverrides;
-    /**
-     * Processes predefined file references
-     */
-    private initializeFileReferences;
-    /**
-     * Resolves mnemonic for a given address
-     */
-    resolveMnemonic(addr: Address): void;
-    /**
-     * Resolves name for a location (delegated to ReferenceManager)
-     */
-    resolveName(location: number, type: AddressType, isBranch: boolean): string;
-    /**
-     * Resolves include for a location
-     */
-    resolveInclude(loc: number, isBranch: boolean): void;
-    /**
-     * Notes a type at a location and manages chunk references
-     */
-    noteType(loc: number, type: string, silent?: boolean, reg?: Registers): string;
-    updateRegisterState(loc: number, reg: Registers): void;
-    /**
-     * Checks if a delimiter has been reached
-     */
-    delimiterReached(delimiter?: number): boolean;
-    /**
-     * Checks if processing of the current part can continue
-     */
-    partCanContinue(): boolean;
-    analyzeAndResolve(): ChunkFile[];
-    /**
-     * Analyzes all blocks in the ROM
-     */
-    /**
-     * Initializes blocks and parts with base references
-     */
-    private initializeBlocksAndParts;
-    /**
-     * Processes a single part
-     */
-    private processPart;
-    /**
-     * Processes a continuous entry (same type as previous)
-     */
-    private processContinuousEntry;
-    /**
-     * Processes a new entry
-     */
-    private processNewEntry;
-    /**
-     * Creates ChunkFile objects from database structure
-     */
-    private createChunkFilesFromDatabase;
-    /**
-     * Creates binary ChunkFiles from DbFiles (enriched with rawData)
-     */
-    private createChunkFilesFromSfx;
-    /**
-     * Creates binary ChunkFiles from DbFiles (enriched with rawData)
-     */
-    private createChunkFilesFromDbFiles;
-    /**
-     * Creates assembly ChunkFiles from DbBlocks (enriched with parts)
-     */
-    private createChunkFilesFromDbBlocks;
-    /**
-     * Analyzes only assembly ChunkFiles (those with parts from DbBlocks)
-     */
-    private analyzeChunkFiles;
-    /**
-     * Resolves references in assembly ChunkFiles only
-     */
-    private resolveReferences;
-    /**
-     * Resolves a single object and its references
-     */
-    private resolveObject;
-    /**
-     * Resolves references in an operation object
-     */
-    private resolveOperationObject;
-    /**
-     * Checks if an operation is a branch operation
-     */
-    private isBranchOperation;
-    /**
-     * Hydrates registers with stored state
-     */
-    hydrateRegisters(reg: Registers): void;
-}
-
+  private static readonly REF_SEARCH_MAX_RANGE;
+  private static readonly BANK_MASK_CHECK;
+  private static readonly BYTE_DELIMITER_THRESHOLD;
+  private static readonly BANK_HIGH_MEMORY_1;
+  private static readonly BANK_HIGH_MEMORY_2;
+  private static readonly POINTER_CHARACTERS;
+  private static readonly LOCATION_REGEX;
+  readonly _root: DbRoot;
+  readonly _stringReader: StringReader;
+  readonly _asmReader: AsmReader;
+  readonly _typeParser: TypeParser;
+  readonly _romDataReader: RomDataReader;
+  readonly _stateManager: ProcessorStateManager;
+  readonly _referenceManager: ReferenceManager;
+  _partEnd: number;
+  _currentChunk: ChunkFile | null;
+  _currentAsmBlock: AsmBlock | null;
+  _enrichedChunks: ChunkFile[];
+  constructor(romData: Uint8Array, root: DbRoot);
+  /**
+       * Processes predefined overrides for registers and bank notes
+       */
+  private initializeOverrides;
+  /**
+       * Processes predefined file references
+       */
+  private initializeFileReferences;
+  /**
+       * Resolves mnemonic for a given address
+       */
+  resolveMnemonic(addr: Address): void;
+  /**
+       * Resolves name for a location (delegated to ReferenceManager)
+       */
+  resolveName(location: number, type: AddressType, isBranch: boolean): string;
+  /**
+       * Resolves include for a location
+       */
+  resolveInclude(loc: number, isBranch: boolean): void;
+  /**
+       * Notes a type at a location and manages chunk references
+       */
+  noteType(loc: number, type: string, silent?: boolean, reg?: Registers): string;
+  updateRegisterState(loc: number, reg: Registers): void;
+  /**
+       * Checks if a delimiter has been reached
+       */
+  delimiterReached(delimiter?: number): boolean;
+  /**
+       * Checks if processing of the current part can continue
+       */
+  partCanContinue(): boolean;
+  analyzeAndResolve(): ChunkFile[];
+  /**
+       * Analyzes all blocks in the ROM
+       */
+  /**
+       * Initializes blocks and parts with base references
+       */
+  private initializeBlocksAndParts;
+  /**
+       * Processes a single part
+       */
+  private processPart;
+  /**
+       * Processes a continuous entry (same type as previous)
+       */
+  private processContinuousEntry;
+  /**
+       * Processes a new entry
+       */
+  private processNewEntry;
+  /**
+       * Creates ChunkFile objects from database structure
+       */
+  private createChunkFilesFromDatabase;
+  /**
+       * Creates binary ChunkFiles from DbFiles (enriched with rawData)
+       */
+  private createChunkFilesFromSfx;
+  /**
+       * Creates binary ChunkFiles from DbFiles (enriched with rawData)
+       */
+  private createChunkFilesFromDbFiles;
+  /**
+       * Creates assembly ChunkFiles from DbBlocks (enriched with parts)
+       */
+  private createChunkFilesFromDbBlocks;
+  /**
+       * Analyzes only assembly ChunkFiles (those with parts from DbBlocks)
+       */
+  private analyzeChunkFiles;
+  /**
+       * Resolves references in assembly ChunkFiles only
+       */
+  private resolveReferences;
+  /**
+       * Resolves a single object and its references
+       */
+  private resolveObject;
+  /**
+       * Resolves references in an operation object
+       */
+  private resolveOperationObject;
+  /**
+       * Checks if an operation is a branch operation
+       */
+  private isBranchOperation;
+  /**
+       * Hydrates registers with stored state
+       */
+  hydrateRegisters(reg: Registers): void;
+}
+//#endregion
+//#region src/rom/extraction/transforms.d.ts
 /**
  * Handles transform processing for assembly instructions
  * Converted from GaiaLib/Rom/Extraction/TransformProcessor.cs
  */
 declare class TransformProcessor {
-    private readonly _blockReader;
-    private readonly _romDataReader;
-    private readonly _referenceManager;
-    private readonly _labelLookup;
-    private static readonly LOCATION_REGEX;
-    constructor(romReader: BlockReader);
-    /**
-     * Retrieves transform information for the current ROM position
-     */
-    getTransform(): string | null;
-    /**
-     * Applies transforms to operands
-     */
-    applyTransforms(op1Label: string | null, op2Label: string | null, operands: unknown[]): void;
-    private applyTransform;
-    private applyDefaultTransform;
-    private cleanTransformName;
-    private resolveTransformReference;
-}
-
+  private readonly _blockReader;
+  private readonly _romDataReader;
+  private readonly _referenceManager;
+  private readonly _labelLookup;
+  private static readonly LOCATION_REGEX;
+  constructor(romReader: BlockReader);
+  /**
+       * Retrieves transform information for the current ROM position
+       */
+  getTransform(): string | null;
+  /**
+       * Applies transforms to operands
+       */
+  applyTransforms(op1Label: string | null, op2Label: string | null, operands: unknown[]): void;
+  private applyTransform;
+  private applyDefaultTransform;
+  private cleanTransformName;
+  private resolveTransformReference;
+}
+//#endregion
+//#region src/rom/extraction/addressing.d.ts
 /**
  * Context information for an operation being processed
  * Converted from GaiaLib/Rom/Extraction/AsmReader.cs OperationContext
  */
 declare class OperationContext {
-    size: number;
-    nextAddress: number;
-    xForm1: string | null;
-    xForm2: string | null;
-    copDef: CopDef | null;
+  size: number;
+  nextAddress: number;
+  xForm1: string | null;
+  xForm2: string | null;
+  copDef: CopDef | null;
 }
 /**
  * Handles different addressing modes for assembly instructions
  * Converted from GaiaLib/Rom/Extraction/AddressingModeHandler.cs
  */
 declare class AddressingModeHandler {
-    private readonly _blockReader;
-    private readonly _transformProcessor;
-    private readonly _copProcessor;
-    private readonly _dataReader;
-    constructor(blockReader: BlockReader, transformProcessor: TransformProcessor);
-    processAddressingMode(code: OpCode, context: OperationContext, reg: Registers): unknown[];
-    private handleImmediateMode;
-    private readImmediateOperand;
-    private updateRegisterForImmediateInstruction;
-    private calculateRegisterValue;
-    private handleAbsoluteLongMode;
-    private handleBlockMoveMode;
-    private handleDirectPageMode;
-    private handlePCRelativeMode;
-    private handleStackRelativeMode;
-    private handleStackInterruptMode;
-    private handleStackOrImpliedMode;
-    private handleAbsoluteMode;
-    private isJumpInstruction;
-    private isPushInstruction;
-}
-
+  private readonly _blockReader;
+  private readonly _transformProcessor;
+  private readonly _copProcessor;
+  private readonly _dataReader;
+  constructor(blockReader: BlockReader, transformProcessor: TransformProcessor);
+  processAddressingMode(code: OpCode, context: OperationContext, reg: Registers): unknown[];
+  private handleImmediateMode;
+  private readImmediateOperand;
+  private updateRegisterForImmediateInstruction;
+  private calculateRegisterValue;
+  private handleAbsoluteLongMode;
+  private handleBlockMoveMode;
+  private handleDirectPageMode;
+  private handlePCRelativeMode;
+  private handleStackRelativeMode;
+  private handleStackInterruptMode;
+  private handleStackOrImpliedMode;
+  private handleAbsoluteMode;
+  private isJumpInstruction;
+  private isPushInstruction;
+}
+//#endregion
+//#region src/rom/extraction/stack.d.ts
 /**
  * Handles stack operations for various stack-related instructions
  * Converted from GaiaLib/Rom/Extraction/StackOperations.cs
  */
 declare class StackOperations {
-    private readonly _registers;
-    private readonly _blockReader;
-    constructor(registers: Registers, blockReader: BlockReader);
-    handleStackOperation(mnemonic: string): void;
-    private handleAccumulatorPush;
-    private handleAccumulatorPull;
-    private handleXIndexPush;
-    private handleXIndexPull;
-    private handleYIndexPush;
-    private handleYIndexPull;
-    private handleExchangeBytes;
-}
-
+  private readonly _registers;
+  private readonly _blockReader;
+  constructor(registers: Registers, blockReader: BlockReader);
+  handleStackOperation(mnemonic: string): void;
+  private handleAccumulatorPush;
+  private handleAccumulatorPull;
+  private handleXIndexPush;
+  private handleXIndexPull;
+  private handleYIndexPush;
+  private handleYIndexPull;
+  private handleExchangeBytes;
+}
+//#endregion
+//#region src/rom/extraction/cop.d.ts
 /**
  * Handles COP (Coprocessor) command processing
  * Converted from GaiaLib/Rom/Extraction/CopCommandProcessor.cs
  */
 declare class CopCommandProcessor {
-    private readonly _blockReader;
-    private readonly _romDataReader;
-    constructor(blockReader: BlockReader);
-    /**
-     * Parses a COP command based on its definition
-     */
-    parseCopCommand(copDef: CopDef, operands: unknown[]): void;
-    private tryParseMemberType;
-    private getMemberTypeSize;
-    private readMemberTypeValue;
-    private createCopLocation;
-    private tryParseAddressType;
-}
-
+  private readonly _blockReader;
+  private readonly _romDataReader;
+  constructor(blockReader: BlockReader);
+  /**
+       * Parses a COP command based on its definition
+       */
+  parseCopCommand(copDef: CopDef, operands: unknown[]): void;
+  private tryParseMemberType;
+  private getMemberTypeSize;
+  private readMemberTypeValue;
+  private createCopLocation;
+  private tryParseAddressType;
+}
+//#endregion
+//#region src/rom/extraction/writer.d.ts
 declare enum ObjectType {
-    TableEntryArray = "TableEntryArray",
-    StructDef = "StructDef",
-    OpArray = "OpArray",
-    LocationWrapper = "LocationWrapper",
-    Address = "Address",
-    StringWrapper = "StringWrapper",
-    ByteArray = "ByteArray",
-    Array = "Array",
-    String = "String",
-    Number = "Number",
-    TypedNumber = "TypedNumber"
+  TableEntryArray = "TableEntryArray",
+  StructDef = "StructDef",
+  OpArray = "OpArray",
+  LocationWrapper = "LocationWrapper",
+  Address = "Address",
+  StringWrapper = "StringWrapper",
+  ByteArray = "ByteArray",
+  Array = "Array",
+  String = "String",
+  Number = "Number",
+  TypedNumber = "TypedNumber",
 }
 declare class BlockWriter {
-    private _root;
-    private _blockReader;
-    private _referenceManager;
-    private _postProcessor;
-    private _isInline;
-    private _currentPart;
-    constructor(reader: BlockReader);
-    generateAllAsm(chunkFiles: ChunkFile[]): any[];
-    generateAsm(block: ChunkFile): string;
-    private getMnemonicsForBlock;
-    private resolveOperand;
-    private getObjectType;
-    private writeObject;
-    private writeTableEntryArray;
-    private writeStructDef;
-    private writeOpArray;
-    private formatDefaultOperand;
-    private writeStringWrapper;
-    private writeArray;
-    private writeNumber;
-    private formatTypedNumber;
-    private writeTypedNumber;
-    private formatOperand;
-}
-
+  private _root;
+  private _blockReader;
+  private _referenceManager;
+  private _postProcessor;
+  private _isInline;
+  private _currentPart;
+  constructor(reader: BlockReader);
+  generateAllAsm(chunkFiles: ChunkFile[]): any[];
+  generateAsm(block: ChunkFile): string;
+  private getMnemonicsForBlock;
+  private resolveOperand;
+  private getObjectType;
+  private writeObject;
+  private writeTableEntryArray;
+  private writeStructDef;
+  private writeOpArray;
+  private formatDefaultOperand;
+  private writeStringWrapper;
+  private writeArray;
+  private writeNumber;
+  private formatTypedNumber;
+  private writeTypedNumber;
+  private formatOperand;
+}
+//#endregion
+//#region src/rom/extraction/postprocessor.d.ts
 /**
  * Handles post processing of extracted blocks.
  * Mirrors functionality of GaiaLib.Rom.Extraction.PostProcessor.
  */
 declare class PostProcessor {
-    private readonly _referenceManager;
-    constructor(reader: BlockReader);
-    /**
-     * Execute post process directive on a block if present.
-     */
-    process(block: ChunkFile): void;
-    /**
-     * Builds a lookup table from struct entries.
-     * Equivalent to PostProcessor.Lookup in C# implementation.
-     */
-    Lookup(block: ChunkFile, keyIx: string, valueIx: string): void;
-}
-
+  private readonly _referenceManager;
+  constructor(reader: BlockReader);
+  /**
+       * Execute post process directive on a block if present.
+       */
+  process(block: ChunkFile): void;
+  /**
+       * Builds a lookup table from struct entries.
+       * Equivalent to PostProcessor.Lookup in C# implementation.
+       */
+  Lookup(block: ChunkFile, keyIx: string, valueIx: string): void;
+}
+//#endregion
+//#region src/rom/rebuild/layout.d.ts
 /**
  * ROM layout planner
  * Converted from ext/GaiaLib/Rom/Rebuild/RomLayout.cs
  */
 declare class RomLayout {
-    private static readonly MIN_ACCEPTED_REMAINING;
-    readonly unmatchedFiles: ChunkFile[];
-    private readonly bestResult;
-    private readonly bestSample;
-    private currentBank;
-    private currentUpper;
-    private bestDepth;
-    private bestOffset;
-    private bestRemain;
-    constructor(files: Iterable<ChunkFile>);
-    organize(): void;
-    private testDepth;
-    private commitPage;
-}
-
+  private static readonly MIN_ACCEPTED_REMAINING;
+  readonly unmatchedFiles: ChunkFile[];
+  private readonly bestResult;
+  private readonly bestSample;
+  private currentBank;
+  private currentUpper;
+  private bestDepth;
+  private bestOffset;
+  private bestRemain;
+  constructor(files: Iterable<ChunkFile>);
+  organize(): void;
+  private testDepth;
+  private commitPage;
+}
+//#endregion
+//#region src/rom/rebuild/writer.d.ts
 /**
  * ROM writer (binary)
  * Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs (subset: binary write only)
  */
 declare class RomWriter {
-    bpsPath?: string;
-    readonly outBuffer: Uint8Array;
-    readonly cartName: string;
-    readonly makerCode: string;
-    readonly root: DbRoot;
-    constructor(root: DbRoot, cartName: string, makerCode: string);
-    repack(files: ChunkFile[]): Promise<Uint8Array>;
-    writeHeader(): void;
-    writeChecksum(): void;
-    writeEntryPoints(asmFiles: ChunkFile[]): void;
-    writeFile(file: ChunkFile, _chunkLookup: Map<string, number>): Promise<number>;
-    private writeAscii;
-    /**
-     * Parse assembly blocks and write binary data to output buffer
-     * Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs ParseAssembly method
-     */
-    private parseAssembly;
-    /**
-     * Helper method to find index of any character from an array in a string
-     */
-    private indexOfAny;
-    /**
-     * Helper method to check if an object is a StringMarker
-     */
-    private isStringMarker;
-    private isTableEntry;
-}
-
+  bpsPath?: string;
+  readonly outBuffer: Uint8Array;
+  readonly cartName: string;
+  readonly makerCode: string;
+  readonly root: DbRoot;
+  constructor(root: DbRoot, cartName: string, makerCode: string);
+  repack(files: ChunkFile[]): Promise<Uint8Array>;
+  writeHeader(): void;
+  writeChecksum(): void;
+  writeEntryPoints(asmFiles: ChunkFile[]): void;
+  writeFile(file: ChunkFile, _chunkLookup: Map<string, number>): Promise<number>;
+  private writeAscii;
+  /**
+       * Parse assembly blocks and write binary data to output buffer
+       * Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs ParseAssembly method
+       */
+  private parseAssembly;
+  /**
+       * Helper method to find index of any character from an array in a string
+       */
+  private indexOfAny;
+  /**
+       * Helper method to check if an object is a StringMarker
+       */
+  private isStringMarker;
+  private isTableEntry;
+}
+//#endregion
+//#region src/rom/rebuild/processor.d.ts
 /**
  * ROM rebuild processor
  * Converted from ext/GaiaLib/Rom/Rebuild/RomProcessor.cs
  */
 declare class RomProcessor {
-    private readonly writer;
-    constructor(writer: RomWriter);
-    repack(allFiles: ChunkFile[]): Promise<void>;
-    static applyPatches(asmFiles: ChunkFile[], patches: ChunkFile[]): void;
+  private readonly writer;
+  constructor(writer: RomWriter);
+  repack(allFiles: ChunkFile[]): Promise<void>;
+  static applyPatches(asmFiles: ChunkFile[], patches: ChunkFile[]): void;
 }
-
+//#endregion
+//#region src/rom/rebuild/assembler-context.d.ts
 /**
  * Shared context interface for assembler components
  * This eliminates circular dependencies between Assembler, AssemblerState, and StringProcessor
  */
 interface AssemblerContext {
-    readonly root: DbRoot;
-    readonly stringProcessor: StringProcessor;
-    currentBlock: AsmBlock | null;
-    lineBuffer: string;
-    blockIndex: number;
-    lastDelimiter: number | null;
-    blocks: AsmBlock[];
-    eof: boolean;
-    lineCount: number;
-    getLine(): boolean;
-    processRawData(): void;
-    parseOperand(operand: string): unknown;
-}
-
+  readonly root: DbRoot;
+  readonly stringProcessor: StringProcessor;
+  currentBlock: AsmBlock | null;
+  lineBuffer: string;
+  blockIndex: number;
+  lastDelimiter: number | null;
+  blocks: AsmBlock[];
+  eof: boolean;
+  lineCount: number;
+  getLine(): boolean;
+  processRawData(): void;
+  parseOperand(operand: string): unknown;
+}
+//#endregion
+//#region src/rom/rebuild/string-processor.d.ts
 /**
  * String processor for assembly parsing
  * Converted from GaiaLib/Rom/Rebuild/StringProcessor.cs
  */
 declare class StringProcessor {
-    private readonly memBuffer;
-    private readonly context;
-    private readonly root;
-    private readonly stringCharLookup;
-    constructor(context: AssemblerContext);
-    consumeString(typeChar: string): void;
-    private flushBuffer;
-    private processString;
-    private applyLayers;
-    private applyMap;
-    private processStringCommand;
-    private getShiftUp;
-}
-
+  private memBuffer;
+  private totalSize;
+  private fixedStr;
+  private readonly context;
+  private readonly root;
+  private readonly stringCharLookup;
+  constructor(context: AssemblerContext);
+  consumeString(typeChar: string): void;
+  private flushBuffer;
+  private processString;
+  private applyLayers;
+  private applyMap;
+  private processStringCommand;
+}
+//#endregion
+//#region src/rom/rebuild/sorted-map.d.ts
 /**
  * A map that sorts keys by length in descending order, then alphabetically
  * This is used for tag replacement where longer tags should be replaced first
  * to avoid conflicts (e.g., "ABCD" should be replaced before "ABC")
  */
 declare class SortedMap<V> {
-    private map;
-    private _keys;
-    get size(): number;
-    set(key: string, value: V): this;
-    get(key: string): V | undefined;
-    has(key: string): boolean;
-    delete(key: string): boolean;
-    clear(): void;
-    keys(): string[];
-    values(): V[];
-    entries(): [string, V][];
-    [Symbol.iterator](): Generator<[string, V], void, unknown>;
-    private sortKeys;
-}
-
+  private map;
+  private _keys;
+  get size(): number;
+  set(key: string, value: V): this;
+  get(key: string): V | undefined;
+  has(key: string): boolean;
+  delete(key: string): boolean;
+  clear(): void;
+  keys(): string[];
+  values(): V[];
+  entries(): [string, V][];
+  [Symbol.iterator](): Generator<[string, V], void, unknown>;
+  private sortKeys;
+}
+//#endregion
+//#region src/rom/rebuild/assembler.d.ts
 /**
  * Main assembler class for parsing assembly files
  * Converted from GaiaLib/Rom/Rebuild/Assembler.cs
  */
 declare class Assembler implements AssemblerContext {
-    readonly root: DbRoot;
-    private readonly lines;
-    private currentLineIndex;
-    readonly stringProcessor: StringProcessor;
-    lineBuffer: string;
-    includes: Set<string>;
+  readonly root: DbRoot;
+  private readonly lines;
+  private currentLineIndex;
+  readonly stringProcessor: StringProcessor;
+  lineBuffer: string;
+  includes: Set<string>;
+  blocks: AsmBlock[];
+  tags: SortedMap<string>;
+  currentBlock: AsmBlock | null;
+  lineCount: number;
+  blockIndex: number;
+  lastDelimiter: number | null;
+  reqBank: number | null;
+  eof: boolean;
+  strDelimRegex: RegExp;
+  constructor(dbRoot: DbRoot, textData: string);
+  parseAssembly(): {
     blocks: AsmBlock[];
-    tags: SortedMap<string>;
-    currentBlock: AsmBlock | null;
-    lineCount: number;
-    blockIndex: number;
-    lastDelimiter: number | null;
+    includes: Set<string>;
     reqBank: number | null;
-    eof: boolean;
-    strDelimRegex: RegExp;
-    constructor(dbRoot: DbRoot, textData: string);
-    parseAssembly(): {
-        blocks: AsmBlock[];
-        includes: Set<string>;
-        reqBank: number | null;
-    };
-    getLine(): boolean;
-    private trimComments;
-    private processDirectives;
-    private processTags;
-    private resolveTags;
-    parseOperand(opnd: string): unknown;
-    processRawData(): void;
-    private hexStringToBytes;
-}
-
+  };
+  getLine(): boolean;
+  private trimComments;
+  private processDirectives;
+  private processTags;
+  private resolveTags;
+  parseOperand(opnd: string): unknown;
+  processRawData(): void;
+  private hexStringToBytes;
+}
+//#endregion
+//#region src/rom/rebuild/assembler-state.d.ts
 /**
  * Assembler state machine for processing assembly text
  * Converted from GaiaLib/Rom/Rebuild/AssemblerState.cs
  */
 declare class AssemblerState {
-    private readonly dbStruct;
-    private readonly parentStruct;
-    private readonly root;
-    private readonly discriminator;
-    private delimiter;
-    private memberOffset;
-    private dataOffset;
-    private readonly memberTypes;
-    private currentType;
-    private readonly context;
-    constructor(context: AssemblerContext, structType?: string | null, saveDelimiter?: boolean);
-    private checkDisc;
-    private advancePart;
-    private processOrigin;
-    private static doMath;
-    private tryCreateLabel;
-    processText(openTag?: string): void;
-    private hexStringToBytes;
-}
-
+  private readonly dbStruct;
+  private readonly parentStruct;
+  private readonly root;
+  private readonly discriminator;
+  private delimiter;
+  private memberOffset;
+  private dataOffset;
+  private readonly memberTypes;
+  private currentType;
+  private readonly context;
+  constructor(context: AssemblerContext, structType?: string | null, saveDelimiter?: boolean);
+  private checkDisc;
+  private advancePart;
+  private processOrigin;
+  private static doMath;
+  private tryCreateLabel;
+  processText(openTag?: string): void;
+  private hexStringToBytes;
+}
+//#endregion
+//#region src/rom/generator.d.ts
 declare class RomGenerator {
-    readonly projectName?: string;
-    crc: number;
-    branchId: string;
-    dbRoot: DbRoot;
-    private sourceData;
-    constructor(projectName?: string);
-    initialize(): Promise<void>;
-    generateProject(modules: string[], manualFiles?: ChunkFile[], unshiftManualFiles?: boolean): Promise<Uint8Array>;
-    private applyProjectInit;
-    private assembleCodeFromText;
-    private generateAsmIncludeLookups;
-    applyPatchFile(chunkFile: ChunkFile, chunkFiles: ChunkFile[], asmFiles: ChunkFile[], patchFiles: ChunkFile[]): void;
-    private writeRom;
-}
-
+  readonly projectName?: string;
+  crc: number;
+  branchId: string;
+  dbRoot: DbRoot;
+  private sourceData;
+  constructor(projectName?: string);
+  initialize(): Promise<void>;
+  generateProject(modules: string[], manualFiles?: ChunkFile[], unshiftManualFiles?: boolean): Promise<Uint8Array>;
+  private applyProjectInit;
+  private assembleCodeFromText;
+  private generateAsmIncludeLookups;
+  applyPatchFile(chunkFile: ChunkFile, chunkFiles: ChunkFile[], asmFiles: ChunkFile[], patchFiles: ChunkFile[]): void;
+  private writeRom;
+}
+//#endregion
+//#region src/compression/QuintetLZ.d.ts
 /**
  * QuintetLZ compression algorithm implementation
  * Dictionary-based compression used in Quintet games
  */
 declare class QuintetLZ implements ICompressionProvider {
-    static readonly DICTIONARY_SIZE = 256;
-    static readonly DICTIONARY_INIT = 32;
-    static readonly DICTIONARY_OFFSET = 239;
-    private static readonly DEFAULT_PAGE_SIZE;
-    /**
-     * 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: Uint8Array, srcPosition?: number, srcLen?: number): Uint8Array;
-    /**
-     * Compact (compress) data using QuintetLZ algorithm
-     * @param srcData Source data to compress
-     * @returns Compressed data
-     */
-    compact(srcData: Uint8Array): Uint8Array;
-}
-
+  static readonly DICTIONARY_SIZE = 256;
+  static readonly DICTIONARY_INIT = 32;
+  static readonly DICTIONARY_OFFSET = 239;
+  private static readonly DEFAULT_PAGE_SIZE;
+  /**
+       * 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: Uint8Array, srcPosition?: number, srcLen?: number): Uint8Array;
+  /**
+       * Compact (compress) data using QuintetLZ algorithm
+       * @param srcData Source data to compress
+       * @returns Compressed data
+       */
+  compact(srcData: Uint8Array): Uint8Array;
+}
+//#endregion
+//#region src/compression/index.d.ts
 declare const CompressionAlgorithms: Record<string, () => ICompressionProvider>;
-
+//#endregion
+//#region src/sprites/SpriteFrame.d.ts
 /**
  * Represents a single frame in a sprite animation sequence
  */
 declare class SpriteFrame {
-    duration: number;
-    groupIndex: number;
-    /**
-     * Internal offset to the group data (not serialized)
-     */
-    groupOffset: number;
-    constructor(duration?: number, groupIndex?: number, groupOffset?: number);
+  duration: number;
+  groupIndex: number;
+  /**
+       * Internal offset to the group data (not serialized)
+       */
+  groupOffset: number;
+  constructor(duration?: number, groupIndex?: number, groupOffset?: number);
 }
-
+//#endregion
+//#region src/sprites/SpritePart.d.ts
 /**
  * Represents a single part/piece of a sprite
  */
 declare class SpritePart {
-    isLarge: boolean;
-    xOffset: number;
-    xOffsetMirror: number;
-    yOffset: number;
-    yOffsetMirror: number;
-    vMirror: boolean;
-    hMirror: boolean;
-    someOffset: number;
-    paletteIndex: number;
-    tileIndex: number;
-    constructor();
-}
-
+  isLarge: boolean;
+  xOffset: number;
+  xOffsetMirror: number;
+  yOffset: number;
+  yOffsetMirror: number;
+  vMirror: boolean;
+  hMirror: boolean;
+  someOffset: number;
+  paletteIndex: number;
+  tileIndex: number;
+  constructor();
+}
+//#endregion
+//#region src/sprites/SpriteGroup.d.ts
 /**
  * Represents a group of sprite parts that form a complete sprite frame
  */
 declare class SpriteGroup {
-    xOffset: number;
-    xOffsetMirror: number;
-    yOffset: number;
-    yOffsetMirror: number;
-    xRecoilHitboxOffset: number;
-    yRecoilHitboxOffset: number;
-    xRecoilHitboxTilesize: number;
-    yRecoilHitboxTilesize: number;
-    xHostileHitboxOffset: number;
-    xHostileHitboxSize: number;
-    yHostileHitboxOffset: number;
-    yHostileHitboxSize: number;
-    parts: SpritePart[];
-    constructor();
-}
-
+  xOffset: number;
+  xOffsetMirror: number;
+  yOffset: number;
+  yOffsetMirror: number;
+  xRecoilHitboxOffset: number;
+  yRecoilHitboxOffset: number;
+  xRecoilHitboxTilesize: number;
+  yRecoilHitboxTilesize: number;
+  xHostileHitboxOffset: number;
+  xHostileHitboxSize: number;
+  yHostileHitboxOffset: number;
+  yHostileHitboxSize: number;
+  parts: SpritePart[];
+  constructor();
+}
+//#endregion
+//#region src/sprites/SpriteMap.d.ts
 /**
  * Represents a complete sprite map with frame sets and groups
  */
 declare class SpriteMap {
-    frameSets: SpriteFrame[][];
-    groups: SpriteGroup[];
-    constructor();
-    /**
-     * Create a SpriteMap from binary data
-     * @param data Binary data buffer
-     * @returns SpriteMap instance
-     */
-    static fromBytes(data: Uint8Array): SpriteMap;
-    /**
-     * Convert this SpriteMap to binary data
-     * @returns Binary data buffer
-     */
-    toBytes(): Uint8Array;
-}
-
+  frameSets: SpriteFrame[][];
+  groups: SpriteGroup[];
+  constructor();
+  /**
+       * Create a SpriteMap from binary data
+       * @param data Binary data buffer
+       * @returns SpriteMap instance
+       */
+  static fromBytes(data: Uint8Array): SpriteMap;
+  /**
+       * Convert this SpriteMap to binary data
+       * @returns Binary data buffer
+       */
+  toBytes(): Uint8Array;
+}
+//#endregion
+//#region src/project/config.d.ts
 /**
  * Project configuration types
  * TODO: Implement comprehensive project configuration
  */
 interface ProjectConfig {
-    name: string;
-    version: string;
-    description?: string;
+  name: string;
+  version: string;
+  description?: string;
 }
-
+//#endregion
+//#region src/collaboration/index.d.ts
 /**
  * Collaboration types and utilities
  * TODO: Implement collaboration functionality
  */
 interface CollaborationConfig {
-    enabled: boolean;
+  enabled: boolean;
 }
-
+//#endregion
+//#region src/supabase/types.d.ts
 /**
  * TypeScript interfaces for Supabase API responses
  * These types represent the structured data returned from ROM database queries
  */
 interface PlatformData {
-    id: string;
-    name: string;
-    meta: any | null;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  name: string;
+  meta: any | null;
+  createdAt: string;
+  updatedAt: string;
 }
 interface BranchBaseData {
-    id: string;
-    name: string | null;
-    version: number | null;
-    isActive?: boolean | null;
-    notes?: string[] | null;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  name: string | null;
+  version: number | null;
+  isActive?: boolean | null;
+  notes?: string[] | null;
+  createdAt: string;
+  updatedAt: string;
 }
 interface FileBaseData {
-    id: string;
-    name: string;
-    type: string;
-    version: number | null;
-    crc: number | null;
-    meta: any | null;
-    isText: boolean;
-    text: string | null;
-    data: Uint8Array | null;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  name: string;
+  type: string;
+  version: number | null;
+  crc: number | null;
+  meta: any | null;
+  isText: boolean;
+  text: string | null;
+  data: Uint8Array | null;
+  createdAt: string;
+  updatedAt: string;
 }
 interface FileBaseRaw extends Omit<FileBaseData, 'data'> {
-    data: string | null;
+  data: string | null;
 }
 /**
  * Platform branch information containing instruction set and addressing modes
  */
 interface PlatformBranchData extends BranchBaseData {
-    platformId: string;
-    addressingModes: any | null;
-    instructionSet: any | null;
-    vectors: any | null;
-    types: any | null;
-    platform: PlatformData;
+  platformId: string;
+  addressingModes: any | null;
+  instructionSet: any | null;
+  vectors: any | null;
+  types: any | null;
+  platform: PlatformData;
 }
 /**
  * Game ROM branch information with platform reference
  */
 interface GameRomBranchData extends BranchBaseData {
-    gameRomId: string;
-    platformBranchId: string;
-    coplib: any | null;
-    config: any | null;
-    files: any | null;
-    blocks: any | null;
-    fixups: any | null;
-    strings: any | null;
-    structs: any | null;
-    scenes: any | null;
-    gameRom: GameRomData;
-    platformBranch: PlatformBranchData;
+  gameRomId: string;
+  platformBranchId: string;
+  coplib: any | null;
+  config: any | null;
+  files: any | null;
+  blocks: any | null;
+  fixups: any | null;
+  strings: any | null;
+  structs: any | null;
+  scenes: any | null;
+  gameRom: GameRomData;
+  platformBranch: PlatformBranchData;
 }
 interface GameRomArtifactData extends FileBaseData {
-    gameRomId: string;
+  gameRomId: string;
 }
 interface GameRomArtifactRaw extends FileBaseRaw {
-    gameRomId: string;
+  gameRomId: string;
 }
 interface GameRomBranchArtifactRaw {
-    id: string;
-    branchId: string;
-    artifactId: string;
-    artifact: GameRomArtifactRaw;
+  id: string;
+  branchId: string;
+  artifactId: string;
+  artifact: GameRomArtifactRaw;
 }
 /**
  * Base ROM information
  */
 interface BaseRomData {
-    id: string;
-    name: string;
-    gameId: string;
-    gameRomId: string;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  name: string;
+  gameId: string;
+  gameRomId: string;
+  createdAt: string;
+  updatedAt: string;
 }
 interface GameData {
-    id: string;
-    name: string;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
 }
 interface RegionData {
-    id: string;
-    name: string;
-    meta: any | null;
-    platformId: string;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  name: string;
+  meta: any | null;
+  platformId: string;
+  createdAt: string;
+  updatedAt: string;
 }
 interface GameRomData {
-    id: string;
-    crc: number;
-    meta: any | null;
-    gameId: string;
-    regionId: string;
-    createdAt: string;
-    updatedAt: string;
-    game: GameData;
-    region: RegionData;
+  id: string;
+  crc: number;
+  meta: any | null;
+  gameId: string;
+  regionId: string;
+  createdAt: string;
+  updatedAt: string;
+  game: GameData;
+  region: RegionData;
 }
 /**
  * Base ROM branch with complete relationship chain
  */
 interface BaseRomBranchData extends BranchBaseData {
-    baseRomId: string;
-    gameRomBranchId: string;
-    gameRomBranch: GameRomBranchData;
-    baseRom: BaseRomData;
+  baseRomId: string;
+  gameRomBranchId: string;
+  gameRomBranch: GameRomBranchData;
+  baseRom: BaseRomData;
 }
 /**
  * Base ROM file containing binary data
  */
 interface BaseRomFileData extends FileBaseData {
-    baseRomId: string;
+  baseRomId: string;
 }
 interface BaseRomBranchFileRaw {
-    id: string;
-    branchId: string;
-    fileId: string;
-    file: BaseRomFileRaw;
+  id: string;
+  branchId: string;
+  fileId: string;
+  file: BaseRomFileRaw;
 }
 /**
  * Raw BaseRomFile data as returned from Supabase (before conversion)
  */
 interface BaseRomFileRaw extends FileBaseRaw {
-    baseRomId: string;
+  baseRomId: string;
 }
 /**
  * Complete ROM payload containing branch data and files
  */
 interface BaseRomPayload {
-    baseRomBranch: BaseRomBranchData;
-    files: BaseRomFileData[];
+  baseRomBranch: BaseRomBranchData;
+  files: BaseRomFileData[];
 }
 /**
  * Options for loading ROM data by name
  */
 interface FromSupabaseByNameOptions {
-    /**
-     * Name of the game to load
-     * @default 'Illusion of Gaia'
-     */
-    gameName: string;
-    /**
-     * Name of the base ROM to load
-     * @default 'GaiaLabs BaseROM'
-     */
-    baseRomName: string;
-    /**
-     * Name of the branch to load
-     * Set to null to load the main/develop branch
-     * Set to undefined to not filter by branch name
-     */
-    branchName?: string | null;
-    /**
-     * Version of the branch to load
-     * Set to null to load the latest/main version
-     * Set to undefined to not filter by version
-     */
-    branchVersion?: number | null;
+  /**
+       * Name of the game to load
+       * @default 'Illusion of Gaia'
+       */
+  gameName: string;
+  /**
+       * Name of the base ROM to load
+       * @default 'GaiaLabs BaseROM'
+       */
+  baseRomName: string;
+  /**
+       * Name of the branch to load
+       * Set to null to load the main/develop branch
+       * Set to undefined to not filter by branch name
+       */
+  branchName?: string | null;
+  /**
+       * Version of the branch to load
+       * Set to null to load the latest/main version
+       * Set to undefined to not filter by version
+       */
+  branchVersion?: number | null;
 }
 /**
  * Error codes for Supabase operations
  */
 declare enum SupabaseErrorCode {
-    BRANCH_NOT_FOUND = "BRANCH_NOT_FOUND",
-    ROM_NOT_FOUND = "ROM_NOT_FOUND",
-    FILES_NOT_FOUND = "FILES_NOT_FOUND",
-    NETWORK_ERROR = "NETWORK_ERROR",
-    INVALID_DATA = "INVALID_DATA",
-    ENVIRONMENT_ERROR = "ENVIRONMENT_ERROR",
-    PERMISSION_ERROR = "PERMISSION_ERROR"
+  BRANCH_NOT_FOUND = "BRANCH_NOT_FOUND",
+  ROM_NOT_FOUND = "ROM_NOT_FOUND",
+  FILES_NOT_FOUND = "FILES_NOT_FOUND",
+  NETWORK_ERROR = "NETWORK_ERROR",
+  INVALID_DATA = "INVALID_DATA",
+  ENVIRONMENT_ERROR = "ENVIRONMENT_ERROR",
+  PERMISSION_ERROR = "PERMISSION_ERROR",
 }
 /**
  * Custom error class for Supabase operations
  */
 declare class SupabaseFromError extends Error {
-    readonly code: SupabaseErrorCode;
-    readonly details?: any;
-    constructor(message: string, code: SupabaseErrorCode, details?: any);
+  readonly code: SupabaseErrorCode;
+  readonly details?: any;
+  constructor(message: string, code: SupabaseErrorCode, details?: any);
 }
 /**
  * Result type for async operations that may fail
  */
 type SupabaseResult<T> = {
-    data: T;
-    error: null;
+  data: T;
+  error: null;
 } | {
-    data: null;
-    error: SupabaseFromError;
+  data: null;
+  error: SupabaseFromError;
 };
 /**
  * Project information
  */
 interface ProjectData {
-    id: string;
-    name: string;
-    meta: any | null;
-    gameId: string;
-    baseRomId: string;
-    createdAt: string;
-    updatedAt: string;
+  id: string;
+  name: string;
+  meta: any | null;
+  gameId: string;
+  baseRomId: string;
+  createdAt: string;
+  updatedAt: string;
 }
 /**
  * Project branch with complete relationship chain
  */
 interface ProjectBranchData extends BranchBaseData {
-    projectId: string;
-    baseRomBranchId: string;
-    modules: any[];
-    project: ProjectData;
-    baseRomBranch: BaseRomBranchData;
+  projectId: string;
+  baseRomBranchId: string;
+  modules: any[];
+  project: ProjectData;
+  baseRomBranch: BaseRomBranchData;
 }
 /**
  * Project file containing binary data
  */
 interface ProjectFileData extends FileBaseData {
-    module: string | null;
-    projectId: string;
+  module: string | null;
+  projectId: string;
 }
 interface ProjectBranchFileRaw {
-    id: string;
-    branchId: string;
-    fileId: string;
-    file: ProjectFileRaw;
+  id: string;
+  branchId: string;
+  fileId: string;
+  file: ProjectFileRaw;
 }
 /**
  * Raw ProjectFile data as returned from Supabase (before conversion)
  */
 interface ProjectFileRaw extends FileBaseRaw {
-    module: string | null;
-    projectId: string;
+  module: string | null;
+  projectId: string;
 }
 /**
  * Complete Project payload containing branch data and files
  */
 interface ProjectPayload {
-    projectBranch: ProjectBranchData;
-    projectFiles: ProjectFileData[];
-    baseRomBranch: BaseRomBranchData;
-    baseRomFiles: BaseRomFileData[];
+  projectBranch: ProjectBranchData;
+  projectFiles: ProjectFileData[];
+  baseRomBranch: BaseRomBranchData;
+  baseRomFiles: BaseRomFileData[];
 }
 /**
  * Options for loading Project data by name
  */
 interface FromSupabaseByProjectOptions {
-    projectName: string;
-    /**
-     * Name of the branch to load
-     * Set to null to load the main/develop branch
-     * Set to undefined to not filter by branch name
-     */
-    branchName?: string | null;
-    /**
-     * Version of the branch to load
-     * Set to null to load the latest/main version
-     * Set to undefined to not filter by version
-     */
-    branchVersion?: number | null;
+  projectName: string;
+  /**
+       * Name of the branch to load
+       * Set to null to load the main/develop branch
+       * Set to undefined to not filter by branch name
+       */
+  branchName?: string | null;
+  /**
+       * Version of the branch to load
+       * Set to null to load the latest/main version
+       * Set to undefined to not filter by version
+       */
+  branchVersion?: number | null;
 }
 /**
  * Query statistics for performance monitoring
  */
 interface QueryStats {
-    branchQueryTime: number;
-    fileQueryTime: number;
-    totalTime: number;
-    fileCount: number;
+  branchQueryTime: number;
+  fileQueryTime: number;
+  totalTime: number;
+  fileCount: number;
 }
-
-/**
- * Supabase client configuration and initialization
- */
-
+//#endregion
+//#region src/supabase/client.d.ts
 /**
  * Database interface definitions based on Prisma schema
  * These types represent the structure of data returned from Supabase queries
  */
 interface Database {
-    public: {
-        Tables: {
-            BaseRom: {
-                Row: {
-                    id: string;
-                    name: string;
-                    gameId: string;
-                    gameRomId: string;
-                    createdAt: string;
-                    updatedAt: string;
-                };
-            };
-            BaseRomBranch: {
-                Row: {
-                    id: string;
-                    name: string | null;
-                    version: number | null;
-                    isPublic: boolean;
-                    baseRomId: string;
-                    gameRomBranchId: string;
-                    fileCrcs: number[];
-                    createdAt: string;
-                    updatedAt: string;
-                };
-            };
-            GameRomBranch: {
-                Row: {
-                    id: string;
-                    name: string | null;
-                    version: number | null;
-                    isPublic: boolean;
-                    gameRomId: string;
-                    platformBranchId: string;
-                    coplib: any | null;
-                    config: any | null;
-                    files: any | null;
-                    blocks: any | null;
-                    fixups: any | null;
-                    strings: any | null;
-                    structs: any | null;
-                    scenes: any | null;
-                    createdAt: string;
-                    updatedAt: string;
-                };
-            };
-            GameRomBranchAsset: {
-                Row: {
-                    id: string;
-                    name: string;
-                    type: string;
-                    gameRomBranchId: string;
-                    text: string | null;
-                    data: string | null;
-                    createdAt: string;
-                    updatedAt: string;
-                };
-            };
-            PlatformBranch: {
-                Row: {
-                    id: string;
-                    name: string | null;
-                    version: number | null;
-                    isPublic: boolean;
-                    platformId: string;
-                    addressingModes: any | null;
-                    instructionSet: any | null;
-                    vectors: any | null;
-                    createdAt: string;
-                    updatedAt: string;
-                };
-            };
-            BaseRomFile: {
-                Row: {
-                    id: string;
-                    name: string;
-                    type: string;
-                    version: number | null;
-                    crc: number | null;
-                    meta: any | null;
-                    baseRomId: string;
-                    data: string;
-                    createdAt: string;
-                    updatedAt: string;
-                };
-            };
+  public: {
+    Tables: {
+      BaseRom: {
+        Row: {
+          id: string;
+          name: string;
+          gameId: string;
+          gameRomId: string;
+          createdAt: string;
+          updatedAt: string;
+        };
+      };
+      BaseRomBranch: {
+        Row: {
+          id: string;
+          name: string | null;
+          version: number | null;
+          isPublic: boolean;
+          baseRomId: string;
+          gameRomBranchId: string;
+          fileCrcs: number[];
+          createdAt: string;
+          updatedAt: string;
+        };
+      };
+      GameRomBranch: {
+        Row: {
+          id: string;
+          name: string | null;
+          version: number | null;
+          isPublic: boolean;
+          gameRomId: string;
+          platformBranchId: string;
+          coplib: any | null;
+          config: any | null;
+          files: any | null;
+          blocks: any | null;
+          fixups: any | null;
+          strings: any | null;
+          structs: any | null;
+          scenes: any | null;
+          createdAt: string;
+          updatedAt: string;
+        };
+      };
+      GameRomBranchAsset: {
+        Row: {
+          id: string;
+          name: string;
+          type: string;
+          gameRomBranchId: string;
+          text: string | null;
+          data: string | null;
+          createdAt: string;
+          updatedAt: string;
+        };
+      };
+      PlatformBranch: {
+        Row: {
+          id: string;
+          name: string | null;
+          version: number | null;
+          isPublic: boolean;
+          platformId: string;
+          addressingModes: any | null;
+          instructionSet: any | null;
+          vectors: any | null;
+          createdAt: string;
+          updatedAt: string;
+        };
+      };
+      BaseRomFile: {
+        Row: {
+          id: string;
+          name: string;
+          type: string;
+          version: number | null;
+          crc: number | null;
+          meta: any | null;
+          baseRomId: string;
+          data: string;
+          createdAt: string;
+          updatedAt: string;
         };
+      };
     };
+  };
 }
 /**
  * Create and configure a Supabase client instance
@@ -2036,14 +2116,8 @@ declare function getSupabaseClient(): SupabaseClient<Database>;
  * Reset the singleton client instance (useful for testing)
  */
 declare function resetSupabaseClient(): void;
-
-/**
- * ROM data loading functions for Supabase integration
- *
- * This module provides functions to load ROM branch data and files from Supabase,
- * enabling cloud-based ROM database functionality for the GaiaLabs platform.
- */
-
+//#endregion
+//#region src/supabase/rom-loader.d.ts
 /**
  * Load ROM data from Supabase using a BaseRomBranch ID
  *
@@ -2116,7 +2190,8 @@ declare function fromSupabaseByName(options: FromSupabaseByNameOptions): Promise
 declare function fromSupabaseByProject(projectName?: string, branchId?: string): Promise<ProjectPayload>;
 declare function fromSupabaseByGameRom(gameName?: string, regionName?: string, platformName?: string, branchId?: string): Promise<ProjectPayload>;
 declare function summaryFromSupabaseByProject(projectName?: string): Promise<ProjectBranchData>;
-
+//#endregion
+//#region src/supabase/utils.d.ts
 /**
  * Utility functions for Supabase integration
  */
@@ -2158,13 +2233,14 @@ declare function uint8ArrayToBase64(uint8Array: Uint8Array): string;
  * @throws {Error} If any required environment variable is missing
  */
 declare function validateEnvironmentVariables(requiredVars: string[]): void;
-
+//#endregion
+//#region src/utils/file.d.ts
 /**
  * Universal file reading utilities
  * Works in both Node.js and browser environments
  */
 interface FileReadOptions {
-    encoding?: 'utf8' | 'binary';
+  encoding?: 'utf8' | 'binary';
 }
 /**
  * Read a file as text
@@ -2212,10 +2288,10 @@ declare function createTempDirectory(prefix: string): Promise<string>;
  */
 declare function removeDirectory(dirPath: string): Promise<void>;
 interface DirectoryEntry {
-    name: string;
-    path: string;
-    isDirectory: boolean;
-    isFile: boolean;
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  isFile: boolean;
 }
 /**
  * List directory contents
@@ -2225,9 +2301,9 @@ interface DirectoryEntry {
  * @returns Promise<DirectoryEntry[]>
  */
 declare function listDirectory(dirPath: string, options?: {
-    recursive?: boolean;
-    filter?: (entry: DirectoryEntry) => boolean;
-    extension?: string;
+  recursive?: boolean;
+  filter?: (entry: DirectoryEntry) => boolean;
+  extension?: string;
 }): Promise<DirectoryEntry[]>;
 /**
  * Save text content to a file
@@ -2245,11 +2321,13 @@ declare function saveFileAsText(path: string, text: string): Promise<void>;
  * @returns Promise<void>
  */
 declare function saveFileAsBinary(path: string, data: Uint8Array): Promise<void>;
-
+//#endregion
+//#region src/utils/crc.d.ts
 declare function crc32_buffer(data: Uint8Array): number;
 declare function crc32_text_utf8(text: string): number;
 declare function crc32_text_utf16(text: string): number;
-
+//#endregion
+//#region src/utils/base64.d.ts
 /**
  * Base64 encoding and decoding utilities for Uint8Arrays
  * Works in both Node.js and browser environments
@@ -2286,25 +2364,27 @@ declare function encodeBase64String(text: string): string;
  * @throws {Error} If the input is not a valid base64 string or doesn't contain valid UTF-8
  */
 declare function decodeBase64String(base64String: string): string;
-
+//#endregion
+//#region src/utils/debug-export.d.ts
 /**
  * Debug utility to export processing results as JSON for comparison
  */
 declare class DebugExporter {
-    /**
-     * Export chunk files to JSON for comparison with C# output
-     */
-    static exportChunkFiles(files: ChunkFile[], filename: string): void;
-    /**
-     * Export patch application summary
-     */
-    static exportPatchSummary(originalFiles: ChunkFile[], patchedFiles: ChunkFile[], patches: ChunkFile[], filename: string): void;
-    /**
-     * Export layout debugging information
-     */
-    static exportLayoutDebug(files: ChunkFile[], filename: string): void;
-}
-
+  /**
+       * Export chunk files to JSON for comparison with C# output
+       */
+  static exportChunkFiles(files: ChunkFile[], filename: string): void;
+  /**
+       * Export patch application summary
+       */
+  static exportPatchSummary(originalFiles: ChunkFile[], patchedFiles: ChunkFile[], patches: ChunkFile[], filename: string): void;
+  /**
+       * Export layout debugging information
+       */
+  static exportLayoutDebug(files: ChunkFile[], filename: string): void;
+}
+//#endregion
+//#region src/utils/index.d.ts
 /**
  * Convert bytes to hex string
  */
@@ -2345,7 +2425,8 @@ declare function binaryToUtf8String(binaryData: Uint8Array): string;
  */
 declare function getNestedProperty(obj: any, path: string): any;
 declare function indexOfAny(str: string, chars: string[], startIndex?: number): number;
-
+//#endregion
+//#region src/index.d.ts
 /**
  * GaiaCore - Universal ROM processing engine
  *
@@ -2366,5 +2447,6 @@ declare const GAIA_CORE_VERSION = "0.1.6";
 declare const isPlatformBrowser: boolean;
 declare const isPlatformNode: string;
 declare const isPlatformWebWorker: boolean;
-
-export { Address, AddressSpace, AddressType, AddressingModeHandler, AsmBlock, AsmBlockUtils, AsmReader, Assembler, type AssemblerContext, AssemblerState, type BaseRomBranchData, type BaseRomBranchFileRaw, type BaseRomData, type BaseRomFileData, type BaseRomFileRaw, type BaseRomPayload, BinType, BitStream, BlockReader, BlockReaderConstants, BlockWriter, type BranchBaseData, Byte, ChunkFile, ChunkFileUtils, type CollaborationConfig, CompressionAlgorithms, CompressionRegistry, CopCommandProcessor, CopDef, type Database, DbAddressingMode, type DbAsset, type DbBaseRomModule, DbBlock, type DbConfig, type DbEntryPoint, DbFile, DbFileType, type DbGameRomModule, DbGroup, type DbLabel, type DbMnemonic, DbOverride, DbPart, type DbPath, type DbRewrite, type DbRoot, DbRootUtils, DbScene, type DbSfx, DbStringCommand, type DbStringLayer, DbStringType, DbStringTypeUtils, DbStruct, DbTransform, DebugExporter, type DirectoryEntry, type FileBaseData, type FileBaseRaw, type FileReadOptions, type FromSupabaseByNameOptions, type FromSupabaseByProjectOptions, GAIA_CORE_VERSION, type GameData, type GameRomArtifactData, type GameRomArtifactRaw, type GameRomBranchArtifactRaw, type GameRomBranchData, type GameRomData, type ICompressionProvider, LocationWrapper, Long, MapExt, MemberType, ObjectType, Op, OpCode, OperationContext, type PlatformBranchData, type PlatformData, PostProcessor, ProcessorStateManager, type ProjectBranchData, type ProjectBranchFileRaw, type ProjectConfig, type ProjectData, type ProjectFileData, type ProjectFileRaw, type ProjectPayload, type QueryStats, QuintetLZ, ReferenceManager, type RegionData, RegisterType, Registers, RomDataReader, RomGenerator, RomLayout, RomProcessingConstants, RomProcessor, RomState, RomStateUtils, RomWriter, SortedMap, SpriteFrame, SpriteGroup, SpriteMap, SpritePart, Stack, StackOperations, StatusFlags, type StringEntry, type StringMarker, StringProcessor, StringReader, StringSizeComparer, type StringWrapper, type StructDef, SupabaseErrorCode, SupabaseFromError, type SupabaseResult, type TableEntry, TransformProcessor, TypeParser, TypedNumber, Word, type XformDef, XformType, base64ToUint8Array, binaryToUtf8String, bytesToHex, clamp, crc32_buffer, crc32_text_utf16, crc32_text_utf8, createChunkFileFromDbBlock, createChunkFileFromDbFile, createDbPath, createSupabaseClient, createTableEntry, createTempDirectory, decodeBase64, decodeBase64String, decodeDataString, encodeBase64, encodeBase64String, fileExists, fromSupabaseByGameRom, fromSupabaseById, fromSupabaseByName, fromSupabaseByProject, getDirectory, getEnvVar, getNestedProperty, getSupabaseClient, hexToBytes, hexToUint8Array, indexOfAny, isPlatformBrowser, isPlatformNode, isPlatformWebWorker, isValidBase64, listDirectory, readFileAsBinary, readFileAsText, readJsonFile, removeDirectory, resetSupabaseClient, saveFileAsBinary, saveFileAsText, summaryFromSupabaseByProject, uint8ArrayToBase64, validateEnvironmentVariables };
+//#endregion
+export { Address, AddressSpace, AddressType, AddressingModeHandler, AsmBlock, AsmBlockUtils, AsmReader, Assembler, AssemblerContext, AssemblerState, BaseRomBranchData, BaseRomBranchFileRaw, BaseRomData, BaseRomFileData, BaseRomFileRaw, BaseRomPayload, BinType, BitStream, BlockReader, BlockReaderConstants, BlockWriter, BranchBaseData, Byte, ChunkFile, ChunkFileUtils, CollaborationConfig, CompressionAlgorithms, CompressionRegistry, CopCommandProcessor, CopDef, Database, DbAddressingMode, DbAsset, DbBaseRomModule, DbBlock, DbConfig, DbEntryPoint, DbFile, DbFileType, DbGameRomModule, DbGroup, DbLabel, DbMnemonic, DbOverride, DbPart, DbPath, DbRewrite, DbRoot, DbRootUtils, DbScene, DbSfx, DbStringCommand, DbStringDictionary, DbStringLayer, DbStringType, DbStringTypeUtils, DbStruct, DbTransform, DebugExporter, DirectoryEntry, FileBaseData, FileBaseRaw, FileReadOptions, FromSupabaseByNameOptions, FromSupabaseByProjectOptions, GAIA_CORE_VERSION, GameData, GameRomArtifactData, GameRomArtifactRaw, GameRomBranchArtifactRaw, GameRomBranchData, GameRomData, ICompressionProvider, LocationWrapper, Long, MapExt, MemberType, MemoryMapMode, ObjectType, Op, OpCode, OperationContext, PlatformBranchData, PlatformData, PostProcessor, ProcessorStateManager, ProjectBranchData, ProjectBranchFileRaw, ProjectConfig, ProjectData, ProjectFileData, ProjectFileRaw, ProjectPayload, QueryStats, QuintetLZ, ReferenceManager, RegionData, RegisterType, Registers, RomDataReader, RomGenerator, RomLayout, RomProcessingConstants, RomProcessor, RomState, RomStateUtils, RomWriter, SortedMap, SpriteFrame, SpriteGroup, SpriteMap, SpritePart, Stack, StackOperations, StatusFlags, StringEntry, StringMarker, StringProcessor, StringReader, StringSizeComparer, StringWrapper, StructDef, SupabaseErrorCode, SupabaseFromError, SupabaseResult, TableEntry, TransformProcessor, TypeParser, TypedNumber, Word, XformDef, XformType, base64ToUint8Array, binaryToUtf8String, bytesToHex, clamp, crc32_buffer, crc32_text_utf16, crc32_text_utf8, createChunkFileFromDbBlock, createChunkFileFromDbFile, createDbPath, createSupabaseClient, createTempDirectory, decodeBase64, decodeBase64String, decodeDataString, encodeBase64, encodeBase64String, fileExists, fromSupabaseByGameRom, fromSupabaseById, fromSupabaseByName, fromSupabaseByProject, getDirectory, getEnvVar, getNestedProperty, getSupabaseClient, hexToBytes, hexToUint8Array, indexOfAny, isPlatformBrowser, isPlatformNode, isPlatformWebWorker, isValidBase64, listDirectory, readFileAsBinary, readFileAsText, readJsonFile, removeDirectory, resetSupabaseClient, saveFileAsBinary, saveFileAsText, summaryFromSupabaseByProject, uint8ArrayToBase64, validateEnvironmentVariables };
+//# sourceMappingURL=index.d.mts.map