silphscope 1.4.21 → 1.4.23

package/silphscope.d.ts

@@ -1,13 +1,32 @@
-type PngFilterType = 
+import { RomReader } from "./src/rom-reader.js";
+
+// this file is getting messy... or well at least to me :p
+// I wonder if it is possible to make multiple .d.ts files and import them into a main one...
+// I mean apparently .js file imports work so I don't see why that wouldn't...
+// but oh well I already have this going may as well stick with it until I get tired of it
+// and refactor :o
+
+export interface RenderedAsset<Meta>  {
+    name: string;
+    category: string;
+    asset: string;
+    path: string;
+    buffer: Buffer;
+    meta: Meta;
+}
+
+export type RomData = Uint8Array | Buffer;
+
+export type PngFilterType =
     | -1
     | 0
     | 1
     | 2
     | 3
     | 4
-    | Array<0 | 1 | 2 | 3 | 4>
+    | Array<0 | 1 | 2 | 3 | 4>;
 
-export interface RenderAllMonsOptions {
+export interface RenderGenericOptions {
     /**
      * Directory to write extracted assets to.
      *
@@ -17,18 +36,6 @@ export interface RenderAllMonsOptions {
      * @default "./out"
      */
     outputDir?: string | null;
-    
-    /**
-     * Number of concurrent render operations.
-     *
-     * Increase with caution. Values that are too high may reduce
-     * performance depending on available CPU and disk resources.
-     *
-     * Set to `1` to render sequentially.
-     *
-     * @default 4
-     */
-    concurrency?: number;
 
     /**
      * PNG filter mode used during encoding.
@@ -73,6 +80,19 @@ export interface RenderAllMonsOptions {
      */
     pngCompressionLevel?: number;
 
+    /**
+     * Return generated image buffers instead of only writing
+     * files to disk.
+     *
+     * Useful for web servers, editors, bots, and other tools
+     * that need direct access to rendered assets.
+     *
+     * @default false
+     */
+    returnFileBuffer?: boolean;
+    }
+
+export interface RenderAllGenericOptions extends RenderGenericOptions {
     /**
      * Print progress information as assets are rendered.
      *
@@ -90,16 +110,19 @@ export interface RenderAllMonsOptions {
     showSummary?: boolean;
 
     /**
-     * Return generated image buffers instead of only writing
-     * files to disk.
+     * Number of concurrent render operations.
      *
-     * Useful for web servers, editors, bots, and other tools
-     * that need direct access to rendered assets.
+     * Increase with caution. Values that are too high may reduce
+     * performance depending on available CPU and disk resources.
      *
-     * @default false
+     * Set to `1` to render sequentially.
+     *
+     * @default 4
      */
-    returnFileBuffer?: boolean; // this stuff is annoying to write lol
+    concurrency?: number;
+}
 
+export interface RenderAllMonsOptions extends RenderAllGenericOptions {
     /**
      * Render mon icon graphics.
      *
@@ -115,14 +138,109 @@ export interface RenderAllMonsOptions {
     footprint?: boolean;
 }
 
-export interface RenderResult {
+export type MonSide = "front" | "back";
+export type MonVariant = "normal" | "shiny";
+
+export interface RenderMonOptions extends RenderGenericOptions {
+    /**
+     * Render mon icon graphics.
+     *
+     * @default true
+     */
+    icon?: boolean;
+
+    /**
+     * Render mon footprint graphics.
+     * 
+     * @default true
+     */
+    footprint?: boolean;
+
+    /**
+     * Render mon side specific graphics.
+     * 
+     * Takes either a single string or an array with two strings.
+     * 
+     * @default ["front","back"]
+     */
+    side?: MonSide | MonSide[];
+
+    /**
+     * Render mon variant specific graphics.
+     * 
+     * Takes either a single string or an array with two strings.
+     * 
+     * @default ["normal","shiny"]
+     */
+    variant?: MonVariant | MonVariant[];
+}
+
+export interface RenderMonIconOptions extends RenderGenericOptions {
+
+}
+
+export interface RenderMonFootOptions extends RenderGenericOptions {
+
+}
+
+export interface MonSpriteMeta {
+    side: "front" | "back";
+    variant: "normal" | "shiny";
+}
+
+export interface MonIconMeta {
+    frame: 1 | 2;
+}
+
+export interface MonFootprintMeta {
+
+}
+
+export type RenderAllMonsBufferResult =
+    | (RenderedAsset<MonSpriteMeta> & {
+        category: "mon";
+        asset: "sprite";
+    })
+    | (RenderedAsset<MonIconMeta> & {
+        category: "mon";
+        asset: "icon";
+    })
+    | (RenderedAsset<MonFootprintMeta> & {
+        category: "mon";
+        asset: "footprint";
+    });
+
+export interface RenderAllResult {
     totalFileCount: number;
 }
 
-export interface RenderResultWithBuffers extends RenderResult {
-    finalResults: Buffer[];
+export interface RenderAllResultWithBuffers<T> extends RenderAllResult {
+    finalResults: T[];
 }
 
+export type RenderMonBufferResult = RenderAllMonsBufferResult;
+
+export type RenderMonIconBufferResult =
+    (RenderedAsset<MonIconMeta>);
+
+export type RenderMonFootBufferResult =
+    (RenderedAsset<MonFootprintMeta>);
+
+export interface RenderResult {
+    fullFileCount: number;
+}
+
+export interface RenderResultWithBuffers<T> extends RenderResult {
+    results: T[];
+}
+
+export interface ObjectDataEntry {
+    index: number;
+}
+
+export type MonData =
+    Record<string, ObjectDataEntry>;
+
 /**
  * Extracts and renders all mon graphics from a Firered/Leafgreen ROM.
  * 
@@ -132,119 +250,122 @@ export interface RenderResultWithBuffers extends RenderResult {
  * @param options Optional configuration for rendering behaviour and other options.
  */
 export function renderAllMons(
-    rom: Uint8Array | Buffer,
+    rom: RomData,
     options?: RenderAllMonsOptions & {
         returnFileBuffer: true;
     }
-): Promise<RenderResultWithBuffers>;
+): Promise<RenderAllResultWithBuffers<RenderAllMonsBufferResult>>;
+
+export function renderAllMons(
+    rom: RomData,
+    options?: RenderAllMonsOptions
+): Promise<RenderAllResult>;
 
 /**
- * Extracts and renders all mon graphics from a Firered/Leafgreen ROM.
+ * Extracts and renders the graphics for a single mon from a Firered/Leafgreen ROM.
  * 
- * Handles front/back, normal/shiny, footprint, and icon graphics.
+ * Capable of handling the front/back normal/shiny body sprites, footprint, and icon graphics of any single mon.
  * 
+ * @param monName Name of the mon to render.
+ * @param mons Mapping of mons to their index values.
+ * @param reader RomReader used for pointer resolution.
  * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
  * @param options Optional configuration for rendering behaviour and other options.
- */ // I have no idea if I have to write this twice... nonetheless here it is I suppose :p
-export function renderAllMons(
-    rom: Uint8Array | Buffer,
-    options?: RenderAllMonsOptions
+ */
+export function renderMon(
+    monName: string,
+    mons: MonData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMonOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderMonBufferResult>>;
+
+export function renderMon(
+    monName: string,
+    mons: MonData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMonOptions,
 ): Promise<RenderResult>;
 
-export interface RenderAllIconsOptions {
-    /**
-     * Directory to write extracted assets to.
-     *
-     * If omitted (set to `null`) and `returnFileBuffer` is enabled, files can be
-     * consumed directly from memory without being written to disk.
-     *
-     * @default "./out"
-     */
-    outputDir?: string | null;
+/**
+ * Extracts and renders the icon graphic of a mon from a Firered/Leafgreen ROM.
+ * 
+ * @param monName Name of the mon to render.
+ * @param mons Mapping of mons to their index values.
+ * @param reader RomReader used for pointer resolution.
+ * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
+ * @param options Optional configuration for rendering behaviour and other options.
+ */
+export function renderMonIcon(
+    monName: string,
+    mons: MonData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMonIconOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderMonIconBufferResult>>;
+
+export function renderMonIcon(
+    monName: string,
+    mons: MonData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMonIconOptions,
+): Promise<RenderResult>;
 
-    /**
-     * Number of concurrent render operations.
-     *
-     * Increase with caution. Values that are too high may reduce
-     * performance depending on available CPU and disk resources.
-     *
-     * Set to `1` to render sequentially.
-     *
-     * @default 4
-     */
-    concurrency?: number;
+/**
+ * Extracts and renders the footprint graphic of a mon from a Firered/Leafgreen ROM.
+ * 
+ * @param monName Name of the mon footprint to render.
+ * @param mons Mapping of mons to their index values.
+ * @param reader RomReader used for pointer resolution.
+ * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
+ * @param options Optional configuration for rendering behaviour and other options.
+ */
+export function renderMonFoot(
+    monName: string,
+    mons: MonData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMonFootOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderMonFootBufferResult>>;
+
+export function renderMonFoot(
+    monName: string,
+    mons: MonData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMonFootOptions
+): Promise<RenderResult>;
 
-    /**
-     * PNG filter mode used during encoding.
-     *
-     * Accepts a value between `-1` and `4`:
-     *
-     * - `-1` = Automatically determine the best filter
-     * - `0` = None
-     * - `1` = Sub
-     * - `2` = Up
-     * - `3` = Average
-     * - `4` = Paeth
-     *
-     * Arrays may also be supplied. When an array is provided,
-     * SilphScope tests only the specified filters and selects
-     * the smallest resulting PNG.
-     *
-     * Examples:
-     *
-     * ```js
-     * pngFilterType: 0
-     * pngFilterType: -1
-     * pngFilterType: [1, 3, 4]
-     * ```
-     *
-     * @default 0
-     */
-    pngFilterType?: PngFilterType;
+export interface RenderAllIconsOptions extends RenderAllGenericOptions {
+    // welp thats funny I guess this one has no unique options...
+}
 
-    /**
-     * PNG compression level.
-     *
-     * Accepts a value between `0` and `9`.
-     *
-     * Higher values generally produce smaller files at the cost
-     * of additional processing time.
-     *
-     * - `0` = No compression
-     * - `9` = Maximum compression
-     *
-     * @default 4
-     */
-    pngCompressionLevel?: number;
+export interface RenderIconOptions extends RenderGenericOptions {
 
-    /**
-     * Print progress information as assets are rendered.
-     *
-     * @default true
-     */
-    verboseLogs?: boolean;
+}
 
-    /**
-     * Print a summary after rendering completes.
-     *
-     * Includes render count, file count, and elapsed time.
-     *
-     * @default true
-     */
-    showSummary?: boolean;
+export interface IconSpriteMeta {
 
-    /**
-     * Return generated image buffers instead of only writing
-     * files to disk.
-     *
-     * Useful for web servers, editors, bots, and other tools
-     * that need direct access to rendered assets.
-     *
-     * @default false
-     */
-    returnFileBuffer?: boolean;
 }
 
+export type RenderAllIconsBufferResult = 
+    | (RenderedAsset<IconSpriteMeta> & {
+        category: "icon";
+        asset: "sprite";
+    });
+
+export type RenderIconBufferResult = RenderAllIconsBufferResult;
+
+export type IconData = Record<string, ObjectDataEntry>;
+
 /**
  * Extracts and renders all icon graphics from a Firered/Leafgreen ROM.
  * 
@@ -254,126 +375,95 @@ export interface RenderAllIconsOptions {
  * @param options Optional configuration for rendering behaviour and other options.
  */
 export function renderAllIcons(
-    rom: Uint8Array | Buffer,
+    rom: RomData,
     options?: RenderAllIconsOptions & {
         returnFileBuffer: true;
     }
-): Promise<RenderResultWithBuffers>;
+): Promise<RenderAllResultWithBuffers<RenderAllIconsBufferResult>>;
+
+export function renderAllIcons(
+    rom: RomData,
+    options?: RenderAllIconsOptions
+): Promise<RenderAllResult>;
 
 /**
- * Extracts and renders all icon graphics from a Firered/Leafgreen ROM.
- * 
- * Handles only icon graphics.
+ * Extracts and renders a item icon graphic from a Firered/Leafgreen ROM.
  * 
+ * @param itemName Name of the item icon to render.
+ * @param items Mapping of item icons to their index values.
+ * @param reader RomReader used for pointer resolution.
  * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
  * @param options Optional configuration for rendering behaviour and other options.
  */
-export function renderAllIcons(
-    rom: Uint8Array | Buffer,
-    options?: RenderAllIconsOptions
+export function renderIcon(
+    itemName: string,
+    items: IconData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderIconOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderIconBufferResult>>;
+
+export function renderIcon(
+    itemName: string,
+    items: IconData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderIconOptions
 ): Promise<RenderResult>;
 
-export interface RenderAllTrainersOptions {
+export interface RenderAllTrainersOptions extends RenderAllGenericOptions {
     /**
-     * Directory to write extracted assets to.
-     *
-     * If omitted (set to `null`) and `returnFileBuffer` is enabled, files can be
-     * consumed directly from memory without being written to disk.
-     *
-     * @default "./out"
+     * Render trainer back graphics.
+     * 
+     * @default true
      */
-    outputDir?: string | null;
+    trainerBackPics?: boolean;
+}
 
+export interface RenderTrainerOptions extends RenderGenericOptions {
     /**
-     * Number of concurrent render operations.
-     *
-     * Increase with caution. Values that are too high may reduce
-     * performance depending on available CPU and disk resources.
-     *
-     * Set to `1` to render sequentially.
-     *
-     * @default 4
+     * Render trainer back graphics.
+     * 
+     * @default true
      */
-    concurrency?: number;
+    trainerBackPics?: boolean;
+}
 
-    /**
-     * PNG filter mode used during encoding.
-     *
-     * Accepts a value between `-1` and `4`:
-     *
-     * - `-1` = Automatically determine the best filter
-     * - `0` = None
-     * - `1` = Sub
-     * - `2` = Up
-     * - `3` = Average
-     * - `4` = Paeth
-     *
-     * Arrays may also be supplied. When an array is provided,
-     * SilphScope tests only the specified filters and selects
-     * the smallest resulting PNG.
-     *
-     * Examples:
-     *
-     * ```js
-     * pngFilterType: 0
-     * pngFilterType: -1
-     * pngFilterType: [1, 3, 4]
-     * ```
-     *
-     * @default 0
-     */
-    pngFilterType?: PngFilterType;
+export interface RenderTrainerBackPicOptions extends RenderGenericOptions {
 
-    /**
-     * PNG compression level.
-     *
-     * Accepts a value between `0` and `9`.
-     *
-     * Higher values generally produce smaller files at the cost
-     * of additional processing time.
-     *
-     * - `0` = No compression
-     * - `9` = Maximum compression
-     *
-     * @default 4
-     */
-    pngCompressionLevel?: number;
+}
 
-    /**
-     * Print progress information as assets are rendered.
-     *
-     * @default true
-     */
-    verboseLogs?: boolean;
+export type TrainerData =
+    Record<string, ObjectDataEntry>;
 
-    /**
-     * Print a summary after rendering completes.
-     *
-     * Includes render count, file count, and elapsed time.
-     *
-     * @default true
-     */
-    showSummary?: boolean;
+export type TrainerBackData = 
+    Record<string, ObjectDataEntry>;
 
-    /**
-     * Return generated image buffers instead of only writing
-     * files to disk.
-     *
-     * Useful for web servers, editors, bots, and other tools
-     * that need direct access to rendered assets.
-     *
-     * @default false
-     */
-    returnFileBuffer?: boolean;
+export interface TrainerFrameMeta {
 
-    /**
-     * Render trainer back graphics.
-     * 
-     * @default true
-     */
-    trainerBackPics?: boolean;
 }
 
+export interface TrainerSpriteMeta {
+    side: "front" | "back";
+}
+
+export type RenderAllTrainersBufferResult =
+    | (RenderedAsset<TrainerFrameMeta> & {
+        category: "trainer";
+        asset: "frame";
+    })
+    | (RenderedAsset<TrainerSpriteMeta> & {
+        category: "trainer";
+        asset: "sprite";
+    });
+
+export type RenderTrainerBufferResult = RenderAllTrainersBufferResult;
+
+export type RenderTrainerBackPicBufferResult =
+    (RenderedAsset<TrainerFrameMeta>);
+
 /**
  * Extracts and renders all trainer graphics from a Firered/Leafgreen ROM.
  * 
@@ -383,118 +473,103 @@ export interface RenderAllTrainersOptions {
  * @param options Optional configuration for rendering behaviour and other options.
  */
 export function renderAllTrainers(
-    rom: Uint8Array | Buffer,
+    rom: RomData,
     options?: RenderAllTrainersOptions & {
         returnFileBuffer: true;
     }
-): Promise<RenderResultWithBuffers>;
+): Promise<RenderAllResultWithBuffers<RenderAllTrainersBufferResult>>;
+
+export function renderAllTrainers(
+    rom: RomData,
+    options?: RenderAllTrainersOptions
+): Promise<RenderAllResult>;
 
 /**
- * Extracts and renders all trainer graphics from a Firered/Leafgreen ROM.
- * 
- * Handles trainer front and back graphics.
+ * Extracts and renders a single trainer's graphic from a Firered/Leafgreen ROM.
  * 
+ * @param trainerName Name of the trainer to render.
+ * @param trainers Mapping of trainers to their index values.
+ * @param backtrainers Mapping of trainers back graphics to their index values.
+ * @param reader RomReader used for pointer resolution.
  * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
  * @param options Optional configuration for rendering behaviour and other options.
  */
-export function renderAllTrainers(
-    rom: Uint8Array | Buffer,
-    options?: RenderAllTrainersOptions
+export function renderTrainer(
+    trainerName: string,
+    trainers: TrainerData,
+    backTrainers: TrainerBackData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderTrainerOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderTrainerBufferResult>>;
+
+export function renderTrainer(
+    trainerName: string,
+    trainers: TrainerData,
+    backTrainers: TrainerBackData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderTrainerOptions
 ): Promise<RenderResult>;
 
-export interface RenderAllMovesOptions {
-    /**
-     * Directory to write extracted assets to.
-     *
-     * If omitted (set to `null`) and `returnFileBuffer` is enabled, files can be
-     * consumed directly from memory without being written to disk.
-     *
-     * @default "./out"
-     */
-    outputDir?: string | null;
-
-    /**
-     * Number of concurrent render operations.
-     *
-     * Increase with caution. Values that are too high may reduce
-     * performance depending on available CPU and disk resources.
-     *
-     * Set to `1` to render sequentially.
-     *
-     * @default 4
-     */
-    concurrency?: number;
-
-    /**
-     * PNG filter mode used during encoding.
-     *
-     * Accepts a value between `-1` and `4`:
-     *
-     * - `-1` = Automatically determine the best filter
-     * - `0` = None
-     * - `1` = Sub
-     * - `2` = Up
-     * - `3` = Average
-     * - `4` = Paeth
-     *
-     * Arrays may also be supplied. When an array is provided,
-     * SilphScope tests only the specified filters and selects
-     * the smallest resulting PNG.
-     *
-     * Examples:
-     *
-     * ```js
-     * pngFilterType: 0
-     * pngFilterType: -1
-     * pngFilterType: [1, 3, 4]
-     * ```
-     *
-     * @default 0
-     */
-    pngFilterType?: PngFilterType;
-
-    /**
-     * PNG compression level.
-     *
-     * Accepts a value between `0` and `9`.
-     *
-     * Higher values generally produce smaller files at the cost
-     * of additional processing time.
-     *
-     * - `0` = No compression
-     * - `9` = Maximum compression
-     *
-     * @default 4
-     */
-    pngCompressionLevel?: number;
+/**
+ * Extracts and renders a trainer's back graphic from a Firered/Leafgreen ROM.
+ * 
+ * @param trainerName Name of the trainer to render.
+ * @param trainers Mapping of trainers to their index values.
+ * @param reader RomReader used for pointer resolution.
+ * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
+ * @param options Optional configuration for rendering behaviour and other options.
+ */
+export function renderTrainerBackPic(
+    trainerName: string,
+    trainers: TrainerBackData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderTrainerBackPicOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderTrainerBackPicBufferResult>>;
+
+export function renderTrainerBackPic(
+    trainerName: string,
+    trainers: TrainerBackData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderTrainerBackPicOptions
+): Promise<RenderResult>;
 
+export interface RenderAllMovesOptions extends RenderAllGenericOptions {
     /**
-     * Print progress information as assets are rendered.
-     *
+     * Creates the original sprite sheet version of the move graphic.
+     * 
+     * Useful if you wish to display or archive the original graphic.
+     * 
      * @default true
      */
-    verboseLogs?: boolean;
+    renderMasterImage?: boolean;
 
     /**
-     * Print a summary after rendering completes.
-     *
-     * Includes render count, file count, and elapsed time.
-     *
+     * Sorts all unused moves into a sub directory.
+     * 
+     * Example:
+     * 
+     * If your outputDir was 
+     * 
+     * `out/Moves`
+     * 
+     * Then this would store the unused moves in
+     * 
+     * `out/Moves/unused`
+     * 
      * @default true
      */
-    showSummary?: boolean;
-
-    /**
-     * Return generated image buffers instead of only writing
-     * files to disk.
-     *
-     * Useful for web servers, editors, bots, and other tools
-     * that need direct access to rendered assets.
-     *
-     * @default false
-     */
-    returnFileBuffer?: boolean;
+    sortUnused?: boolean;
+}
 
+export interface RenderMoveOptions extends RenderGenericOptions {
     /**
      * Creates the original sprite sheet version of the move graphic.
      * 
@@ -505,12 +580,12 @@ export interface RenderAllMovesOptions {
     renderMasterImage?: boolean;
 
     /**
-   (set to `null`)   * Sorts all unused moves into a sub directory.
+     * Sorts all unused moves into a sub directory.
      * 
      * Example:
      * 
      * If your outputDir was 
-    | null  * 
+     * 
      * `out/Moves`
      * 
      * Then this would store the unused moves in
@@ -522,6 +597,48 @@ export interface RenderAllMovesOptions {
     sortUnused?: boolean;
 }
 
+export interface MoveSpriteMeta {
+
+}
+
+export interface MoveFrameMeta {
+
+}
+
+export type RenderAllMovesBufferResult =
+    | (RenderedAsset<MoveSpriteMeta> & {
+        category: "move";
+        asset: "sprite";
+    })
+    | (RenderedAsset<MoveFrameMeta> & {
+        category: "move";
+        asset: "frame";
+    });
+
+export type RenderMoveBufferResult = RenderAllMovesBufferResult;
+
+export interface Frame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export interface MoveDataEntry {
+    index: number;
+    animTag: string;
+    imageSize: string;
+    imageWidth: number;
+    imageHeight: number;
+    frameCount: number;
+    frames: Frame[];
+    note?: string;
+    unused?: boolean;
+}
+
+export type MoveData =
+    Record<string, MoveDataEntry>;
+
 /**
  * Extracts, renders, and cuts all move graphics from a Firered/Leafgreen ROM.
  * 
@@ -531,118 +648,72 @@ export interface RenderAllMovesOptions {
  * @param options Optional configuration for rendering behaviour and other options.
  */
 export function renderAllMoves(
-    rom: Uint8Array | Buffer,
+    rom: RomData,
     options?: RenderAllMovesOptions & {
         returnFileBuffer: true;
     }
-): Promise<RenderResultWithBuffers>;
+): Promise<RenderAllResultWithBuffers<RenderAllMovesBufferResult>>;
+
+export function renderAllMoves(
+    rom: RomData,
+    options?: RenderAllMovesOptions
+): Promise<RenderAllResult>;
 
 /**
- * Extracts, renders, and cuts all move graphics from a Firered/Leafgreen ROM.
- * 
- * Handles both used and unused move graphics.
+ * Extracts and renders a move graphic from a Firered/Leafgreen ROM.
  * 
+ * @param moveName Name of the move to render.
+ * @param moves Mapping of moves to their index values, frames, and dimensions.
+ * @param reader RomReader used for pointer resolution.
  * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
  * @param options Optional configuration for rendering behaviour and other options.
  */
-export function renderAllMoves(
-    rom: Uint8Array | Buffer,
-    options?: RenderAllMovesOptions
+export function renderMove(
+    moveName: string,
+    moves: MoveData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMoveOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderMoveBufferResult>>;
+
+export function renderMove(
+    moveName: string,
+    moves: MoveData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderMoveOptions
 ): Promise<RenderResult>;
 
-export interface RenderAllBallsOptions {
-    /**
-     * Directory to write extracted assets to.
-     *
-     * If omitted (set to `null`) and `returnFileBuffer` is enabled, files can be
-     * consumed directly from memory without being written to disk.
-     *
-     * @default "./out"
-     */
-    outputDir?: string | null;
-
-    /**
-     * Number of concurrent render operations.
-     *
-     * Increase with caution. Values that are too high may reduce
-     * performance depending on available CPU and disk resources.
-     *
-     * Set to `1` to render sequentially.
-     *
-     * @default 4
-     */
-    concurrency?: number;
-
-    /**
-     * PNG filter mode used during encoding.
-     *
-     * Accepts a value between `-1` and `4`:
-     *
-     * - `-1` = Automatically determine the best filter
-     * - `0` = None
-     * - `1` = Sub
-     * - `2` = Up
-     * - `3` = Average
-     * - `4` = Paeth
-     *
-     * Arrays may also be supplied. When an array is provided,
-     * SilphScope tests only the specified filters and selects
-     * the smallest resulting PNG.
-     *
-     * Examples:
-     *
-     * ```js
-     * pngFilterType: 0
-     * pngFilterType: -1
-     * pngFilterType: [1, 3, 4]
-     * ```
-     *
-     * @default 0
-     */
-    pngFilterType?: PngFilterType;
-
-    /**
-     * PNG compression level.
-     *
-     * Accepts a value between `0` and `9`.
-     *
-     * Higher values generally produce smaller files at the cost
-     * of additional processing time.
-     *
-     * - `0` = No compression
-     * - `9` = Maximum compression
-     *
-     * @default 4
-     */
-    pngCompressionLevel?: number;
-
+export interface RenderAllBallsOptions extends RenderAllGenericOptions {
     /**
-     * Print progress information as assets are rendered.
-     *
+     * Render ball particle graphics.
+     * 
      * @default true
      */
-    verboseLogs?: boolean;
+    ballParticles?: boolean;
 
     /**
-     * Print a summary after rendering completes.
-     *
-     * Includes render count, file count, and elapsed time.
-     *
+     * Creates the original sprite sheet version of the ball graphic.
+     * 
+     * Useful if you wish to display or archive the original graphic.
+     * 
      * @default true
      */
-    showSummary?: boolean;
+    renderMasterBallImage?: boolean;
 
     /**
-     * Return generated image buffers instead of only writing
-     * files to disk.
-     *
-     * Useful for web servers, editors, bots, and other tools
-     * that need direct access to rendered assets.
-     *
-     * @default false
+     * Creates the original sprite sheet version of the ball particle graphic.
+     * 
+     * Useful if you wish to display or archive the original graphic.
+     * 
+     * @default true
      */
-    returnFileBuffer?: boolean;
+    renderMasterBallParticleImage?: boolean;
+}
 
+export interface RenderBallOptions extends RenderGenericOptions {
     /**
      * Render ball particle graphics.
      * 
@@ -669,6 +740,50 @@ export interface RenderAllBallsOptions {
     renderMasterBallParticleImage?: boolean;
 }
 
+export interface RenderBallParticleOptions extends RenderGenericOptions {
+    /**
+     * Creates the original sprite sheet version of the ball particle graphic.
+     * 
+     * Useful if you wish to display or archive the original graphic.
+     * 
+     * @default true
+     */
+    renderMasterBallParticleImage?: boolean;
+}
+
+export interface BallSpriteMeta {
+    particleOrBall: "particle" | "ball";
+}
+
+export interface BallFrameMeta {
+    particleOrBall: "particle" | "ball";
+}
+
+export type RenderAllBallsBufferResult =
+    | (RenderedAsset<BallSpriteMeta> & {
+        category: "ball";
+        asset: "sprite";
+    })
+    | (RenderedAsset<BallFrameMeta> & {
+        category: "ball";
+        asset: "frame";
+    });
+
+export type RenderBallBufferResult = RenderAllBallsBufferResult;
+
+export type RenderBallParticleBufferResult = RenderAllBallsBufferResult;
+
+export interface BallDataEntry {
+    index: number;
+    frameCount: number;
+    frames: Frame[];
+    particleFrameCount: number;
+    particleFrames: Frame[];
+}
+
+export type BallData =
+    Record<string, BallDataEntry>;
+
 /**
  * Extracts, renders, and cuts all ball graphics from a Firered/Leafgreen ROM.
  * 
@@ -678,109 +793,72 @@ export interface RenderAllBallsOptions {
  * @param options Optional configuration for rendering behaviour and other options.
  */
 export function renderAllBalls(
-    rom: Uint8Array | Buffer,
+    rom: RomData,
     options?: RenderAllBallsOptions & {
         returnFileBuffer: true;
     }
-): Promise<RenderResultWithBuffers>;
+): Promise<RenderAllResultWithBuffers<RenderAllBallsBufferResult>>;
+
+export function renderAllBalls(
+    rom: RomData,
+    options?: RenderAllBallsOptions
+): Promise<RenderAllResult>;
 
 /**
- * Extracts renders, and cuts all ball graphics from a Firered/Leafgreen ROM.
- * 
- * Handles both ball and ball particle graphics.
+ * Extracts and renders a ball graphic from a Firered/Leafgreen ROM.
  * 
+ * @param ballName Name of the ball to render.
+ * @param balls Mapping of balls to their index values and frames.
+ * @param reader RomReader used for pointer resolution.
  * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
  * @param options Optional configuration for rendering behaviour and other options.
  */
-export function renderAllBalls(
-    rom: Uint8Array | Buffer,
-    options?: RenderAllBallsOptions
+export function renderBall(
+    ballName: string,
+    balls: BallData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderBallOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderBallBufferResult>>;
+
+export function renderBall(
+    ballName: string,
+    balls: BallData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderBallOptions
 ): Promise<RenderResult>;
 
-export interface RenderAllGraphicsOptions {
-
-    /**
-     * Number of concurrent render operations.
-     *
-     * Increase with caution. Values that are too high may reduce
-     * performance depending on available CPU and disk resources.
-     *
-     * Set to `1` to render sequentially.
-     *
-     * @default 4
-     */
-    concurrency?: number;
-
-    /**
-     * PNG filter mode used during encoding.
-     *
-     * Accepts a value between `-1` and `4`:
-     *
-     * - `-1` = Automatically determine the best filter
-     * - `0` = None
-     * - `1` = Sub
-     * - `2` = Up
-     * - `3` = Average
-     * - `4` = Paeth
-     *
-     * Arrays may also be supplied. When an array is provided,
-     * SilphScope tests only the specified filters and selects
-     * the smallest resulting PNG.
-     *
-     * Examples:
-     *
-     * ```js
-     * pngFilterType: 0
-     * pngFilterType: -1
-     * pngFilterType: [1, 3, 4]
-     * ```
-     *
-     * @default 0
-     */
-    pngFilterType?: PngFilterType;
-
-    /**
-     * PNG compression level.
-     *
-     * Accepts a value between `0` and `9`.
-     *
-     * Higher values generally produce smaller files at the cost
-     * of additional processing time.
-     *
-     * - `0` = No compression
-     * - `9` = Maximum compression
-     *
-     * @default 4
-     */
-    pngCompressionLevel?: number;
-
-    /**
-     * Print progress information as assets are rendered.
-     *
-     * @default true
-     */
-    verboseLogs?: boolean;
-
-    /**
-     * Print a summary after rendering completes.
-     *
-     * Includes render count, file count, and elapsed time.
-     *
-     * @default true
-     */
-    showSummary?: boolean;
-
-    /**
-     * Return generated image buffers instead of only writing
-     * files to disk.
-     *
-     * Useful for web servers, editors, bots, and other tools
-     * that need direct access to rendered assets.
-     *
-     * @default false
-     */
-    returnFileBuffer?: boolean;
+/**
+ * Extracts and renders a ball particle graphic from a Firered/Leafgreen ROM.
+ * 
+ * @param ballName Name of the ball to render.
+ * @param balls Mapping of balls to their index values and frames.
+ * @param reader RomReader used for pointer resolution.
+ * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
+ * @param options Optional configuration for rendering behaviour and other options.
+ */
+export function renderBallParticle(
+    ballName: string,
+    balls: BallData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderBallParticleOptions & {
+        returnFileBuffer: true,
+    }
+): Promise<RenderResultWithBuffers<RenderBallParticleBufferResult>>;
+
+export function renderBallParticle(
+    ballName: string,
+    balls: BallData,
+    reader: RomReader,
+    rom: RomData,
+    options?: RenderBallParticleOptions
+): Promise<RenderResult>;
 
+export interface RenderAllGraphicsOptions extends Omit<RenderAllGenericOptions, "outputDir"> {
     /**
      * Directory to write extracted mon assets to.
      *
@@ -836,7 +914,7 @@ export interface RenderAllGraphicsOptions {
      * 
      * @default true
      */
-    sortUnusedMoves: boolean;
+    sortUnusedMoves?: boolean;
 
     /**
      * Directory to write extracted balls assets to.
@@ -849,6 +927,13 @@ export interface RenderAllGraphicsOptions {
     outputBallDir?: string;
 }
 
+export type RenderAllGraphicsBufferResult =
+    | RenderAllMonsBufferResult
+    | RenderAllIconsBufferResult
+    | RenderAllTrainersBufferResult
+    | RenderAllMovesBufferResult
+    | RenderAllBallsBufferResult;
+
 /**
  * Extracts and renders all graphics from a Firered/Leafgreen ROM.
  * 
@@ -858,21 +943,13 @@ export interface RenderAllGraphicsOptions {
  * @param options Optional configuration for rendering behaviour and other options.
  */
 export function renderAllGraphics(
-    rom: Uint8Array | Buffer,
+    rom: RomData,
     options?: RenderAllGraphicsOptions & {
         returnFileBuffer: true;
     }
-): Promise<RenderResultWithBuffers>;
+): Promise<RenderAllResultWithBuffers<RenderAllGraphicsBufferResult>>;
 
-/**
- * Extracts and renders all graphics from a Firered/Leafgreen ROM.
- * 
- * Handles everything currently handled by all other separate render functions.
- * 
- * @param rom The Firered/Leafgreen ROM file as a Buffer or Uint8Array.
- * @param options Optional configuration for rendering behaviour and other options.
- */
 export function renderAllGraphics(
-    rom: Uint8Array | Buffer,
+    rom: RomData,
     options?: RenderAllGraphicsOptions
-): Promise<RenderResult>;
+): Promise<RenderAllResult>;