@gaialabs/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1015 @@
+import { DbRoot, BinType, DbPath, AddressingMode, AddressType, StatusFlags, CopDef, DbStringType, StringWrapper, DbBlock, DbPart, Address } from 'gaia-shared';
+export { DbRoot } from 'gaia-shared';
+
+/**
+ * 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);
+}
+
+/**
+ * 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();
+}
+
+/**
+ * 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();
+}
+
+/**
+ * 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;
+}
+
+/**
+ * ROM state management for SNES hardware emulation
+ * Converted from GaiaLib/Rom/RomState.cs
+ */
+declare class RomState {
+    readonly cgram: Uint8Array<ArrayBuffer>;
+    readonly vram: Uint8Array<ArrayBuffer>;
+    readonly mainTileset: Uint8Array<ArrayBuffer>;
+    readonly effectTileset: Uint8Array<ArrayBuffer>;
+    mainTilesetPath?: string;
+    effectTilesetPath?: string;
+    mainTilemap: Uint8Array<ArrayBuffer>;
+    mainTilemapW: number;
+    mainTilemapH: number;
+    mainTilemapPath?: string;
+    effectTilemap: Uint8Array<ArrayBuffer>;
+    effectTilemapW: number;
+    effectTilemapH: number;
+    effectTilemapPath?: string;
+    static spriteMap: SpriteMap | null;
+    static spriteMapPath: string | null;
+    /**
+     * Strip address space prefixes from names
+     */
+    static stripName(name: string): string;
+    /**
+     * Create ROM state from scene metadata
+     * Simplified version of the C# implementation
+     */
+    static fromScene(baseDir: string, root: DbRoot, metaFile: string, id: number): Promise<RomState>;
+    /**
+     * Process scene command (simplified version)
+     * TODO: Implement full command processing
+     */
+    private static processCommand;
+}
+/**
+ * ROM state utilities
+ */
+declare class RomStateUtils {
+    /**
+     * Create empty ROM state
+     */
+    static createEmpty(): RomState;
+    /**
+     * Clear all data in ROM state
+     */
+    static clear(state: RomState): void;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Main project management class
+ * Converted from GaiaLib/ProjectRoot.cs
+ */
+interface ProjectConfig {
+    name: string;
+    romPath: string;
+    baseDir: string;
+    system?: string;
+    database: string;
+    flipsPath?: string;
+    resources: Record<BinType, DbPath>;
+    databasePath?: string;
+    systemPath?: string;
+    compression?: string;
+}
+/**
+ * Project root management
+ */
+declare class ProjectRoot {
+    config: ProjectConfig;
+    name: string;
+    romPath: string;
+    baseDir: string;
+    system?: string;
+    database: string;
+    flipsPath?: string;
+    resources: Record<BinType, DbPath>;
+    databasePath?: string;
+    systemPath?: string;
+    compression?: string;
+    constructor(config: ProjectConfig);
+    /**
+     * Get compression provider
+     */
+    getCompression(): ICompressionProvider;
+    /**
+     * Load project from file or directory
+     */
+    static load(path?: string): Promise<ProjectRoot>;
+    /**
+     * Build the ROM (simplified)
+     */
+    build(): Promise<void>;
+    /**
+     * Dump database and extract ROM data
+     */
+    dumpDatabase(): Promise<DbRoot>;
+}
+
+/**
+ * Unified ROM processor providing high-level APIs for common ROM processing workflows
+ * This is the main entry point for ROM processing operations
+ */
+declare class RomProcessor {
+    private projectRoot;
+    private dbRoot;
+    private romData;
+    private romState;
+    constructor(projectConfig: ProjectConfig);
+    /**
+     * Create ROM processor from project file or directory
+     */
+    static fromProject(path?: string): Promise<RomProcessor>;
+    /**
+     * Load ROM data from file or URL
+     */
+    loadRom(romPath?: string): Promise<void>;
+    /**
+     * Initialize database and load ROM metadata
+     */
+    initialize(): Promise<void>;
+    /**
+     * Analyze ROM structure and extract metadata
+     */
+    analyze(): Promise<RomAnalysisResult>;
+    /**
+     * Extract files from ROM data
+     */
+    extract(outputDir: string): Promise<ExtractionResult>;
+    /**
+     * Process scene data for a specific scene ID
+     */
+    processScene(sceneId: number, metaFile: string): Promise<RomState>;
+    /**
+     * Build ROM from extracted files
+     */
+    build(outputPath: string): Promise<BuildResult>;
+    /**
+     * Get compression provider for the project
+     */
+    getCompression(): QuintetLZ;
+    /**
+     * Get current ROM state
+     */
+    getRomState(): RomState | null;
+    /**
+     * Get database root
+     */
+    getDatabase(): DbRoot | null;
+    /**
+     * Get project configuration
+     */
+    getProject(): ProjectRoot;
+    private analyzeHeader;
+    private detectCompression;
+    private analyzeOpcodes;
+}
+interface RomAnalysisResult {
+    romSize: number;
+    headerInfo: RomHeaderInfo;
+    entryPoints: any[];
+    fileCount: number;
+    blockCount: number;
+    compressionUsed: boolean;
+    spriteMapFound: boolean;
+    opcodeStats: OpcodeStats;
+}
+interface RomHeaderInfo {
+    title: string;
+    mapMode: number;
+    cartridgeType: number;
+    romSize: number;
+    ramSize: number;
+    isValid: boolean;
+}
+interface ExtractionResult {
+    extractedFiles: string[];
+    errors: string[];
+    totalSize: number;
+}
+interface BuildResult {
+    success: boolean;
+    outputPath: string;
+    romSize: number;
+    errors: string[];
+}
+interface OpcodeStats {
+    totalOpcodes: number;
+    uniqueOpcodes: number;
+    coverage: number;
+}
+
+/**
+ * Project lifecycle management events
+ */
+interface ProjectEvents {
+    onLoadStart?: () => void;
+    onLoadComplete?: (processor: RomProcessor) => void;
+    onLoadError?: (error: Error) => void;
+    onAnalysisStart?: () => void;
+    onAnalysisComplete?: (results: any) => void;
+    onExtractionStart?: () => void;
+    onExtractionComplete?: (results: any) => void;
+    onBuildStart?: () => void;
+    onBuildComplete?: (results: any) => void;
+}
+/**
+ * Project status tracking
+ */
+interface ProjectStatus {
+    isLoaded: boolean;
+    isAnalyzed: boolean;
+    isExtracted: boolean;
+    canBuild: boolean;
+    lastError?: Error;
+    progress: number;
+    currentTask?: string;
+}
+/**
+ * Unified project manager for complete project lifecycle management
+ * This is the highest-level API for managing ROM hacking projects
+ */
+declare class ProjectManager {
+    private processor;
+    private status;
+    private events;
+    constructor(events?: ProjectEvents);
+    /**
+     * Create project manager from existing project configuration
+     */
+    static fromConfig(config: ProjectConfig, events?: ProjectEvents): Promise<ProjectManager>;
+    /**
+     * Create project manager from project file or directory
+     */
+    static fromPath(path: string, events?: ProjectEvents): Promise<ProjectManager>;
+    /**
+     * Load project from configuration
+     */
+    loadProject(config: ProjectConfig): Promise<void>;
+    /**
+     * Load project from file or directory path
+     */
+    loadProjectFromPath(path: string): Promise<void>;
+    /**
+     * Analyze ROM structure and extract metadata
+     */
+    analyzeRom(): Promise<any>;
+    /**
+     * Extract files from ROM
+     */
+    extractFiles(outputDir: string): Promise<any>;
+    /**
+     * Build ROM from extracted files
+     */
+    buildRom(outputPath: string): Promise<any>;
+    /**
+     * Process specific scene
+     */
+    processScene(sceneId: number, metaFile: string): Promise<RomState>;
+    /**
+     * Get current project status
+     */
+    getStatus(): ProjectStatus;
+    /**
+     * Get the ROM processor instance
+     */
+    getProcessor(): RomProcessor | null;
+    /**
+     * Get project configuration
+     */
+    getProjectConfig(): ProjectConfig | null;
+    /**
+     * Get database root
+     */
+    getDatabase(): DbRoot | null;
+    /**
+     * Get ROM state
+     */
+    getRomState(): RomState | null;
+    /**
+     * Reset project to initial state
+     */
+    reset(): void;
+    /**
+     * Complete workflow: load, analyze, extract, and build
+     */
+    completeWorkflow(projectPath: string, outputDir: string, outputRomPath: string): Promise<any>;
+    private updateStatus;
+}
+
+/**
+ * Represents a 65816 processor opcode
+ */
+declare class OpCode {
+    code: number;
+    mnem: string;
+    mode: AddressingMode;
+    size: number;
+    constructor(code: number, mnem: string, mode: AddressingMode, size: number);
+}
+/**
+ * Complete 65816 instruction set lookup table
+ */
+declare const ALL_OPCODES: Record<number, OpCode>;
+/**
+ * Grouped opcodes by mnemonic
+ */
+declare const GROUPED_OPCODES: Record<string, OpCode[]>;
+/**
+ * Regular expressions for parsing addressing modes
+ */
+declare const ADDRESSING_REGEX: Record<AddressingMode, RegExp>;
+/**
+ * Hex character validation regex
+ */
+declare const HEX_REGEX: RegExp;
+/**
+ * Utility methods for OpCode class
+ */
+declare class OpCodeUtils {
+    /**
+     * Get all available opcodes
+     */
+    static getAllOpcodes(): OpCode[];
+    /**
+     * Get opcodes by mnemonic
+     */
+    static getByMnemonic(mnemonic: string): OpCode[];
+    /**
+     * Find opcode by hex value
+     */
+    static findByCode(code: number): OpCode | undefined;
+}
+
+/**
+ * Manages CPU processor state during ROM analysis
+ * Converted from GaiaLib/Rom/Extraction/ProcessorStateManager.cs
+ */
+declare class ProcessorStateManager {
+    readonly accumulatorFlags: Map<number, boolean | null>;
+    readonly indexFlags: Map<number, boolean | null>;
+    readonly bankNotes: Map<number, number | null>;
+    readonly stackPositions: Map<number, number>;
+    /**
+     * Hydrate processor registers with stored state
+     * Uses Registers from gaia-core/assembly for processor state management
+     */
+    hydrateRegisters(position: number, reg: any): void;
+    getAccumulatorFlag(location: number): boolean | null | undefined;
+    setAccumulatorFlag(location: number, value: boolean | null): void;
+    tryAddAccumulatorFlag(location: number, value: boolean | null): boolean;
+    getIndexFlag(location: number): boolean | null | undefined;
+    setIndexFlag(location: number, value: boolean | null): void;
+    tryAddIndexFlag(location: number, value: boolean | null): boolean;
+    getBankNote(location: number): number | null | undefined;
+    setBankNote(location: number, value: number | null): 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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 {
+    accumulatorFlag?: boolean;
+    indexFlag?: boolean;
+    direct?: number;
+    dataBank?: number;
+    accumulator?: number;
+    xIndex?: number;
+    yIndex?: number;
+    stack: Stack;
+    constructor();
+    /**
+     * Get the current status flags
+     */
+    get statusFlags(): StatusFlags;
+    /**
+     * Set the status flags
+     */
+    set statusFlags(value: StatusFlags);
+    /**
+     * Reset all registers to initial state
+     */
+    reset(): void;
+}
+
+/**
+ * Represents a single assembly operation/instruction
+ */
+declare class Op {
+    code: OpCode;
+    location: number;
+    operands: unknown[];
+    size: number;
+    copDef?: CopDef;
+    constructor(code: OpCode, location?: number, operands?: unknown[], size?: number);
+    /**
+     * Get the formatted string representation of this operation
+     */
+    toString(): string;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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 ACCUMULATOR_OP_MASK;
+    private static readonly ACCUMULATOR_OP_VALUE;
+    private static readonly VARIABLE_SIZE_INDICATOR;
+    private static readonly TWO_BYTES_SIZE;
+    private static readonly THREE_BYTES_SIZE;
+    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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+    get AccumulatorFlags(): Map<number, boolean | null>;
+    get IndexFlags(): Map<number, boolean | null>;
+    get BankNotes(): Map<number, number | null>;
+    get StackPosition(): Map<number, number>;
+    get _structTable(): Map<number, string>;
+    get _markerTable(): Map<number, number>;
+    get _nameTable(): Map<number, string>;
+    _currentBlock: DbBlock;
+    _currentPart: DbPart | null;
+    _partEnd: number;
+    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;
+    private updateRegisterState;
+    /**
+     * Checks if a delimiter has been reached
+     */
+    delimiterReached(delimiter?: number): boolean;
+    /**
+     * Checks if processing of the current part can continue
+     */
+    partCanContinue(): boolean;
+    /**
+     * Main analysis entry point
+     */
+    analyzeAndResolve(): void;
+    /**
+     * Analyzes all blocks in the ROM
+     */
+    private analyzeBlocks;
+    /**
+     * 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;
+    /**
+     * Resolves all references after analysis
+     */
+    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;
+    /**
+     * PascalCase wrapper for hydrateRegisters (for C# compatibility)
+     */
+    HydrateRegisters(reg: Registers): void;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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: any;
+}
+/**
+ * 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 updateStatusFlags;
+    private handleAbsoluteLongMode;
+    private handleBlockMoveMode;
+    private handleDirectPageMode;
+    private handlePCRelativeMode;
+    private handleStackRelativeMode;
+    private handleStackInterruptMode;
+    private handleStackOrImpliedMode;
+    private handleAbsoluteMode;
+    private isJumpInstruction;
+    private isPushInstruction;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Reads and extracts SFX data from ROM
+ * Converted from GaiaLib/Rom/Extraction/SfxReader.cs
+ */
+declare class SfxReader {
+    private readonly _romData;
+    private readonly _dbRoot;
+    private _location;
+    private _count;
+    constructor(romData: Uint8Array, dbRoot: DbRoot);
+    /**
+     * Reads a byte from the rom data
+     */
+    private readByte;
+    /**
+     * Reads a short from the rom data
+     */
+    private readShort;
+    /**
+     * Extracts the sfx from the rom data to the given output path
+     */
+    extract(outPath: string): Promise<void>;
+    /**
+     * Gets the path information for a binary type
+     * TODO: This should be implemented in DbRoot
+     */
+    private getPath;
+}
+
+/**
+ * Reads and extracts files from ROM
+ * Converted from GaiaLib/Rom/Extraction/FileReader.cs
+ */
+declare class FileReader {
+    static readonly PALETTE_MIN_SIZE = 512;
+    private readonly _romData;
+    private readonly _dbRoot;
+    private readonly _compression;
+    constructor(romData: Uint8Array, dbRoot: DbRoot, provider: ICompressionProvider);
+    /**
+     * Extracts all files from the ROM to the given output path
+     */
+    extract(outPath: string): Promise<void>;
+    private processFileData;
+    /**
+     * Gets the path information for a binary type from DbRoot configuration
+     */
+    private getPath;
+}
+
+/**
+ * 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;
+}
+
+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"
+}
+declare class BlockWriter {
+    private _root;
+    private _blockReader;
+    private _referenceManager;
+    private _postProcessor;
+    private _isInline;
+    private _currentPart;
+    constructor(reader: BlockReader);
+    writeBlocks(outPath: string): Promise<void>;
+    generateAsm(block: DbBlock): 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;
+}
+
+/**
+ * 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: DbBlock): void;
+    /**
+     * Builds a lookup table from struct entries.
+     * Equivalent to PostProcessor.Lookup in C# implementation.
+     */
+    Lookup(block: DbBlock, keyIx: string, valueIx: string): void;
+}
+
+declare const ROM_REBUILD_MODULE = "gaia-core/rom/rebuild";
+
+/**
+ * GaiaCore - Universal ROM processing engine
+ *
+ * This package provides the core functionality for ROM processing
+ * that can run in both browser (Web Worker) and Node.js environments.
+ *
+ * High-level APIs:
+ * - RomProcessor: Unified ROM processing workflows
+ * - ProjectManager: Complete project lifecycle management
+ *
+ * Low-level modules:
+ * - ROM: ROM state management, project configuration
+ * - Assembly: 65816 instruction set, stack operations
+ * - Compression: QuintetLZ compression algorithm
+ * - Sprites: Sprite animation system
+ */
+declare const GAIA_CORE_VERSION = "0.1.0";
+declare const isPlatformBrowser: boolean;
+declare const isPlatformNode: string | false;
+declare const isPlatformWebWorker: boolean;
+
+export { ADDRESSING_REGEX, ALL_OPCODES, AddressingModeHandler, AsmReader, BlockReader, BlockWriter, type BuildResult, CopCommandProcessor, type ExtractionResult, FileReader, GAIA_CORE_VERSION, GROUPED_OPCODES, HEX_REGEX, type ICompressionProvider, ObjectType, Op, OpCode, OpCodeUtils, type OpcodeStats, OperationContext, PostProcessor, ProcessorStateManager, type ProjectConfig, type ProjectEvents, ProjectManager, ProjectRoot, type ProjectStatus, QuintetLZ, ROM_REBUILD_MODULE, ReferenceManager, Registers, type RomAnalysisResult, RomDataReader, type RomHeaderInfo, RomProcessor, RomState, RomStateUtils, SfxReader, SpriteFrame, SpriteGroup, SpriteMap, SpritePart, Stack, StackOperations, StringReader, TransformProcessor, TypeParser, isPlatformBrowser, isPlatformNode, isPlatformWebWorker };