@nodecraft/rendermite 1.0.5 → 1.0.7

package/dist/render/legacy-tints.d.ts

@@ -1,5 +1,5 @@
-import { i as TextureLoader } from "../loader-TFFNV4Jl.js";
-import { n as TintColor } from "../face-CpVdnf-w.js";
+import { i as TextureLoader } from "../loader-Myy22TDL.js";
+import { r as TintColor } from "../face-C49L66sQ.js";
 //#region src/render/legacy-tints.d.ts
 /**
  * Tints for a model rendered without an item definition (pre-1.21.4 eras and

package/dist/render/obj.d.ts

@@ -1,9 +1,9 @@
-import { a as ResourceManager } from "../manager-CoZaeQTu.js";
-import { i as TextureLoader } from "../loader-TFFNV4Jl.js";
-import { r as ResolvedModel } from "../loader-C-6QN3xv.js";
-import { t as FloatTexture } from "../blend-Qvrn6YgK.js";
+import { a as ResourceManager } from "../manager-Cv1NeFyF.js";
+import { i as TextureLoader } from "../loader-Myy22TDL.js";
+import { r as ResolvedModel } from "../loader-D22zZME7.js";
+import { t as FloatTexture } from "../blend-CEHoJ7tM.js";
 import { n as Vec3 } from "../vector-DRKRi4--.js";
-import { n as RenderOptions } from "../renderer-nbMCw1Pl.js";
+import { i as RenderOptions } from "../renderer-B20ssjRm.js";
 //#region src/render/obj.d.ts
 interface ObjTriangle {
   positions: [Vec3, Vec3, Vec3];

package/dist/render/obj.js

@@ -1,2 +1,2 @@
-import { c as renderObjModel, o as parseMtl, s as parseObj } from "../renderer-LDhBNHcl.js";
+import { c as renderObjModel, o as parseMtl, s as parseObj } from "../renderer-gQW_I7YG.js";
 export { parseMtl, parseObj, renderObjModel };

package/dist/render/pipeline.d.ts

@@ -0,0 +1,2 @@
+import { i as RenderedFrames, n as ItemRenderOutcome, r as PipelineSettings, t as ItemPipeline } from "../pipeline-HiA3DC71.js";
+export { ItemPipeline, ItemRenderOutcome, PipelineSettings, RenderedFrames };

package/dist/render/pipeline.js

@@ -0,0 +1,2 @@
+import { t as ItemPipeline } from "../pipeline-Da2Kavba.js";
+export { ItemPipeline };

package/dist/render/rasterizer.d.ts

@@ -1,2 +1,2 @@
-import { a as createFaceBuffer, i as compactFaceBuffer, n as RasterPoint, o as drawTexturedTriangle, r as RowCursor, s as phpRound, t as FaceBuffer } from "../rasterizer-Dh35qXbn.js";
-export { FaceBuffer, RasterPoint, RowCursor, compactFaceBuffer, createFaceBuffer, drawTexturedTriangle, phpRound };
+import { a as clearFaceBuffer, c as drawTexturedTriangle, i as RowCursor, l as phpRound, n as FaceBuffer, o as compactFaceBuffer, r as RasterPoint, s as createFaceBuffer, t as DirtyRect } from "../rasterizer-B9ZGJI3-.js";
+export { DirtyRect, FaceBuffer, RasterPoint, RowCursor, clearFaceBuffer, compactFaceBuffer, createFaceBuffer, drawTexturedTriangle, phpRound };

package/dist/render/rasterizer.js

@@ -1,2 +1,2 @@
-import { a as phpRound, i as drawTexturedTriangle, n as compactFaceBuffer, r as createFaceBuffer, t as RowCursor } from "../rasterizer-BHWDrmGz.js";
-export { RowCursor, compactFaceBuffer, createFaceBuffer, drawTexturedTriangle, phpRound };
+import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, r as compactFaceBuffer, t as RowCursor } from "../rasterizer-76qO8TDh.js";
+export { RowCursor, clearFaceBuffer, compactFaceBuffer, createFaceBuffer, drawTexturedTriangle, phpRound };

package/dist/render/renderer.d.ts

@@ -1,2 +1,2 @@
-import { a as pointResize, i as boxDownscale, n as RenderOptions, o as renderModel, r as RenderedFrames, s as renderModelFrames, t as ItemRenderError } from "../renderer-nbMCw1Pl.js";
-export { ItemRenderError, RenderOptions, RenderedFrames, boxDownscale, pointResize, renderModel, renderModelFrames };
+import { a as RenderedFrames, c as renderModel, i as RenderOptions, l as renderModelFrames, n as AnimationLimits, o as boxDownscale, r as ItemRenderError, s as pointResize, t as AnimationDiagnostics } from "../renderer-B20ssjRm.js";
+export { AnimationDiagnostics, AnimationLimits, ItemRenderError, RenderOptions, RenderedFrames, boxDownscale, pointResize, renderModel, renderModelFrames };

package/dist/render/renderer.js

@@ -1,2 +1,2 @@
-import { a as renderModelFrames, i as renderModel, n as boxDownscale, r as pointResize, t as ItemRenderError } from "../renderer-LDhBNHcl.js";
+import { a as renderModelFrames, i as renderModel, n as boxDownscale, r as pointResize, t as ItemRenderError } from "../renderer-gQW_I7YG.js";
 export { ItemRenderError, boxDownscale, pointResize, renderModel, renderModelFrames };

package/dist/render/tints.d.ts

@@ -1,2 +1,2 @@
-import { a as resolveTint, i as parseTintValue, n as InvalidTinterDefinitionError, o as resolveTints, r as TintContext, t as DYE_COLORS } from "../tints-txt-8xI5.js";
+import { a as resolveTint, i as parseTintValue, n as InvalidTinterDefinitionError, o as resolveTints, r as TintContext, t as DYE_COLORS } from "../tints-BH9l0ND0.js";
 export { DYE_COLORS, InvalidTinterDefinitionError, TintContext, parseTintValue, resolveTint, resolveTints };

package/dist/{renderer-nbMCw1Pl.d.ts → renderer-B20ssjRm.d.ts}

@@ -1,15 +1,21 @@
-import { a as ResourceManager } from "./manager-CoZaeQTu.js";
-import { i as TextureLoader } from "./loader-TFFNV4Jl.js";
-import { r as ResolvedModel } from "./loader-C-6QN3xv.js";
-import { t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { a as ResourceManager } from "./manager-Cv1NeFyF.js";
+import { i as TextureLoader } from "./loader-Myy22TDL.js";
+import { r as ResolvedModel } from "./loader-D22zZME7.js";
+import { t as FloatTexture } from "./blend-CEHoJ7tM.js";
 import { t as Mat4 } from "./vector-DRKRi4--.js";
 import { a as LightingProfileName } from "./lighting-3FGRC3Af.js";
-import { n as TintColor } from "./face-CpVdnf-w.js";
+import { r as TintColor } from "./face-C49L66sQ.js";
 //#region src/render/renderer.d.ts
+interface AnimationLimits {
+  /** Emitted frames per icon (default 128). */
+  maxFrames?: number;
+}
 interface RenderOptions {
   size: number;
   quality: number;
   lightingProfile: LightingProfileName;
+  /** Bounds on animated timelines; defaults apply when omitted. */
+  animation?: AnimationLimits;
   /** Accumulated item-definition transformation (inner matrix). */
   itemTransform?: Mat4;
   /** Tint colors by index (face tintindex / generated layer number). */
@@ -22,6 +28,17 @@ interface RenderedFrames {
   frames: FloatTexture[];
   /** Display duration per frame in milliseconds (50ms per game tick). */
   delaysMs: number[];
+  /** What the timeline did, so a bounded animation is never a silent one. */
+  animation?: AnimationDiagnostics;
+}
+interface AnimationDiagnostics {
+  /** Combined cycle length in game ticks (the lcm of the textures' periods). */
+  ticks: number;
+  /** Ticks considered before identical neighbours were coalesced. */
+  candidates: number;
+  /** Whether the frame cap forced even sampling instead of exact frames. */
+  sampled: boolean;
+  interpolated: boolean;
 }
 /**
  * Render every animation frame of a model (a single frame for unanimated
@@ -41,4 +58,4 @@ declare function pointResize(texture: FloatTexture, width: number, height: numbe
  */
 declare function boxDownscale(texture: FloatTexture, factor: number): FloatTexture;
 //#endregion
-export { pointResize as a, boxDownscale as i, RenderOptions as n, renderModel as o, RenderedFrames as r, renderModelFrames as s, ItemRenderError as t };
+export { RenderedFrames as a, renderModel as c, RenderOptions as i, renderModelFrames as l, AnimationLimits as n, boxDownscale as o, ItemRenderError as r, pointResize as s, AnimationDiagnostics as t };

package/dist/{renderer-LDhBNHcl.js → renderer-gQW_I7YG.js}

@@ -1,13 +1,13 @@
 import { c as normalize, g as transformVector, m as sub, n as displayMatrix, o as identity, r as dot, s as multiply, t as cross } from "./vector-CCxLae_T.js";
 import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
-import { i as resolveTexture } from "./loader-A-BZa8J4.js";
-import { a as tintTexture, n as cloneFloatTexture, r as darkenTexture, s as toFloatTexture, t as blendPixel } from "./blend-CHP2-j9U.js";
-import { t as combineFaceBuffers } from "./compose-qjhyBvnS.js";
-import { a as phpRound, i as drawTexturedTriangle, r as createFaceBuffer, t as RowCursor } from "./rasterizer-BHWDrmGz.js";
-import { n as renderFace, t as faceMaxZ } from "./face-D-N1amV4.js";
+import { a as tintTexture, n as cloneFloatTexture, r as darkenTexture, s as toFloatTexture, t as blendPixel } from "./blend-D0XWgVQr.js";
+import { t as combineFaceBuffers } from "./compose-lWPrB7wh.js";
+import { a as drawTexturedTriangle, i as createFaceBuffer, n as clearFaceBuffer, o as phpRound, t as RowCursor } from "./rasterizer-76qO8TDh.js";
+import { n as renderFace, t as faceMaxZ } from "./face-Cl1O4m2i.js";
 import { t as paintBucketFluid } from "./fluid-bucket-D-GpUQjg.js";
 import { r as buildElementFaces } from "./geometry-uIDha8S4.js";
 import { c as lightsForProfile } from "./lighting--5myudVu.js";
+import { i as resolveTexture } from "./loader-B8NJO7pR.js";
 //#region src/render/obj.ts
 /**
 * Forge/NeoForge OBJ model rendering — the class the old pipeline left
@@ -140,6 +140,7 @@ async function renderObjModel(model, resources, textures, options) {
 	const transformation = multiply(guiMatrix, options.itemTransform ?? identity());
 	const renderSize = options.size * options.quality;
 	const out = createFaceBuffer(renderSize, renderSize);
+	const scratch = createFaceBuffer(renderSize, renderSize);
 	const shaded = /* @__PURE__ */ new Map();
 	for (const triangle of parsed.triangles) {
 		const transformed = triangle.positions.map((position) => transformVector(transformation, position));
@@ -164,7 +165,7 @@ async function renderObjModel(model, resources, textures, options) {
 			darkenTexture(texture, 1 - bucket / 64, 0, 0, texture.width, texture.height);
 			shaded.set(key, texture);
 		}
-		const scratch = createFaceBuffer(renderSize, renderSize);
+		clearFaceBuffer(scratch);
 		const cursor = new RowCursor();
 		const point = (index) => {
 			return {
@@ -176,7 +177,8 @@ async function renderObjModel(model, resources, textures, options) {
 			};
 		};
 		drawTexturedTriangle(point(0), point(1), point(2), scratch, texture, cursor);
-		for (let pixel = 0; pixel < renderSize * renderSize; pixel++) {
+		for (let y = Math.max(scratch.dirty.minY, 0); y <= Math.min(scratch.dirty.maxY, renderSize - 1); y++) for (let x = Math.max(scratch.dirty.minX, 0); x <= Math.min(scratch.dirty.maxX, renderSize - 1); x++) {
+			const pixel = y * renderSize + x;
 			const offset = pixel * 4;
 			const alpha = scratch.colors[offset + 3];
 			if (alpha <= 0) continue;
@@ -241,16 +243,19 @@ async function renderModelFrames(model, textures, options) {
 		ticks = ticks / gcd(ticks, texture.tickLength) * texture.tickLength;
 		interpolated ||= texture.interpolated;
 	}
-	const maxSkippable = interpolated ? Math.ceil(ticks / MAX_ANIMATION_FRAMES) : null;
+	const maxFrames = Math.max(1, options.animation?.maxFrames ?? MAX_ANIMATION_FRAMES);
+	const exact = interpolated ? null : changeTicks(animated.values().toArray(), ticks, maxFrames);
+	const candidates = exact ?? evenlySpacedTicks(ticks, maxFrames);
 	const frames = [];
 	const emitTicks = [];
 	let lastKey = null;
-	let sinceLast = 0;
-	for (let tick = 0; tick < ticks; tick++) {
-		sinceLast++;
-		const key = animated.values().map((texture) => texture.resolveFrame(tick).frame).toArray().join(",");
-		if (lastKey !== null && key === lastKey && !interpolated && tick !== ticks - 1) continue;
-		if (lastKey !== null && interpolated && maxSkippable !== null && sinceLast < maxSkippable && key === lastKey) continue;
+	const session = createSession();
+	for (const tick of candidates) {
+		const key = animated.values().map((texture) => {
+			const resolved = texture.resolveFrame(tick);
+			return texture.interpolated ? `${resolved.frame}+${resolved.interpolation}` : String(resolved.frame);
+		}).toArray().join(",");
+		if (key === lastKey) continue;
 		const supplier = async (reference) => {
 			if (skipped.has(reference)) return null;
 			const texture = animated.get(reference);
@@ -258,20 +263,59 @@ async function renderModelFrames(model, textures, options) {
 			return texture.at(tick);
 		};
 		const renderSize = options.size * options.quality;
-		const full = model.builtinParent === "builtin/generated" ? await renderGeneratedItemWith(model, supplier, renderSize, options.tints) : await renderElementModelWith(model, supplier, renderSize, options);
+		const full = model.builtinParent === "builtin/generated" ? await renderGeneratedItemWith(model, supplier, renderSize, options.tints) : await renderElementModelWith(model, supplier, renderSize, options, session);
 		frames.push(options.quality === 1 ? full : boxDownscale(full, options.quality));
 		emitTicks.push(tick);
 		lastKey = key;
-		sinceLast = 0;
 	}
 	return {
 		frames,
 		delaysMs: emitTicks.map((tick, index) => {
 			const next = index + 1 < emitTicks.length ? emitTicks[index + 1] : ticks;
 			return Math.max(TICK_MS, (next - tick) * TICK_MS);
-		})
+		}),
+		animation: {
+			ticks,
+			candidates: candidates.length,
+			sampled: exact === null && ticks > frames.length,
+			interpolated
+		}
 	};
 }
+/**
+* Every tick in the combined timeline where some texture switches frame, or
+* null once that exceeds `limit` — past that the caller samples instead, and
+* enumerating a multi-minute timeline in full would be the very cost this
+* bound exists to avoid.
+*/
+function changeTicks(textures, ticks, limit) {
+	const found = /* @__PURE__ */ new Set([0]);
+	for (const texture of textures) {
+		if (texture.frameCount <= 1) continue;
+		const period = Math.max(1, texture.tickLength);
+		const starts = texture.frameStartTicks();
+		for (let base = 0; base < ticks; base += period) for (const start of starts) {
+			const tick = base + start;
+			if (tick < ticks) found.add(tick);
+			if (found.size > limit) return null;
+		}
+	}
+	return [...found].toSorted((left, right) => left - right);
+}
+/** `count` tick positions spread evenly across the cycle, always starting at 0. */
+function evenlySpacedTicks(ticks, maxFrames) {
+	const count = Math.min(ticks, maxFrames);
+	const sampled = [];
+	let previous = -1;
+	for (let index = 0; index < count; index++) {
+		const tick = Math.floor(index * ticks / count);
+		if (tick !== previous) {
+			sampled.push(tick);
+			previous = tick;
+		}
+	}
+	return sampled;
+}
 async function loadAnimatedTexture(model, textures, reference) {
 	const locator = resolveTexture(model, reference);
 	if (locator) {
@@ -391,11 +435,23 @@ async function renderElementModel(model, textures, renderSize, options) {
 	};
 	return renderElementModelWith(model, supplier, renderSize, options);
 }
-async function renderElementModelWith(model, supplier, renderSize, options) {
+function createSession() {
+	return {
+		geometry: null,
+		order: null,
+		transformation: null,
+		scratch: null,
+		shadeCache: /* @__PURE__ */ new WeakMap(),
+		floatTextures: /* @__PURE__ */ new Map(),
+		faceBuffers: []
+	};
+}
+/** Interpolated frames are new objects every tick; don't grow without bound. */
+const MAX_CACHED_FLOAT_TEXTURES = 32;
+async function renderElementModelWith(model, supplier, renderSize, options, session = createSession()) {
 	const lights = lightsForProfile(options.lightingProfile);
 	const light = model.elementsGuiLight === "side" ? lights.side : lights.front;
 	const loadedTextures = /* @__PURE__ */ new Map();
-	const floatTextures = /* @__PURE__ */ new Map();
 	const load = (reference) => {
 		let pending = loadedTextures.get(reference);
 		if (!pending) {
@@ -404,47 +460,68 @@ async function renderElementModelWith(model, supplier, renderSize, options) {
 		}
 		return pending;
 	};
-	const faces = [];
+	if (!session.geometry) {
+		const geometry = [];
+		for (const element of model.elements) for (const face of buildElementFaces(element)) geometry.push({
+			geometry: face,
+			maxZ: faceMaxZ(face)
+		});
+		session.geometry = geometry;
+		session.order = geometry.map((_, index) => index).toSorted((left, right) => geometry[left].maxZ - geometry[right].maxZ);
+	}
+	const specs = session.geometry;
+	const order = session.order ?? [];
 	let skippedFaces = 0;
-	for (const element of model.elements) for (const geometry of buildElementFaces(element)) {
-		const texture = await load(geometry.textureRef);
-		if (!texture) {
-			skippedFaces++;
-			continue;
-		}
-		let float = floatTextures.get(texture);
+	let drawable = 0;
+	for (const spec of specs) if (await load(spec.geometry.textureRef)) drawable++;
+	else skippedFaces++;
+	if (drawable === 0 && skippedFaces > 0) throw new ItemRenderError(`Every face texture unresolved in ${model.locator} (would render invisible)`);
+	if (!session.transformation) {
+		const gui = model.display.gui;
+		const guiMatrix = displayMatrix(gui?.rotation ?? [
+			0,
+			0,
+			0
+		], gui?.translation ?? [
+			0,
+			0,
+			0
+		], gui?.scale ?? [
+			1,
+			1,
+			1
+		]);
+		session.transformation = multiply(guiMatrix, options.itemTransform ?? identity());
+	}
+	session.scratch ??= createFaceBuffer(renderSize, renderSize);
+	if (session.floatTextures.size > MAX_CACHED_FLOAT_TEXTURES) session.floatTextures.clear();
+	const buffers = [];
+	for (const index of order) {
+		const spec = specs[index];
+		const texture = await load(spec.geometry.textureRef);
+		if (!texture) continue;
+		let float = session.floatTextures.get(texture);
 		if (!float) {
 			float = toFloatTexture(texture);
-			floatTextures.set(texture, float);
+			session.floatTextures.set(texture, float);
 		}
-		faces.push({
-			geometry,
+		const cached = session.faceBuffers[index];
+		if (cached?.texture === float) {
+			if (cached.buffer) buffers.push(cached.buffer);
+			continue;
+		}
+		const face = {
+			geometry: spec.geometry,
 			texture: float,
 			light,
-			tint: geometry.tintIndex !== null ? options.tints?.[geometry.tintIndex] ?? null : null,
-			maxZ: faceMaxZ(geometry)
-		});
-	}
-	if (faces.length === 0 && skippedFaces > 0) throw new ItemRenderError(`Every face texture unresolved in ${model.locator} (would render invisible)`);
-	faces.sort((a, b) => a.maxZ - b.maxZ);
-	const gui = model.display.gui;
-	const guiMatrix = displayMatrix(gui?.rotation ?? [
-		0,
-		0,
-		0
-	], gui?.translation ?? [
-		0,
-		0,
-		0
-	], gui?.scale ?? [
-		1,
-		1,
-		1
-	]);
-	const transformation = multiply(guiMatrix, options.itemTransform ?? identity());
-	const buffers = [];
-	for (const face of faces) {
-		const buffer = renderFace(face, renderSize, renderSize, transformation);
+			tint: spec.geometry.tintIndex !== null ? options.tints?.[spec.geometry.tintIndex] ?? null : null,
+			maxZ: spec.maxZ
+		};
+		const buffer = renderFace(face, renderSize, renderSize, session.transformation, session.scratch, session.shadeCache);
+		session.faceBuffers[index] = {
+			texture: float,
+			buffer
+		};
 		if (buffer) buffers.push(buffer);
 	}
 	return combineFaceBuffers(renderSize, renderSize, buffers);
@@ -452,14 +529,19 @@ async function renderElementModelWith(model, supplier, renderSize, options) {
 /** Nearest-neighbour resize matching Imagick FILTER_POINT (destination-center sampling). */
 function pointResize(texture, width, height) {
 	const data = new Float64Array(width * height * 4);
+	const srcXs = new Int32Array(width);
+	for (let x = 0; x < width; x++) {
+		const srcX = Math.floor((x + .5) * texture.width / width);
+		srcXs[x] = srcX >= texture.width ? texture.width - 1 : srcX;
+	}
 	for (let y = 0; y < height; y++) {
 		let srcY = Math.floor((y + .5) * texture.height / height);
 		srcY = srcY >= texture.height ? texture.height - 1 : srcY;
+		const srcRow = srcY * texture.width;
+		const dstRow = y * width;
 		for (let x = 0; x < width; x++) {
-			let srcX = Math.floor((x + .5) * texture.width / width);
-			srcX = srcX >= texture.width ? texture.width - 1 : srcX;
-			const src = (srcY * texture.width + srcX) * 4;
-			const dst = (y * width + x) * 4;
+			const src = (srcRow + srcXs[x]) * 4;
+			const dst = (dstRow + x) * 4;
 			data[dst] = texture.data[src];
 			data[dst + 1] = texture.data[src + 1];
 			data[dst + 2] = texture.data[src + 2];
@@ -485,6 +567,7 @@ function boxPass(texture, factor, isHorizontal) {
 	const width = isHorizontal ? Math.round(texture.width / factor) : texture.width;
 	const height = isHorizontal ? texture.height : Math.round(texture.height / factor);
 	const data = new Float64Array(width * height * 4);
+	const { data: src } = texture;
 	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
 		let r = 0;
 		let g = 0;
@@ -492,11 +575,11 @@ function boxPass(texture, factor, isHorizontal) {
 		let alphaSum = 0;
 		for (let i = 0; i < factor; i++) {
 			const srcX = isHorizontal ? x * factor + i : x;
-			const src = ((isHorizontal ? y : y * factor + i) * texture.width + srcX) * 4;
-			const alpha = Math.round(texture.data[src + 3] * 65535);
-			r += Math.round(texture.data[src] * 65535) * alpha;
-			g += Math.round(texture.data[src + 1] * 65535) * alpha;
-			b += Math.round(texture.data[src + 2] * 65535) * alpha;
+			const srcOffset = ((isHorizontal ? y : y * factor + i) * texture.width + srcX) * 4;
+			const alpha = Math.round(src[srcOffset + 3] * 65535);
+			r += Math.round(src[srcOffset] * 65535) * alpha;
+			g += Math.round(src[srcOffset + 1] * 65535) * alpha;
+			b += Math.round(src[srcOffset + 2] * 65535) * alpha;
 			alphaSum += alpha;
 		}
 		const dst = (y * width + x) * 4;

package/dist/resources/cache.d.ts

@@ -0,0 +1,30 @@
+//#region src/resources/cache.d.ts
+/**
+ * Least-recently-used map used by the model and texture loaders. Their caches
+ * were unbounded, which is fine for one namespace and not fine for a run that
+ * walks thousands of them in a single process — resident memory only ever grew.
+ */
+declare class LruCache<K, V> {
+  private readonly entries;
+  private readonly maxEntries;
+  private readonly weigh;
+  private readonly maxWeight;
+  private readonly weights;
+  private weight;
+  constructor(maxEntries: number, options?: {
+    maxWeight?: number;
+    weigh?: (value: V) => number;
+  });
+  private evict;
+  get size(): number;
+  get(key: K): V | undefined;
+  set(key: K, value: V): void;
+  /**
+   * Record a value's real cost once it is known. Loaders cache promises, so the
+   * weight of a decoded texture only exists after it resolves.
+   */
+  settle(key: K, value: V): void;
+  clear(): void;
+}
+//#endregion
+export { LruCache };

package/dist/resources/cache.js

@@ -0,0 +1,2 @@
+import { t as LruCache } from "../cache-Cr2ON3RQ.js";
+export { LruCache };

package/dist/resources/descriptor.d.ts

@@ -0,0 +1,2 @@
+import { c as describeResources, l as restoreResources, o as DescribableResourceManager, s as ResourceDescriptor } from "../manager-Cv1NeFyF.js";
+export { DescribableResourceManager, ResourceDescriptor, describeResources, restoreResources };

package/dist/resources/descriptor.js

@@ -0,0 +1,2 @@
+import { n as restoreResources, t as describeResources } from "../descriptor-DWebtkI1.js";
+export { describeResources, restoreResources };

package/dist/resources/jar.d.ts

@@ -1,2 +1,2 @@
-import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-6T3xdgaL.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-CFkA-VgT.js";
 export { JarResourceManager, UnsafeJarError, isUnsafeEntryPath };

package/dist/resources/jar.js

@@ -1,2 +1,2 @@
-import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-Bt3i0ls4.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "../jar-D9z-X7tA.js";
 export { JarResourceManager, UnsafeJarError, isUnsafeEntryPath };

package/dist/resources/manager.d.ts

@@ -1,2 +1,2 @@
-import { a as ResourceManager, i as ResourceKindName, n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-CoZaeQTu.js";
+import { a as ResourceManager, i as ResourceKindName, n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-Cv1NeFyF.js";
 export { FolderResourceManager, LayeredResourceManager, ResourceKind, ResourceKindName, ResourceManager };

package/dist/resources/manager.js

@@ -1,2 +1,2 @@
-import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-dfI7b9N4.js";
+import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "../manager-CkletR5K.js";
 export { FolderResourceManager, LayeredResourceManager, ResourceKind };

package/dist/resources/synthetic.d.ts

@@ -1,2 +1,2 @@
-import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-CDsj--li.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-Qk-BSUXO.js";
 export { KindFilteredResourceManager, MapResourceManager };

package/dist/resources/synthetic.js

@@ -1,2 +1,2 @@
-import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-DC2bSnGe.js";
+import { n as MapResourceManager, t as KindFilteredResourceManager } from "../synthetic-ZAUjXT7E.js";
 export { KindFilteredResourceManager, MapResourceManager };

package/dist/resources/zip-reader.d.ts

@@ -0,0 +1,5 @@
+import { ZipFile } from "yauzl";
+//#region src/resources/zip-reader.d.ts
+declare function openZip(zipPath: string): Promise<ZipFile>;
+//#endregion
+export { openZip };

package/dist/resources/zip-reader.js

@@ -0,0 +1,2 @@
+import { t as openZip } from "../zip-reader-BSbJKUT1.js";
+export { openZip };