framefields 2.3.1 → 2.4.0

package/dist/{dist-jU289ehm.mjs → dist-DRB6Vg5u.mjs}

@@ -12675,6 +12675,63 @@ var InputStore = class {
 	}
 };
 const inputStore = new InputStore();
+/** The texture formats the renderer decodes (sharp); others (TGA, BMP, PSD, DDS, …) are skipped. */
+const MIME_BY_EXT = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".gif": "image/gif",
+	".tif": "image/tiff",
+	".tiff": "image/tiff",
+	".avif": "image/avif"
+};
+/** MIME type of an image file name, by extension (PNG when unknown). */
+function textureMime(name) {
+	return MIME_BY_EXT[path.extname(name).toLowerCase()] ?? "image/png";
+}
+/** Whether the renderer can decode a texture with this file name (no extension: assume yes). */
+function isSupportedTexture(name) {
+	const ext = path.extname(name.replace(/\\/g, "/")).toLowerCase();
+	return !ext || ext in MIME_BY_EXT;
+}
+/**
+* Reads a texture a model file refers to. Exporters often write absolute
+* paths from the author's machine (`C:\Users\…\wood.png`), so after the
+* path as written (relative to `basePath`), the file name is also tried in
+* `basePath`, its `textures/` folder and any `*.fbm` folder next to it.
+*/
+function readTextureFile(ref, basePath) {
+	if (!ref || typeof fs === "undefined" || !fs.existsSync) return void 0;
+	if (!isSupportedTexture(ref)) return void 0;
+	let cleaned = ref.trim().replace(/^file:\/\//, "");
+	try {
+		cleaned = decodeURIComponent(cleaned);
+	} catch (_) {}
+	const normalized = cleaned.replace(/\\/g, "/");
+	const fileName = normalized.split("/").pop() ?? normalized;
+	const candidates = [];
+	if (path.isAbsolute(normalized)) candidates.push(normalized);
+	if (basePath) {
+		candidates.push(path.resolve(basePath, normalized));
+		candidates.push(path.join(basePath, fileName));
+		candidates.push(path.join(basePath, "textures", fileName));
+		try {
+			for (const entry of fs.readdirSync(basePath)) if (entry.toLowerCase().endsWith(".fbm")) candidates.push(path.join(basePath, entry, fileName));
+		} catch (_) {}
+	}
+	for (const file of candidates) try {
+		if (fs.existsSync(file) && fs.statSync(file).isFile()) return {
+			bytes: new Uint8Array(fs.readFileSync(file)),
+			mime: textureMime(file)
+		};
+	} catch (_) {}
+}
+/** Warns that a model's texture is missing or in an unsupported format (the mesh renders untextured). */
+function warnMissingTexture(loader, material, ref) {
+	const reason = isSupportedTexture(ref) ? "was not found" : `is in an unsupported format (use ${Object.keys(MIME_BY_EXT).join(", ")})`;
+	console.warn(`[${loader}] Texture "${ref}" for material "${material}" ${reason}; the material renders without it.`);
+}
 var ObjLoader = class ObjLoader$1 {
 	/**
 	* Parses Wavefront .obj text content (and optional .mtl text) into Model3DData.
@@ -12692,7 +12749,7 @@ var ObjLoader = class ObjLoader$1 {
 		};
 		meshBuilders.push(currentBuilder);
 		const materials = {};
-		if (mtlText) Object.assign(materials, ObjLoader$1.parseMtl(mtlText));
+		if (mtlText) Object.assign(materials, ObjLoader$1.loadTextures(ObjLoader$1.parseMtl(mtlText), options.basePath));
 		const lines = objText.split(/\r?\n/);
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i]?.trim();
@@ -12705,7 +12762,7 @@ var ObjLoader = class ObjLoader$1 {
 					const resolvedMtlPath = path.resolve(options.basePath, mtlFileName);
 					if (fs.existsSync(resolvedMtlPath)) {
 						const content = fs.readFileSync(resolvedMtlPath, "utf-8");
-						Object.assign(materials, ObjLoader$1.parseMtl(content));
+						Object.assign(materials, ObjLoader$1.loadTextures(ObjLoader$1.parseMtl(content), path.dirname(resolvedMtlPath)));
 					}
 				} catch (_) {}
 			} else if (cmd === "v") {
@@ -12793,12 +12850,12 @@ var ObjLoader = class ObjLoader$1 {
 			maxY = 1;
 			maxZ = 1;
 		}
-		let centerX = (minX + maxX) * .5;
-		let centerY = (minY + maxY) * .5;
-		let centerZ = (minZ + maxZ) * .5;
-		let sizeX = Math.max(1e-4, maxX - minX);
-		let sizeY = Math.max(1e-4, maxY - minY);
-		let sizeZ = Math.max(1e-4, maxZ - minZ);
+		const centerX = (minX + maxX) * .5;
+		const centerY = (minY + maxY) * .5;
+		const centerZ = (minZ + maxZ) * .5;
+		const sizeX = Math.max(1e-4, maxX - minX);
+		const sizeY = Math.max(1e-4, maxY - minY);
+		const sizeZ = Math.max(1e-4, maxZ - minZ);
 		const maxDim = Math.max(sizeX, sizeY, sizeZ);
 		let scaleMultiplier = 1;
 		if (options.normalizeSize && options.normalizeSize > 0) scaleMultiplier = options.normalizeSize / maxDim;
@@ -13012,8 +13069,57 @@ var ObjLoader = class ObjLoader$1 {
 					const val = Number.parseFloat(parts[1] ?? "1");
 					currentMat.opacity = cmd === "d" ? val : 1 - val;
 					if (currentMat.diffuseColor) currentMat.diffuseColor[3] = currentMat.opacity;
-				} else if (cmd === "map_kd") currentMat.diffuseTexture = parts.slice(1).join(" ");
-				else if (cmd === "map_bump" || cmd === "bump") currentMat.normalTexture = parts.slice(1).join(" ");
+				} else if (cmd === "map_kd") {
+					currentMat.diffuseTexture = ObjLoader$1.mapFileName(parts);
+					const clamp = parts.findIndex((p) => p.toLowerCase() === "-clamp");
+					currentMat.textureWrap = clamp > 0 && parts[clamp + 1]?.toLowerCase() === "on" ? "clamp" : "repeat";
+				} else if (cmd === "norm" || cmd === "map_kn") currentMat.normalTexture = ObjLoader$1.mapFileName(parts);
+			}
+		}
+		return materials;
+	}
+	/** Option arities of MTL map statements (`-o`, `-s`, `-t` take 1–3 numbers). */
+	static MAP_OPTION_ARGS = {
+		"-blendu": 1,
+		"-blendv": 1,
+		"-cc": 1,
+		"-clamp": 1,
+		"-texres": 1,
+		"-bm": 1,
+		"-boost": 1,
+		"-imfchan": 1,
+		"-type": 1,
+		"-mm": 2
+	};
+	/** The file name of a map statement (`map_Kd -s 1 1 1 wood grain.png`), past its options. */
+	static mapFileName(parts) {
+		let i = 1;
+		while (i < parts.length && parts[i]?.startsWith("-")) {
+			const option = parts[i].toLowerCase();
+			i++;
+			if (option === "-o" || option === "-s" || option === "-t") for (let n = 0; n < 3 && i < parts.length; n++) {
+				if (Number.isNaN(Number(parts[i]))) break;
+				i++;
+			}
+			else i += ObjLoader$1.MAP_OPTION_ARGS[option] ?? 0;
+		}
+		return parts.slice(i).join(" ");
+	}
+	/** Reads the diffuse and normal maps the materials name, relative to `dir`. */
+	static loadTextures(materials, dir) {
+		if (!dir) return materials;
+		for (const mat of Object.values(materials)) {
+			if (mat.diffuseTexture && !mat.diffuseTextureBuffer) {
+				const file = readTextureFile(mat.diffuseTexture, dir);
+				if (file) {
+					mat.diffuseTextureBuffer = file.bytes;
+					mat.diffuseTextureMime = file.mime;
+				} else warnMissingTexture("ObjLoader", mat.name, mat.diffuseTexture);
+			}
+			if (mat.normalTexture && !mat.normalTextureBuffer) {
+				const file = readTextureFile(mat.normalTexture, dir);
+				if (file) mat.normalTextureBuffer = file.bytes;
+				else warnMissingTexture("ObjLoader", mat.name, mat.normalTexture);
 			}
 		}
 		return materials;
@@ -13049,192 +13155,501 @@ function loadOBJ(srcOrData, mtlText, options = {}) {
 	}
 	return ObjLoader.parse(text, mtlText, options);
 }
-var FbxLoader = class FbxLoader$1 {
-	static FBX_KTIME = 46186158e3;
-	/**
-	* Parses binary or text FBX buffer/string into Model3DData.
-	*/
-	static parse(bufferOrString, options = {}) {
-		const rootNode = typeof bufferOrString === "string" ? FbxLoader$1.parseAscii(bufferOrString) : FbxLoader$1.isBinary(bufferOrString) ? FbxLoader$1.parseBinary(bufferOrString) : FbxLoader$1.parseAscii(new TextDecoder().decode(bufferOrString));
-		return FbxLoader$1.buildModelFromTree(rootNode, options);
+/**
+* Adds each triangle's (area-weighted) face normal to its three vertices, then
+* normalizes every vertex normal in place.
+*/
+function accumulateVertexNormals(positions, indices, normals) {
+	const vertex = (i) => [
+		positions[i * 3],
+		positions[i * 3 + 1],
+		positions[i * 3 + 2]
+	];
+	for (let i = 0; i < indices.length; i += 3) {
+		const i0 = indices[i];
+		const i1 = indices[i + 1];
+		const i2 = indices[i + 2];
+		const p0 = vertex(i0);
+		const fn = Vector3Math.cross(Vector3Math.subtract(vertex(i1), p0), Vector3Math.subtract(vertex(i2), p0));
+		for (const v of [
+			i0,
+			i1,
+			i2
+		]) {
+			normals[v * 3] += fn[0];
+			normals[v * 3 + 1] += fn[1];
+			normals[v * 3 + 2] += fn[2];
+		}
 	}
-	static isBinary(buffer) {
-		const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-		if (view.length < 27) return false;
-		const header = "Kaydara FBX Binary  \0\0";
-		for (let i = 0; i < 23; i++) if (view[i] !== header.charCodeAt(i)) return false;
-		return true;
+	for (let i = 0; i < normals.length; i += 3) {
+		const nx = normals[i];
+		const ny = normals[i + 1];
+		const nz = normals[i + 2];
+		const len = Math.hypot(nx, ny, nz) || 1;
+		normals[i] = nx / len;
+		normals[i + 1] = ny / len;
+		normals[i + 2] = nz / len;
 	}
-	/**
-	* Parses Binary FBX 7.x/6.x format.
-	*/
-	static parseBinary(buffer) {
-		const u8 = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-		const view = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
-		const is64Bit = view.getUint32(23, true) >= 7500;
-		let offset = 27;
-		const root = {
-			name: "Root",
-			props: [],
-			children: []
-		};
-		const readNode = () => {
-			if (offset >= u8.byteLength) return null;
-			let endOffset;
-			let numProperties;
-			let nameLen;
-			if (is64Bit) {
-				if (offset + 25 > u8.byteLength) return null;
-				endOffset = Number(view.getBigUint64(offset, true));
-				numProperties = Number(view.getBigUint64(offset + 8, true));
-				nameLen = view.getUint8(offset + 24);
-				offset += 25;
-			} else {
-				if (offset + 13 > u8.byteLength) return null;
-				endOffset = view.getUint32(offset, true);
-				numProperties = view.getUint32(offset + 4, true);
-				nameLen = view.getUint8(offset + 12);
-				offset += 13;
-			}
-			if (endOffset === 0) return null;
-			const name = new TextDecoder().decode(u8.subarray(offset, offset + nameLen));
-			offset += nameLen;
-			const props = [];
-			for (let p = 0; p < numProperties; p++) {
-				const typeCode = String.fromCharCode(u8[offset]);
-				offset += 1;
-				switch (typeCode) {
-					case "Y":
-						props.push(view.getInt16(offset, true));
-						offset += 2;
-						break;
-					case "C":
-					case "B":
-						props.push(view.getUint8(offset) !== 0);
-						offset += 1;
-						break;
-					case "I":
-						props.push(view.getInt32(offset, true));
-						offset += 4;
-						break;
-					case "F":
-						props.push(view.getFloat32(offset, true));
-						offset += 4;
-						break;
-					case "D":
-						props.push(view.getFloat64(offset, true));
-						offset += 8;
-						break;
-					case "L":
-						props.push(Number(view.getBigInt64(offset, true)));
-						offset += 8;
-						break;
-					case "S": {
-						const len = view.getUint32(offset, true);
-						offset += 4;
-						const str = new TextDecoder().decode(u8.subarray(offset, offset + len));
-						props.push(str);
-						offset += len;
-						break;
-					}
-					case "R": {
-						const len = view.getUint32(offset, true);
-						offset += 4;
-						const raw = u8.subarray(offset, offset + len);
-						props.push(raw);
-						offset += len;
-						break;
-					}
-					case "f":
-					case "d":
-					case "i":
-					case "l":
-					case "b":
-					case "c": {
-						const arrayLen = view.getUint32(offset, true);
-						const encoding = view.getUint32(offset + 4, true);
-						const compressedLen = view.getUint32(offset + 8, true);
-						offset += 12;
-						let arrayBuffer;
-						if (encoding === 1) {
-							arrayBuffer = inflateSync(u8.subarray(offset, offset + compressedLen));
-							offset += compressedLen;
-						} else {
-							const totalBytes = arrayLen * (typeCode === "d" || typeCode === "l" ? 8 : typeCode === "f" || typeCode === "i" ? 4 : 1);
-							arrayBuffer = u8.subarray(offset, offset + totalBytes);
-							offset += totalBytes;
-						}
-						const arrayView = new DataView(arrayBuffer.buffer, arrayBuffer.byteOffset, arrayBuffer.byteLength);
-						if (typeCode === "f") {
-							const arr = new Float32Array(arrayLen);
-							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getFloat32(k * 4, true);
-							props.push(arr);
-						} else if (typeCode === "d") {
-							const arr = new Float64Array(arrayLen);
-							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getFloat64(k * 8, true);
-							props.push(arr);
-						} else if (typeCode === "i") {
-							const arr = new Int32Array(arrayLen);
-							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getInt32(k * 4, true);
-							props.push(arr);
-						} else if (typeCode === "l") {
-							const arr = new Float64Array(arrayLen);
-							for (let k = 0; k < arrayLen; k++) arr[k] = Number(arrayView.getBigInt64(k * 8, true));
-							props.push(arr);
-						} else if (typeCode === "b") {
-							const arr = new Uint8Array(arrayLen);
-							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getUint8(k);
-							props.push(arr);
-						} else props.push(arrayBuffer);
-						break;
-					}
-					default: break;
-				}
-			}
-			const children = [];
-			while (offset < endOffset) {
-				const child = readNode();
-				if (child) children.push(child);
-				else break;
-			}
-			offset = endOffset;
-			return {
-				name,
-				props,
-				children
-			};
-		};
-		while (offset < u8.byteLength - (is64Bit ? 25 : 13)) {
-			const node = readNode();
-			if (node) root.children.push(node);
-			else break;
-		}
-		return root;
+}
+/** Axis-aligned bounds of xyz position arrays (all zero when empty). */
+function computeBounds(...positionArrays) {
+	let minX = Infinity, minY = Infinity, minZ = Infinity;
+	let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+	for (const positions of positionArrays) for (let i = 0; i < positions.length; i += 3) {
+		const x = positions[i];
+		const y = positions[i + 1];
+		const z = positions[i + 2];
+		if (x < minX) minX = x;
+		if (x > maxX) maxX = x;
+		if (y < minY) minY = y;
+		if (y > maxY) maxY = y;
+		if (z < minZ) minZ = z;
+		if (z > maxZ) maxZ = z;
 	}
-	/**
-	* Parses ASCII FBX format.
-	*/
-	static parseAscii(text) {
-		const root = {
-			name: "Root",
-			props: [],
-			children: []
-		};
-		const stack = [root];
-		const lines = text.split(/\r?\n/);
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i]?.trim();
-			if (!line || line.startsWith(";")) continue;
-			if (line === "}") {
-				if (stack.length > 1) stack.pop();
-				continue;
-			}
-			const colonIdx = line.indexOf(":");
-			if (colonIdx === -1) continue;
-			const name = line.substring(0, colonIdx).trim();
-			const rest = line.substring(colonIdx + 1).trim();
-			const hasBrace = rest.endsWith("{");
-			const propStr = hasBrace ? rest.slice(0, -1).trim() : rest;
+	if (!Number.isFinite(minX)) {
+		minX = minY = minZ = 0;
+		maxX = maxY = maxZ = 0;
+	}
+	return {
+		min: [
+			minX,
+			minY,
+			minZ
+		],
+		max: [
+			maxX,
+			maxY,
+			maxZ
+		],
+		center: [
+			(minX + maxX) * .5,
+			(minY + maxY) * .5,
+			(minZ + maxZ) * .5
+		],
+		size: [
+			maxX - minX,
+			maxY - minY,
+			maxZ - minZ
+		]
+	};
+}
+/**
+* The placement `LoadModelOptions` asks for: recentring on the bounds
+* (`center`), fitting the largest side to `normalizeSize`, then `scale`.
+*/
+function resolveModelTransform(bounds, options) {
+	const maxDimension = Math.max(...bounds.size, 1e-4);
+	let scaleMultiplier = 1;
+	if (options.normalizeSize && options.normalizeSize > 0) scaleMultiplier = options.normalizeSize / maxDimension;
+	const scale = [
+		scaleMultiplier,
+		scaleMultiplier,
+		scaleMultiplier
+	];
+	if (typeof options.scale === "number") {
+		scale[0] *= options.scale;
+		scale[1] *= options.scale;
+		scale[2] *= options.scale;
+	} else if (Array.isArray(options.scale)) {
+		scale[0] *= options.scale[0];
+		scale[1] *= options.scale[1];
+		scale[2] *= options.scale[2];
+	}
+	return {
+		offset: options.center ? bounds.center : [
+			0,
+			0,
+			0
+		],
+		scale
+	};
+}
+/** `(p - offset) * scale` for every xyz position. */
+function transformPositions(positions, { offset, scale }) {
+	const out = new Float32Array(positions.length);
+	for (let i = 0; i < positions.length; i += 3) {
+		out[i] = (positions[i] - offset[0]) * scale[0];
+		out[i + 1] = (positions[i + 1] - offset[1]) * scale[1];
+		out[i + 2] = (positions[i + 2] - offset[2]) * scale[2];
+	}
+	return out;
+}
+/** Uint16 indices while every vertex fits, Uint32 beyond 65535 vertices. */
+function createIndexArray(indices, vertexCount) {
+	return vertexCount > 65535 ? new Uint32Array(indices) : new Uint16Array(indices);
+}
+/** The model's bounds after `transform`, as `Model3DData.bounds` reports them. */
+function transformModelBounds(bounds, { offset, scale }) {
+	const min = [
+		(bounds.min[0] - offset[0]) * scale[0],
+		(bounds.min[1] - offset[1]) * scale[1],
+		(bounds.min[2] - offset[2]) * scale[2]
+	];
+	const max = [
+		(bounds.max[0] - offset[0]) * scale[0],
+		(bounds.max[1] - offset[1]) * scale[1],
+		(bounds.max[2] - offset[2]) * scale[2]
+	];
+	return {
+		min,
+		max,
+		center: [
+			(min[0] + max[0]) * .5,
+			(min[1] + max[1]) * .5,
+			(min[2] + max[2]) * .5
+		],
+		size: [
+			max[0] - min[0],
+			max[1] - min[1],
+			max[2] - min[2]
+		],
+		boundingSphereRadius: Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) * .5
+	};
+}
+/**
+* Poses a model's scene graph (glTF semantics): samples an animation clip's
+* translation / rotation / scale tracks at a time, composes the node
+* hierarchy into model-space matrices, and turns a skin's joints into the
+* joint matrices the mesh shader blends (joint world × inverse bind).
+*/
+/** Joints per skin the mesh shader holds (mesh3d.wgsl jointMatrices). */
+const MAX_JOINTS = 128;
+/** Column-major translate · rotate(quaternion) · scale. */
+function trsMatrix(t, q, s) {
+	const [x, y, z, w] = q;
+	const xx = x * x;
+	const yy = y * y;
+	const zz = z * z;
+	const xy = x * y;
+	const xz = x * z;
+	const yz = y * z;
+	const wx = w * x;
+	const wy = w * y;
+	const wz = w * z;
+	return [
+		(1 - 2 * (yy + zz)) * s[0],
+		2 * (xy + wz) * s[0],
+		2 * (xz - wy) * s[0],
+		0,
+		2 * (xy - wz) * s[1],
+		(1 - 2 * (xx + zz)) * s[1],
+		2 * (yz + wx) * s[1],
+		0,
+		2 * (xz + wy) * s[2],
+		2 * (yz - wx) * s[2],
+		(1 - 2 * (xx + yy)) * s[2],
+		0,
+		t[0],
+		t[1],
+		t[2],
+		1
+	];
+}
+function normalizeQuat(q) {
+	const len = Math.hypot(q[0], q[1], q[2], q[3]) || 1;
+	return [
+		q[0] / len,
+		q[1] / len,
+		q[2] / len,
+		q[3] / len
+	];
+}
+function slerp(a, b, t) {
+	let cos = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+	const sign = cos < 0 ? -1 : 1;
+	cos *= sign;
+	if (cos > .9995) return normalizeQuat([
+		a[0] + (sign * b[0] - a[0]) * t,
+		a[1] + (sign * b[1] - a[1]) * t,
+		a[2] + (sign * b[2] - a[2]) * t,
+		a[3] + (sign * b[3] - a[3]) * t
+	]);
+	const theta = Math.acos(cos);
+	const sin = Math.sin(theta);
+	const wa = Math.sin((1 - t) * theta) / sin;
+	const wb = sign * Math.sin(t * theta) / sin;
+	return [
+		a[0] * wa + b[0] * wb,
+		a[1] * wa + b[1] * wb,
+		a[2] * wa + b[2] * wb,
+		a[3] * wa + b[3] * wb
+	];
+}
+/** Index of the last keyframe at or before `time` (binary search). */
+function keyBefore(times, time$2) {
+	let lo = 0;
+	let hi = times.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >> 1;
+		if ((times[mid] ?? 0) <= time$2) lo = mid;
+		else hi = mid - 1;
+	}
+	return lo;
+}
+/** Element `k` (of `size` components) of a track's values; cubic tracks store [in, value, out] triples. */
+function valueAt(values, k, size, cubic, part = 1) {
+	const at = cubic ? (k * 3 + part) * size : k * size;
+	return Array.from(values.subarray(at, at + size));
+}
+function sampleChannel(track, values, size, time$2) {
+	const { times } = track;
+	const cubic = track.interpolation === "cubic";
+	const last = times.length - 1;
+	if (time$2 <= (times[0] ?? 0)) return valueAt(values, 0, size, cubic);
+	if (time$2 >= (times[last] ?? 0)) return valueAt(values, last, size, cubic);
+	const k = keyBefore(times, time$2);
+	if (track.interpolation === "step") return valueAt(values, k, size, cubic);
+	const t0 = times[k] ?? 0;
+	const dt = (times[k + 1] ?? t0) - t0;
+	const u = dt > 0 ? (time$2 - t0) / dt : 0;
+	const a = valueAt(values, k, size, cubic);
+	const b = valueAt(values, k + 1, size, cubic);
+	if (cubic) {
+		const outA = valueAt(values, k, size, true, 2);
+		const inB = valueAt(values, k + 1, size, true, 0);
+		const u2 = u * u;
+		const u3 = u2 * u;
+		const out = a.map((p0, i) => (2 * u3 - 3 * u2 + 1) * p0 + (u3 - 2 * u2 + u) * dt * (outA[i] ?? 0) + (-2 * u3 + 3 * u2) * (b[i] ?? 0) + (u3 - u2) * dt * (inB[i] ?? 0));
+		return size === 4 ? normalizeQuat(out) : out;
+	}
+	if (size === 4) return slerp(a, b, u);
+	return a.map((v, i) => v + ((b[i] ?? v) - v) * u);
+}
+/** Each node's local matrix with the clip's tracks applied at `time` (seconds). */
+function localMatrices(nodes, clip, time$2) {
+	const t = nodes.map((n) => [...n.translation]);
+	const r = nodes.map((n) => [...n.rotation]);
+	const s = nodes.map((n) => [...n.scale]);
+	const byName = new Map(nodes.map((n, i) => [n.name, i]));
+	for (const track of clip?.tracks ?? []) {
+		const i = track.node ?? byName.get(track.nodeName);
+		if (i === void 0 || !track.times.length) continue;
+		if (track.translations) t[i] = sampleChannel(track, track.translations, 3, time$2);
+		if (track.rotations) r[i] = sampleChannel(track, track.rotations, 4, time$2);
+		if (track.scales) s[i] = sampleChannel(track, track.scales, 3, time$2);
+	}
+	return nodes.map((n, i) => n.matrix ?? trsMatrix(t[i], r[i], s[i]));
+}
+/**
+* Model-space matrix of every node, posed by `clip` at `time` seconds (the
+* rest pose without a clip). Parents may follow their children in the list.
+*/
+function poseNodes(model, clip, time$2) {
+	const nodes = model.nodes ?? [];
+	const local = localMatrices(nodes, clip, time$2);
+	const world = new Array(nodes.length);
+	const resolve$1$1 = (i) => {
+		const done = world[i];
+		if (done) return done;
+		const parent = nodes[i].parent;
+		const m = parent < 0 ? local[i] : Matrix4Math.multiply(resolve$1$1(parent), local[i]);
+		world[i] = m;
+		return m;
+	};
+	return nodes.map((_, i) => resolve$1$1(i));
+}
+/** The joint matrices of one skin for a posed scene graph, padded with identity to MAX_JOINTS. */
+function jointMatrices(model, skinIndex, world) {
+	const skin = model.skins?.[skinIndex];
+	if (!skin) throw new Error(`model has no skin ${skinIndex}`);
+	const out = new Float32Array(MAX_JOINTS * 16);
+	for (let j = 0; j < MAX_JOINTS; j++) {
+		const node = skin.joints[j];
+		if (node === void 0) {
+			out.set(Matrix4Math.identity(), j * 16);
+			continue;
+		}
+		const ibm = Array.from(skin.inverseBindMatrices.subarray(j * 16, j * 16 + 16));
+		out.set(Matrix4Math.multiply(world[node], ibm), j * 16);
+	}
+	return out;
+}
+var FbxLoader = class FbxLoader$1 {
+	static FBX_KTIME = 46186158e3;
+	/**
+	* Parses binary or text FBX buffer/string into Model3DData.
+	*/
+	static parse(bufferOrString, options = {}) {
+		const rootNode = typeof bufferOrString === "string" ? FbxLoader$1.parseAscii(bufferOrString) : FbxLoader$1.isBinary(bufferOrString) ? FbxLoader$1.parseBinary(bufferOrString) : FbxLoader$1.parseAscii(new TextDecoder().decode(bufferOrString));
+		return FbxLoader$1.buildModelFromTree(rootNode, options);
+	}
+	static isBinary(buffer) {
+		const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+		if (view.length < 27) return false;
+		const header = "Kaydara FBX Binary  \0\0";
+		for (let i = 0; i < 23; i++) if (view[i] !== header.charCodeAt(i)) return false;
+		return true;
+	}
+	/**
+	* Parses Binary FBX 7.x/6.x format.
+	*/
+	static parseBinary(buffer) {
+		const u8 = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+		const view = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+		const is64Bit = view.getUint32(23, true) >= 7500;
+		let offset = 27;
+		const root = {
+			name: "Root",
+			props: [],
+			children: []
+		};
+		const readNode = () => {
+			if (offset >= u8.byteLength) return null;
+			let endOffset;
+			let numProperties;
+			let nameLen;
+			if (is64Bit) {
+				if (offset + 25 > u8.byteLength) return null;
+				endOffset = Number(view.getBigUint64(offset, true));
+				numProperties = Number(view.getBigUint64(offset + 8, true));
+				nameLen = view.getUint8(offset + 24);
+				offset += 25;
+			} else {
+				if (offset + 13 > u8.byteLength) return null;
+				endOffset = view.getUint32(offset, true);
+				numProperties = view.getUint32(offset + 4, true);
+				nameLen = view.getUint8(offset + 12);
+				offset += 13;
+			}
+			if (endOffset === 0) return null;
+			const name = new TextDecoder().decode(u8.subarray(offset, offset + nameLen));
+			offset += nameLen;
+			const props = [];
+			for (let p = 0; p < numProperties; p++) {
+				const typeCode = String.fromCharCode(u8[offset]);
+				offset += 1;
+				switch (typeCode) {
+					case "Y":
+						props.push(view.getInt16(offset, true));
+						offset += 2;
+						break;
+					case "C":
+					case "B":
+						props.push(view.getUint8(offset) !== 0);
+						offset += 1;
+						break;
+					case "I":
+						props.push(view.getInt32(offset, true));
+						offset += 4;
+						break;
+					case "F":
+						props.push(view.getFloat32(offset, true));
+						offset += 4;
+						break;
+					case "D":
+						props.push(view.getFloat64(offset, true));
+						offset += 8;
+						break;
+					case "L":
+						props.push(Number(view.getBigInt64(offset, true)));
+						offset += 8;
+						break;
+					case "S": {
+						const len = view.getUint32(offset, true);
+						offset += 4;
+						const str = new TextDecoder().decode(u8.subarray(offset, offset + len));
+						props.push(str);
+						offset += len;
+						break;
+					}
+					case "R": {
+						const len = view.getUint32(offset, true);
+						offset += 4;
+						const raw = u8.subarray(offset, offset + len);
+						props.push(raw);
+						offset += len;
+						break;
+					}
+					case "f":
+					case "d":
+					case "i":
+					case "l":
+					case "b":
+					case "c": {
+						const arrayLen = view.getUint32(offset, true);
+						const encoding = view.getUint32(offset + 4, true);
+						const compressedLen = view.getUint32(offset + 8, true);
+						offset += 12;
+						let arrayBuffer;
+						if (encoding === 1) {
+							arrayBuffer = inflateSync(u8.subarray(offset, offset + compressedLen));
+							offset += compressedLen;
+						} else {
+							const totalBytes = arrayLen * (typeCode === "d" || typeCode === "l" ? 8 : typeCode === "f" || typeCode === "i" ? 4 : 1);
+							arrayBuffer = u8.subarray(offset, offset + totalBytes);
+							offset += totalBytes;
+						}
+						const arrayView = new DataView(arrayBuffer.buffer, arrayBuffer.byteOffset, arrayBuffer.byteLength);
+						if (typeCode === "f") {
+							const arr = new Float32Array(arrayLen);
+							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getFloat32(k * 4, true);
+							props.push(arr);
+						} else if (typeCode === "d") {
+							const arr = new Float64Array(arrayLen);
+							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getFloat64(k * 8, true);
+							props.push(arr);
+						} else if (typeCode === "i") {
+							const arr = new Int32Array(arrayLen);
+							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getInt32(k * 4, true);
+							props.push(arr);
+						} else if (typeCode === "l") {
+							const arr = new Float64Array(arrayLen);
+							for (let k = 0; k < arrayLen; k++) arr[k] = Number(arrayView.getBigInt64(k * 8, true));
+							props.push(arr);
+						} else if (typeCode === "b") {
+							const arr = new Uint8Array(arrayLen);
+							for (let k = 0; k < arrayLen; k++) arr[k] = arrayView.getUint8(k);
+							props.push(arr);
+						} else props.push(arrayBuffer);
+						break;
+					}
+					default: break;
+				}
+			}
+			const children = [];
+			while (offset < endOffset) {
+				const child = readNode();
+				if (child) children.push(child);
+				else break;
+			}
+			offset = endOffset;
+			return {
+				name,
+				props,
+				children
+			};
+		};
+		while (offset < u8.byteLength - (is64Bit ? 25 : 13)) {
+			const node = readNode();
+			if (node) root.children.push(node);
+			else break;
+		}
+		return root;
+	}
+	/**
+	* Parses ASCII FBX format.
+	*/
+	static parseAscii(text) {
+		const root = {
+			name: "Root",
+			props: [],
+			children: []
+		};
+		const stack = [root];
+		const lines = text.split(/\r?\n/);
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i]?.trim();
+			if (!line || line.startsWith(";")) continue;
+			if (line === "}") {
+				if (stack.length > 1) stack.pop();
+				continue;
+			}
+			const colonIdx = line.indexOf(":");
+			if (colonIdx === -1) continue;
+			const name = line.substring(0, colonIdx).trim();
+			const rest = line.substring(colonIdx + 1).trim();
+			const hasBrace = rest.endsWith("{");
+			const propStr = hasBrace ? rest.slice(0, -1).trim() : rest;
 			const props = [];
 			if (propStr) {
 				const rawProps = propStr.split(",").map((p) => p.trim());
@@ -13253,6 +13668,53 @@ var FbxLoader = class FbxLoader$1 {
 		}
 		return root;
 	}
+	/** Material properties a texture can feed, by the FBX (or Maya / 3ds Max) property name. */
+	static textureSlot(prop) {
+		const p = prop.toLowerCase();
+		if (p === "diffusecolor" || p === "diffuse" || p.endsWith("|basecolor") || p.endsWith("|base_color") || p === "basecolor") return "diffuse";
+		if (p === "normalmap" || p.endsWith("|normalcamera") || p.endsWith("|bump_map")) return "normal";
+	}
+	/**
+	* Fills a material's diffuse / normal map from its connected Texture
+	* objects: the bytes embedded in the Video's `Content`, else the file
+	* named by `RelativeFilename` / `FileName`, looked up next to the model.
+	*/
+	static attachTextures(material, materialId, objects, connections, basePath) {
+		const stringChild = (node, name) => {
+			const value = node?.children.find((c) => c.name === name)?.props[0];
+			return typeof value === "string" && value ? value : void 0;
+		};
+		for (const c of connections) {
+			if (c.parentId !== materialId || !c.propName) continue;
+			const slot = FbxLoader$1.textureSlot(c.propName);
+			const texture = objects.get(c.childId);
+			if (!slot || texture?.node.name !== "Texture") continue;
+			if (slot === "diffuse" ? material.diffuseTextureBuffer : material.normalTextureBuffer) continue;
+			const video = connections.filter((v) => v.parentId === c.childId && !v.propName).map((v) => objects.get(v.childId)?.node).find((n) => n?.name === "Video");
+			const ref = stringChild(texture.node, "RelativeFilename") ?? stringChild(texture.node, "FileName") ?? stringChild(video, "RelativeFilename") ?? stringChild(video, "Filename");
+			if (ref && !isSupportedTexture(ref)) {
+				warnMissingTexture("FbxLoader", material.name, ref);
+				continue;
+			}
+			let bytes;
+			const content = video?.children.find((n) => n.name === "Content")?.props[0];
+			if (content instanceof Uint8Array && content.length > 0) bytes = content;
+			else if (ref) bytes = readTextureFile(ref, basePath)?.bytes;
+			if (!bytes) {
+				if (ref) warnMissingTexture("FbxLoader", material.name, ref);
+				continue;
+			}
+			if (slot === "diffuse") {
+				material.diffuseTextureBuffer = bytes;
+				material.diffuseTextureMime = textureMime(ref ?? "");
+				if (ref) material.diffuseTexture = ref;
+				material.textureWrap = "repeat";
+			} else {
+				material.normalTextureBuffer = bytes;
+				if (ref) material.normalTexture = ref;
+			}
+		}
+	}
 	/**
 	* Builds ready-to-render Model3DData from parsed FBX node tree.
 	*/
@@ -13286,6 +13748,20 @@ var FbxLoader = class FbxLoader$1 {
 				});
 			}
 		}
+		const materialNameForGeometry = (geometryId) => {
+			for (const c of connections) {
+				const mat = c.parentId === geometryId ? objects.get(c.childId) : void 0;
+				if (mat?.node.name === "Material" && !c.propName) return mat.name;
+			}
+			for (const g$1 of connections) {
+				if (g$1.childId !== geometryId || g$1.propName) continue;
+				for (const m of connections) {
+					if (m.parentId !== g$1.parentId || m.propName) continue;
+					const mat = objects.get(m.childId);
+					if (mat?.node.name === "Material") return mat.name;
+				}
+			}
+		};
 		const meshes = [];
 		const materials = {};
 		function extractArrayProp(node) {
@@ -13296,149 +13772,142 @@ var FbxLoader = class FbxLoader$1 {
 			if (Array.isArray(node.props) && node.props.length > 0 && typeof node.props[0] === "number") return node.props;
 			return [];
 		}
+		const modelIds = [...objects.values()].filter((o) => o.node.name === "Model").map((o) => o.id);
+		const nodeIndexById = new Map(modelIds.map((id, i) => [id, i]));
+		const nodes = modelIds.map((id) => {
+			const model$1 = objects.get(id);
+			const parentConn = connections.find((c) => c.childId === id && !c.propName && nodeIndexById.has(c.parentId));
+			return {
+				name: model$1.name,
+				parent: parentConn ? nodeIndexById.get(parentConn.parentId) : -1,
+				translation: readVec3(model$1.node, "Lcl Translation", 0),
+				rotation: modelRotation(model$1.node, fbxEulerToQuat(readVec3(model$1.node, "Lcl Rotation", 0), rotationOrder(model$1.node))),
+				scale: readVec3(model$1.node, "Lcl Scaling", 1)
+			};
+		});
+		const modelOfGeometry = (geometryId) => connections.find((c) => c.childId === geometryId && !c.propName && nodeIndexById.has(c.parentId))?.parentId;
+		const skins = [];
 		for (const [id, entry] of objects) if (entry.node.name === "Geometry" && (entry.type === "Mesh" || entry.node.props[2] === "Mesh" || entry.type === "")) {
 			const geomNode = entry.node;
 			const verticesNode = geomNode.children.find((c) => c.name === "Vertices");
 			const indicesNode = geomNode.children.find((c) => c.name === "PolygonVertexIndex");
-			const normalLayer = geomNode.children.find((c) => c.name === "LayerElementNormal");
-			const uvLayer = geomNode.children.find((c) => c.name === "LayerElementUV");
 			if (!verticesNode || !indicesNode) continue;
 			const rawVerts = extractArrayProp(verticesNode);
 			const rawPolyIndices = extractArrayProp(indicesNode);
-			const normalsNode = normalLayer?.children.find((c) => c.name === "Normals");
-			const rawNormals = extractArrayProp(normalsNode);
-			const uvsNode = uvLayer?.children.find((c) => c.name === "UV");
-			const uvIndexNode = uvLayer?.children.find((c) => c.name === "UVIndex");
-			const rawUvs = extractArrayProp(uvsNode);
-			const rawUvIndices = extractArrayProp(uvIndexNode);
-			const triangles = [];
-			const triVertexIndexSequence = [];
-			let polygon = [];
-			for (let i = 0; i < rawPolyIndices.length; i++) {
-				const idx = rawPolyIndices[i];
-				if (idx < 0) {
-					polygon.push(-(idx + 1));
-					triVertexIndexSequence.push(i);
-					if (polygon.length >= 3) for (let k = 1; k < polygon.length - 1; k++) triangles.push([
-						polygon[0],
-						polygon[k],
-						polygon[k + 1]
-					]);
-					polygon = [];
-				} else {
-					polygon.push(idx);
-					triVertexIndexSequence.push(i);
-				}
-			}
-			const outPositions = [];
-			const outNormals = [];
-			const outUvs = [];
-			const outIndices = [];
-			for (let t = 0; t < triangles.length; t++) {
-				const tri = triangles[t];
-				for (let v = 0; v < 3; v++) {
-					const vertIdx = tri[v];
-					const outIdx = outPositions.length / 3;
-					const px = rawVerts[vertIdx * 3] ?? 0;
-					const py = rawVerts[vertIdx * 3 + 1] ?? 0;
-					const pz = rawVerts[vertIdx * 3 + 2] ?? 0;
-					outPositions.push(px, py, pz);
-					if (rawNormals.length > 0) {
-						const nx = rawNormals[vertIdx * 3] ?? 0;
-						const ny = rawNormals[vertIdx * 3 + 1] ?? 0;
-						const nz = rawNormals[vertIdx * 3 + 2] ?? 0;
-						outNormals.push(nx, ny, nz);
-					} else outNormals.push(0, 0, 1);
-					if (rawUvs.length > 0) {
-						let uvIdx = vertIdx;
-						if (rawUvIndices.length > 0) uvIdx = rawUvIndices[vertIdx] ?? vertIdx;
-						const u = rawUvs[uvIdx * 2] ?? 0;
-						const v$1 = rawUvs[uvIdx * 2 + 1] ?? 0;
-						outUvs.push(u, 1 - v$1);
-					} else outUvs.push(0, 0);
-					outIndices.push(outIdx);
-				}
-			}
-			if (rawNormals.length === 0 || options.smoothNormals) {
-				const computedNormals = new Float32Array(outPositions.length);
-				for (let i = 0; i < outIndices.length; i += 3) {
-					const i0 = outIndices[i];
-					const i1 = outIndices[i + 1];
-					const i2 = outIndices[i + 2];
-					const p0 = [
-						outPositions[i0 * 3],
-						outPositions[i0 * 3 + 1],
-						outPositions[i0 * 3 + 2]
-					];
-					const p1 = [
-						outPositions[i1 * 3],
-						outPositions[i1 * 3 + 1],
-						outPositions[i1 * 3 + 2]
-					];
-					const p2 = [
-						outPositions[i2 * 3],
-						outPositions[i2 * 3 + 1],
-						outPositions[i2 * 3 + 2]
-					];
-					const edge1 = Vector3Math.subtract(p1, p0);
-					const edge2 = Vector3Math.subtract(p2, p0);
-					const faceNormal = Vector3Math.cross(edge1, edge2);
-					computedNormals[i0 * 3] += faceNormal[0];
-					computedNormals[i0 * 3 + 1] += faceNormal[1];
-					computedNormals[i0 * 3 + 2] += faceNormal[2];
-					computedNormals[i1 * 3] += faceNormal[0];
-					computedNormals[i1 * 3 + 1] += faceNormal[1];
-					computedNormals[i1 * 3 + 2] += faceNormal[2];
-					computedNormals[i2 * 3] += faceNormal[0];
-					computedNormals[i2 * 3 + 1] += faceNormal[1];
-					computedNormals[i2 * 3 + 2] += faceNormal[2];
-				}
-				for (let v = 0; v < outPositions.length / 3; v++) {
-					const nx = computedNormals[v * 3];
-					const ny = computedNormals[v * 3 + 1];
-					const nz = computedNormals[v * 3 + 2];
-					const len = Math.hypot(nx, ny, nz) || 1;
-					outNormals[v * 3] = nx / len;
-					outNormals[v * 3 + 1] = ny / len;
-					outNormals[v * 3 + 2] = nz / len;
-				}
+			const layer = (name, data, index, size) => {
+				const node = geomNode.children.find((c) => c.name === name);
+				if (!node) return void 0;
+				return layerElement(node, extractArrayProp(node.children.find((c) => c.name === data)), extractArrayProp(node.children.find((c) => c.name === index)), size);
+			};
+			const normalAt = layer("LayerElementNormal", "Normals", "NormalsIndex", 3);
+			const uvAt = layer("LayerElementUV", "UV", "UVIndex", 2);
+			const corners = [];
+			let polygon = [];
+			let polyIndex = 0;
+			for (let i = 0; i < rawPolyIndices.length; i++) {
+				const idx = rawPolyIndices[i];
+				polygon.push({
+					cp: idx < 0 ? -(idx + 1) : idx,
+					pv: i
+				});
+				if (idx >= 0) continue;
+				for (let k = 1; k < polygon.length - 1; k++) for (const c of [
+					polygon[0],
+					polygon[k],
+					polygon[k + 1]
+				]) corners.push({
+					...c,
+					poly: polyIndex
+				});
+				polygon = [];
+				polyIndex++;
+			}
+			const numVerts = corners.length;
+			const outPositions = new Float32Array(numVerts * 3);
+			const outNormals = new Float32Array(numVerts * 3);
+			const outUvs = new Float32Array(numVerts * 2);
+			const outIndices = new Array(numVerts);
+			corners.forEach(({ cp, pv, poly }, v) => {
+				outPositions[v * 3] = rawVerts[cp * 3] ?? 0;
+				outPositions[v * 3 + 1] = rawVerts[cp * 3 + 1] ?? 0;
+				outPositions[v * 3 + 2] = rawVerts[cp * 3 + 2] ?? 0;
+				const n = normalAt?.(cp, pv, poly);
+				outNormals.set(n ?? [
+					0,
+					0,
+					1
+				], v * 3);
+				const uv = uvAt?.(cp, pv, poly);
+				outUvs[v * 2] = uv?.[0] ?? 0;
+				outUvs[v * 2 + 1] = 1 - (uv?.[1] ?? 0);
+				outIndices[v] = v;
+			});
+			if (!normalAt || options.smoothNormals) {
+				outNormals.fill(0);
+				accumulateVertexNormals(outPositions, outIndices, outNormals);
 			}
-			const skinConn = connections.find((c) => c.parentId === id && objects.get(c.childId)?.type === "Deformer" && objects.get(c.childId)?.node.props[2] === "Skin");
+			const skinConn = connections.find((c) => c.parentId === id && objects.get(c.childId)?.node.name === "Deformer" && objects.get(c.childId)?.node.props[2] === "Skin");
 			let jointIndices;
 			let jointWeights;
+			let skinIndex;
 			if (skinConn) {
-				const numVerts = outPositions.length / 3;
-				jointIndices = new Float32Array(numVerts * 4);
-				jointWeights = new Float32Array(numVerts * 4);
-				connections.filter((c) => c.parentId === skinConn.childId && objects.get(c.childId)?.type === "Deformer" && objects.get(c.childId)?.node.props[2] === "Cluster").forEach((cc, boneIdx) => {
-					const clusterNode = objects.get(cc.childId)?.node;
-					const indexesNode = clusterNode?.children.find((c) => c.name === "Indexes");
-					const weightsNode = clusterNode?.children.find((c) => c.name === "Weights");
-					if (indexesNode && weightsNode) {
-						const cIndexes = extractArrayProp(indexesNode);
-						const cWeights = extractArrayProp(weightsNode);
-						for (let k = 0; k < cIndexes.length; k++) {
-							const weight = cWeights[k] ?? 0;
-							for (let v = 0; v < numVerts; v++) for (let slot = 0; slot < 4; slot++) if (jointWeights[v * 4 + slot] === 0) {
-								jointIndices[v * 4 + slot] = boneIdx;
-								jointWeights[v * 4 + slot] = weight;
-								break;
-							}
-						}
+				const joints = [];
+				const inverseBinds = [];
+				const influences = /* @__PURE__ */ new Map();
+				for (const cc of connections) {
+					const cluster = objects.get(cc.childId);
+					if (cc.parentId !== skinConn.childId || cluster?.node.name !== "Deformer" || cluster.node.props[2] !== "Cluster") continue;
+					const boneId = connections.find((b) => b.parentId === cluster.id && nodeIndexById.has(b.childId))?.childId;
+					if (boneId === void 0) continue;
+					const joint = joints.length;
+					joints.push(nodeIndexById.get(boneId));
+					const transform$1 = matrixChild(cluster.node, "Transform");
+					const link = matrixChild(cluster.node, "TransformLink");
+					inverseBinds.push(...Matrix4Math.multiply(Matrix4Math.invert(link) ?? Matrix4Math.identity(), transform$1));
+					const cpIndexes = extractArrayProp(cluster.node.children.find((c) => c.name === "Indexes"));
+					const cpWeights = extractArrayProp(cluster.node.children.find((c) => c.name === "Weights"));
+					for (let k = 0; k < cpIndexes.length; k++) {
+						const weight = Number(cpWeights[k] ?? 0);
+						if (!(weight > 0)) continue;
+						const cp = Number(cpIndexes[k]);
+						const list = influences.get(cp) ?? [];
+						list.push([joint, weight]);
+						influences.set(cp, list);
 					}
-				});
+				}
+				if (joints.length > MAX_JOINTS) throw new Error(`FBX skin has ${joints.length} bones; the mesh shader holds ${MAX_JOINTS}`);
+				if (joints.length > 0) {
+					skinIndex = skins.length;
+					skins.push({
+						joints,
+						inverseBindMatrices: new Float32Array(inverseBinds)
+					});
+					jointIndices = new Float32Array(numVerts * 4);
+					jointWeights = new Float32Array(numVerts * 4);
+					corners.forEach(({ cp }, v) => {
+						const top = (influences.get(cp) ?? []).sort((a, b) => b[1] - a[1]).slice(0, 4);
+						const total = top.reduce((sum, [, w]) => sum + w, 0);
+						top.forEach(([joint, weight], slot) => {
+							jointIndices[v * 4 + slot] = joint;
+							jointWeights[v * 4 + slot] = total > 0 ? weight / total : 0;
+						});
+					});
+				}
 			}
-			const isLarge = outPositions.length / 3 > 65535;
+			const modelId = modelOfGeometry(id);
+			const isLarge = numVerts > 65535;
 			meshes.push({
 				id: `fbx_mesh_${id}`,
 				name: entry.name,
-				positions: new Float32Array(outPositions),
-				normals: new Float32Array(outNormals),
-				uvs: new Float32Array(outUvs),
+				positions: outPositions,
+				normals: outNormals,
+				uvs: outUvs,
 				indices: isLarge ? new Uint32Array(outIndices) : new Uint16Array(outIndices),
 				jointIndices,
 				jointWeights,
-				materialName: entry.name
+				materialName: materialNameForGeometry(id) ?? entry.name,
+				node: modelId !== void 0 ? nodeIndexById.get(modelId) : void 0,
+				skin: skinIndex
 			});
 		}
 		for (const [, entry] of objects) if (entry.node.name === "Material") {
@@ -13467,12 +13936,14 @@ var FbxLoader = class FbxLoader$1 {
 					}
 				}
 			}
-			materials[entry.name] = {
+			const material = {
 				name: entry.name,
 				diffuseColor,
 				shininess,
 				opacity
 			};
+			FbxLoader$1.attachTextures(material, entry.id, objects, connections, options.basePath);
+			materials[entry.name] = material;
 		}
 		const animations = [];
 		for (const [id, entry] of objects) if (entry.node.name === "AnimationStack") {
@@ -13492,12 +13963,13 @@ var FbxLoader = class FbxLoader$1 {
 					const key = `${targetModel?.id ?? curveNodeObj.id}|${kind}`;
 					let group = groups.get(key);
 					if (!group) {
-						const model = targetModel?.node;
+						const model$1 = targetModel?.node;
 						group = {
 							nodeName: targetModel?.name ?? curveNodeObj.name,
-							model,
+							modelId: targetModel?.id,
+							model: model$1,
 							kind,
-							defaults: staticTransform(model, curveNodeObj.node, kind),
+							defaults: staticTransform(model$1, curveNodeObj.node, kind),
 							channels: [
 								void 0,
 								void 0,
@@ -13522,7 +13994,13 @@ var FbxLoader = class FbxLoader$1 {
 				}
 				for (const group of groups.values()) {
 					const track = buildTransformTrack(group);
-					if (track) tracks.push(track);
+					if (!track) continue;
+					if (group.modelId !== void 0) track.node = nodeIndexById.get(group.modelId);
+					if (track.rotations && group.model) for (let k = 0; k < track.rotations.length; k += 4) {
+						const q = Array.from(track.rotations.subarray(k, k + 4));
+						track.rotations.set(modelRotation(group.model, q), k);
+					}
+					tracks.push(track);
 				}
 			}
 			let maxDuration = 1;
@@ -13537,68 +14015,172 @@ var FbxLoader = class FbxLoader$1 {
 				tracks
 			});
 		}
-		let minX = Infinity;
-		let minY = Infinity;
-		let minZ = Infinity;
-		let maxX = -Infinity;
-		let maxY = -Infinity;
-		let maxZ = -Infinity;
-		for (const mesh of meshes) for (let i = 0; i < mesh.positions.length; i += 3) {
-			const x = mesh.positions[i];
-			const y = mesh.positions[i + 1];
-			const z = mesh.positions[i + 2];
-			if (x < minX) minX = x;
-			if (y < minY) minY = y;
-			if (z < minZ) minZ = z;
-			if (x > maxX) maxX = x;
-			if (y > maxY) maxY = y;
-			if (z > maxZ) maxZ = z;
-		}
-		if (!Number.isFinite(minX)) {
-			minX = -1;
-			minY = -1;
-			minZ = -1;
-			maxX = 1;
-			maxY = 1;
-			maxZ = 1;
-		}
-		const sizeX = maxX - minX;
-		const sizeY = maxY - minY;
-		const sizeZ = maxZ - minZ;
-		const centerX = (minX + maxX) * .5;
-		const centerY = (minY + maxY) * .5;
-		const centerZ = (minZ + maxZ) * .5;
-		const sphereRadius = Math.hypot(sizeX, sizeY, sizeZ) * .5;
-		return {
+		const model = {
 			meshes,
 			materials,
 			animations,
+			nodes,
+			skins,
 			bounds: {
 				min: [
-					minX,
-					minY,
-					minZ
+					0,
+					0,
+					0
 				],
 				max: [
-					maxX,
-					maxY,
-					maxZ
+					0,
+					0,
+					0
 				],
 				center: [
-					centerX,
-					centerY,
-					centerZ
+					0,
+					0,
+					0
 				],
 				size: [
-					sizeX,
-					sizeY,
-					sizeZ
+					0,
+					0,
+					0
 				],
-				boundingSphereRadius: sphereRadius
+				boundingSphereRadius: 0
+			}
+		};
+		const rest = poseNodes(model, void 0, 0);
+		const lo = [
+			Infinity,
+			Infinity,
+			Infinity
+		];
+		const hi = [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		];
+		for (const mesh of meshes) {
+			const place = mesh.node !== void 0 ? rest[mesh.node] : void 0;
+			for (let i = 0; i < mesh.positions.length; i += 3) {
+				const p = [
+					mesh.positions[i],
+					mesh.positions[i + 1],
+					mesh.positions[i + 2]
+				];
+				const q = place ? Matrix4Math.projectPoint(place, p) : p;
+				for (let a = 0; a < 3; a++) {
+					if (q[a] < lo[a]) lo[a] = q[a];
+					if (q[a] > hi[a]) hi[a] = q[a];
+				}
 			}
+		}
+		if (!Number.isFinite(lo[0])) {
+			lo.fill(-1);
+			hi.fill(1);
+		}
+		const { offset, scale } = resolveModelTransform({
+			min: lo,
+			max: hi,
+			center: [
+				(lo[0] + hi[0]) * .5,
+				(lo[1] + hi[1]) * .5,
+				(lo[2] + hi[2]) * .5
+			],
+			size: [
+				hi[0] - lo[0],
+				hi[1] - lo[1],
+				hi[2] - lo[2]
+			]
+		}, options);
+		model.rootTransform = Matrix4Math.multiply(Matrix4Math.scale(scale[0], scale[1], scale[2]), Matrix4Math.translate(-offset[0], -offset[1], -offset[2]));
+		const min = [
+			0,
+			1,
+			2
+		].map((a) => (lo[a] - offset[a]) * scale[a]);
+		const max = [
+			0,
+			1,
+			2
+		].map((a) => (hi[a] - offset[a]) * scale[a]);
+		model.bounds = {
+			min,
+			max,
+			center: [
+				(min[0] + max[0]) * .5,
+				(min[1] + max[1]) * .5,
+				(min[2] + max[2]) * .5
+			],
+			size: [
+				max[0] - min[0],
+				max[1] - min[1],
+				max[2] - min[2]
+			],
+			boundingSphereRadius: Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) * .5
 		};
+		return model;
 	}
 };
+/** A Properties70 vector (Lcl Translation / Rotation / Scaling), `fallback` where absent. */
+function readVec3(node, name, fallback) {
+	const v = readProperty70(node, name);
+	return [
+		0,
+		1,
+		2
+	].map((a) => {
+		const x = v?.[a];
+		return x !== void 0 && Number.isFinite(x) ? x : fallback;
+	});
+}
+function multiplyQuat(a, b) {
+	return [
+		a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
+		a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
+		a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
+		a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2]
+	];
+}
+/**
+* A Model's full local rotation for an Lcl Rotation `q`:
+* PreRotation · q · PostRotation⁻¹ (FBX always applies pre/post in XYZ order).
+*/
+function modelRotation(model, q) {
+	const pre = readProperty70(model, "PreRotation");
+	const post = readProperty70(model, "PostRotation");
+	let out = q;
+	if (pre) out = multiplyQuat(fbxEulerToQuat(readVec3(model, "PreRotation", 0)), out);
+	if (post) {
+		const p = fbxEulerToQuat(readVec3(model, "PostRotation", 0));
+		out = multiplyQuat(out, [
+			-p[0],
+			-p[1],
+			-p[2],
+			p[3]
+		]);
+	}
+	return out;
+}
+/** A 4×4 matrix child (`Transform: *16 { a: … }`), identity when absent. */
+function matrixChild(node, name) {
+	const child = node.children.find((c) => c.name === name);
+	const raw = child?.children.find((c) => c.name === "a")?.props ?? child?.props;
+	const values = raw?.[0] instanceof Float64Array || raw?.[0] instanceof Float32Array ? Array.from(raw[0]) : (raw ?? []).map(Number);
+	return values.length === 16 ? values : Matrix4Math.identity();
+}
+/**
+* A geometry layer (normals, UVs) as a lookup by corner: its mapping says
+* whether values are per control point, per polygon vertex, per polygon or
+* one for all; IndexToDirect layers go through their index array.
+*/
+function layerElement(layer, data, index, size) {
+	if (data.length === 0) return void 0;
+	const text = (name) => String(layer.children.find((c) => c.name === name)?.props[0] ?? "");
+	const mapping = text("MappingInformationType");
+	const indexed = /^Index/.test(text("ReferenceInformationType")) && index.length > 0;
+	return (cp, pv, poly) => {
+		let i = mapping === "ByPolygonVertex" ? pv : mapping === "ByPolygon" ? poly : mapping === "AllSame" ? 0 : cp;
+		if (indexed) i = Number(index[i] ?? i);
+		return Array.from({ length: size }, (_, c) => Number(data[i * size + c] ?? 0));
+	};
+}
 /**
 * Classifies a curve node from its OP connection property ("Lcl Translation",
 * "Lcl Rotation", "Lcl Scaling") or, failing that, its short name ("T", "R", "S").
@@ -13739,181 +14321,34 @@ function buildTransformTrack(group) {
 	return {
 		nodeName: group.nodeName,
 		times,
-		translations: group.kind === "T" ? values : void 0,
-		rotations: isRotation ? values : void 0,
-		scales: group.kind === "S" ? values : void 0
-	};
-}
-function parseFBX(bufferOrText, options = {}) {
-	return FbxLoader.parse(bufferOrText, options);
-}
-function loadFBX(srcOrData, options = {}) {
-	let data = srcOrData;
-	if (typeof srcOrData === "string") {
-		const trimmed = srcOrData.trim();
-		if (!(trimmed.includes("FBXHeaderExtension") || trimmed.includes("Kaydara FBX")) && typeof fs !== "undefined" && fs.existsSync) try {
-			let filePath = srcOrData.startsWith("file://") ? srcOrData.slice(7) : srcOrData;
-			try {
-				filePath = decodeURIComponent(filePath);
-			} catch (_) {}
-			if (fs.existsSync(filePath)) {
-				const buf = fs.readFileSync(filePath);
-				data = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-			}
-		} catch (_) {}
-	}
-	return FbxLoader.parse(data, options);
-}
-/**
-* Adds each triangle's (area-weighted) face normal to its three vertices, then
-* normalizes every vertex normal in place.
-*/
-function accumulateVertexNormals(positions, indices, normals) {
-	const vertex = (i) => [
-		positions[i * 3],
-		positions[i * 3 + 1],
-		positions[i * 3 + 2]
-	];
-	for (let i = 0; i < indices.length; i += 3) {
-		const i0 = indices[i];
-		const i1 = indices[i + 1];
-		const i2 = indices[i + 2];
-		const p0 = vertex(i0);
-		const fn = Vector3Math.cross(Vector3Math.subtract(vertex(i1), p0), Vector3Math.subtract(vertex(i2), p0));
-		for (const v of [
-			i0,
-			i1,
-			i2
-		]) {
-			normals[v * 3] += fn[0];
-			normals[v * 3 + 1] += fn[1];
-			normals[v * 3 + 2] += fn[2];
-		}
-	}
-	for (let i = 0; i < normals.length; i += 3) {
-		const nx = normals[i];
-		const ny = normals[i + 1];
-		const nz = normals[i + 2];
-		const len = Math.hypot(nx, ny, nz) || 1;
-		normals[i] = nx / len;
-		normals[i + 1] = ny / len;
-		normals[i + 2] = nz / len;
-	}
-}
-/** Axis-aligned bounds of xyz position arrays (all zero when empty). */
-function computeBounds(...positionArrays) {
-	let minX = Infinity, minY = Infinity, minZ = Infinity;
-	let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-	for (const positions of positionArrays) for (let i = 0; i < positions.length; i += 3) {
-		const x = positions[i];
-		const y = positions[i + 1];
-		const z = positions[i + 2];
-		if (x < minX) minX = x;
-		if (x > maxX) maxX = x;
-		if (y < minY) minY = y;
-		if (y > maxY) maxY = y;
-		if (z < minZ) minZ = z;
-		if (z > maxZ) maxZ = z;
-	}
-	if (!Number.isFinite(minX)) {
-		minX = minY = minZ = 0;
-		maxX = maxY = maxZ = 0;
-	}
-	return {
-		min: [
-			minX,
-			minY,
-			minZ
-		],
-		max: [
-			maxX,
-			maxY,
-			maxZ
-		],
-		center: [
-			(minX + maxX) * .5,
-			(minY + maxY) * .5,
-			(minZ + maxZ) * .5
-		],
-		size: [
-			maxX - minX,
-			maxY - minY,
-			maxZ - minZ
-		]
-	};
-}
-/**
-* The placement `LoadModelOptions` asks for: recentring on the bounds
-* (`center`), fitting the largest side to `normalizeSize`, then `scale`.
-*/
-function resolveModelTransform(bounds, options) {
-	const maxDimension = Math.max(...bounds.size, 1e-4);
-	let scaleMultiplier = 1;
-	if (options.normalizeSize && options.normalizeSize > 0) scaleMultiplier = options.normalizeSize / maxDimension;
-	const scale = [
-		scaleMultiplier,
-		scaleMultiplier,
-		scaleMultiplier
-	];
-	if (typeof options.scale === "number") {
-		scale[0] *= options.scale;
-		scale[1] *= options.scale;
-		scale[2] *= options.scale;
-	} else if (Array.isArray(options.scale)) {
-		scale[0] *= options.scale[0];
-		scale[1] *= options.scale[1];
-		scale[2] *= options.scale[2];
-	}
-	return {
-		offset: options.center ? bounds.center : [
-			0,
-			0,
-			0
-		],
-		scale
+		translations: group.kind === "T" ? values : void 0,
+		rotations: isRotation ? values : void 0,
+		scales: group.kind === "S" ? values : void 0
 	};
 }
-/** `(p - offset) * scale` for every xyz position. */
-function transformPositions(positions, { offset, scale }) {
-	const out = new Float32Array(positions.length);
-	for (let i = 0; i < positions.length; i += 3) {
-		out[i] = (positions[i] - offset[0]) * scale[0];
-		out[i + 1] = (positions[i + 1] - offset[1]) * scale[1];
-		out[i + 2] = (positions[i + 2] - offset[2]) * scale[2];
-	}
-	return out;
-}
-/** Uint16 indices while every vertex fits, Uint32 beyond 65535 vertices. */
-function createIndexArray(indices, vertexCount) {
-	return vertexCount > 65535 ? new Uint32Array(indices) : new Uint16Array(indices);
+function parseFBX(bufferOrText, options = {}) {
+	return FbxLoader.parse(bufferOrText, options);
 }
-/** The model's bounds after `transform`, as `Model3DData.bounds` reports them. */
-function transformModelBounds(bounds, { offset, scale }) {
-	const min = [
-		(bounds.min[0] - offset[0]) * scale[0],
-		(bounds.min[1] - offset[1]) * scale[1],
-		(bounds.min[2] - offset[2]) * scale[2]
-	];
-	const max = [
-		(bounds.max[0] - offset[0]) * scale[0],
-		(bounds.max[1] - offset[1]) * scale[1],
-		(bounds.max[2] - offset[2]) * scale[2]
-	];
-	return {
-		min,
-		max,
-		center: [
-			(min[0] + max[0]) * .5,
-			(min[1] + max[1]) * .5,
-			(min[2] + max[2]) * .5
-		],
-		size: [
-			max[0] - min[0],
-			max[1] - min[1],
-			max[2] - min[2]
-		],
-		boundingSphereRadius: Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) * .5
-	};
+function loadFBX(srcOrData, options = {}) {
+	let data = srcOrData;
+	if (typeof srcOrData === "string") {
+		const trimmed = srcOrData.trim();
+		if (!(trimmed.includes("FBXHeaderExtension") || trimmed.includes("Kaydara FBX")) && typeof fs !== "undefined" && fs.existsSync) try {
+			let filePath = srcOrData.startsWith("file://") ? srcOrData.slice(7) : srcOrData;
+			try {
+				filePath = decodeURIComponent(filePath);
+			} catch (_) {}
+			if (fs.existsSync(filePath)) {
+				const buf = fs.readFileSync(filePath);
+				data = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+				options = {
+					basePath: path.dirname(filePath),
+					...options
+				};
+			}
+		} catch (_) {}
+	}
+	return FbxLoader.parse(data, options);
 }
 var StlLoader = class StlLoader$1 {
 	/**
@@ -14340,250 +14775,97 @@ var PlyLoader = class PlyLoader$1 {
 			let nx = 0, ny = 0, nz = 0;
 			let u = 0, vCoord = 0;
 			let r = 1, g$1 = 1, b = 1, a = 1;
-			for (const prop of vProps) {
-				const val = readType(prop.type);
-				const pName = prop.name.toLowerCase();
-				if (pName === "x") x = val;
-				else if (pName === "y") y = val;
-				else if (pName === "z") z = val;
-				else if (pName === "nx") nx = val;
-				else if (pName === "ny") ny = val;
-				else if (pName === "nz") nz = val;
-				else if (pName === "u" || pName === "s") u = val;
-				else if (pName === "v" || pName === "t") vCoord = val;
-				else if (pName === "red" || pName === "r") r = prop.type.includes("int") ? val / 255 : val;
-				else if (pName === "green" || pName === "g") g$1 = prop.type.includes("int") ? val / 255 : val;
-				else if (pName === "blue" || pName === "b") b = prop.type.includes("int") ? val / 255 : val;
-				else if (pName === "alpha" || pName === "a") a = prop.type.includes("int") ? val / 255 : val;
-			}
-			rawPositions.push(x, y, z);
-			rawNormals.push(nx, ny, nz);
-			rawUvs.push(u, 1 - vCoord);
-			if (hasColors) rawColors.push(r, g$1, b, a);
-		}
-		const listProp = (faceElement?.properties ?? []).find((p) => p.isList);
-		for (let f = 0; f < faceCount; f++) {
-			if (offset >= bodyBytes.byteLength) break;
-			if (listProp) {
-				const count = readType(listProp.countType ?? "uchar");
-				const verts = [];
-				for (let k = 0; k < count; k++) verts.push(readType(listProp.itemType ?? "int"));
-				if (verts.length >= 3) {
-					const v0 = verts[0];
-					for (let i = 1; i < verts.length - 1; i++) rawIndices.push(v0, verts[i], verts[i + 1]);
-				}
-			}
-		}
-		return PlyLoader$1.finalizeModel(rawPositions, rawNormals, rawUvs, hasColors ? rawColors : void 0, rawIndices, hasNormals, options);
-	}
-	static finalizeModel(rawPositions, rawNormals, rawUvs, rawColors, rawIndices, hasNormals, options) {
-		if (!hasNormals || options.smoothNormals) accumulateVertexNormals(rawPositions, rawIndices, rawNormals);
-		const bounds = computeBounds(rawPositions);
-		const transform$1 = resolveModelTransform(bounds, options);
-		const positions = transformPositions(rawPositions, transform$1);
-		const indexArray = createIndexArray(rawIndices, positions.length / 3);
-		const defaultMaterial = {
-			name: "ply_default",
-			diffuseColor: [
-				.8,
-				.8,
-				.85,
-				1
-			],
-			shininess: 32,
-			specularIntensity: .5,
-			...options.defaultMaterial
-		};
-		return {
-			name: "PLY_Model",
-			meshes: [{
-				id: "ply_mesh_0",
-				name: "ply_geometry",
-				positions,
-				normals: new Float32Array(rawNormals),
-				uvs: new Float32Array(rawUvs),
-				colors: rawColors ? new Float32Array(rawColors) : void 0,
-				indices: indexArray,
-				materialName: "ply_default"
-			}],
-			materials: { ply_default: defaultMaterial },
-			animations: [],
-			bounds: transformModelBounds(bounds, transform$1)
-		};
-	}
-	/**
-	* Loads a PLY file synchronously or asynchronously from a path or URL.
-	*/
-	static load(srcOrData, options = {}) {
-		if (typeof srcOrData !== "string") return PlyLoader$1.parse(srcOrData, options);
-		if (srcOrData.startsWith("/") || srcOrData.startsWith("./") || srcOrData.startsWith("../") || srcOrData.startsWith("file://")) {
-			const cleanPath = srcOrData.startsWith("file://") ? srcOrData.replace("file://", "") : srcOrData;
-			const buf = fs.readFileSync(cleanPath);
-			return PlyLoader$1.parse(buf, options);
-		}
-		return PlyLoader$1.parse(srcOrData, options);
-	}
-};
-function loadPLY(srcOrData, options = {}) {
-	return PlyLoader.load(srcOrData, options);
-}
-/**
-* Poses a model's scene graph (glTF semantics): samples an animation clip's
-* translation / rotation / scale tracks at a time, composes the node
-* hierarchy into model-space matrices, and turns a skin's joints into the
-* joint matrices the mesh shader blends (joint world × inverse bind).
-*/
-/** Joints per skin the mesh shader holds (mesh3d.wgsl jointMatrices). */
-const MAX_JOINTS = 128;
-/** Column-major translate · rotate(quaternion) · scale. */
-function trsMatrix(t, q, s) {
-	const [x, y, z, w] = q;
-	const xx = x * x;
-	const yy = y * y;
-	const zz = z * z;
-	const xy = x * y;
-	const xz = x * z;
-	const yz = y * z;
-	const wx = w * x;
-	const wy = w * y;
-	const wz = w * z;
-	return [
-		(1 - 2 * (yy + zz)) * s[0],
-		2 * (xy + wz) * s[0],
-		2 * (xz - wy) * s[0],
-		0,
-		2 * (xy - wz) * s[1],
-		(1 - 2 * (xx + zz)) * s[1],
-		2 * (yz + wx) * s[1],
-		0,
-		2 * (xz + wy) * s[2],
-		2 * (yz - wx) * s[2],
-		(1 - 2 * (xx + yy)) * s[2],
-		0,
-		t[0],
-		t[1],
-		t[2],
-		1
-	];
-}
-function normalizeQuat(q) {
-	const len = Math.hypot(q[0], q[1], q[2], q[3]) || 1;
-	return [
-		q[0] / len,
-		q[1] / len,
-		q[2] / len,
-		q[3] / len
-	];
-}
-function slerp(a, b, t) {
-	let cos = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-	const sign = cos < 0 ? -1 : 1;
-	cos *= sign;
-	if (cos > .9995) return normalizeQuat([
-		a[0] + (sign * b[0] - a[0]) * t,
-		a[1] + (sign * b[1] - a[1]) * t,
-		a[2] + (sign * b[2] - a[2]) * t,
-		a[3] + (sign * b[3] - a[3]) * t
-	]);
-	const theta = Math.acos(cos);
-	const sin = Math.sin(theta);
-	const wa = Math.sin((1 - t) * theta) / sin;
-	const wb = sign * Math.sin(t * theta) / sin;
-	return [
-		a[0] * wa + b[0] * wb,
-		a[1] * wa + b[1] * wb,
-		a[2] * wa + b[2] * wb,
-		a[3] * wa + b[3] * wb
-	];
-}
-/** Index of the last keyframe at or before `time` (binary search). */
-function keyBefore(times, time$2) {
-	let lo = 0;
-	let hi = times.length - 1;
-	while (lo < hi) {
-		const mid = lo + hi + 1 >> 1;
-		if ((times[mid] ?? 0) <= time$2) lo = mid;
-		else hi = mid - 1;
-	}
-	return lo;
-}
-/** Element `k` (of `size` components) of a track's values; cubic tracks store [in, value, out] triples. */
-function valueAt(values, k, size, cubic, part = 1) {
-	const at = cubic ? (k * 3 + part) * size : k * size;
-	return Array.from(values.subarray(at, at + size));
-}
-function sampleChannel(track, values, size, time$2) {
-	const { times } = track;
-	const cubic = track.interpolation === "cubic";
-	const last = times.length - 1;
-	if (time$2 <= (times[0] ?? 0)) return valueAt(values, 0, size, cubic);
-	if (time$2 >= (times[last] ?? 0)) return valueAt(values, last, size, cubic);
-	const k = keyBefore(times, time$2);
-	if (track.interpolation === "step") return valueAt(values, k, size, cubic);
-	const t0 = times[k] ?? 0;
-	const dt = (times[k + 1] ?? t0) - t0;
-	const u = dt > 0 ? (time$2 - t0) / dt : 0;
-	const a = valueAt(values, k, size, cubic);
-	const b = valueAt(values, k + 1, size, cubic);
-	if (cubic) {
-		const outA = valueAt(values, k, size, true, 2);
-		const inB = valueAt(values, k + 1, size, true, 0);
-		const u2 = u * u;
-		const u3 = u2 * u;
-		const out = a.map((p0, i) => (2 * u3 - 3 * u2 + 1) * p0 + (u3 - 2 * u2 + u) * dt * (outA[i] ?? 0) + (-2 * u3 + 3 * u2) * (b[i] ?? 0) + (u3 - u2) * dt * (inB[i] ?? 0));
-		return size === 4 ? normalizeQuat(out) : out;
+			for (const prop of vProps) {
+				const val = readType(prop.type);
+				const pName = prop.name.toLowerCase();
+				if (pName === "x") x = val;
+				else if (pName === "y") y = val;
+				else if (pName === "z") z = val;
+				else if (pName === "nx") nx = val;
+				else if (pName === "ny") ny = val;
+				else if (pName === "nz") nz = val;
+				else if (pName === "u" || pName === "s") u = val;
+				else if (pName === "v" || pName === "t") vCoord = val;
+				else if (pName === "red" || pName === "r") r = prop.type.includes("int") ? val / 255 : val;
+				else if (pName === "green" || pName === "g") g$1 = prop.type.includes("int") ? val / 255 : val;
+				else if (pName === "blue" || pName === "b") b = prop.type.includes("int") ? val / 255 : val;
+				else if (pName === "alpha" || pName === "a") a = prop.type.includes("int") ? val / 255 : val;
+			}
+			rawPositions.push(x, y, z);
+			rawNormals.push(nx, ny, nz);
+			rawUvs.push(u, 1 - vCoord);
+			if (hasColors) rawColors.push(r, g$1, b, a);
+		}
+		const listProp = (faceElement?.properties ?? []).find((p) => p.isList);
+		for (let f = 0; f < faceCount; f++) {
+			if (offset >= bodyBytes.byteLength) break;
+			if (listProp) {
+				const count = readType(listProp.countType ?? "uchar");
+				const verts = [];
+				for (let k = 0; k < count; k++) verts.push(readType(listProp.itemType ?? "int"));
+				if (verts.length >= 3) {
+					const v0 = verts[0];
+					for (let i = 1; i < verts.length - 1; i++) rawIndices.push(v0, verts[i], verts[i + 1]);
+				}
+			}
+		}
+		return PlyLoader$1.finalizeModel(rawPositions, rawNormals, rawUvs, hasColors ? rawColors : void 0, rawIndices, hasNormals, options);
 	}
-	if (size === 4) return slerp(a, b, u);
-	return a.map((v, i) => v + ((b[i] ?? v) - v) * u);
-}
-/** Each node's local matrix with the clip's tracks applied at `time` (seconds). */
-function localMatrices(nodes, clip, time$2) {
-	const t = nodes.map((n) => [...n.translation]);
-	const r = nodes.map((n) => [...n.rotation]);
-	const s = nodes.map((n) => [...n.scale]);
-	const byName = new Map(nodes.map((n, i) => [n.name, i]));
-	for (const track of clip?.tracks ?? []) {
-		const i = track.node ?? byName.get(track.nodeName);
-		if (i === void 0 || !track.times.length) continue;
-		if (track.translations) t[i] = sampleChannel(track, track.translations, 3, time$2);
-		if (track.rotations) r[i] = sampleChannel(track, track.rotations, 4, time$2);
-		if (track.scales) s[i] = sampleChannel(track, track.scales, 3, time$2);
+	static finalizeModel(rawPositions, rawNormals, rawUvs, rawColors, rawIndices, hasNormals, options) {
+		if (!hasNormals || options.smoothNormals) accumulateVertexNormals(rawPositions, rawIndices, rawNormals);
+		const bounds = computeBounds(rawPositions);
+		const transform$1 = resolveModelTransform(bounds, options);
+		const positions = transformPositions(rawPositions, transform$1);
+		const indexArray = createIndexArray(rawIndices, positions.length / 3);
+		const defaultMaterial = {
+			name: "ply_default",
+			diffuseColor: rawColors ? [
+				1,
+				1,
+				1,
+				1
+			] : [
+				.8,
+				.8,
+				.85,
+				1
+			],
+			shininess: 32,
+			specularIntensity: .5,
+			...options.defaultMaterial
+		};
+		return {
+			name: "PLY_Model",
+			meshes: [{
+				id: "ply_mesh_0",
+				name: "ply_geometry",
+				positions,
+				normals: new Float32Array(rawNormals),
+				uvs: new Float32Array(rawUvs),
+				colors: rawColors ? new Float32Array(rawColors) : void 0,
+				indices: indexArray,
+				materialName: "ply_default"
+			}],
+			materials: { ply_default: defaultMaterial },
+			animations: [],
+			bounds: transformModelBounds(bounds, transform$1)
+		};
 	}
-	return nodes.map((n, i) => n.matrix ?? trsMatrix(t[i], r[i], s[i]));
-}
-/**
-* Model-space matrix of every node, posed by `clip` at `time` seconds (the
-* rest pose without a clip). Parents may follow their children in the list.
-*/
-function poseNodes(model, clip, time$2) {
-	const nodes = model.nodes ?? [];
-	const local = localMatrices(nodes, clip, time$2);
-	const world = new Array(nodes.length);
-	const resolve$1$1 = (i) => {
-		const done = world[i];
-		if (done) return done;
-		const parent = nodes[i].parent;
-		const m = parent < 0 ? local[i] : Matrix4Math.multiply(resolve$1$1(parent), local[i]);
-		world[i] = m;
-		return m;
-	};
-	return nodes.map((_, i) => resolve$1$1(i));
-}
-/** The joint matrices of one skin for a posed scene graph, padded with identity to MAX_JOINTS. */
-function jointMatrices(model, skinIndex, world) {
-	const skin = model.skins?.[skinIndex];
-	if (!skin) throw new Error(`model has no skin ${skinIndex}`);
-	const out = new Float32Array(MAX_JOINTS * 16);
-	for (let j = 0; j < MAX_JOINTS; j++) {
-		const node = skin.joints[j];
-		if (node === void 0) {
-			out.set(Matrix4Math.identity(), j * 16);
-			continue;
+	/**
+	* Loads a PLY file synchronously or asynchronously from a path or URL.
+	*/
+	static load(srcOrData, options = {}) {
+		if (typeof srcOrData !== "string") return PlyLoader$1.parse(srcOrData, options);
+		if (srcOrData.startsWith("/") || srcOrData.startsWith("./") || srcOrData.startsWith("../") || srcOrData.startsWith("file://")) {
+			const cleanPath = srcOrData.startsWith("file://") ? srcOrData.replace("file://", "") : srcOrData;
+			const buf = fs.readFileSync(cleanPath);
+			return PlyLoader$1.parse(buf, options);
 		}
-		const ibm = Array.from(skin.inverseBindMatrices.subarray(j * 16, j * 16 + 16));
-		out.set(Matrix4Math.multiply(world[node], ibm), j * 16);
+		return PlyLoader$1.parse(srcOrData, options);
 	}
-	return out;
+};
+function loadPLY(srcOrData, options = {}) {
+	return PlyLoader.load(srcOrData, options);
 }
 const COMPONENTS = {
 	SCALAR: 1,
@@ -14613,6 +14895,11 @@ function componentReader(componentType, normalized = false) {
 		default: return (dv, at) => dv.getFloat32(at, true);
 	}
 }
+/** Mesh compression the loader cannot decode: a file that requires it fails with a clear error. */
+const UNSUPPORTED_REQUIRED_EXTENSIONS = {
+	KHR_draco_mesh_compression: "Draco mesh compression",
+	EXT_meshopt_compression: "meshopt compression"
+};
 const GLB_MAGIC = 1179937895;
 const CHUNK_TYPE_JSON = 1313821514;
 const CHUNK_TYPE_BIN = 5130562;
@@ -14667,6 +14954,10 @@ var GltfLoader = class GltfLoader$1 {
 				}
 			}
 		}
+		for (const ext of doc.extensionsRequired ?? []) {
+			const what = UNSUPPORTED_REQUIRED_EXTENSIONS[ext];
+			if (what) throw new Error(`glTF file requires ${ext} (${what}), which framefields cannot decode. Re-export the model without mesh compression (in Blender's glTF exporter, turn off Compression).`);
+		}
 		return GltfLoader$1.buildModel(doc, binaryBuffers, options, basePath);
 	}
 	static unpackGlb(bytes) {
@@ -14754,11 +15045,59 @@ var GltfLoader = class GltfLoader$1 {
 		}
 		if (!basePath) return void 0;
 		const file = path.isAbsolute(image.uri) ? image.uri : path.join(basePath, decodeURIComponent(image.uri));
-		if (!fs.existsSync(file)) return void 0;
-		const ext = path.extname(file).toLowerCase();
+		if (!fs.existsSync(file)) {
+			GltfLoader$1.warn(`Image "${image.uri}" was not found next to the model; textures using it are skipped.`);
+			return;
+		}
 		return {
 			bytes: new Uint8Array(fs.readFileSync(file)),
-			mime: image.mimeType ?? (ext === ".png" ? "image/png" : "image/jpeg")
+			mime: image.mimeType ?? textureMime(file)
+		};
+	}
+	static warn(message) {
+		console.warn(`[GltfLoader] ${message}`);
+	}
+	/** The UV set of a texture reference (KHR_texture_transform may override it). */
+	static texCoordOf(info) {
+		return info.extensions?.KHR_texture_transform?.texCoord ?? info.texCoord ?? 0;
+	}
+	/** The UV set and transform of the material's base color map (else its first map). */
+	static uvPlan(mat) {
+		const first = [
+			mat?.pbrMetallicRoughness?.baseColorTexture,
+			mat?.normalTexture,
+			mat?.pbrMetallicRoughness?.metallicRoughnessTexture,
+			mat?.occlusionTexture,
+			mat?.emissiveTexture
+		].find((t) => t !== void 0);
+		return first ? {
+			texCoord: GltfLoader$1.texCoordOf(first),
+			transform: first.extensions?.KHR_texture_transform
+		} : { texCoord: 0 };
+	}
+	/**
+	* A texture's decodable image: EXT_texture_webp's source when present.
+	* KTX2 / Basis (KHR_texture_basisu) and other formats the renderer
+	* cannot decode are skipped with a warning.
+	*/
+	static textureImage(doc, binaryBuffers, textureIndex, basePath, label) {
+		const texture = doc.textures?.[textureIndex];
+		if (!texture) return void 0;
+		const source = texture.extensions?.EXT_texture_webp?.source ?? texture.source;
+		if (source === void 0) {
+			if (texture.extensions?.KHR_texture_basisu) GltfLoader$1.warn(`${label} is a KTX2 / Basis texture, which framefields cannot decode; it is skipped (use PNG, JPEG or WebP).`);
+			return;
+		}
+		const image = GltfLoader$1.imageBytes(doc, binaryBuffers, source, basePath);
+		if (!image) return void 0;
+		if (!SUPPORTED_IMAGE_MIMES.has(image.mime)) {
+			GltfLoader$1.warn(`${label} is ${image.mime}, which framefields cannot decode; it is skipped (use PNG, JPEG or WebP).`);
+			return;
+		}
+		const sampler = texture.sampler !== void 0 ? doc.samplers?.[texture.sampler] : void 0;
+		return {
+			...image,
+			sampler
 		};
 	}
 	static buildMaterial(doc, binaryBuffers, mat, name, basePath) {
@@ -14798,38 +15137,45 @@ var GltfLoader = class GltfLoader$1 {
 				1
 			];
 		} else if (mat.extensions?.KHR_materials_unlit) material.shading = "unlit";
-		const texRef = pbr?.baseColorTexture;
-		const texture = texRef ? doc.textures?.[texRef.index] : void 0;
-		if (texture?.source !== void 0) {
-			const image = GltfLoader$1.imageBytes(doc, binaryBuffers, texture.source, basePath);
-			if (image) {
-				material.diffuseTextureBuffer = image.bytes;
-				material.diffuseTextureMime = image.mime;
-				const wrap = texture.sampler !== void 0 ? doc.samplers?.[texture.sampler]?.wrapS : void 0;
-				material.textureWrap = wrap === 33071 ? "clamp" : wrap === 33648 ? "mirror" : "repeat";
+		const plan = GltfLoader$1.uvPlan(mat);
+		const image = (info, slot) => {
+			if (!info) return void 0;
+			const label = `The ${slot} map of material "${name}"`;
+			const set = GltfLoader$1.texCoordOf(info);
+			if (set !== plan.texCoord) {
+				GltfLoader$1.warn(`${label} uses UV set ${set}, but the mesh draws with UV set ${plan.texCoord}; the map is skipped.`);
+				return;
 			}
-		}
-		const mapBytes = (ref) => {
-			const tex = ref ? doc.textures?.[ref.index] : void 0;
-			return tex?.source !== void 0 ? GltfLoader$1.imageBytes(doc, binaryBuffers, tex.source, basePath)?.bytes : void 0;
+			const t = info.extensions?.KHR_texture_transform;
+			if (JSON.stringify(t ?? null) !== JSON.stringify(plan.transform ?? null)) GltfLoader$1.warn(`${label} has a different KHR_texture_transform than the mesh's first map; it is drawn with that one's.`);
+			return GltfLoader$1.textureImage(doc, binaryBuffers, info.index, basePath, label);
 		};
-		const normal = mapBytes(mat.normalTexture);
+		const base = image(pbr?.baseColorTexture, "base color");
+		if (base) {
+			material.diffuseTextureBuffer = base.bytes;
+			material.diffuseTextureMime = base.mime;
+			const wrap = base.sampler?.wrapS;
+			material.textureWrap = wrap === 33071 ? "clamp" : wrap === 33648 ? "mirror" : "repeat";
+			if (base.sampler?.magFilter === 9728) material.textureFilter = "nearest";
+		}
+		const mapBytes = (info, slot) => image(info, slot)?.bytes;
+		const normal = mapBytes(mat.normalTexture, "normal");
 		if (normal) {
 			material.normalTextureBuffer = normal;
 			material.normalScale = mat.normalTexture?.scale ?? 1;
 		}
-		const mr = mapBytes(pbr?.metallicRoughnessTexture);
+		const mr = mapBytes(pbr?.metallicRoughnessTexture, "metallic-roughness");
 		if (mr) {
 			material.metallicRoughnessTextureBuffer = mr;
 			material.roughness = pbr?.roughnessFactor ?? 1;
 			material.metallic = pbr?.metallicFactor ?? 1;
 		}
-		const occlusion = mapBytes(mat.occlusionTexture);
+		const occlusion = mapBytes(mat.occlusionTexture, "occlusion");
 		if (occlusion) {
 			material.occlusionTextureBuffer = occlusion;
 			material.occlusionStrength = mat.occlusionTexture?.strength ?? 1;
 		}
-		const emissiveMap = material.emissive && mapBytes(mat.emissiveTexture);
+		const emissiveMap = material.emissive && mapBytes(mat.emissiveTexture, "emissive");
 		if (emissiveMap) material.emissiveTextureBuffer = emissiveMap;
 		return material;
 	}
@@ -14903,6 +15249,7 @@ var GltfLoader = class GltfLoader$1 {
 			const key = materialKeys[idx];
 			materials[key] = GltfLoader$1.buildMaterial(doc, binaryBuffers, mat, key, basePath);
 		});
+		const uvPlans = (doc.materials ?? []).map((mat) => GltfLoader$1.uvPlan(mat));
 		const nodes = GltfLoader$1.buildNodes(doc);
 		const skins = (doc.skins ?? []).map((skin) => ({
 			joints: skin.joints,
@@ -14966,11 +15313,18 @@ var GltfLoader = class GltfLoader$1 {
 				const read = (acc) => acc === void 0 ? void 0 : GltfLoader$1.readFloats(doc, binaryBuffers, acc);
 				const pos = read(prim.attributes.POSITION);
 				const numVerts = pos.count;
+				const plan = prim.material !== void 0 ? uvPlans[prim.material] : void 0;
+				const attributes = prim.attributes;
+				const uvs = read(attributes[`TEXCOORD_${plan?.texCoord ?? 0}`])?.data ?? read(prim.attributes.TEXCOORD_0)?.data ?? new Float32Array(numVerts * 2);
+				if (plan?.transform) applyTextureTransform(uvs, plan.transform);
 				const colors = read(prim.attributes.COLOR_0);
 				let rgba;
 				if (colors) {
 					rgba = new Float32Array(numVerts * 4).fill(1);
-					for (let v = 0; v < numVerts; v++) for (let c = 0; c < colors.itemSize; c++) rgba[v * 4 + c] = colors.data[v * colors.itemSize + c] ?? 1;
+					for (let v = 0; v < numVerts; v++) for (let c = 0; c < colors.itemSize; c++) {
+						const value = colors.data[v * colors.itemSize + c] ?? 1;
+						rgba[v * 4 + c] = c < 3 ? linearToSrgb(value) : value;
+					}
 				}
 				let indices;
 				if (prim.indices !== void 0) indices = GltfLoader$1.readIndices(doc, binaryBuffers, prim.indices);
@@ -14998,7 +15352,7 @@ var GltfLoader = class GltfLoader$1 {
 					name: meshDef.name ?? `Mesh_${inst.mesh}`,
 					positions: pos.data,
 					normals: read(prim.attributes.NORMAL)?.data ?? new Float32Array(numVerts * 3),
-					uvs: read(prim.attributes.TEXCOORD_0)?.data ?? new Float32Array(numVerts * 2),
+					uvs,
 					colors: rgba,
 					jointIndices: skinned ? read(prim.attributes.JOINTS_0)?.data : void 0,
 					jointWeights: skinned ? read(prim.attributes.WEIGHTS_0)?.data : void 0,
@@ -15072,8 +15426,8 @@ var GltfLoader = class GltfLoader$1 {
 	*/
 	static load(srcOrData, options = {}) {
 		if (typeof srcOrData !== "string") return GltfLoader$1.parse(srcOrData, options);
-		if (srcOrData.startsWith("/") || srcOrData.startsWith("./") || srcOrData.startsWith("../") || srcOrData.startsWith("file://")) {
-			const cleanPath = srcOrData.startsWith("file://") ? srcOrData.replace("file://", "") : srcOrData;
+		const cleanPath = srcOrData.startsWith("file://") ? srcOrData.replace("file://", "") : srcOrData;
+		if (srcOrData.startsWith("/") || srcOrData.startsWith("./") || srcOrData.startsWith("../") || srcOrData.startsWith("file://") || !srcOrData.trimStart().startsWith("{") && fs.existsSync(cleanPath)) {
 			const buf = fs.readFileSync(cleanPath);
 			const basePath = path.dirname(cleanPath);
 			return GltfLoader$1.parse(buf, options, basePath);
@@ -15087,6 +15441,33 @@ function loadGLTF(srcOrData, options = {}) {
 function loadGLB(srcOrData, options = {}) {
 	return GltfLoader.load(srcOrData, options);
 }
+function linearToSrgb(c) {
+	const x = Math.min(Math.max(c, 0), 1);
+	return x <= .0031308 ? x * 12.92 : 1.055 * x ** (1 / 2.4) - .055;
+}
+/** The image types the renderer decodes (sharp). */
+const SUPPORTED_IMAGE_MIMES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif",
+	"image/tiff",
+	"image/avif"
+]);
+/**
+* Bakes KHR_texture_transform into UVs in place: uv' = T * R * S * uv
+* (offset, then rotation counter-clockwise in UV space, then scale).
+*/
+function applyTextureTransform(uvs, { offset = [0, 0], rotation = 0, scale = [1, 1] }) {
+	const c = Math.cos(rotation);
+	const s = Math.sin(rotation);
+	for (let i = 0; i < uvs.length; i += 2) {
+		const u = uvs[i] * scale[0];
+		const v = uvs[i + 1] * scale[1];
+		uvs[i] = c * u + s * v + offset[0];
+		uvs[i + 1] = -s * u + c * v + offset[1];
+	}
+}
 const DEFAULT_PALETTE = [[
 	0,
 	0,
@@ -15660,7 +16041,12 @@ var OffLoader = class OffLoader$1 {
 		const indexArray = createIndexArray(rawIndices, positions.length / 3);
 		const defaultMaterial = {
 			name: "off_default",
-			diffuseColor: [
+			diffuseColor: hasColors ? [
+				1,
+				1,
+				1,
+				1
+			] : [
 				.8,
 				.8,
 				.85,
@@ -20139,7 +20525,7 @@ function decodeBase64(base64$1) {
 }
 function extractFontFamiliesFromLottie(lottieJson) {
 	const fonts = /* @__PURE__ */ new Set();
-	const fontsList = lottieJson?.fonts?.list;
+	const fontsList = (lottieJson?.fonts)?.list;
 	if (Array.isArray(fontsList)) for (const entry of fontsList) {
 		if (entry?.fName && typeof entry.fName === "string") fonts.add(entry.fName);
 		if (entry?.fFamily && typeof entry.fFamily === "string") fonts.add(entry.fFamily);
@@ -20147,19 +20533,24 @@ function extractFontFamiliesFromLottie(lottieJson) {
 	const layers = lottieJson?.layers;
 	if (!Array.isArray(layers)) return [...fonts];
 	for (const layer of layers) {
-		if (layer?.ty !== 5) continue;
-		const k = layer?.t?.d?.k ?? layer?.t?.k;
+		const l = layer;
+		if (l?.ty !== 5) continue;
+		const k = l?.t?.d?.k ?? l?.t?.k;
 		if (!k) continue;
 		const kArr = Array.isArray(k) ? k : [k];
 		for (const kf of kArr) {
+			const kfObj = kf;
 			const possibleDocs = [
-				kf?.s,
-				kf?.e,
+				kfObj?.s,
+				kfObj?.e,
 				kf
 			].filter(Boolean);
 			for (const doc of possibleDocs) {
 				const docArr = Array.isArray(doc) ? doc : [doc];
-				for (const d of docArr) if (d?.f && typeof d.f === "string") fonts.add(d.f);
+				for (const d of docArr) {
+					const docItem = d;
+					if (docItem?.f && typeof docItem.f === "string") fonts.add(docItem.f);
+				}
 			}
 		}
 	}
@@ -20187,7 +20578,7 @@ async function registerLottieFont(family) {
 	if (typeof window !== "undefined" && typeof document !== "undefined" && typeof document.createElement === "function" && typeof document.getElementById === "function") {
 		try {
 			await localFontManager.loadFont(family, fontUrl);
-		} catch (err) {
+		} catch (_err) {
 			fontUrl = GetFontAssetUrl(family);
 			try {
 				await localFontManager.loadFont(family, fontUrl);
@@ -20229,16 +20620,58 @@ async function registerLottieFont(family) {
 	if (registered) registeredLottieFonts.add(family);
 	else console.warn(`[LottieRenderer] All font registration attempts failed for "${family}". Text using this font will not render.`);
 }
+var HeadlessLottieCanvas = class {
+	width;
+	height;
+	style = {};
+	constructor(width, height) {
+		this.width = width;
+		this.height = height;
+	}
+	addEventListener() {}
+	removeEventListener() {}
+	getContext(contextId) {
+		if (contextId === "2d") return {
+			fillRect() {},
+			clearRect() {},
+			putImageData() {},
+			createImageData(width, height) {
+				return {
+					width,
+					height,
+					data: new Uint8ClampedArray(width * height * 4)
+				};
+			},
+			getImageData(_sx, _sy, sw, sh) {
+				return {
+					width: sw,
+					height: sh,
+					data: new Uint8ClampedArray(sw * sh * 4)
+				};
+			}
+		};
+		return null;
+	}
+	getBoundingClientRect() {
+		return {
+			left: 0,
+			top: 0,
+			width: this.width,
+			height: this.height
+		};
+	}
+};
 var LottieInstance = class {
 	dotLottie;
 	canvas;
 	loadPromise;
 	_width;
 	_height;
+	uploadBuffer = null;
 	constructor(src, width, height, data) {
 		this._width = width;
 		this._height = height;
-		this.canvas = new OffscreenCanvas(width, height);
+		this.canvas = typeof window !== "undefined" && typeof document !== "undefined" && typeof document.createElement === "function" && typeof document.getElementById === "function" ? new OffscreenCanvas(width, height) : new HeadlessLottieCanvas(width, height);
 		this.dotLottie = new DotLottie({
 			canvas: this.canvas,
 			...data ? { data } : { src },
@@ -20281,6 +20714,29 @@ var LottieInstance = class {
 	async ready() {
 		await this.loadPromise;
 	}
+	renderPixels(frame, fit) {
+		const loopedFrame = Math.floor(frame) % Math.max(1, this.totalFrames);
+		this.dotLottie.setLayout({
+			align: [.5, .5],
+			fit: fit || "contain"
+		});
+		this.dotLottie.resize();
+		this.dotLottie.setFrame(loopedFrame);
+		try {
+			this.dotLottie.render?.();
+		} catch (_) {}
+		const core = this.dotLottie._dotLottieCore;
+		if (core && typeof core.get_pixel_buffer === "function") {
+			const buf = core.get_pixel_buffer();
+			const expectedLength = this._width * this._height * 4;
+			if (buf && buf.byteLength === expectedLength) {
+				if (!this.uploadBuffer || this.uploadBuffer.byteLength !== expectedLength) this.uploadBuffer = new Uint8Array(expectedLength);
+				this.uploadBuffer.set(buf);
+				return premultiplyPixels(this.uploadBuffer);
+			}
+		}
+		return null;
+	}
 	renderFrame(frame, fit) {
 		const loopedFrame = Math.floor(frame) % Math.max(1, this.totalFrames);
 		this.dotLottie.setLayout({
@@ -20298,6 +20754,7 @@ var LottieInstance = class {
 		try {
 			this.dotLottie.destroy();
 		} catch (_) {}
+		this.uploadBuffer = null;
 	}
 };
 let wasmConfigured = false;
@@ -20329,13 +20786,7 @@ function polyfillHeadlessDOM() {
 async function ensureWasmConfigured() {
 	if (wasmConfigured) return;
 	if (!(typeof window !== "undefined" && typeof document !== "undefined" && typeof document.createElement === "function" && typeof document.getElementById === "function")) {
-		if (typeof globalThis.OffscreenCanvas === "undefined") try {
-			const { Canvas: Canvas$1 } = await import(
-				/* webpackIgnore: true */
-				"skia-canvas"
-);
-			globalThis.OffscreenCanvas = Canvas$1;
-		} catch {}
+		if (typeof globalThis.OffscreenCanvas === "undefined") globalThis.OffscreenCanvas = HeadlessLottieCanvas;
 		polyfillHeadlessDOM();
 		if (typeof globalThis.Response === "function") try {
 			Object.defineProperty(globalThis.Response, Symbol.hasInstance, {
@@ -20418,7 +20869,7 @@ var LottieLoader = class {
 						try {
 							const fs$1 = await import(
 								/* webpackIgnore: true */
-								"fs/promises"
+								"node:fs/promises"
 );
 							if (filePath.endsWith(".json")) {
 								const jsonContent = await fs$1.readFile(filePath, "utf-8");
@@ -20467,37 +20918,27 @@ async function drawLottieNode(ctx, pass, props) {
 	const cacheKey = `${props.src}@@${loopedFrame}@@${resolvedWidth}x${resolvedHeight}@@${fitMode}`;
 	let tex = textureCache.acquire(cacheKey);
 	if (!tex) {
-		const canvas = instance.renderFrame(loopedFrame, fitMode);
 		tex = ctx.device.createTexture({
 			size: [instance.width, instance.height],
 			format: "rgba8unorm",
 			usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT
 		});
-		try {
-			ctx.device.queue.copyExternalImageToTexture({ source: canvas }, {
-				texture: tex,
-				premultipliedAlpha: true
-			}, [instance.width, instance.height]);
-		} catch {
-			const c2d = canvas.getContext("2d");
-			if (c2d) {
-				const imgData = c2d.getImageData(0, 0, instance.width, instance.height);
-				const pixelBuffer = premultiplyPixels(new Uint8Array(imgData.data.buffer, imgData.data.byteOffset, imgData.data.byteLength));
-				ctx.device.queue.writeTexture({ texture: tex }, pixelBuffer, { bytesPerRow: instance.width * 4 }, [instance.width, instance.height]);
-			} else {
-				const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
-				if (gl) {
-					const pixels = new Uint8Array(instance.width * instance.height * 4);
-					gl.readPixels(0, 0, instance.width, instance.height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-					const flipped = new Uint8Array(pixels.length);
-					const bytesPerRow = instance.width * 4;
-					for (let y = 0; y < instance.height; y++) {
-						const srcOffset = y * bytesPerRow;
-						const dstOffset = (instance.height - 1 - y) * bytesPerRow;
-						flipped.set(pixels.subarray(srcOffset, srcOffset + bytesPerRow), dstOffset);
-					}
-					ctx.device.queue.writeTexture({ texture: tex }, flipped, { bytesPerRow }, [instance.width, instance.height]);
-				} else console.error("[LottieRenderer] Could not acquire 2D or WebGL context to read pixels.");
+		const pixelBuffer = instance.renderPixels(loopedFrame, fitMode);
+		if (pixelBuffer) ctx.device.queue.writeTexture({ texture: tex }, pixelBuffer, { bytesPerRow: instance.width * 4 }, [instance.width, instance.height]);
+		else {
+			const canvas = instance.renderFrame(loopedFrame, fitMode);
+			try {
+				ctx.device.queue.copyExternalImageToTexture({ source: canvas }, {
+					texture: tex,
+					premultipliedAlpha: true
+				}, [instance.width, instance.height]);
+			} catch {
+				const c2d = canvas.getContext("2d");
+				if (c2d) {
+					const imgData = c2d.getImageData(0, 0, instance.width, instance.height);
+					const fallbackBuffer = premultiplyPixels(new Uint8Array(imgData.data.buffer, imgData.data.byteOffset, imgData.data.byteLength));
+					ctx.device.queue.writeTexture({ texture: tex }, fallbackBuffer, { bytesPerRow: instance.width * 4 }, [instance.width, instance.height]);
+				}
 			}
 		}
 		textureCache.set(cacheKey, tex, ctx.device);
@@ -20823,8 +21264,40 @@ var MediaDecoderCache = class {
 	videoDecoders = /* @__PURE__ */ new Map();
 	audioDecoders = /* @__PURE__ */ new Map();
 	lastAccessed = /* @__PURE__ */ new Map();
+	/** Rendered frames so far (see `tick`), and the frame each decoder was last used on. */
+	ticks = 0;
+	lastTick = /* @__PURE__ */ new Map();
 	touchKey(key) {
 		this.lastAccessed.set(key, Date.now());
+		this.lastTick.set(key, this.ticks);
+	}
+	dropKey(key) {
+		const videoDecoder = this.videoDecoders.get(key);
+		if (videoDecoder) {
+			try {
+				videoDecoder.destroy();
+			} catch (_) {}
+			this.videoDecoders.delete(key);
+		}
+		const audioDecoder = this.audioDecoders.get(key);
+		if (audioDecoder) {
+			try {
+				audioDecoder.destroy();
+			} catch (_) {}
+			this.audioDecoders.delete(key);
+		}
+		this.lastAccessed.delete(key);
+		this.lastTick.delete(key);
+	}
+	/**
+	* Called once per rendered frame by headless renders. A decoder holds a
+	* full-frame RGBA buffer and native decoder state, so one that no layer has
+	* drawn for `idleFrames` frames (its clip ended, or a still render used a
+	* one-off id) is released instead of waiting for the wall-clock prune.
+	*/
+	tick(idleFrames = 120) {
+		this.ticks++;
+		for (const [key, last] of this.lastTick) if (this.ticks - last > idleFrames) this.dropKey(key);
 	}
 	destroy() {
 		for (const decoder of this.videoDecoders.values()) try {
@@ -20836,22 +21309,15 @@ var MediaDecoderCache = class {
 		} catch (_) {}
 		this.audioDecoders.clear();
 		this.lastAccessed.clear();
+		this.lastTick.clear();
+	}
+	/** Decoders currently open (for tests and diagnostics). */
+	get size() {
+		return this.videoDecoders.size + this.audioDecoders.size;
 	}
 	prune(maxAgeMs = 3e5) {
 		const now = Date.now();
-		for (const [key, lastTime] of this.lastAccessed.entries()) if (now - lastTime > maxAgeMs) {
-			const videoDecoder = this.videoDecoders.get(key);
-			if (videoDecoder) {
-				videoDecoder.destroy();
-				this.videoDecoders.delete(key);
-			}
-			const audioDecoder = this.audioDecoders.get(key);
-			if (audioDecoder) {
-				audioDecoder.destroy();
-				this.audioDecoders.delete(key);
-			}
-			this.lastAccessed.delete(key);
-		}
+		for (const [key, lastTime] of this.lastAccessed.entries()) if (now - lastTime > maxAgeMs) this.dropKey(key);
 	}
 	getVideo(url, isHeadless, nodeId) {
 		const key = `${url}-${isHeadless}-${nodeId ?? "default"}`;
@@ -20876,16 +21342,8 @@ var MediaDecoderCache = class {
 		return decoder;
 	}
 	clearNode(nodeId) {
-		for (const [key, decoder] of this.videoDecoders) if (key.includes(nodeId)) {
-			decoder.destroy();
-			this.videoDecoders.delete(key);
-			this.lastAccessed.delete(key);
-		}
-		for (const [key, decoder] of this.audioDecoders) if (key.includes(nodeId)) {
-			decoder.destroy();
-			this.audioDecoders.delete(key);
-			this.lastAccessed.delete(key);
-		}
+		const keys = [...this.videoDecoders.keys(), ...this.audioDecoders.keys()];
+		for (const key of keys) if (key.includes(nodeId)) this.dropKey(key);
 	}
 };
 const mediaDecoderCache = new MediaDecoderCache();
@@ -26523,6 +26981,7 @@ struct VertexInput {
     @location(2) normal   : vec3<f32>,
     @location(3) joints   : vec4<f32>,
     @location(4) weights  : vec4<f32>,
+    @location(5) color    : vec4<f32>, // vertex color (display / sRGB), white when absent
 };
 
 struct VertexOutput {
@@ -26531,6 +26990,7 @@ struct VertexOutput {
     @location(1)       worldPos    : vec3<f32>,
     @location(2)       worldNormal : vec3<f32>,
     @location(3)       linearDepth : f32,
+    @location(4)       color       : vec4<f32>,
 };
 
 @vertex
@@ -26575,6 +27035,7 @@ fn vs_main(in: VertexInput) -> VertexOutput {
 
     out.clipPos = cam.viewProjMatrix * worldPos4;
     out.uv = in.uv;
+    out.color = in.color;
 
     out.linearDepth = dot(worldPos4.xyz - cam.cameraPos.xyz, cam.cameraDir.xyz);
     return out;
@@ -26719,12 +27180,12 @@ fn shadeMesh(in: VertexOutput, isFront: bool) -> MeshFragment {
     if (texColor.a < model.shade.a) {
         discard;
     }
-    let alpha = texColor.a * model.params.x * model.colorTint.a * matteCoverage(in.clipPos.xy);
+    let alpha = texColor.a * in.color.a * model.params.x * model.colorTint.a * matteCoverage(in.clipPos.xy);
     if (alpha <= 0.001) {
         discard;
     }
 
-    let baseRgb = texColor.rgb * model.colorTint.rgb;
+    let baseRgb = texColor.rgb * in.color.rgb * model.colorTint.rgb;
     var out: MeshFragment;
     if (model.materialParams.w > 1.5) {
         var toon = baseRgb;
@@ -27416,6 +27877,11 @@ var Mesh3DPipeline = class {
 	/** (0.5, 0.5, 1): an unperturbed tangent-space normal. */
 	flatNormalTexture;
 	defaultSkinningBuffer;
+	/** White vertex colors for meshes without any, grown to the largest mesh. */
+	whiteColorBuffer = null;
+	whiteColorCapacity = 0;
+	/** Outgrown white buffers: earlier draws this frame may still read them. */
+	retiredColorBuffers = [];
 	modelData = new Float32Array(52 + SURFACE_PARAMS_FLOATS);
 	constructor(device, format, depthFormat = "depth24plus", cameraLayout, lightsLayout, sampleCount = 1) {
 		this.device = device;
@@ -27507,6 +27973,13 @@ var Mesh3DPipeline = class {
 						format: "float32x4"
 					}
 				]
+			}, {
+				arrayStride: 16,
+				attributes: [{
+					shaderLocation: 5,
+					offset: 0,
+					format: "float32x4"
+				}]
 			}]
 		};
 		const base = {
@@ -27701,6 +28174,7 @@ var Mesh3DPipeline = class {
 		pass.setBindGroup(2, textureBindGroup);
 		pass.setBindGroup(3, lightsBindGroup);
 		pass.setVertexBuffer(0, meshBuffers.vertexBuffer);
+		pass.setVertexBuffer(1, this.colorsFor(meshBuffers));
 		pass.setIndexBuffer(meshBuffers.indexBuffer, meshBuffers.indexFormat);
 		pass.drawIndexed(meshBuffers.indexCount);
 	}
@@ -27710,10 +28184,31 @@ var Mesh3DPipeline = class {
 		pass.setBindGroup(0, lightCameraBindGroup);
 		pass.setBindGroup(1, this.packModel(data));
 		pass.setVertexBuffer(0, meshBuffers.vertexBuffer);
+		pass.setVertexBuffer(1, this.colorsFor(meshBuffers));
 		pass.setIndexBuffer(meshBuffers.indexBuffer, meshBuffers.indexFormat);
 		pass.drawIndexed(meshBuffers.indexCount);
 	}
+	colorsFor(meshBuffers) {
+		if (meshBuffers.colorBuffer) return meshBuffers.colorBuffer;
+		const needed = Math.max(1, Math.ceil(meshBuffers.vertexBuffer.size / 64));
+		if (!this.whiteColorBuffer || this.whiteColorCapacity < needed) {
+			if (this.whiteColorBuffer) this.retiredColorBuffers.push(this.whiteColorBuffer);
+			const capacity = 2 ** Math.ceil(Math.log2(needed));
+			this.whiteColorBuffer = this.device.createBuffer({
+				label: "Mesh3DWhiteVertexColors",
+				size: capacity * 16,
+				usage: GPUBufferUsage.VERTEX,
+				mappedAtCreation: true
+			});
+			new Float32Array(this.whiteColorBuffer.getMappedRange()).fill(1);
+			this.whiteColorBuffer.unmap();
+			this.whiteColorCapacity = capacity;
+		}
+		return this.whiteColorBuffer;
+	}
 	destroy() {
+		this.whiteColorBuffer?.destroy();
+		for (const buffer of this.retiredColorBuffers) buffer.destroy();
 		this.modelPool.destroy();
 		this.skinningPool.destroy();
 		this.defaultWhiteTexture.destroy();
@@ -30260,11 +30755,23 @@ var Renderer3D = class {
 		if (is32Bit) new Uint32Array(indexBuffer.getMappedRange()).set(mesh.indices);
 		else new Uint16Array(indexBuffer.getMappedRange()).set(mesh.indices);
 		indexBuffer.unmap();
+		let colorBuffer;
+		if (mesh.colors && mesh.colors.length >= numVerts * 4) {
+			colorBuffer = this.device.createBuffer({
+				label: "Mesh3DVertexColors",
+				size: Math.max(16, numVerts * 16),
+				usage: GPUBufferUsage.VERTEX,
+				mappedAtCreation: true
+			});
+			new Float32Array(colorBuffer.getMappedRange()).set(mesh.colors.subarray(0, numVerts * 4));
+			colorBuffer.unmap();
+		}
 		cached$1 = {
 			vertexBuffer,
 			indexBuffer,
 			indexCount: mesh.indices.length,
-			indexFormat: is32Bit ? "uint32" : "uint16"
+			indexFormat: is32Bit ? "uint32" : "uint16",
+			colorBuffer
 		};
 		this.meshBuffersCache.set(mesh, cached$1);
 		return cached$1;
@@ -30282,7 +30789,8 @@ var Renderer3D = class {
 			}),
 			indexBuffer: meshBuffers.indexBuffer,
 			indexCount: meshBuffers.indexCount,
-			indexFormat: meshBuffers.indexFormat
+			indexFormat: meshBuffers.indexFormat,
+			colorBuffer: meshBuffers.colorBuffer
 		};
 	}
 	drawMesh3D(pass, cameraBindGroup, lightsBindGroup, meshOrBuffers, texture, opts = {}, useMrt = false) {
@@ -30292,13 +30800,15 @@ var Renderer3D = class {
 			1,
 			1,
 			1
-		], twoSided = true, wireframe = false, isSkinned = false, skinningMatrices, material = "lit", shadeColor, alphaCutoff, textureWrap = "clamp", shininess = 32, roughness, specularIntensity = .5, ambientIntensity = 1, metallic } = opts;
+		], twoSided = true, wireframe = false, isSkinned = false, skinningMatrices, material = "lit", shadeColor, alphaCutoff, textureWrap = "clamp", textureFilter = "linear", shininess = 32, roughness, specularIntensity = .5, ambientIntensity = 1, metallic } = opts;
 		const m = this.meshModelMatrix(opts);
 		const normalMatrix = opts.normalMatrix ?? Light3D.computeNormalMatrix(m);
 		const address = ADDRESS_MODES[textureWrap];
 		const sampler = this.samplerCache.getSampler(this.device, {
 			addressModeU: address,
-			addressModeV: address
+			addressModeV: address,
+			magFilter: textureFilter,
+			...textureFilter === "nearest" && { maxAnisotropy: 1 }
 		});
 		const glassy = material === "glass" || material === "acrylic" || material === "frosted";
 		const glass = glassy ? {
@@ -30397,7 +30907,14 @@ var Renderer3D = class {
 			"sharp"
 )).default;
 		const source = Buffer.from(encoded instanceof Uint8Array ? encoded : new Uint8Array(encoded));
-		const { width, height } = await sharp(source).metadata();
+		let width;
+		let height;
+		try {
+			({width, height} = await sharp(source).metadata());
+		} catch (err) {
+			console.warn(`[Renderer3D] Could not decode texture "${label}"; drawing without it:`, err instanceof Error ? err.message : err);
+			return;
+		}
 		if (!width || !height) return void 0;
 		const mipLevelCount = Math.floor(Math.log2(Math.max(width, height))) + 1;
 		const texture = this.device.createTexture({
@@ -31135,4 +31652,4 @@ if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThi
 
 //#endregion
 export { resolveTextSpans as $, TextSelectorSchema as $t, ensureDevice as A, sampleAudioSpectrumScale as An, GlyphAnchorGroupingSchema as At, loadModel3D as B, SignalRegistry as Bt, drawGifNode as C, evaluateTypewriterState as Cn, AudioSpectrumTypographySchema as Ct, drawSignalNode as D, getScramblePool as Dn, EnhancedTextNodeSchema as Dt, drawParagraphNode as E, generatePathSegments as En, DynamicStrokePropertiesSchema as Et, getRenderer2D as F, ParticleDissolveConfigSchema as Ft, parseColor as G, TextAnimatorBuilder as Gt, lutStore as H, Spatial3DPropertiesSchema as Ht, initHeadlessWebGPU as I, SelectorBasedOnSchema as It, parseOBJ as J, TextPathBuilder as Jt, parseFBX as K, TextCursorConfigSchema as Kt, inputStore as L, SelectorModeSchema as Lt, generateExtrudedTextGeometry as M, samplePathChainGeometry as Mn, KineticMarqueeConfigSchema as Mt, getHeadlessFontPath as N, signalRegistry as Nn, LineSpacingDynamicsSchema as Nt, drawSvgNode as O, getShuffledOrder as On, ExpressionSelectorSchema as Ot, getPrimitiveGeometry as P, waveToCubicBeziers as Pn, LongShadowConfigSchema as Pt, registerHeadlessFont as Q, TextScrambleConfigSchema as Qt, jointMatrices as R, SelectorShapeSchema as Rt, drawCaptionNode as S, evaluateSpringProgress as Sn, AudioSignalComputePipeline as St, drawLottieNode as T, generateArcLengthLUT as Tn, CubicBezierSegmentSchema as Tt, measureMaxCaptionHeight as U, SpringPhysicsSchema as Ut, loadOBJ as V, SkewPropertiesSchema as Vt, mediaDecoderCache as W, TextAnchorConfigSchema as Wt, poseNodes as X, TextPathSourceSchema as Xt, parseSvgPathToSegments as Y, TextPathOptionsSchema as Yt, probeVideoSize as Z, TextRangeSelectorSchema as Zt, buildShapeSvgPath as _, evaluateCubicBezierDerivative as _n, AdvancedTextAnimatorBuilder as _t, GlassPipeline as a, Vec2Schema as an, resolveMediaSourceUrl as at, colorMatrixWgsl as b, evaluateSelectorCombination as bn, AnchorPresetSchema as bt, Renderer2D as c, buildPathLUT as cn, LIGHT_UNIFORM_SIZE_BYTES as ct, ScreenSpaceRelightPipeline as d, computeLineLeadingDisplacement as dn, Matrix4Math as dt, TextSignalSelectorSchema as en, shaderStore as et, ShadowPipeline as f, computeRangeSelectorWeight as fn, Path3D as ft, WebGPUAudioProcessor as g, evaluateCubicBezier as gn, AETextAnimatorSchema as gt, SlugPipeline as h, ellipseToCubicBeziers as hn, resolveEnvironment as ht, EffectPipeline as i, VariableFontAxesSchema as in, GetFontAssetUrl as it, fitSpansToText as j, sampleCurveGeometry as jn, GlyphAnchorPointSchema as jt, drawVideoNode as k, parseSvgPathToCubicBeziers as kn, ExtendedGlyphPropertiesSchema as kt, Renderer3D as l, buildWGSLSignalFn as ln, Light3D as lt, SlugGeometry as m, distanceToCurveParameter as mn, parseColorToRgb as mt, AudioLatentTrackCache as n, TypewriterAnimatorSchema as nn, srtLoader as nt, MotionBlurPipeline as o, VolumetricFormationConfigSchema as on, Camera3D as ot, SlugFontCache as p, deterministicWigglyNoise as pn, Vector3Math as pt, parseMTL as q, TextCursorStyleSchema as qt, AudioMeshDeformPipeline as r, TypingCadenceSchema as rn, textureCache as rt, NodeSurfaceProvider as s, VolumetricFormationModeSchema as sn, ENVIRONMENT_PRESETS as st, AudioLatentEngine as t, TextWigglySelectorSchema as tn, spansText as tt, SSAOPipeline as u, computeAnchorPivotOffset as un, MAX_LIGHTS as ut, clearAllVideoCache as v, evaluateExpressionSelector as vn, AdvancedTextAnimatorSchema as vt, drawImageNode as w, evaluateVolumetricFormation as wn, ChromaticGlitchConfigSchema as wt, describeGpu as x, evaluateSkewMatrix as xn, AnimatableGlyphPropsSchema as xt, clearHeadlessFonts as y, evaluateMarqueeOffset as yn, AnchorGroupingSchema as yt, loadFBX as z, SelectorUnitsSchema as zt };
-//# sourceMappingURL=dist-jU289ehm.mjs.map
+//# sourceMappingURL=dist-DRB6Vg5u.mjs.map