murow 0.0.71 → 0.0.73

package/dist/webgpu/types/2d/renderer.d.ts

@@ -1,8 +1,24 @@
-import { Base2DRenderer } from 'murow/renderer/base-2d-renderer';
+import { Base2DRenderer } from 'murow/renderer';
 import type { Renderer2DOptions, SpriteHandle, SpriteOptions, SpritesheetHandle, SpritesheetSource } from 'murow/renderer';
 import { Camera2D } from '../camera/camera-2d';
+import { type ParsedSpritesheet } from 'murow/renderer';
 import { GeometryBuilder, type GeometryOptions } from '../geometry/geometry-builder';
 import { ComputeBuilder, type ComputeOptions } from '../compute/compute-builder';
+import type { PrefabBucket2D, Prefab2D } from 'murow/renderer';
+export interface WebGPU2DRendererOptions extends Renderer2DOptions {
+    /**
+     * Pre-loaded prefab bucket. When provided, the renderer uploads each prefab
+     * to the GPU during `init()`, and `addSprite({ prefab: bucket.get('id') })`
+     * resolves to the right spritesheet handle. The bucket must have `load()`
+     * resolved before being passed in.
+     */
+    prefabs?: PrefabBucket2D;
+    /**
+     * How many sprite instances you intend to spawn. Used to size buffers when
+     * `maxSprites` is not given explicitly. Defaults to 1024.
+     */
+    maxInstances?: number;
+}
 export declare class WebGPU2DRenderer extends Base2DRenderer {
     private root;
     private _device;
@@ -36,8 +52,15 @@ export declare class WebGPU2DRenderer extends Base2DRenderer {
     private uniformData;
     private resizeObserver;
     private resizeCallbacks;
-    constructor(canvas: HTMLCanvasElement, options: Renderer2DOptions);
+    private readonly _prefabs;
+    constructor(canvas: HTMLCanvasElement, options: WebGPU2DRendererOptions);
     init(): Promise<void>;
+    /**
+     * Upload every prefab in the bucket to the GPU and stash the resulting
+     * SpritesheetHandle on each prefab so `bucket.get(id)` returns something
+     * usable as a sprite source.
+     */
+    private uploadPrefabBucket;
     private setupResizeObserver;
     /**
      * Register a callback that fires when the canvas resizes.
@@ -45,7 +68,15 @@ export declare class WebGPU2DRenderer extends Base2DRenderer {
      */
     onResize(callback: (width: number, height: number) => void): void;
     loadSpritesheet(source: SpritesheetSource): Promise<SpritesheetHandle>;
-    addSprite(opts: SpriteOptions): SpriteHandle;
+    /**
+     * Upload a previously-parsed spritesheet to the GPU. Returns a SpritesheetHandle.
+     * Splitting parse (CPU) from upload (GPU) lets callers parse spritesheets in parallel
+     * before a renderer exists.
+     */
+    uploadParsedSpritesheet(parsed: ParsedSpritesheet): SpritesheetHandle;
+    addSprite(opts: Omit<SpriteOptions, 'sheet'> & {
+        sheet: SpritesheetHandle | Prefab2D;
+    }): SpriteHandle;
     removeSprite(sprite: SpriteHandle): void;
     storePreviousState(): void;
     createGeometry(name: string, options: GeometryOptions): GeometryBuilder;

package/dist/webgpu/types/2d/sprite-accessor.d.ts

@@ -1,4 +1,4 @@
-import type { SpriteHandle } from "murow/renderer/types";
+import type { SpriteHandle } from "murow/renderer";
 export declare class SpriteAccessor implements SpriteHandle {
     private dynamicData;
     private staticData;

package/dist/webgpu/types/3d/clip-resync-coordinator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Bridges the bucket's `clips-changed` events to per-skin resync work in the
+ * renderer. The renderer registers `prefabId → skinIndex` at upload time;
+ * subsequent events flag affected skins in a pending set the renderer drains
+ * each frame.
+ */
+import type { PrefabBucket } from 'murow';
+export declare class GltfClipResyncCoordinator {
+    private bucket;
+    private readonly skinIndexByPrefabId;
+    private readonly _pending;
+    constructor(bucket: PrefabBucket);
+    /** Map a prefab id to its index in the renderer's `skinnedModels` list. */
+    registerSkin(prefabId: string, skinIndex: number): void;
+    /** Skin indices whose clip set has changed since the last `clear()`. */
+    get pending(): ReadonlySet<number>;
+    clear(): void;
+    /** Unsubscribe from the bucket and reset its animation clip sets. */
+    dispose(): void;
+}

package/dist/webgpu/types/3d/renderer.d.ts

@@ -1,8 +1,8 @@
-import { Base3DRenderer } from 'murow/renderer/base-3d-renderer';
-import type { Renderer3DOptions } from 'murow/renderer/types';
+import { Base3DRenderer } from 'murow/renderer';
+import type { Renderer3DOptions } from 'murow/renderer';
 import { ComputeBuilder, type ComputeOptions } from '../compute/compute-builder';
 import { Camera3D } from '../camera/camera-3d';
-import { type PlayOptions } from './skeletal-animation';
+import { type ParsedGltf, type PrefabBucket3D, type Prefab3D, type PlayOptions } from 'murow/renderer';
 export interface ModelData {
     positions: Float32Array;
     normals?: Float32Array;
@@ -25,6 +25,8 @@ export interface MeshInstanceHandle {
     setScale(x: number, y: number, z: number): void;
     play?(name: string, opts?: PlayOptions): void;
     stop?(): void;
+    /** Free this instance's renderer slot. Safe to call once per handle. */
+    destroy(): void;
 }
 /** A loaded glTF model — may contain multiple mesh parts that share a skeleton. */
 export interface GltfModel {
@@ -44,23 +46,46 @@ export interface InstanceHandle {
     play?(name: string, opts?: PlayOptions): void;
     stop?(): void;
     readonly skinned: boolean;
+    /** Free this instance's renderer slot(s). Safe to call once per handle. */
+    destroy(): void;
 }
 export interface MeshInstanceOptions {
-    model: ModelHandle | GltfModel;
-    x?: number;
-    y?: number;
-    z?: number;
-    rotX?: number;
-    rotY?: number;
-    rotZ?: number;
-    scaleX?: number;
-    scaleY?: number;
-    scaleZ?: number;
-    color?: [number, number, number];
+    /**
+     * The model to instance. Either a renderer-internal handle (from `loadGltf`,
+     * `loadModel`, `createGrid`) or a prefab fetched from a `PrefabBucket3D` —
+     * `bucket.get('my-id')`.
+     */
+    model: ModelHandle | GltfModel | Prefab3D;
+    /** World position. Defaults to `[0, 0, 0]`. */
+    position?: readonly [x: number, y: number, z: number];
+    /** Euler rotation in radians. Defaults to `[0, 0, 0]`. */
+    rotation?: readonly [x: number, y: number, z: number];
+    /** Per-axis scale. Pass a single number to scale uniformly. Defaults to `[1, 1, 1]`. */
+    scale?: number | readonly [x: number, y: number, z: number];
+    /** Tint color RGB. Defaults to `[1, 1, 1]`. */
+    color?: readonly [r: number, g: number, b: number];
 }
 export interface WebGPU3DRendererOptions extends Renderer3DOptions {
     maxSkinnedInstances?: number;
     maxBonesPerSkin?: number;
+    /**
+     * Pre-loaded prefab bucket. When provided, the renderer self-sizes its
+     * skinned-instance + bone buffers from the bucket's prefab stats, and
+     * uploads each prefab to the GPU during `init()`. The bucket must have
+     * `load()` resolved before being passed in.
+     *
+     * `maxSkinnedInstances` defaults to `maxInstances * maxSkinnedPartsPerPrefab`.
+     * `maxBonesPerSkin` defaults to the maximum joint count across all prefabs.
+     */
+    prefabs?: PrefabBucket3D;
+    /**
+     * Max distance (world units) at which skeletal animation is computed for
+     * skinned instances. Past this, instances still render but reuse their
+     * last bone matrices; their internal animation clocks keep ticking on
+     * CPU. See `renderer.setAnimationCullDistance` to change at runtime.
+     * Set to `Infinity` to disable. Default 50.
+     */
+    animationCullDistance?: number;
 }
 export declare class WebGPU3DRenderer extends Base3DRenderer {
     private root;
@@ -92,6 +117,7 @@ export declare class WebGPU3DRenderer extends Base3DRenderer {
     private models;
     private nextModelId;
     private skinnedModels;
+    private clipResync;
     private skinnedMeshLayout;
     private rawSkinnedPipeline;
     private rawSkinnedTexturedPipeline;
@@ -103,6 +129,7 @@ export declare class WebGPU3DRenderer extends Base3DRenderer {
     private packedAnimData;
     private animComputeKernel;
     private animComputeNeedsRebuild;
+    private animKernelBudgets;
     private animClipTableOffset;
     private animChannelTableOffset;
     private animJointLookupOffset;
@@ -115,12 +142,20 @@ export declare class WebGPU3DRenderer extends Base3DRenderer {
     private skinnedFreeList;
     private skinnedBatcher;
     private skinnedStaticDirty;
+    private skinnedStaticDV;
     private skinnedInstanceModelIds;
     private skinnedInstanceBoneOffsets;
     private skinnedAnimStates;
     private nextBoneOffset;
+    /** Reusable bone-offset blocks per skinIndex. Pushed on remove, popped on add. Indexed by skinIndex (low cardinality), so a Map of lists is fine. */
+    private freedBoneOffsets;
+    /** Per-bone-offset refcount. Linked multi-part instances share a block; freed when refcount hits 0. Indexed by boneOffset (< maxTotalBones). */
+    private boneOffsetRefcount;
+    /** Per-bone-offset skinIndex tag, so we can return the block to the right per-skin freelist on remove. */
+    private boneOffsetSkinIndex;
     private readonly maxSkinnedInstances;
     private readonly maxBonesPerSkin;
+    private animationCullDistanceSq;
     private rawSkinnedDynamicBuffer;
     private rawSkinnedStaticBuffer;
     private rawSkinnedUniformBuffer;
@@ -129,8 +164,16 @@ export declare class WebGPU3DRenderer extends Base3DRenderer {
     readonly camera: Camera3D;
     private uniformData;
     private lastRenderTime;
+    private readonly _prefabs;
     constructor(canvas: HTMLCanvasElement, options: WebGPU3DRendererOptions);
     init(): Promise<void>;
+    /**
+     * Upload every prefab in the bucket to the GPU and stash the handle on
+     * each prefab so `bucket.get(id)` resolves to a usable model. Also
+     * subscribes the resync coordinator to the bucket's `clips-changed`
+     * channel for lazy load/unload.
+     */
+    private uploadPrefabBucket;
     private setupResizeObserver;
     /**
      * Register a callback that fires when the canvas resizes.
@@ -138,6 +181,30 @@ export declare class WebGPU3DRenderer extends Base3DRenderer {
      */
     onResize(callback: (width: number, height: number) => void): void;
     createCompute(name: string, options: ComputeOptions): ComputeBuilder;
+    /**
+     * Set the maximum distance (in world units) at which the renderer keeps
+     * computing skeletal animation. Skinned instances farther than this are
+     * still drawn, but with their last-computed bone matrices instead of
+     * fresh ones, which saves GPU compute work. Their internal animation
+     * clocks keep ticking on CPU, so when they come back into range they
+     * resume in sync.
+     *
+     * Lower values trade visual smoothness on distant characters for FPS.
+     * Pass `Infinity` to disable culling entirely (always animate).
+     *
+     * Safe to call any time; takes effect on the next frame.
+     *
+     * @param distance Max distance to animate at, in world units.
+     */
+    setAnimationCullDistance(distance: number): void;
+    /** Current animation cull distance (in world units). See `setAnimationCullDistance`. */
+    get animationCullDistance(): number;
+    /**
+     * Max skinned instances the renderer was sized for at construction.
+     * Independent budget from `maxInstances` since skinned characters use a
+     * separate set of GPU buffers. Read-only.
+     */
+    get maxSkinned(): number;
     /**
      * Create a flat grid mesh on the XZ plane at Y=0.
      *
@@ -151,6 +218,18 @@ export declare class WebGPU3DRenderer extends Base3DRenderer {
         step?: number;
         lineWidth?: number;
     }): ModelHandle;
+    /**
+     * Create a unit-cube mesh centered at the origin. Pass `size` to scale the
+     * edge length, or keep size = 1 and scale at the instance level.
+     *
+     * ```ts
+     * const cube = renderer.createCube();
+     * renderer.addInstance({ model: cube, color: [1, 0.5, 0.2], scale: 2 });
+     * ```
+     */
+    createCube(opts?: {
+        size?: number;
+    }): ModelHandle;
     /**
      * Register a model. Returns a handle for addInstance().
      *
@@ -187,19 +266,58 @@ export declare class WebGPU3DRenderer extends Base3DRenderer {
     loadGltf(url: string, opts?: {
         animations?: string[];
     }): Promise<GltfModel>;
+    /**
+     * Upload a previously-parsed glTF to the GPU. Returns a GltfModel handle.
+     * Splitting parse (CPU) from upload (GPU) lets callers parse models in parallel
+     * before a renderer exists and inspect joint counts / vertex totals to size the
+     * renderer appropriately.
+     */
+    uploadParsedGltf(parsed: ParsedGltf): GltfModel;
     /**
      * Add an instance. For skinned models, pass `linkedTo` to share bone matrices
      * with another instance (e.g., when spawning all parts of a character).
      */
     addInstance(opts: MeshInstanceOptions): InstanceHandle;
     private addGltfInstance;
+    /**
+     * Spawn a composite prefab by spawning each of its parts at the composed
+     * (instance + offset) transform. The returned handle broadcasts subsequent
+     * `setPosition` / `setRotation` to every child, keeping each child's
+     * baked offset applied on top of the new value.
+     */
+    private addCompositeInstance;
     private addSkinnedInstance;
+    /**
+     * Drain pending resyncs from the coordinator. Per affected skin: rebuild
+     * its `SkeletalAnimation` clip list densely, remap in-flight animStates,
+     * then full-repack `packedAnimData`. Falls back to a kernel rebuild only
+     * when the new data exceeds the kernel's allocated budgets.
+     *
+     * The dense renumbering is load-bearing: the kernel reads each clip by
+     * its per-skin index, which must equal `SkeletalAnimation`'s clip id.
+     */
+    private syncLazyAnimationChanges;
+    /** Doubling-growth budgets for kernel storage buffers, with sensible floors. */
+    private growBudgetsForPacked;
+    /** Upload `packedAnimData` to the existing kernel iff it fits the current budgets. Returns false to force a rebuild. */
+    private tryUploadInPlace;
     /**
      * Update skeletal animations for all skinned instances. Call once per tick.
      */
     private updatedBoneOffsets;
+    /**
+     * Returns true if a skinned instance's bone-matrix compute should be
+     * dispatched this frame. Combines frustum culling (scaled bounding sphere)
+     * and a configurable distance cull from the camera. Callers pass the
+     * camera position + cullDistSq once outside the loop to avoid re-reading.
+     */
+    private shouldDispatchSkinning;
     private updateAnimations;
-    removeInstance(handle: MeshInstanceHandle): void;
+    /**
+     * Free an instance's renderer slot. Equivalent to `handle.destroy()` -
+     * kept as a convenience for direct lookup. Safe to call multiple times.
+     */
+    removeInstance(handle: InstanceHandle): void;
     storePreviousState(): void;
     render(alpha: number): void;
     /**

package/dist/webgpu/types/3d/skeletal-animation-compute/index.d.ts

@@ -1,2 +1,2 @@
-export { buildAnimationKernel } from './kernel';
+export { buildAnimationKernel, uploadPackedToKernel, type AnimationKernelBudgets } from './kernel';
 export { packAnimationData, type PackedBuffers } from './packer';

package/dist/webgpu/types/3d/skeletal-animation-compute/kernel.d.ts

@@ -1,8 +1,25 @@
 import { type ComputeKernel } from '../../compute/compute-builder';
 import type { TgpuRoot } from 'typegpu';
 import { type PackedBuffers } from './packer';
-import type { PackedAnimationData } from '../gltf-skin-parser';
-export declare function buildAnimationKernel(root: TgpuRoot, packed: PackedAnimationData, maxInstances: number, maxTotalBones: number): {
+import type { PackedAnimationData } from 'murow/renderer';
+/**
+ * Capacity headroom for each storage buffer. Over-allocating is harmless —
+ * the kernel only ever reads as far as the uploaded data describes — and
+ * lets resyncs upload via `writeBuffer` instead of rebuilding the kernel.
+ */
+export interface AnimationKernelBudgets {
+    skelI32Capacity: number;
+    animF32Capacity: number;
+    matricesCapacity: number;
+}
+export declare function buildAnimationKernel(root: TgpuRoot, packed: PackedAnimationData, maxInstances: number, maxTotalBones: number, budgets: AnimationKernelBudgets): {
     kernel: ComputeKernel;
     packedBuffers: PackedBuffers;
+    budgets: AnimationKernelBudgets;
 };
+/**
+ * Re-upload packed animation data into an already-built kernel. Uses
+ * `device.queue.writeBuffer` directly against the typed arrays — TypeGPU's
+ * per-element write path is dramatically slower for big buffers.
+ */
+export declare function uploadPackedToKernel(root: TgpuRoot, kernel: ComputeKernel, pb: PackedBuffers): void;

package/dist/webgpu/types/3d/skeletal-animation-compute/packer.d.ts

@@ -2,7 +2,7 @@
  * Packs animation data into flat typed arrays for GPU consumption.
  * Separated from the kernel so packing logic can be tested independently.
  */
-import type { PackedAnimationData } from '../gltf-skin-parser';
+import type { PackedAnimationData } from 'murow/renderer';
 export interface PackedBuffers {
     skelI32: Int32Array;
     animF32: Float32Array;

package/dist/webgpu/types/camera/camera-2d.d.ts

@@ -1,4 +1,4 @@
-import type { Camera2DState } from 'murow/renderer/types';
+import type { Camera2DState } from 'murow/renderer';
 export declare class Camera2D implements Camera2DState {
     x: number;
     y: number;

package/dist/webgpu/types/camera/camera-3d.d.ts

@@ -1,5 +1,5 @@
 import { Ray3D } from "murow/core/ray";
-import type { Camera3DState } from 'murow/renderer/types';
+import type { Camera3DState } from 'murow/renderer';
 export declare class Camera3D implements Camera3DState {
     position: [number, number, number];
     target: [number, number, number];

package/dist/webgpu/types/index.d.ts

@@ -1,32 +1,35 @@
 /**
  * @murow/webgpu — WebGPU rendering backend for murow.
  *
- * Re-exports TypeGPU's data module as `d` for user-facing shader authoring.
+ * This package supplies the **concrete WebGPU renderers** (2D + 3D), camera
+ * implementations, and the GPU-bound pieces (textures, compute, geometry
+ * builders, TypeGPU shader authoring).
+ *
+ * Renderer-agnostic primitives — `PrefabBucket`, parsers, skeletal animation,
+ * spritesheet helpers — live in the top-level `murow` package and should be
+ * imported from there.
  */
 export { d, std } from './shaders/typegpu';
 export { WebGPU2DRenderer } from './2d/renderer';
+export type { WebGPU2DRendererOptions } from './2d/renderer';
 export { SpriteAccessor } from './2d/sprite-accessor';
+export { AnimationController } from './2d/animation';
+export type { AnimationClip, AnimationState, AnimationClipConfig } from './2d/animation';
 export { WebGPU3DRenderer } from './3d/renderer';
-export type { ModelData, ModelHandle, GltfModel, InstanceHandle, MeshInstanceHandle, MeshInstanceOptions } from './3d/renderer';
+export type { ModelData, ModelHandle, GltfModel, InstanceHandle, MeshInstanceHandle, MeshInstanceOptions, } from './3d/renderer';
 export { MorphAnimation } from './3d/morph-animation';
 export type { MorphClip, MorphState, MorphClipConfig } from './3d/morph-animation';
-export { SkeletalAnimation } from './3d/skeletal-animation';
-export type { SkeletalClip, SkeletalAnimState, PlayOptions } from './3d/skeletal-animation';
-export type { SkinData, AnimationClipData, AnimationChannel } from './3d/gltf-skin-parser';
 export { Camera2D } from './camera/camera-2d';
 export { Camera3D } from './camera/camera-3d';
-export { GeometryBuilder, CustomGeometry, InstanceAccessor, InstanceContext, getFieldFloats, createGeometryDataLayout } from './geometry/geometry-builder';
-export type { GeometryOptions, InstanceLayoutConfig, CustomGeometryLayout, GeometryDataLayout, ShaderContext } from './geometry/geometry-builder';
+export { GeometryBuilder, CustomGeometry, InstanceAccessor, InstanceContext, getFieldFloats, createGeometryDataLayout, } from './geometry/geometry-builder';
+export type { GeometryOptions, InstanceLayoutConfig, CustomGeometryLayout, GeometryDataLayout, ShaderContext, } from './geometry/geometry-builder';
 export { resolveBuiltInGeometry } from './geometry/built-in';
 export type { BuiltInGeometry, GeometryData } from './geometry/built-in';
-export { Spritesheet, computeGridUVs, computeTexturePackerUVs, loadImage, createTextureFromBitmap } from './spritesheet/spritesheet';
-export type { SpritesheetConfig, TexturePackerData } from './spritesheet/spritesheet';
+export { Spritesheet, createTextureFromBitmap } from './spritesheet/spritesheet';
 export { ParticleEmitter } from './particle/emitter';
 export type { ParticleEmitterConfig, Range } from './particle/emitter';
-export { AnimationController } from './2d/animation';
-export type { AnimationClip, AnimationState, AnimationClipConfig } from './2d/animation';
 export { ComputeBuilder, ComputeKernel } from './compute/compute-builder';
 export type { ComputeOptions, ComputeBufferDef, ComputeInput } from './compute/compute-builder';
 export { rotate2d, worldToClip2d, worldToClip3d, remap, scaleRotate2d, inverseLerp } from './shaders/utils';
 export * from './core/constants';
-export { DynamicSprite, StaticSprite, SpriteUniforms, DynamicInstance3D, StaticInstance3D, DynamicMesh, StaticMesh, SkinnedStaticMesh, MeshUniforms } from './core/types';
+export { DynamicSprite, StaticSprite, SpriteUniforms, DynamicInstance3D, StaticInstance3D, DynamicMesh, StaticMesh, SkinnedStaticMesh, MeshUniforms, } from './core/types';

package/dist/webgpu/types/particle/emitter.d.ts

@@ -1,4 +1,4 @@
-import type { SpritesheetHandle } from 'murow/renderer/types';
+import type { SpritesheetHandle } from 'murow/renderer';
 import type { WebGPU2DRenderer } from '../2d/renderer';
 export interface Range {
     min: number;

package/dist/webgpu/types/spritesheet/spritesheet.d.ts

@@ -1,39 +1,13 @@
 /**
- * Spritesheet — manages sprite UV coordinates and GPU texture.
- * Supports grid-based spritesheets and texture-packer JSON.
+ * GPU-bound parts of spritesheet handling. Pure helpers (UV math, image loading)
+ * live in `murow/renderer/spritesheet-helpers`; they're re-exported here for
+ * backwards compatibility with code that did `import { ... } from 'murow/webgpu'`.
  *
  * Texture creation uses the raw GPUDevice (accessed via root.device)
  * since TypeGPU's texture API is unstable and we need copyExternalImageToTexture.
  */
-import type { SpritesheetHandle, SpriteUV } from 'murow/renderer/types';
-export interface GridSpritesheetConfig {
-    image: string;
-    frameWidth: number;
-    frameHeight: number;
-}
-export interface TexturePackerFrame {
-    frame: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-}
-export interface TexturePackerData {
-    frames: Record<string, TexturePackerFrame>;
-    meta: {
-        size: {
-            w: number;
-            h: number;
-        };
-    };
-}
-export interface SpritesheetConfig {
-    image: string;
-    frameWidth?: number;
-    frameHeight?: number;
-    data?: string;
-}
+import type { SpritesheetHandle, SpriteUV } from 'murow/renderer';
+export { computeGridUVs, computeTexturePackerUVs, loadImage, type GridSpritesheetConfig, type SpritesheetConfig, type TexturePackerData, type TexturePackerFrame, } from 'murow/renderer';
 export declare class Spritesheet implements SpritesheetHandle {
     readonly id: number;
     readonly frameCount: number;
@@ -48,9 +22,6 @@ export declare class Spritesheet implements SpritesheetHandle {
     get width(): number;
     get height(): number;
 }
-export declare function computeGridUVs(imageWidth: number, imageHeight: number, frameWidth: number, frameHeight: number): SpriteUV[];
-export declare function computeTexturePackerUVs(data: TexturePackerData): SpriteUV[];
-export declare function loadImage(url: string): Promise<ImageBitmap>;
 export declare function createTextureFromBitmap(device: GPUDevice, bitmap: ImageBitmap): {
     texture: GPUTexture;
     view: GPUTextureView;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "murow",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "description": "A lightweight TypeScript game engine for server-authoritative multiplayer games",
   "types": "dist/types/index.d.ts",
   "type": "module",

package/dist/cjs/renderer/base-3d-renderer.js

@@ -1 +0,0 @@
-var s=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var l=(r,e)=>{for(var a in e)s(r,a,{get:e[a],enumerable:!0})},c=(r,e,a,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of d(e))!p.call(r,t)&&t!==a&&s(r,t,{get:()=>e[t],enumerable:!(n=m(e,t))||n.enumerable});return r};var D=r=>c(s({},"__esModule",{value:!0}),r);var x={};l(x,{Base3DRenderer:()=>i});module.exports=D(x);var o=require("./base-renderer");class i extends o.BaseRenderer{constructor(e,a){super(e,a),this.maxModels=a.maxModels}}

package/dist/esm/renderer/base-2d-renderer.js

@@ -1 +0,0 @@
-import{BaseRenderer as t}from"./base-renderer";class p extends t{constructor(r,e){super(r,e),this.maxSprites=e.maxSprites}}export{p as Base2DRenderer};

package/dist/esm/renderer/base-3d-renderer.js

@@ -1 +0,0 @@
-import{BaseRenderer as a}from"./base-renderer";class n extends a{constructor(r,e){super(r,e),this.maxModels=e.maxModels}}export{n as Base3DRenderer};