@bloopjs/toodle 0.0.101 → 0.0.103

package/dist/textures/AssetManager.d.ts

@@ -4,14 +4,22 @@ import type { Limits } from "../limits";
 import { QuadNode } from "../scene/QuadNode";
 import type { SceneNode } from "../scene/SceneNode";
 import { TextShader } from "../text/TextShader";
+import { Bundles } from "./Bundles";
 import type { AtlasBundleOpts, AtlasCoords, CpuTextureAtlas, TextureBundleOpts } from "./types";
 export type TextureId = string;
 export type BundleId = string;
 export type FontId = string;
+export type AssetManagerOptions = {
+    /** Existing Bundles instance to use for CPU-side storage. If not provided, a new one is created. */
+    bundles?: Bundles;
+    /** Texture format (default: "rgba8unorm") */
+    format?: "rgba8unorm" | "rg8unorm";
+};
 export declare class AssetManager {
     #private;
     readonly textureAtlas: GPUTexture;
-    constructor(device: GPUDevice, presentationFormat: GPUTextureFormat, limits: Limits, format?: "rgba8unorm" | "rg8unorm");
+    readonly bundles: Bundles;
+    constructor(device: GPUDevice, presentationFormat: GPUTextureFormat, limits: Limits, options?: AssetManagerOptions);
     /**
      * True dimensions of a loaded texture, prior to any transparent pixel cropping.
      *
@@ -36,7 +44,7 @@ export declare class AssetManager {
     /**
      * A read-only map of all currently loaded textures.
      */
-    get textures(): Map<string, AtlasCoords[]>;
+    get textures(): ReadonlyMap<string, AtlasCoords[]>;
     /**
      * A read-only array of all currently loaded texture ids.
      */

package/dist/textures/AssetManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../src/textures/AssetManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,eAAe,EAEf,iBAAiB,EAGlB,MAAM,SAAS,CAAC;AAGjB,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC9B,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAQ5B,qBAAa,YAAY;;IACvB,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC;gBAWhC,MAAM,EAAE,SAAS,EACjB,kBAAkB,EAAE,gBAAgB,EACpC,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,YAAY,GAAG,UAAyB;IAwBlD;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAS5B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAWnC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO;IAUjC;;OAEG;IACH,IAAI,QAAQ,+BAEX;IAED;;OAEG;IACH,IAAI,UAAU,aAEb;IAED;;;;;;;;;;;;;;;;OAgBG;IACG,YAAY,CAAC,IAAI,EAAE,iBAAiB,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtE;;;;;;;;;OASG;IACG,WAAW,CACf,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,GAAG,GAAG,WAAW,EACtB,OAAO,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;;;;IAwCtC;;;;;;;;OAQG;IACG,cAAc,CAClB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,iBAAiB,GAAG,eAAe,GACxC,OAAO,CAAC,QAAQ,CAAC;IAapB;;;;OAIG;IACG,UAAU,CAAC,QAAQ,EAAE,QAAQ;IAmBnC;;;;;OAKG;IACG,YAAY,CAAC,QAAQ,EAAE,QAAQ;IAqBrC;;;;;;OAMG;IACG,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,iBAAiB,SAAM;IAqB5D,OAAO,CAAC,EAAE,EAAE,MAAM;IASlB,wBAAwB,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ;IAqNnD;;OAEG;IACH,KAAK;sCAEyB,MAAM,EAAE;kCAKZ,MAAM,EAAE;QAMhC;;;;;;;WAOG;6BACkB,SAAS,UAAU,WAAW;QAWnD;;;;;WAKG;6BACkB,SAAS,KAAG,WAAW,EAAE;QAS9C;;;;;WAKG;+BACoB,SAAS,KAAG,IAAI;QAUvC;;;;WAIG;;YAGC;;;eAGG;;YAEH;;eAEG;;YAEH;;eAEG;;;QAKP;;;WAGG;;QAWH;;;;;WAKG;2BACsB,eAAe;QAyCxC;;;;WAIG;kCAC6B,MAAM;MActC;IAmCF;;OAEG;IACH,OAAO;CAGR"}
+{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../src/textures/AssetManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,eAAe,EACf,iBAAiB,EAElB,MAAM,SAAS,CAAC;AAGjB,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC9B,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,mBAAmB,GAAG;IAChC,oGAAoG;IACpG,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;CACpC,CAAC;AAEF,qBAAa,YAAY;;IACvB,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;gBASxB,MAAM,EAAE,SAAS,EACjB,kBAAkB,EAAE,gBAAgB,EACpC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAAwB;IA2BnC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAS5B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAWnC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO;IAUjC;;OAEG;IACH,IAAI,QAAQ,uCAEX;IAED;;OAEG;IACH,IAAI,UAAU,aAEb;IAED;;;;;;;;;;;;;;;;OAgBG;IACG,YAAY,CAAC,IAAI,EAAE,iBAAiB,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtE;;;;;;;;;OASG;IACG,WAAW,CACf,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,GAAG,GAAG,WAAW,EACtB,OAAO,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;;;;IAwCtC;;;;;;;;OAQG;IACG,cAAc,CAClB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,iBAAiB,GAAG,eAAe,GACxC,OAAO,CAAC,QAAQ,CAAC;IAapB;;;;OAIG;IACG,UAAU,CAAC,QAAQ,EAAE,QAAQ;IAsBnC;;;;;OAKG;IACG,YAAY,CAAC,QAAQ,EAAE,QAAQ;IAkBrC;;;;;;OAMG;IACG,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,iBAAiB,SAAM;IAqB5D,OAAO,CAAC,EAAE,EAAE,MAAM;IASlB,wBAAwB,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ;IA4FnD;;OAEG;IACH,KAAK;sCAEyB,MAAM,EAAE;kCAKZ,MAAM,EAAE;QAIhC;;;;;;;WAOG;6BACkB,SAAS,UAAU,WAAW;QAInD;;;;;WAKG;6BACkB,SAAS,KAAG,WAAW,EAAE;QAI9C;;;;;WAKG;+BACoB,SAAS,KAAG,IAAI;QAIvC;;;;WAIG;;YAGC;;;eAGG;;YAEH;;eAEG;;YAEH;;eAEG;;;QAKP;;;WAGG;;QAWH;;;;;WAKG;2BACsB,eAAe;QAsCxC;;;;WAIG;kCAC6B,MAAM;MAItC;IAmCF;;OAEG;IACH,OAAO;CAGR"}

package/dist/textures/Bundles.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Bundles - A renderer-agnostic class for managing texture bundles and atlas coordinates.
+ *
+ * This class can be used standalone (without WebGPU) for:
+ * - Registering pre-baked texture atlases (Pixi/AssetPack format)
+ * - Looking up texture regions and UV coordinates
+ * - Managing bundle state
+ *
+ * For WebGPU rendering, use AssetManager which wraps this class and handles GPU operations.
+ */
+import type { Size } from "../coreTypes/Size";
+import type { Vec2 } from "../coreTypes/Vec2";
+import type { AtlasBundleOpts, AtlasCoords, CpuTextureAtlas, TextureRegion } from "./types";
+export type TextureId = string;
+export type BundleId = string;
+/**
+ * Options for creating a Bundles instance
+ */
+export type BundlesOptions = {
+    /** The size of the texture atlas (default: 4096) */
+    atlasSize?: number;
+};
+/**
+ * Bundles manages texture bundle registration and atlas coordinate lookups.
+ *
+ * This is a pure TypeScript class with no WebGPU dependencies, suitable for
+ * use with custom renderers (e.g., WebGL fallbacks).
+ */
+export declare class Bundles {
+    #private;
+    constructor(options?: BundlesOptions);
+    /**
+     * Register a bundle of pre-baked texture atlases.
+     *
+     * @param bundleId - Unique identifier for this bundle
+     * @param opts - Atlas bundle options containing atlas definitions
+     * @returns The bundle ID
+     */
+    registerAtlasBundle(bundleId: BundleId, opts: AtlasBundleOpts): Promise<BundleId>;
+    /**
+     * Register a bundle with pre-built CPU texture atlases.
+     * Used internally by AssetManager for texture bundles that require GPU packing.
+     *
+     * @param bundleId - Unique identifier for this bundle
+     * @param atlases - Pre-built CPU texture atlases
+     */
+    registerDynamicBundle(bundleId: BundleId, atlases: CpuTextureAtlas[]): void;
+    /**
+     * Check if a bundle is registered.
+     *
+     * @param bundleId - The bundle ID to check
+     */
+    hasBundle(bundleId: BundleId): boolean;
+    /**
+     * Check if a bundle is loaded.
+     *
+     * @param bundleId - The bundle ID to check
+     */
+    isBundleLoaded(bundleId: BundleId): boolean;
+    /**
+     * Get the atlas indices for a loaded bundle.
+     *
+     * @param bundleId - The bundle ID
+     * @returns Array of atlas indices, or empty array if not loaded
+     */
+    getBundleAtlasIndices(bundleId: BundleId): number[];
+    /**
+     * Mark a bundle as loaded without populating texture lookups.
+     * Used when texture lookups are already populated via loadAtlas.
+     *
+     * @param bundleId - The bundle to mark as loaded
+     * @param atlasIndices - Array of atlas indices, one per atlas
+     */
+    setBundleLoaded(bundleId: BundleId, atlasIndices: number[]): void;
+    /**
+     * Mark a bundle as loaded and populate texture lookups.
+     * For standalone usage (without AssetManager).
+     *
+     * @param bundleId - The bundle to mark as loaded
+     * @param atlasIndices - Array of atlas indices, one per atlas. If not provided, indices are auto-assigned sequentially.
+     */
+    markBundleLoaded(bundleId: BundleId, atlasIndices?: number[]): void;
+    /**
+     * Unmark a bundle as loaded and remove texture lookups.
+     *
+     * @param bundleId - The bundle to unload
+     */
+    unloadBundle(bundleId: BundleId): void;
+    /**
+     * A read-only map of all currently loaded textures.
+     */
+    get textures(): ReadonlyMap<TextureId, AtlasCoords[]>;
+    /**
+     * A read-only array of all currently loaded texture ids.
+     */
+    get textureIds(): TextureId[];
+    /**
+     * Get the atlas coordinates for a texture.
+     *
+     * @param id - The texture ID
+     * @returns Array of atlas coordinates (may have multiple if texture exists in multiple atlases)
+     */
+    getAtlasCoords(id: TextureId): AtlasCoords[];
+    /**
+     * Set the atlas coordinates for a texture.
+     * This allows for UV precision adjustments.
+     *
+     * @param id - The texture ID
+     * @param coords - The atlas coordinates to set
+     */
+    setAtlasCoords(id: TextureId, coords: AtlasCoords): void;
+    /**
+     * Add atlas coordinates for a texture entry.
+     * Used by AssetManager.loadAtlas for textures loaded outside of bundles.
+     *
+     * @param id - The texture ID
+     * @param coords - The atlas coordinates to add
+     */
+    addTextureEntry(id: TextureId, coords: AtlasCoords): void;
+    /**
+     * Remove texture entries for a specific atlas index.
+     * Used by AssetManager.unloadAtlas.
+     *
+     * @param atlasIndex - The atlas index to remove entries for
+     */
+    removeTextureEntriesForAtlas(atlasIndex: number): void;
+    /**
+     * Get the texture region (without atlas index) for a texture.
+     *
+     * @param id - The texture ID
+     * @returns The texture region, or undefined if not found
+     */
+    getTextureRegion(id: TextureId): TextureRegion | undefined;
+    /**
+     * Get the crop offset for a texture.
+     *
+     * @param id - The texture ID
+     * @returns The crop offset vector
+     */
+    getTextureOffset(id: TextureId): Vec2;
+    /**
+     * Get the original (uncropped) size of a texture.
+     *
+     * @param id - The texture ID
+     * @returns The original size in pixels
+     */
+    getSize(id: TextureId): Size;
+    /**
+     * Get the cropped size of a texture.
+     *
+     * @param id - The texture ID
+     * @returns The cropped size in pixels
+     */
+    getCroppedSize(id: TextureId): Size;
+    /**
+     * Check if a texture exists.
+     *
+     * @param id - The texture ID
+     * @returns True if the texture is registered
+     */
+    hasTexture(id: TextureId): boolean;
+    /**
+     * Get all registered bundle IDs.
+     */
+    getRegisteredBundleIds(): BundleId[];
+    /**
+     * Get all loaded bundle IDs.
+     */
+    getLoadedBundleIds(): BundleId[];
+    /**
+     * Get the CPU-side atlas data for a bundle.
+     * Useful for custom renderers that need access to the raw atlas data.
+     *
+     * @param bundleId - The bundle ID
+     * @returns Array of CPU texture atlases
+     */
+    getBundleAtlases(bundleId: BundleId): CpuTextureAtlas[];
+    /**
+     * The atlas size used for coordinate calculations.
+     */
+    get atlasSize(): number;
+}
+//# sourceMappingURL=Bundles.d.ts.map

package/dist/textures/Bundles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bundles.d.ts","sourceRoot":"","sources":["../../src/textures/Bundles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,eAAe,EAEf,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAQ9B;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,OAAO;;gBAKN,OAAO,GAAE,cAAmB;IAIxC;;;;;;OAMG;IACG,mBAAmB,CACvB,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,QAAQ,CAAC;IAmEpB;;;;;;OAMG;IACH,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,EAAE,GAAG,IAAI;IAQ3E;;;;OAIG;IACH,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAItC;;;;OAIG;IACH,cAAc,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAK3C;;;;;OAKG;IACH,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,EAAE;IAKnD;;;;;;OAMG;IACH,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI;IASjE;;;;;;OAMG;IACH,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;IAwCnE;;;;OAIG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IA8BtC;;OAEG;IACH,IAAI,QAAQ,IAAI,WAAW,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC,CAEpD;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,SAAS,EAAE,CAE5B;IAED;;;;;OAKG;IACH,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,WAAW,EAAE;IAU5C;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAWxD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IASzD;;;;;OAKG;IACH,4BAA4B,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IActD;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS;IAQ1D;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAUrC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAS5B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAYnC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO;IAIlC;;OAEG;IACH,sBAAsB,IAAI,QAAQ,EAAE;IAIpC;;OAEG;IACH,kBAAkB,IAAI,QAAQ,EAAE;IAMhC;;;;;;OAMG;IACH,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,EAAE;IAQvD;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;CA0EF"}

package/dist/textures/mod.d.ts

@@ -1,2 +1,4 @@
+export type { BundlesOptions } from "./Bundles";
+export { Bundles } from "./Bundles";
 export type * from "./types";
 //# sourceMappingURL=mod.d.ts.map

package/dist/textures/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/textures/mod.ts"],"names":[],"mappings":"AAAA,mBAAmB,SAAS,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/textures/mod.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,mBAAmB,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloopjs/toodle",
-  "version": "0.0.101",
+  "version": "0.0.103",
   "type": "module",
   "files": [
     "dist",

package/src/mod.ts

@@ -20,3 +20,4 @@ export * as Textures from "./textures/mod";
 export * as Utils from "./utils/mod";
 
 export { AssetManager } from "./textures/AssetManager";
+export { Bundles } from "./textures/Bundles";

package/src/textures/AssetManager.ts

@@ -8,14 +8,13 @@ import { FontPipeline } from "../text/FontPipeline";
 import { MsdfFont } from "../text/MsdfFont";
 import { TextShader } from "../text/TextShader";
 import { assert } from "../utils/mod";
+import { Bundles } from "./Bundles";
 import { TextureComputeShader } from "./TextureComputeShader";
 import type {
   AtlasBundleOpts,
   AtlasCoords,
   CpuTextureAtlas,
-  PixiRegion,
   TextureBundleOpts,
-  TextureRegion,
   TextureWithMetadata,
 } from "./types";
 import { getBitmapFromUrl, packBitmapsToAtlas } from "./util";
@@ -24,18 +23,18 @@ export type TextureId = string;
 export type BundleId = string;
 export type FontId = string;
 
-type Bundle = {
-  atlases: CpuTextureAtlas[];
-  isLoaded: boolean;
-  atlasIndices: number[];
+export type AssetManagerOptions = {
+  /** Existing Bundles instance to use for CPU-side storage. If not provided, a new one is created. */
+  bundles?: Bundles;
+  /** Texture format (default: "rgba8unorm") */
+  format?: "rgba8unorm" | "rg8unorm";
 };
 
 export class AssetManager {
   readonly textureAtlas: GPUTexture;
+  readonly bundles: Bundles;
   #device: GPUDevice;
   #presentationFormat: GPUTextureFormat;
-  #bundles: Map<BundleId, Bundle> = new Map();
-  #textures: Map<string, AtlasCoords[]> = new Map();
   #fonts: Map<string, TextShader> = new Map();
   #cropComputeShader: TextureComputeShader;
   #limits: Limits;
@@ -45,11 +44,14 @@ export class AssetManager {
     device: GPUDevice,
     presentationFormat: GPUTextureFormat,
     limits: Limits,
-    format: "rgba8unorm" | "rg8unorm" = "rgba8unorm",
+    options: AssetManagerOptions = {},
   ) {
     this.#device = device;
     this.#presentationFormat = presentationFormat;
     this.#limits = limits;
+    this.bundles =
+      options.bundles ?? new Bundles({ atlasSize: limits.textureSize });
+    const format = options.format ?? "rgba8unorm";
     this.textureAtlas = device.createTexture({
       label: "Asset Manager Atlas Texture",
       size: [
@@ -108,27 +110,27 @@ export class AssetManager {
    * @returns Whether the image has been cropped (i.e. if it has uvScaledCropped)
    */
   isCropped(id: TextureId): boolean {
-    if (!this.#textures.has(id)) {
+    if (!this.bundles.hasTexture(id)) {
       throw new Error(
         `Texture ${id} not found in atlas. Have you called toodle.loadTextures with this id or toodle.loadBundle with a bundle that contains it?`,
       );
     }
 
-    return this.#textures.get(id)![0].uvScaleCropped === undefined;
+    return this.bundles.getAtlasCoords(id)[0].uvScaleCropped === undefined;
   }
 
   /**
    * A read-only map of all currently loaded textures.
    */
   get textures() {
-    return this.#textures;
+    return this.bundles.textures;
   }
 
   /**
    * A read-only array of all currently loaded texture ids.
    */
   get textureIds() {
-    return Array.from(this.#textures.keys());
+    return this.bundles.textureIds;
   }
 
   /**
@@ -200,7 +202,7 @@ export class AssetManager {
       atlasIndex,
     };
 
-    this.#textures.set(id, [coords]);
+    this.bundles.addTextureEntry(id, coords);
     this.#availableIndices.delete(atlasIndex);
 
     textureWrapper.texture.destroy();
@@ -238,22 +240,25 @@ export class AssetManager {
    * See: https://toodle.gg/f849595b3ed13fc956fc1459a5cb5f0228f9d259/examples/texture-bundles.html
    */
   async loadBundle(bundleId: BundleId) {
-    const bundle = this.#bundles.get(bundleId);
-    if (!bundle) {
+    if (!this.bundles.hasBundle(bundleId)) {
       throw new Error(`Bundle ${bundleId} not found`);
     }
 
-    if (bundle.isLoaded) {
+    if (this.bundles.isBundleLoaded(bundleId)) {
       console.warn(`Bundle ${bundleId} is already loaded.`);
       return;
     }
 
-    for (const atlas of bundle.atlases) {
+    const atlases = this.bundles.getBundleAtlases(bundleId);
+    const atlasIndices: number[] = [];
+
+    for (const atlas of atlases) {
       const atlasIndex = await this.extra.loadAtlas(atlas);
-      bundle.atlasIndices.push(atlasIndex);
+      atlasIndices.push(atlasIndex);
     }
 
-    bundle.isLoaded = true;
+    // Use setBundleLoaded (not markBundleLoaded) since loadAtlas already populated textures
+    this.bundles.setBundleLoaded(bundleId, atlasIndices);
   }
 
   /**
@@ -263,24 +268,21 @@ export class AssetManager {
    * @param bundleId - The id of the bundle to unload
    */
   async unloadBundle(bundleId: BundleId) {
-    const bundle = this.#bundles.get(bundleId);
-    if (!bundle) {
+    if (!this.bundles.hasBundle(bundleId)) {
       throw new Error(`Bundle ${bundleId} not found`);
     }
 
-    if (!bundle.isLoaded) {
+    if (!this.bundles.isBundleLoaded(bundleId)) {
       console.warn(`Bundle ${bundleId} is not loaded.`);
       return;
     }
 
+    const atlasIndices = this.bundles.getBundleAtlasIndices(bundleId);
     await Promise.all(
-      bundle.atlasIndices.map((atlasIndex) =>
-        this.extra.unloadAtlas(atlasIndex),
-      ),
+      atlasIndices.map((atlasIndex) => this.extra.unloadAtlas(atlasIndex)),
     );
 
-    bundle.isLoaded = false;
-    bundle.atlasIndices = [];
+    this.bundles.unloadBundle(bundleId);
   }
 
   /**
@@ -328,15 +330,13 @@ export class AssetManager {
     )
       return;
 
-    const coords: AtlasCoords[] | undefined = this.#textures.get(
-      node.textureId,
-    );
-    if (!coords || !coords.length) {
+    if (!this.bundles.hasTexture(node.textureId)) {
       throw new Error(
         `Node ${node.id} references an invalid texture ${node.textureId}.`,
       );
     }
 
+    const coords = this.bundles.getAtlasCoords(node.textureId);
     if (
       coords.find((coord) => coord.atlasIndex === node.atlasCoords.atlasIndex)
     )
@@ -345,22 +345,6 @@ export class AssetManager {
     node.extra.setAtlasCoords(coords[0]);
   }
 
-  /**
-   * Sets a designated texture ID to the corresponding `AtlasRegion` built from a `TextureRegion` and `numerical atlas index.
-   * @param id - `String` representing the texture name. I.e. "PlayerSprite"
-   * @param textureRegion - `TextureRegion` corresponding the uv and texture offsets
-   * @param atlasIndex - `number` of the atlas that the texture will live in.
-   * @private
-   */
-  #addTexture(id: string, textureRegion: TextureRegion, atlasIndex: number) {
-    this.#textures.set(id, [
-      {
-        ...textureRegion,
-        atlasIndex,
-      },
-    ]);
-  }
-
   /**
    *
    * @param bitmap - `ImageBitmap` to be processed into a `GPUTexture` for storage and manipulation
@@ -422,115 +406,12 @@ export class AssetManager {
       this.#device,
     );
 
-    this.#bundles.set(bundleId, {
-      atlases,
-      atlasIndices: [],
-      isLoaded: false,
-    });
+    this.bundles.registerDynamicBundle(bundleId, atlases);
   }
 
   async #registerBundleFromAtlases(bundleId: BundleId, opts: AtlasBundleOpts) {
-    const atlases: CpuTextureAtlas[] = [];
-
-    for (const atlas of opts.atlases) {
-      const jsonUrl =
-        atlas.json ??
-        new URL(
-          atlas.png!.toString().replace(".png", ".json"),
-          atlas.png!.origin,
-        );
-      const pngUrl =
-        atlas.png ??
-        new URL(
-          atlas.json!.toString().replace(".json", ".png"),
-          atlas.json!.origin,
-        );
-
-      const atlasDef = await (await fetch(jsonUrl)).json();
-      const bitmap = !opts.rg8
-        ? await getBitmapFromUrl(pngUrl)
-        : await createImageBitmap(new ImageData(1, 1)); // placeholder bitmap if using rg8
-
-      let rg8Bytes: Uint8Array<ArrayBuffer> | undefined;
-      if (opts.rg8) {
-        const rg8url = new URL(
-          pngUrl.toString().replace(".png", ".rg8.gz"),
-          pngUrl.origin,
-        );
-        const rgBytes = await fetch(rg8url).then(async (r) => {
-          const enc = (r.headers.get("content-encoding") || "").toLowerCase();
-          // If server/CDN already set Content-Encoding, Fetch returns decompressed bytes.
-          if (
-            enc.includes("gzip") ||
-            enc.includes("br") ||
-            enc.includes("deflate")
-          ) {
-            return new Uint8Array(await r.arrayBuffer());
-          }
-
-          assert(r.body, "Response body of rg8 file is null");
-          const ds = new DecompressionStream("gzip");
-          const ab = await new Response(r.body.pipeThrough(ds)).arrayBuffer();
-          return new Uint8Array(ab);
-        });
-        rg8Bytes = rgBytes;
-      }
-
-      const cpuTextureAtlas: CpuTextureAtlas = {
-        texture: bitmap,
-        rg8Bytes,
-        textureRegions: new Map(),
-        width: opts.rg8 ? this.#limits.textureSize : bitmap.width,
-        height: opts.rg8 ? this.#limits.textureSize : bitmap.height,
-      };
-
-      for (const [assetId, frame] of Object.entries(atlasDef.frames) as [
-        string,
-        PixiRegion,
-      ][]) {
-        const leftCrop = frame.spriteSourceSize.x;
-        const rightCrop =
-          frame.sourceSize.w -
-          frame.spriteSourceSize.x -
-          frame.spriteSourceSize.w;
-        const topCrop = frame.spriteSourceSize.y;
-        const bottomCrop =
-          frame.sourceSize.h -
-          frame.spriteSourceSize.y -
-          frame.spriteSourceSize.h;
-
-        cpuTextureAtlas.textureRegions.set(assetId, {
-          cropOffset: {
-            x: leftCrop - rightCrop,
-            y: bottomCrop - topCrop,
-          },
-          originalSize: {
-            width: frame.sourceSize.w,
-            height: frame.sourceSize.h,
-          },
-          uvOffset: {
-            x: frame.frame.x / cpuTextureAtlas.width,
-            y: frame.frame.y / cpuTextureAtlas.height,
-          },
-          uvScale: {
-            width: frame.sourceSize.w / cpuTextureAtlas.width,
-            height: frame.sourceSize.h / cpuTextureAtlas.height,
-          },
-          uvScaleCropped: {
-            width: frame.frame.w / cpuTextureAtlas.width,
-            height: frame.frame.h / cpuTextureAtlas.height,
-          },
-        });
-      }
-
-      atlases.push(cpuTextureAtlas);
-    }
-
-    this.#bundles.set(bundleId, {
-      atlases,
-      atlasIndices: [],
-      isLoaded: false,
-    });
+    // Delegate to the Bundles instance for atlas parsing
+    await this.bundles.registerAtlasBundle(bundleId, opts);
   }
 
   /**
@@ -539,14 +420,12 @@ export class AssetManager {
   extra = {
     // Get an array of all currently registered bundle ids.
     getRegisteredBundleIds: (): string[] => {
-      return this.#bundles ? Array.from(this.#bundles.keys()) : [];
+      return this.bundles.getRegisteredBundleIds();
     },
 
     // Get an array of all currently loaded bundle ids.
     getLoadedBundleIds: (): string[] => {
-      return Array.from(this.#bundles.entries())
-        .filter(([, value]) => value.isLoaded)
-        .map(([key]) => key);
+      return this.bundles.getLoadedBundleIds();
     },
 
     /**
@@ -558,14 +437,7 @@ export class AssetManager {
      * @param coords - The atlas coordinates to set
      */
     setAtlasCoords: (id: TextureId, coords: AtlasCoords) => {
-      const oldCoords: AtlasCoords[] | undefined = this.#textures.get(id);
-      if (!oldCoords) return;
-      const indexToModify = oldCoords.findIndex(
-        (coord) => coord.atlasIndex === coords.atlasIndex,
-      );
-      if (indexToModify === -1) return;
-      oldCoords[indexToModify] = coords;
-      this.#textures.set(id, oldCoords);
+      this.bundles.setAtlasCoords(id, coords);
     },
 
     /**
@@ -575,12 +447,7 @@ export class AssetManager {
      * @returns An array of the atlas coordinates for the texture
      */
     getAtlasCoords: (id: TextureId): AtlasCoords[] => {
-      if (!this.#textures.has(id)) {
-        throw new Error(
-          `Texture ${id} not found in atlas. Have you called toodle.loadBundle with a bundle that contains this id (or toodle.loadTextures with this id as a key)?`,
-        );
-      }
-      return this.#textures.get(id) ?? [];
+      return this.bundles.getAtlasCoords(id);
     },
 
     /**
@@ -590,13 +457,7 @@ export class AssetManager {
      * @returns Point of the texture's associated X,Y offset
      */
     getTextureOffset: (id: TextureId): Vec2 => {
-      const texture: AtlasCoords[] | undefined = this.#textures.get(id);
-      if (!texture) {
-        throw new Error(
-          `Texture ${id} not found in atlas. Have you called toodle.loadTextures with this id or toodle.loadBundle with a bundle that contains it?`,
-        );
-      }
-      return texture[0].cropOffset;
+      return this.bundles.getTextureOffset(id);
     },
 
     /**
@@ -675,10 +536,7 @@ export class AssetManager {
       }
 
       for (const [id, region] of atlas.textureRegions) {
-        const existing = this.#textures.get(id);
-        if (existing) {
-          existing.push({ ...region, atlasIndex });
-        } else this.#addTexture(id, region, atlasIndex);
+        this.bundles.addTextureEntry(id, { ...region, atlasIndex });
       }
       return atlasIndex;
     },
@@ -690,17 +548,7 @@ export class AssetManager {
      */
     unloadAtlas: async (atlasIndex: number) => {
       this.#availableIndices.add(atlasIndex);
-      for (const [id, coords] of this.#textures.entries()) {
-        const indexToModify = coords.findIndex(
-          (coord) => coord.atlasIndex === atlasIndex,
-        );
-        if (indexToModify !== -1) {
-          coords.splice(indexToModify, 1);
-        }
-        if (!coords.length) {
-          this.#textures.delete(id);
-        }
-      }
+      this.bundles.removeTextureEntriesForAtlas(atlasIndex);
     },
   };