@gaialabs/core 0.1.19 → 0.2.1

package/dist/index.d.ts

@@ -1,835 +0,0 @@
-import { StatusFlags, DbRoot, AddressType, DbStringType, StringWrapper, Op, OpCode, ChunkFile, AsmBlock, Address, CopDef, DbEntryPoint, ICompressionProvider } from '@gaialabs/shared';
-
-/**
- * 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>;
-}
-/**
- * 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;
-}
-
-/**
- * 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;
-}
-
-/**
- * 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: Registers): 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;
-}
-
-/**
- * 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 PROCESSOR_FLAG_MASK;
-    private static readonly ACCUMULATOR_OP_MASK;
-    private static readonly ACCUMULATOR_OP_VALUE;
-    static readonly VARIABLE_SIZE_INDICATOR = -2;
-    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>;
-    _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;
-    private updateRegisterState;
-    /**
-     * 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;
-}
-
-/**
- * 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: 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 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;
-}
-
-/**
- * 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);
-    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;
-}
-
-/**
- * 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;
-}
-
-/**
- * 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;
-}
-
-/**
- * ROM writer (binary)
- * Converted from ext/GaiaLib/Rom/Rebuild/RomWriter.cs (subset: binary write only)
- */
-declare class RomWriter {
-    bpsPath?: string;
-    readonly outBuffer: Uint8Array;
-    readonly entryPoints: DbEntryPoint[];
-    readonly cartName: string;
-    readonly makerCode: string;
-    constructor(entryPoints: DbEntryPoint[], cartName: string, makerCode: string);
-    repack(files: ChunkFile[]): Promise<Uint8Array>;
-    writeHeader(): void;
-    writeChecksum(): void;
-    writeEntryPoints(asmFiles: ChunkFile[]): void;
-    writeTransform(location: number, value: number, size?: number): 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;
-}
-
-/**
- * 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;
-}
-
-/**
- * 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;
-}
-
-/**
- * String processor for assembly parsing
- * Converted from GaiaLib/Rom/Rebuild/StringProcessor.cs
- */
-declare class StringProcessor {
-    private readonly memBuffer;
-    private readonly context;
-    private readonly root;
-    constructor(context: AssemblerContext);
-    dispose(): void;
-    consumeString(): void;
-    private flushBuffer;
-    private processString;
-    private applyLayers;
-    private applyMap;
-    private processStringCommand;
-    private getShiftUp;
-}
-
-/**
- * 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;
-}
-
-/**
- * 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>;
-    blocks: AsmBlock[];
-    tags: SortedMap<string | null>;
-    currentBlock: AsmBlock | null;
-    lineCount: number;
-    blockIndex: number;
-    lastDelimiter: number | null;
-    reqBank: number | null;
-    eof: boolean;
-    constructor(dbRoot: DbRoot, textData: string);
-    dispose(): void;
-    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;
-}
-
-/**
- * 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;
-}
-
-declare class RomGenerator {
-    readonly projectName?: string;
-    crc: number;
-    branchId: string;
-    dbRoot: DbRoot;
-    private sourceData;
-    constructor(projectName?: string);
-    initialize(): Promise<void>;
-    validateAndDownload(sourceData: Uint8Array): Promise<boolean>;
-    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;
-}
-
-/**
- * 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;
-}
-
-/**
- * Register compression providers with the global registry
- */
-declare function registerCompressionProviders(): void;
-
-/**
- * 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;
-}
-
-/**
- * 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.6";
-declare const isPlatformBrowser: boolean;
-declare const isPlatformNode: string | false;
-declare const isPlatformWebWorker: boolean;
-
-export { AddressingModeHandler, AsmReader, Assembler, type AssemblerContext, AssemblerState, BlockReader, BlockWriter, CopCommandProcessor, GAIA_CORE_VERSION, ObjectType, OperationContext, PostProcessor, ProcessorStateManager, QuintetLZ, ReferenceManager, Registers, RomDataReader, RomGenerator, RomLayout, RomProcessor, RomState, RomStateUtils, RomWriter, SortedMap, SpriteFrame, SpriteGroup, SpriteMap, SpritePart, Stack, StackOperations, StringProcessor, StringReader, TransformProcessor, TypeParser, isPlatformBrowser, isPlatformNode, isPlatformWebWorker, registerCompressionProviders };