@openusd-wasm/three-loader 0.0.3 → 0.0.5

package/dist/openusd_three_loader.js

@@ -1,38 +1,8 @@
 import { createPxr } from "@openusd-wasm/pxr";
 import * as THREE from "three";
 import { FileLoader, Loader } from "three";
-import { autoResolveAssetFiles, autoResolveTextureFiles, createPackageTextureResolver, createTextureResolverFromEntries, findPackageRootLayer } from "@openusd-wasm/utils";
-//#region src/metadata.ts
-const MATERIAL_INPUT_SUFFIXES = [
-	"diffuseColor",
-	"base_color",
-	"baseColor",
-	"emissiveColor",
-	"normal",
-	"occlusion",
-	"opacity",
-	"alpha",
-	"roughness",
-	"metallic",
-	"metallicFactor",
-	"file",
-	"wrapS",
-	"wrapT",
-	"st",
-	"in",
-	"varname",
-	"scale",
-	"translation",
-	"rotation"
-];
-const JOINT_TYPES = {
-	PhysicsFixedJoint: "fixed",
-	PhysicsRevoluteJoint: "revolute",
-	PhysicsPrismaticJoint: "prismatic",
-	PhysicsSphericalJoint: "spherical",
-	PhysicsDistanceJoint: "distance",
-	PhysicsJoint: "joint"
-};
+import { autoResolveAssetFiles, autoResolveTextureFiles, createTextureResolverFromEntries, extractPackageEntries, findPackageRootLayer } from "@openusd-wasm/utils";
+//#region src/scene-data/common.ts
 function dispose$1(value) {
 	if (value && typeof value === "object" && "delete" in value && typeof value.delete === "function") value.delete();
 }
@@ -71,42 +41,6 @@ function toArray(value) {
 function toNumberArray(value) {
 	return toArray(value).map((item) => Number(item)).filter((item) => Number.isFinite(item));
 }
-function toVector3(value, fallback) {
-	const numbers = toNumberArray(value);
-	if (numbers.length < 3) return fallback;
-	return [
-		numbers[0] ?? fallback[0],
-		numbers[1] ?? fallback[1],
-		numbers[2] ?? fallback[2]
-	];
-}
-function toVector4(value) {
-	if (Array.isArray(value)) {
-		const numbers = toNumberArray(value);
-		if (numbers.length >= 4) return [
-			numbers[0] ?? 1,
-			numbers[1] ?? 0,
-			numbers[2] ?? 0,
-			numbers[3] ?? 0
-		];
-	}
-	if (value && typeof value === "object") {
-		const { real, imaginary } = value;
-		const imaginaryNumbers = toNumberArray(imaginary);
-		const r = asFiniteNumber(real);
-		if (r !== null && imaginaryNumbers.length >= 3) return [
-			r,
-			imaginaryNumbers[0] ?? 0,
-			imaginaryNumbers[1] ?? 0,
-			imaginaryNumbers[2] ?? 0
-		];
-	}
-	return null;
-}
-function matricesNearlyEqual(a, b) {
-	if (!a || !b || a.length < 16 || b.length < 16) return false;
-	return a.every((value, index) => Math.abs(value - (b[index] ?? 0)) < 1e-8);
-}
 function attr(prim, name, time, defaultValue = null) {
 	const attribute = prim.GetAttribute(name);
 	try {
@@ -121,26 +55,6 @@ function attributeValue(attribute, time, defaultValue = null, authoredOnly = fal
 	const value = attribute.Get(time);
 	return value === null || value === void 0 ? defaultValue : normalizeValue(value);
 }
-function attrMetadata(prim, name, key, defaultValue = null) {
-	const attribute = prim.GetAttribute(name);
-	try {
-		if (!isValid$1(attribute)) return defaultValue;
-		const value = attribute.GetMetadata(key);
-		return value === null || value === void 0 ? defaultValue : normalizeValue(value);
-	} finally {
-		dispose$1(attribute);
-	}
-}
-function relationshipTargetPaths(relationship) {
-	if (!isValid$1(relationship)) return [];
-	const targets = relationship.GetTargets();
-	if (!Array.isArray(targets)) return [];
-	try {
-		return targets.map(pathToString);
-	} finally {
-		disposeAll(targets);
-	}
-}
 function schemaAttributeValue(schema, methodName, time, defaultValue = null, authoredOnly = false) {
 	const attribute = schema[methodName]();
 	try {
@@ -149,89 +63,71 @@ function schemaAttributeValue(schema, methodName, time, defaultValue = null, aut
 		dispose$1(attribute);
 	}
 }
-function schemaRelationshipTargets(schema, methodName) {
-	const relationship = schema[methodName]();
-	try {
-		return relationshipTargetPaths(relationship);
-	} finally {
-		dispose$1(relationship);
-	}
-}
-function assetPathValue(assetPath) {
-	const path = typeof assetPath.GetAssetPath === "function" ? String(assetPath.GetAssetPath()) : "";
-	if (!path) return null;
-	const resolvedPath = typeof assetPath.GetResolvedPath === "function" ? String(assetPath.GetResolvedPath()) : "";
-	return resolvedPath ? {
-		path,
-		resolvedPath
-	} : { path };
-}
-function propertyPathPrimPath(path) {
-	if (path && typeof path === "object") {
-		const maybePath = path;
-		if (typeof maybePath.GetPrimPath === "function") {
-			const primPath = maybePath.GetPrimPath();
-			try {
-				return pathToString(primPath) || null;
-			} finally {
-				dispose$1(primPath);
-			}
-		}
-	}
-	return pathToString(path).split(/\.(?:outputs|inputs):/)[0] || null;
-}
-function inputSourcePrimPath(input) {
-	const connections = input.GetRawConnectedSourcePaths();
-	if (!Array.isArray(connections)) return null;
-	try {
-		if (connections.length === 0) return null;
-		return propertyPathPrimPath(connections[0]);
-	} finally {
-		disposeAll(connections);
-	}
-}
-function primChildren(prim) {
-	const children = prim.GetChildren();
-	return Array.isArray(children) ? children : [];
-}
-function primAtPath(pxr, stage, path) {
-	const sdfPath = new pxr.Sdf.Path(path);
-	try {
-		return stage.GetPrimAtPath(sdfPath);
-	} finally {
-		dispose$1(sdfPath);
-	}
+//#endregion
+//#region src/scene-data/animations.ts
+function skelAnimationFrameRange(animation, stageInfo) {
+	const sampleTimes = [
+		...animation.translations.map((sample) => sample.time),
+		...animation.rotations.map((sample) => sample.time),
+		...animation.scales.map((sample) => sample.time)
+	];
+	if (sampleTimes.length === 0) return null;
+	if (stageInfo.endTimeCode > stageInfo.startTimeCode) return {
+		start: stageInfo.startTimeCode,
+		end: stageInfo.endTimeCode
+	};
+	const secondsStart = Math.min(...sampleTimes);
+	const secondsEnd = Math.max(...sampleTimes);
+	return {
+		start: stageInfo.startTimeCode + secondsStart * stageInfo.timeCodesPerSecond,
+		end: stageInfo.startTimeCode + secondsEnd * stageInfo.timeCodesPerSecond
+	};
 }
-function materialBinding(pxr, prim) {
-	const binding = new pxr.UsdShade.MaterialBindingAPI(prim);
-	try {
-		if (!isValid$1(binding)) return null;
-		const computed = binding.ComputeBoundMaterial("", false);
-		if (!Array.isArray(computed)) return null;
-		const [material, bindingRel] = computed;
-		try {
-			if (!isValid$1(bindingRel)) return null;
-			const resolvedPath = pxr.UsdShade.MaterialBindingAPI.GetResolvedTargetPathFromBindingRel(bindingRel);
-			try {
-				const path = pathToString(resolvedPath);
-				if (path) return path;
-			} finally {
-				dispose$1(resolvedPath);
-			}
-			if (!material || !isValid$1(material)) return null;
-			const materialPrim = material.GetPrim();
-			try {
-				return isValid$1(materialPrim) ? String(materialPrim.GetPath()) : null;
-			} finally {
-				dispose$1(materialPrim);
-			}
-		} finally {
-			disposeAll(computed);
+function getModelAnimations(pxr, prims, stageInfo, skels) {
+	const timeCodesPerSecond = stageInfo.timeCodesPerSecond;
+	const skelAnimationTracks = [];
+	const xformInfo = pxr.UsdGeom.ComputeXformAnimationInfo(prims, stageInfo.startTimeCode, stageInfo.endTimeCode, timeCodesPerSecond);
+	let start = xformInfo.startTimeCode;
+	let end = xformInfo.endTimeCode;
+	const animationsByPath = new Map(skels.animations.map((animation) => [animation.path, animation]));
+	for (const skeleton of skels.skeletons) {
+		const bindingAnimationSource = skels.bindings.find((binding) => binding.skeletonPath === skeleton.path)?.animationSource;
+		const animation = bindingAnimationSource ? animationsByPath.get(bindingAnimationSource) : skels.animations[0];
+		if (!animation) continue;
+		const range = skelAnimationFrameRange(animation, stageInfo);
+		if (!range || range.end <= range.start) continue;
+		skelAnimationTracks.push({
+			skeletonPath: skeleton.path,
+			animationPath: animation.path,
+			samplesStartTimeCode: range.start,
+			samplesEndTimeCode: range.end
+		});
+		if (end <= start) {
+			start = range.start;
+			end = range.end;
+		} else {
+			start = Math.min(start, range.start);
+			end = Math.max(end, range.end);
 		}
-	} finally {
-		dispose$1(binding);
 	}
+	if (end <= start) return [];
+	const transforms = xformInfo.transforms ?? [];
+	if (transforms.length === 0 && skelAnimationTracks.length === 0) return [];
+	const firstSkelAnimation = skelAnimationTracks[0] ? animationsByPath.get(skelAnimationTracks[0].animationPath) : null;
+	return [{
+		id: firstSkelAnimation ? `skel:${firstSkelAnimation.path}` : "stage:default",
+		name: firstSkelAnimation?.name ?? "Stage Animation",
+		source: firstSkelAnimation ? "skel" : "stage",
+		variant: null,
+		startTimeCode: start,
+		endTimeCode: end,
+		timeCodesPerSecond,
+		transforms,
+		skelAnimations: skelAnimationTracks
+	}];
 }
+//#endregion
+//#region src/scene-data/view.ts
 function localTransformForPrim(pxr, prim, time) {
 	if (!prim.IsA("Xformable")) return {
 		localMatrix: null,
@@ -274,491 +170,156 @@ function getModelView(pxr, prims, time) {
 		};
 	}) };
 }
-function valueAt(values, index) {
-	return index >= 0 && index < values.length ? values[index] : null;
-}
-function samplePrimvar(values, indices, interpolation, pointIndex, faceIndex, faceVertexIndex, pointCount, faceCount, faceVertexCount) {
-	if (values.length === 0) return null;
-	let domainIndex;
-	if (values.length === faceVertexCount) domainIndex = faceVertexIndex;
-	else if (values.length === pointCount) domainIndex = pointIndex;
-	else if (values.length === faceCount) domainIndex = faceIndex;
-	else if (values.length === 1) domainIndex = 0;
-	else if (interpolation === "faceVarying") domainIndex = faceVertexIndex;
-	else if (interpolation === "vertex" || interpolation === "varying") domainIndex = pointIndex;
-	else if (interpolation === "uniform") domainIndex = faceIndex;
-	else domainIndex = pointIndex;
-	let valueIndex = domainIndex;
-	if (indices.length > 0) {
-		const indexed = indices[domainIndex];
-		if (indexed === void 0) return null;
-		valueIndex = indexed;
+//#endregion
+//#region src/scene-data/cameras.ts
+function toClippingRange(value) {
+	const numbers = toNumberArray(value);
+	if (numbers.length < 2) return null;
+	const near = numbers[0];
+	const far = numbers[1];
+	return Number.isFinite(near) && Number.isFinite(far) ? [near, far] : null;
+}
+function getModelCameras(pxr, prims, time) {
+	const cameras = [];
+	for (const prim of prims) {
+		if (prim.GetTypeName() !== "Camera") continue;
+		const camera = new pxr.UsdGeom.Camera(prim);
+		try {
+			if (!isValid$1(camera)) continue;
+			const projection = String(schemaAttributeValue(camera, "GetProjectionAttr", time, "perspective") || "perspective");
+			cameras.push({
+				path: String(prim.GetPath()),
+				name: String(prim.GetName()),
+				projection: projection === "orthographic" ? "orthographic" : "perspective",
+				horizontalAperture: asFiniteNumber(schemaAttributeValue(camera, "GetHorizontalApertureAttr", time, null)),
+				verticalAperture: asFiniteNumber(schemaAttributeValue(camera, "GetVerticalApertureAttr", time, null)),
+				focalLength: asFiniteNumber(schemaAttributeValue(camera, "GetFocalLengthAttr", time, null)),
+				clippingRange: toClippingRange(schemaAttributeValue(camera, "GetClippingRangeAttr", time, null)),
+				localMatrix: localTransformForPrim(pxr, prim, time).localMatrix
+			});
+		} finally {
+			dispose$1(camera);
+		}
 	}
-	return valueAt(values, valueIndex);
+	return cameras;
 }
-function meshPrimvar(prim, name, time) {
+//#endregion
+//#region src/scene-data/material-binding.ts
+function materialBinding(pxr, prim) {
+	const nativeBinding = pxr.UsdShade.ComputeBoundMaterialPath(prim);
+	if (!nativeBinding) return null;
+	const resolvedTargetPath = typeof nativeBinding.resolvedTargetPath === "string" ? nativeBinding.resolvedTargetPath : "";
+	const materialPath = typeof nativeBinding.materialPath === "string" ? nativeBinding.materialPath : "";
+	return resolvedTargetPath || materialPath || null;
+}
+//#endregion
+//#region src/scene-data/materials.ts
+function asMaterialTextureInfo(value) {
+	const info = value;
 	return {
-		values: toArray(attr(prim, name, time, [])),
-		indices: toNumberArray(attr(prim, `${name}:indices`, time, [])),
-		interpolation: String(attrMetadata(prim, name, "interpolation", attr(prim, `${name}:interpolation`, time, "")) || "") || null
+		uvPrimvar: typeof info?.uvPrimvar === "string" && info.uvPrimvar ? info.uvPrimvar : "primvars:st",
+		uvTransform: info?.uvTransform && typeof info.uvTransform === "object" ? info.uvTransform : null
 	};
 }
-function asVec2(value, fallback) {
-	const numbers = toNumberArray(value);
-	if (numbers.length < 2) return fallback;
-	return [numbers[0] ?? fallback[0], numbers[1] ?? fallback[1]];
-}
-function asFloat(value, fallback = 0) {
-	const number = asFiniteNumber(value);
-	return number === null ? fallback : number;
-}
-function shaderId(shader) {
-	const id = shader.GetShaderId();
-	return typeof id === "string" && id ? id : null;
-}
-function shaderInputValue(shader, inputName, time, defaultValue = null) {
-	const input = shader.GetInput(inputName);
+function textureInfoForMaterial(pxr, stage, materialPath, time) {
+	if (!materialPath) return {
+		uvPrimvar: "primvars:st",
+		uvTransform: null
+	};
+	const path = new pxr.Sdf.Path(materialPath);
+	const materialPrim = stage.GetPrimAtPath(path);
 	try {
-		if (!isValid$1(input)) return defaultValue;
-		const value = input.Get(time);
-		return value === null || value === void 0 ? defaultValue : normalizeValue(value);
+		return asMaterialTextureInfo(pxr.UsdShade.ComputeMaterialTextureInfo(materialPrim, time));
 	} finally {
-		dispose$1(input);
+		dispose$1(materialPrim);
+		dispose$1(path);
 	}
 }
-function shaderInputConnectionPath(shader, inputName) {
-	const input = shader.GetInput(inputName);
-	try {
-		if (!isValid$1(input)) return null;
-		return inputSourcePrimPath(input);
-	} finally {
-		dispose$1(input);
-	}
+function cachedTextureInfoForMaterial(pxr, stage, materialPath, time, cache) {
+	const key = materialPath ?? "";
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const value = textureInfoForMaterial(pxr, stage, materialPath, time);
+	cache.set(key, value);
+	return value;
 }
-function shaderChildByPath(material, path) {
-	const children = primChildren(material);
-	try {
-		for (const child of children) if (String(child.GetPath()) === path) return child;
-		return null;
-	} finally {
-		for (const child of children) if (String(child.GetPath()) !== path) dispose$1(child);
+function getModelMaterials(pxr, prims, time) {
+	const materials = [];
+	for (const prim of prims) {
+		if (prim.GetTypeName() !== "Material") continue;
+		const material = pxr.UsdShade.ComputeMaterialInfo(prim, time);
+		materials.push({
+			path: material.path,
+			inputs: material.inputs,
+			shaders: material.shaders
+		});
 	}
+	return materials;
 }
-function primvarNameForTextureShader(pxr, stage, material, textureShader, time) {
-	const stSourcePath = shaderInputConnectionPath(textureShader, "st");
-	if (!stSourcePath) return null;
-	const stSource = shaderChildByPath(material, stSourcePath) ?? primAtPath(pxr, stage, stSourcePath);
+//#endregion
+//#region src/scene-data/mesh.ts
+function triangulateMesh(pxr, stage, prim, time, boundMaterial, materialTextureCache) {
+	const textureInfo = cachedTextureInfoForMaterial(pxr, stage, boundMaterial, time, materialTextureCache);
+	const mesh = new pxr.UsdGeom.Mesh(prim);
 	try {
-		if (!isValid$1(stSource)) return null;
-		const stShader = new pxr.UsdShade.Shader(stSource);
-		try {
-			if (!isValid$1(stShader)) return null;
-			const id = shaderId(stShader);
-			if (id === "UsdPrimvarReader_float2") {
-				const varname = shaderInputValue(stShader, "varname", time);
-				return typeof varname === "string" && varname ? varname : null;
-			}
-			if (id === "UsdTransform2d") {
-				const nestedSourcePath = shaderInputConnectionPath(stShader, "in") ?? shaderInputConnectionPath(stShader, "st");
-				if (!nestedSourcePath) return null;
-				const nestedSource = shaderChildByPath(material, nestedSourcePath) ?? primAtPath(pxr, stage, nestedSourcePath);
-				try {
-					if (!isValid$1(nestedSource)) return null;
-					const nestedShader = new pxr.UsdShade.Shader(nestedSource);
-					try {
-						if (!isValid$1(nestedShader) || shaderId(nestedShader) !== "UsdPrimvarReader_float2") return null;
-						const varname = shaderInputValue(nestedShader, "varname", time);
-						return typeof varname === "string" && varname ? varname : null;
-					} finally {
-						dispose$1(nestedShader);
-					}
-				} finally {
-					dispose$1(nestedSource);
-				}
-			}
-			return null;
-		} finally {
-			dispose$1(stShader);
-		}
+		return mesh.ComputeTriangulatedGeometry(time, textureInfo.uvPrimvar, textureInfo.uvTransform);
 	} finally {
-		dispose$1(stSource);
+		dispose$1(mesh);
 	}
 }
-function texturePrimvarForMaterial(pxr, stage, materialPath, time) {
-	if (!materialPath) return "primvars:st";
-	const material = primAtPath(pxr, stage, materialPath);
+function triangulateSphere(pxr, prim, time) {
+	const sphere = new pxr.UsdGeom.Sphere(prim);
 	try {
-		if (!isValid$1(material)) return "primvars:st";
-		const children = primChildren(material);
-		try {
-			for (const child of children) {
-				if (child.GetTypeName() !== "Shader") continue;
-				const shader = new pxr.UsdShade.Shader(child);
-				try {
-					if (!isValid$1(shader) || shaderId(shader) !== "UsdUVTexture") continue;
-					const varname = primvarNameForTextureShader(pxr, stage, material, shader, time);
-					if (varname) return `primvars:${varname}`;
-				} finally {
-					dispose$1(shader);
-				}
-			}
-		} finally {
-			disposeAll(children);
-		}
-		return "primvars:st";
+		return sphere.ComputeTriangulatedGeometry(time);
 	} finally {
-		dispose$1(material);
+		dispose$1(sphere);
 	}
 }
-function textureTransformForMaterial(pxr, stage, materialPath, time) {
-	if (!materialPath) return null;
-	const material = primAtPath(pxr, stage, materialPath);
+function triangulateCylinder(pxr, prim, time) {
+	const cylinder = new pxr.UsdGeom.Cylinder(prim);
 	try {
-		if (!isValid$1(material)) return null;
-		const children = primChildren(material);
-		try {
-			for (const child of children) {
-				if (child.GetTypeName() !== "Shader") continue;
-				const shader = new pxr.UsdShade.Shader(child);
-				try {
-					if (!isValid$1(shader) || shaderId(shader) !== "UsdUVTexture") continue;
-					const sourcePath = shaderInputConnectionPath(shader, "st");
-					if (!sourcePath) return null;
-					const transform = primAtPath(pxr, stage, sourcePath);
-					try {
-						if (!isValid$1(transform)) return null;
-						const transformShader = new pxr.UsdShade.Shader(transform);
-						try {
-							if (!isValid$1(transformShader) || shaderId(transformShader) !== "UsdTransform2d") return null;
-							const scale = asVec2(shaderInputValue(transformShader, "scale", time), [1, 1]);
-							const translation = asVec2(shaderInputValue(transformShader, "translation", time), [0, 0]);
-							return {
-								scaleX: scale[0],
-								scaleY: scale[1],
-								translateX: translation[0],
-								translateY: translation[1],
-								rotation: asFloat(shaderInputValue(transformShader, "rotation", time))
-							};
-						} finally {
-							dispose$1(transformShader);
-						}
-					} finally {
-						dispose$1(transform);
-					}
-				} finally {
-					dispose$1(shader);
-				}
-			}
-		} finally {
-			disposeAll(children);
-		}
-		return null;
+		return cylinder.ComputeTriangulatedGeometry(time);
 	} finally {
-		dispose$1(material);
+		dispose$1(cylinder);
 	}
 }
-function transformUv(uv, transform) {
-	const numbers = toNumberArray(uv);
-	if (numbers.length < 2) return null;
-	let u = numbers[0] ?? 0;
-	let v = numbers[1] ?? 0;
-	if (!transform) return [u, v];
-	u *= transform.scaleX;
-	v *= transform.scaleY;
-	const rotation = transform.rotation * Math.PI / 180;
-	if (rotation !== 0) {
-		const cos = Math.cos(rotation);
-		const sin = Math.sin(rotation);
-		const nextU = u * cos - v * sin;
-		const nextV = u * sin + v * cos;
-		u = nextU;
-		v = nextV;
-	}
-	return [u + transform.translateX, v + transform.translateY];
-}
-function triangulateMesh(pxr, stage, prim, time) {
-	const points = toArray(attr(prim, "points", time, []));
-	const faceCounts = toNumberArray(attr(prim, "faceVertexCounts", time, []));
-	const faceIndices = toNumberArray(attr(prim, "faceVertexIndices", time, []));
-	const normals = toArray(attr(prim, "normals", time, []));
-	const normalInterpolation = String(attrMetadata(prim, "normals", "interpolation", attr(prim, "normals:interpolation", time, "")) || "") || null;
-	const boundMaterial = materialBinding(pxr, prim);
-	const uv = meshPrimvar(prim, texturePrimvarForMaterial(pxr, stage, boundMaterial, time), time);
-	const colors = toArray(attr(prim, "primvars:displayColor", time, []));
-	const opacities = toArray(attr(prim, "primvars:displayOpacity", time, []));
-	const uvTransform = textureTransformForMaterial(pxr, stage, boundMaterial, time);
-	const triangleCorners = [];
-	let cursor = 0;
-	for (let faceIndex = 0; faceIndex < faceCounts.length; ++faceIndex) {
-		const count = faceCounts[faceIndex] ?? 0;
-		const face = faceIndices.slice(cursor, cursor + count);
-		for (let index = 1; index < count - 1; ++index) triangleCorners.push([
-			face[0] ?? -1,
-			faceIndex,
-			cursor
-		], [
-			face[index] ?? -1,
-			faceIndex,
-			cursor + index
-		], [
-			face[index + 1] ?? -1,
-			faceIndex,
-			cursor + index + 1
-		]);
-		cursor += count;
-	}
-	const positions = [];
-	const flatNormals = [];
-	const uvs = [];
-	for (const [pointIndex, faceIndex, faceVertexIndex] of triangleCorners) {
-		const point = toNumberArray(points[pointIndex]);
-		if (point.length >= 3) positions.push(point[0] ?? 0, point[1] ?? 0, point[2] ?? 0);
-		if (normals.length > 0) {
-			const normal = toNumberArray(samplePrimvar(normals, [], normalInterpolation, pointIndex, faceIndex, faceVertexIndex, points.length, faceCounts.length, faceIndices.length));
-			if (normal.length >= 3) flatNormals.push(normal[0] ?? 0, normal[1] ?? 0, normal[2] ?? 0);
-		}
-		if (uv.values.length > 0) {
-			const transformedUv = transformUv(samplePrimvar(uv.values, uv.indices, uv.interpolation, pointIndex, faceIndex, faceVertexIndex, points.length, faceCounts.length, faceIndices.length), uvTransform);
-			if (transformedUv) uvs.push(transformedUv[0], transformedUv[1]);
-		}
-	}
-	return {
-		positions,
-		normals: flatNormals,
-		uvs,
-		displayColor: colors.length > 0 ? toVector3(colors[0], [
-			1,
-			1,
-			1
-		]) : null,
-		displayOpacity: opacities.length > 0 ? asFiniteNumber(opacities[0]) : null
-	};
+function geomSubsetMaterialFallback(pxr, prim) {
+	const material = pxr.UsdShade.ComputeGeomSubsetMaterialFallback(prim);
+	return typeof material === "string" && material ? material : null;
 }
 function getModelElements(pxr, stage, prims, time) {
 	const elements = [];
+	const materialTextureCache = /* @__PURE__ */ new Map();
 	for (const prim of prims) {
-		if (prim.GetTypeName() !== "Mesh") continue;
+		const typeName = String(prim.GetTypeName());
+		if (typeName !== "Mesh" && typeName !== "Sphere" && typeName !== "Cylinder") continue;
+		const material = materialBinding(pxr, prim) ?? geomSubsetMaterialFallback(pxr, prim);
 		elements.push({
 			path: String(prim.GetPath()),
 			doubleSided: Boolean(attr(prim, "doubleSided", time, false)),
-			material: materialBinding(pxr, prim),
-			geometry: triangulateMesh(pxr, stage, prim, time)
+			material,
+			geometry: typeName === "Sphere" ? triangulateSphere(pxr, prim, time) : typeName === "Cylinder" ? triangulateCylinder(pxr, prim, time) : triangulateMesh(pxr, stage, prim, time, material, materialTextureCache)
 		});
 	}
 	return elements;
 }
-function collectShadeInputs(connectable, time) {
-	const inputs = {};
-	const shadeInputs = connectable.GetInputs();
-	try {
-		for (const input of shadeInputs) {
-			const baseName = String(input.GetBaseName());
-			if (!MATERIAL_INPUT_SUFFIXES.some((suffix) => baseName.endsWith(suffix))) continue;
-			const name = String(input.GetFullName());
-			const value = input.Get(time);
-			const connections = input.GetRawConnectedSourcePaths();
-			if (value !== null && value !== void 0) inputs[name] = normalizeValue(value);
-			if (Array.isArray(connections)) try {
-				if (connections.length > 0) inputs[`${name}.connect`] = connections.map(pathToString);
-			} finally {
-				disposeAll(connections);
-			}
-		}
-	} finally {
-		disposeAll(shadeInputs);
-	}
-	return inputs;
-}
-function collectShaderSourceAssets(shader) {
-	const inputs = {};
-	const sourceTypes = shader.GetSourceTypes();
-	if (!Array.isArray(sourceTypes)) return inputs;
-	for (const sourceType of sourceTypes) {
-		const sourceTypeName = String(sourceType);
-		const sourceAsset = shader.GetSourceAsset(sourceTypeName);
-		try {
-			const value = assetPathValue(sourceAsset);
-			if (!value) continue;
-			const name = sourceTypeName ? `info:${sourceTypeName}:sourceAsset` : "info:sourceAsset";
-			inputs[name] = value;
-		} finally {
-			dispose$1(sourceAsset);
-		}
-	}
-	return inputs;
-}
-function getModelMaterials(pxr, prims, time) {
-	const materials = [];
-	for (const prim of prims) {
-		if (prim.GetTypeName() !== "Material") continue;
-		const material = new pxr.UsdShade.Material(prim);
-		const children = primChildren(prim);
-		const shaders = [];
-		try {
-			if (!isValid$1(material)) continue;
-			for (const child of children) {
-				if (child.GetTypeName() !== "Shader") continue;
-				const shader = new pxr.UsdShade.Shader(child);
-				try {
-					if (!isValid$1(shader)) continue;
-					const idValue = shader.GetShaderId();
-					const id = typeof idValue === "string" && idValue ? idValue : null;
-					const inputs = {
-						...collectShadeInputs(shader, time),
-						...collectShaderSourceAssets(shader)
-					};
-					if (Object.keys(inputs).length === 0 && id !== "UsdPreviewSurface" && id !== "UsdUVTexture") continue;
-					shaders.push({
-						path: String(child.GetPath()),
-						id,
-						inputs
-					});
-				} finally {
-					dispose$1(shader);
-				}
-			}
-			materials.push({
-				path: String(prim.GetPath()),
-				inputs: collectShadeInputs(material, time),
-				shaders
-			});
-		} finally {
-			disposeAll(children);
-			dispose$1(material);
-		}
-	}
-	return materials;
-}
-function driveForNamespace(pxr, prim, namespace, time) {
-	const driveAPI = new pxr.UsdPhysics.DriveAPI(prim, namespace);
-	const drive = {
-		targetPosition: null,
-		targetVelocity: null,
-		stiffness: null,
-		damping: null,
-		maxForce: null
-	};
-	try {
-		if (!isValid$1(driveAPI)) return null;
-		drive.targetPosition = asFiniteNumber(schemaAttributeValue(driveAPI, "GetTargetPositionAttr", time, null, true));
-		drive.targetVelocity = asFiniteNumber(schemaAttributeValue(driveAPI, "GetTargetVelocityAttr", time, null, true));
-		drive.stiffness = asFiniteNumber(schemaAttributeValue(driveAPI, "GetStiffnessAttr", time, null, true));
-		drive.damping = asFiniteNumber(schemaAttributeValue(driveAPI, "GetDampingAttr", time, null, true));
-		drive.maxForce = asFiniteNumber(schemaAttributeValue(driveAPI, "GetMaxForceAttr", time, null, true));
-		return Object.values(drive).some((value) => value !== null) ? drive : null;
-	} finally {
-		dispose$1(driveAPI);
-	}
-}
-function jointTypeForPrim(typeName) {
-	if (JOINT_TYPES[typeName]) return JOINT_TYPES[typeName];
-	if (typeName.startsWith("Physics") && typeName.endsWith("Joint")) return typeName.slice(7, -5).toLowerCase() || "joint";
-	return null;
-}
-function jointLimitSchema(pxr, prim, typeName) {
-	switch (typeName) {
-		case "PhysicsRevoluteJoint": return new pxr.UsdPhysics.RevoluteJoint(prim);
-		case "PhysicsPrismaticJoint": return new pxr.UsdPhysics.PrismaticJoint(prim);
-		case "PhysicsSphericalJoint": return new pxr.UsdPhysics.SphericalJoint(prim);
-		case "PhysicsDistanceJoint": return new pxr.UsdPhysics.DistanceJoint(prim);
-		default: return null;
-	}
+//#endregion
+//#region src/scene-data/joints.ts
+function getModelJoints(pxr, prims, time) {
+	return pxr.UsdPhysics.ComputeModelJoints(prims, time);
 }
-function jointAxisAndLimits(pxr, prim, typeName, time) {
-	const schema = jointLimitSchema(pxr, prim, typeName);
-	if (!schema) return {
-		axis: null,
-		lowerLimit: null,
-		upperLimit: null
-	};
-	try {
-		if (!isValid$1(schema)) return {
-			axis: null,
-			lowerLimit: null,
-			upperLimit: null
-		};
-		if (typeName === "PhysicsSphericalJoint") {
-			const axis = schemaAttributeValue(schema, "GetAxisAttr", time);
-			return {
-				axis: typeof axis === "string" ? axis : null,
-				lowerLimit: asFiniteNumber(schemaAttributeValue(schema, "GetConeAngle0LimitAttr", time, null, true)),
-				upperLimit: asFiniteNumber(schemaAttributeValue(schema, "GetConeAngle1LimitAttr", time, null, true))
-			};
-		}
-		if (typeName === "PhysicsDistanceJoint") return {
-			axis: null,
-			lowerLimit: asFiniteNumber(schemaAttributeValue(schema, "GetMinDistanceAttr", time, null, true)),
-			upperLimit: asFiniteNumber(schemaAttributeValue(schema, "GetMaxDistanceAttr", time, null, true))
-		};
-		const axis = schemaAttributeValue(schema, "GetAxisAttr", time);
-		return {
-			axis: typeof axis === "string" ? axis : null,
-			lowerLimit: asFiniteNumber(schemaAttributeValue(schema, "GetLowerLimitAttr", time)),
-			upperLimit: asFiniteNumber(schemaAttributeValue(schema, "GetUpperLimitAttr", time))
-		};
-	} finally {
-		dispose$1(schema);
-	}
+//#endregion
+//#region src/scene-data/physics.ts
+function getModelPhysics(pxr, prims, time, joints) {
+	return pxr.UsdPhysics.ComputeModelPhysics(prims, time, joints);
 }
-function getModelJoints(pxr, prims, time) {
-	const joints = [];
-	for (const prim of prims) {
-		const typeName = String(prim.GetTypeName());
-		const jointType = jointTypeForPrim(typeName);
-		if (!jointType) continue;
-		const joint = new pxr.UsdPhysics.Joint(prim);
-		if (!isValid$1(joint)) {
-			dispose$1(joint);
-			continue;
-		}
-		const angularDrive = driveForNamespace(pxr, prim, "angular", time);
-		const linearDrive = driveForNamespace(pxr, prim, "linear", time);
-		const drives = {};
-		if (angularDrive) drives.angular = angularDrive;
-		if (linearDrive) drives.linear = linearDrive;
-		const body0 = schemaRelationshipTargets(joint, "GetBody0Rel");
-		const body1 = schemaRelationshipTargets(joint, "GetBody1Rel");
-		const drive = jointType === "prismatic" ? linearDrive ?? angularDrive : angularDrive ?? linearDrive;
-		const axisAndLimits = jointAxisAndLimits(pxr, prim, typeName, time);
-		try {
-			joints.push({
-				path: String(prim.GetPath()),
-				name: String(prim.GetName()),
-				typeName,
-				jointType,
-				body0: body0[0] ?? null,
-				body1: body1[0] ?? null,
-				...axisAndLimits,
-				localPos0: toVector3(schemaAttributeValue(joint, "GetLocalPos0Attr", time, [
-					0,
-					0,
-					0
-				]), [
-					0,
-					0,
-					0
-				]),
-				localPos1: toVector3(schemaAttributeValue(joint, "GetLocalPos1Attr", time, [
-					0,
-					0,
-					0
-				]), [
-					0,
-					0,
-					0
-				]),
-				localRot0: toVector4(schemaAttributeValue(joint, "GetLocalRot0Attr", time)),
-				localRot1: toVector4(schemaAttributeValue(joint, "GetLocalRot1Attr", time)),
-				enabled: Boolean(schemaAttributeValue(joint, "GetJointEnabledAttr", time, true)),
-				drive,
-				drives
-			});
-		} finally {
-			dispose$1(joint);
-		}
-	}
-	return joints;
+//#endregion
+//#region src/scene-data/skel.ts
+function getModelSkels(pxr, prims, time, stageInfo) {
+	return pxr.UsdSkel.ComputeModelSkels(prims, time, stageInfo.startTimeCode, stageInfo.endTimeCode, stageInfo.timeCodesPerSecond || 24);
 }
+//#endregion
+//#region src/scene-data/stage.ts
 function getStageInfo(pxr, stage, options) {
 	const defaultPrim = stage.GetDefaultPrim();
 	try {
@@ -775,79 +336,99 @@ function getStageInfo(pxr, stage, options) {
 		dispose$1(defaultPrim);
 	}
 }
-function sampleLocalMatrix(pxr, prim, frame) {
-	const time = new pxr.Usd.TimeCode(frame);
-	try {
-		return localTransformForPrim(pxr, prim, time).localMatrix;
-	} finally {
-		dispose$1(time);
+//#endregion
+//#region src/scene-data/variants.ts
+function requireVariantSets(prim) {
+	if (typeof prim.GetVariantSets !== "function") throw new Error("USD wasm runtime is missing Usd.Prim.GetVariantSets; rebuild @openusd-wasm/core");
+	return prim.GetVariantSets();
+}
+function applyVariantSelections(pxr, stage, selections = []) {
+	if (selections.length === 0) return;
+	for (const selection of selections) {
+		const path = new pxr.Sdf.Path(selection.primPath);
+		const prim = stage.GetPrimAtPath(path);
+		let variantSets = null;
+		let variantSet = null;
+		try {
+			if (!isValid$1(prim)) continue;
+			variantSets = requireVariantSets(prim);
+			variantSet = variantSets.GetVariantSet(selection.setName);
+			if (!isValid$1(variantSet)) continue;
+			if (selection.selection) variantSet.SetVariantSelection(selection.selection);
+			else variantSet.ClearVariantSelection();
+		} finally {
+			dispose$1(variantSet);
+			dispose$1(variantSets);
+			dispose$1(prim);
+			dispose$1(path);
+		}
 	}
 }
-function animationSampleFrames(start, end) {
-	const maxSamples = 1e3;
-	const span = end - start;
-	if (span <= 0) return [];
-	const wholeFrameCount = Number.isInteger(start) && Number.isInteger(end) ? Math.floor(span) + 1 : 0;
-	if (wholeFrameCount > 1 && wholeFrameCount <= maxSamples) return Array.from({ length: wholeFrameCount }, (_, index) => start + index);
-	const sampleCount = Math.min(maxSamples, Math.max(2, Math.ceil(span) + 1));
-	return Array.from({ length: sampleCount }, (_, index) => {
-		return start + span * index / (sampleCount - 1);
-	});
+function setVariantSelection(pxr, stage, selection) {
+	applyVariantSelections(pxr, stage, [selection]);
 }
-function getModelAnimations(pxr, prims, stageInfo) {
-	const start = stageInfo.startTimeCode;
-	const end = stageInfo.endTimeCode;
-	const timeCodesPerSecond = stageInfo.timeCodesPerSecond;
-	if (end <= start) return [];
-	const frames = animationSampleFrames(start, end);
-	if (frames.length < 2) return [];
-	const transforms = [];
-	for (const prim of prims) {
-		if (!prim.IsA("Xformable")) continue;
-		const defaultTime = pxr.Usd.TimeCode.Default();
-		try {
-			if (toArray(attr(prim, "xformOpOrder", defaultTime, [])).length === 0) continue;
-		} finally {
-			dispose$1(defaultTime);
+function getModelVariants(stage) {
+	const stagePrims = typeof stage.Traverse === "function" ? stage.Traverse() : [];
+	const variants = [];
+	try {
+		for (const prim of stagePrims) {
+			const variantSets = requireVariantSets(prim);
+			try {
+				const setNames = variantSets.GetNames();
+				if (!Array.isArray(setNames)) continue;
+				for (const setName of setNames) {
+					const variantSet = variantSets.GetVariantSet(String(setName));
+					try {
+						if (!isValid$1(variantSet)) continue;
+						const variantNames = variantSet.GetVariantNames();
+						variants.push({
+							primPath: pathToString(prim.GetPath()),
+							primName: String(prim.GetName?.() ?? ""),
+							setName: String(setName),
+							variantNames: Array.isArray(variantNames) ? variantNames.map(String) : [],
+							selection: String(variantSet.GetVariantSelection?.() ?? "") || null
+						});
+					} finally {
+						dispose$1(variantSet);
+					}
+				}
+			} finally {
+				dispose$1(variantSets);
+			}
 		}
-		const samples = frames.map((frame) => {
-			const localMatrix = sampleLocalMatrix(pxr, prim, frame);
-			return localMatrix ? {
-				time: (frame - start) / timeCodesPerSecond,
-				localMatrix
-			} : null;
-		}).filter((sample) => sample !== null);
-		if (samples.length < 2) continue;
-		const first = samples[0]?.localMatrix ?? null;
-		if (!samples.some((sample) => !matricesNearlyEqual(first, sample.localMatrix))) continue;
-		transforms.push({
-			primPath: String(prim.GetPath()),
-			samples
-		});
+	} finally {
+		disposeAll(stagePrims);
 	}
-	return transforms.length > 0 ? [{
-		startTimeCode: start,
-		endTimeCode: end,
-		timeCodesPerSecond,
-		transforms
-	}] : [];
+	return variants.sort((a, b) => a.setName.localeCompare(b.setName) || a.primPath.localeCompare(b.primPath));
+}
+//#endregion
+//#region src/scene-data.ts
+function traverseRenderablePrims(stage) {
+	if (typeof stage.TraverseInstanceProxies !== "function") throw new Error("USD wasm runtime is missing Usd.Stage.TraverseInstanceProxies; rebuild @openusd-wasm/core");
+	return stage.TraverseInstanceProxies();
 }
-function extractUSDModelData(pxr, stage, options = {}) {
+function extractUSDSceneData(pxr, stage, options = {}) {
 	const resolvedOptions = {
 		sourcePath: options.sourcePath ?? "",
 		rootLayerIdentifier: options.rootLayerIdentifier ?? ""
 	};
 	const time = pxr.Usd.TimeCode.Default();
-	const prims = stage.Traverse();
+	const prims = traverseRenderablePrims(stage);
 	try {
 		const stageInfo = getStageInfo(pxr, stage, resolvedOptions);
+		const skels = getModelSkels(pxr, prims, time, stageInfo);
+		const joints = getModelJoints(pxr, prims, time);
 		return {
 			stage: stageInfo,
 			view: getModelView(pxr, prims, time),
 			elements: getModelElements(pxr, stage, prims, time),
 			materials: getModelMaterials(pxr, prims, time),
-			joints: getModelJoints(pxr, prims, time),
-			animations: getModelAnimations(pxr, prims, stageInfo)
+			physics: getModelPhysics(pxr, prims, time, joints),
+			joints,
+			cameras: getModelCameras(pxr, prims, time),
+			skels,
+			animations: getModelAnimations(pxr, prims, stageInfo, skels),
+			variants: getModelVariants(stage)
 		};
 	} finally {
 		disposeAll(prims);
@@ -855,8 +436,7 @@ function extractUSDModelData(pxr, stage, options = {}) {
 	}
 }
 //#endregion
-//#region src/three.ts
-const sharedTextureCache = /* @__PURE__ */ new Map();
+//#region src/three/matrix.ts
 function matrixFromUsd(values) {
 	const matrix = new THREE.Matrix4();
 	matrix.set(values[0] ?? 1, values[4] ?? 0, values[8] ?? 0, values[12] ?? 0, values[1] ?? 0, values[5] ?? 1, values[9] ?? 0, values[13] ?? 0, values[2] ?? 0, values[6] ?? 0, values[10] ?? 1, values[14] ?? 0, values[3] ?? 0, values[7] ?? 0, values[11] ?? 0, values[15] ?? 1);
@@ -866,6 +446,246 @@ function applyLocalMatrix(object, values) {
 	if (!values || values.length < 16) return;
 	matrixFromUsd(values).decompose(object.position, object.quaternion, object.scale);
 }
+//#endregion
+//#region src/three/geometry.ts
+function findJointIndex(joints, name) {
+	const exact = joints.indexOf(name);
+	if (exact >= 0) return exact;
+	return joints.findIndex((joint) => joint.split("/").pop() === name);
+}
+function skinAttributesForElement(element, binding, skeleton) {
+	if (!binding || !skeleton) return null;
+	const vertexCount = Math.floor(element.geometry.positions.length / 3);
+	if (vertexCount <= 0) return null;
+	const pointIndices = element.geometry.pointIndices;
+	const elementSize = Math.max(1, binding.elementSize || 1);
+	const skinIndices = [];
+	const skinWeights = [];
+	for (let vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex) {
+		const base = Number(pointIndices?.[vertexIndex] ?? vertexIndex) * elementSize;
+		const influences = [];
+		for (let influenceIndex = 0; influenceIndex < elementSize; ++influenceIndex) {
+			const weight = Number(binding.jointWeights[base + influenceIndex] ?? 0);
+			if (!Number.isFinite(weight) || weight <= 0) continue;
+			const authoredIndex = Math.trunc(Number(binding.jointIndices[base + influenceIndex] ?? -1));
+			const skeletonIndex = binding.joints.length > 0 ? findJointIndex(skeleton.joints, binding.joints[authoredIndex] ?? "") : authoredIndex;
+			if (skeletonIndex < 0 || skeletonIndex >= skeleton.joints.length) continue;
+			influences.push({
+				index: skeletonIndex,
+				weight
+			});
+		}
+		influences.sort((a, b) => b.weight - a.weight);
+		const top = influences.slice(0, 4);
+		const total = top.reduce((sum, item) => sum + item.weight, 0);
+		for (let slot = 0; slot < 4; ++slot) {
+			const influence = top[slot];
+			skinIndices.push(influence?.index ?? 0);
+			skinWeights.push(influence && total > 0 ? influence.weight / total : 0);
+		}
+	}
+	return {
+		indices: skinIndices,
+		weights: skinWeights
+	};
+}
+function buildGeometry(element, binding, skeleton) {
+	const geometry = new THREE.BufferGeometry();
+	geometry.setAttribute("position", new THREE.Float32BufferAttribute(element.geometry.positions, 3));
+	if (element.geometry.normals.length > 0 && element.geometry.normals.length === element.geometry.positions.length) geometry.setAttribute("normal", new THREE.Float32BufferAttribute(element.geometry.normals, 3));
+	else geometry.computeVertexNormals();
+	if (element.geometry.uvs.length > 0) geometry.setAttribute("uv", new THREE.Float32BufferAttribute(element.geometry.uvs, 2));
+	const skin = skinAttributesForElement(element, binding, skeleton);
+	if (skin) {
+		geometry.setAttribute("skinIndex", new THREE.Uint16BufferAttribute(skin.indices, 4));
+		geometry.setAttribute("skinWeight", new THREE.Float32BufferAttribute(skin.weights, 4));
+	}
+	if (geometry.index && geometry.hasAttribute("position") && geometry.hasAttribute("normal") && geometry.hasAttribute("uv")) geometry.computeTangents();
+	geometry.computeBoundingBox();
+	geometry.computeBoundingSphere();
+	return geometry;
+}
+function resolveBindingSkeleton(data, binding) {
+	if (!binding) return void 0;
+	if (binding.skeletonPath) {
+		const exact = data.skels.skeletons.find((skeleton) => skeleton.path === binding.skeletonPath);
+		if (exact) return exact;
+	}
+	return data.skels.skeletons[0];
+}
+function buildSkeletonBones(skeleton) {
+	return skeleton.joints.map((joint, index) => {
+		const bone = new THREE.Bone();
+		bone.name = joint.split("/").pop() || `joint_${index}`;
+		bone.userData.usd = {
+			kind: "skelJoint",
+			skeletonPath: skeleton.path,
+			jointPath: joint,
+			jointIndex: index
+		};
+		bone.matrixAutoUpdate = false;
+		const restMatrix = skeleton.restSkelTransforms?.[index] ?? skeleton.bindTransforms[index] ?? skeleton.restTransforms[index];
+		if (restMatrix && restMatrix.length >= 16) bone.matrix.copy(matrixFromUsd(restMatrix));
+		return bone;
+	});
+}
+function bindSkinnedMeshes(data, objectsByPath, wrapper) {
+	const bonesBySkeletonPath = /* @__PURE__ */ new Map();
+	const boneHostsBySkeletonPath = /* @__PURE__ */ new Map();
+	const threeSkeletons = /* @__PURE__ */ new Map();
+	for (const skeletonInfo of data.skels.skeletons) {
+		const bones = buildSkeletonBones(skeletonInfo);
+		bonesBySkeletonPath.set(skeletonInfo.path, bones);
+		const inverseBindMatrices = skeletonInfo.bindTransforms.map((matrix) => matrixFromUsd(matrix).invert());
+		const skeleton = new THREE.Skeleton(bones, inverseBindMatrices);
+		threeSkeletons.set(skeletonInfo.path, skeleton);
+		const skeletonObject = objectsByPath.get(skeletonInfo.path);
+		const boneHost = new THREE.Group();
+		boneHost.name = `${skeletonObject?.name ?? "Skeleton"}_BoneHost`;
+		boneHost.matrixAutoUpdate = false;
+		boneHostsBySkeletonPath.set(skeletonInfo.path, boneHost);
+		if (wrapper) {
+			wrapper.updateMatrixWorld(true);
+			boneHost.matrix.copy(wrapper.matrixWorld).invert();
+			wrapper.add(boneHost);
+		}
+		for (const bone of bones) boneHost.add(bone);
+	}
+	for (const binding of data.skels.bindings) {
+		const mesh = objectsByPath.get(binding.primPath);
+		const skeletonInfo = resolveBindingSkeleton(data, binding);
+		if (!(mesh instanceof THREE.SkinnedMesh) || !skeletonInfo) continue;
+		const skeleton = threeSkeletons.get(skeletonInfo.path);
+		if (!skeleton) continue;
+		const bindMatrix = binding.geomBindTransform ? matrixFromUsd(binding.geomBindTransform) : new THREE.Matrix4();
+		mesh.bindMode = THREE.DetachedBindMode;
+		mesh.bind(skeleton, bindMatrix);
+		mesh.frustumCulled = false;
+	}
+	return {
+		bonesBySkeletonPath,
+		boneHostsBySkeletonPath
+	};
+}
+//#endregion
+//#region src/three/animations.ts
+function createTransformTracks(animation, objectsByPath) {
+	const tracks = [];
+	for (const transform of animation.transforms) {
+		const object = objectsByPath.get(transform.primPath);
+		if (!object || transform.samples.length < 2) continue;
+		const times = [];
+		const positions = [];
+		const quaternions = [];
+		const scales = [];
+		let previousQuaternion = null;
+		for (const sample of transform.samples) {
+			const matrix = matrixFromUsd(sample.localMatrix);
+			const position = new THREE.Vector3();
+			const quaternion = new THREE.Quaternion();
+			const scale = new THREE.Vector3();
+			matrix.decompose(position, quaternion, scale);
+			if (previousQuaternion && previousQuaternion.dot(quaternion) < 0) quaternion.set(-quaternion.x, -quaternion.y, -quaternion.z, -quaternion.w);
+			previousQuaternion = quaternion.clone();
+			times.push(sample.time);
+			positions.push(position.x, position.y, position.z);
+			quaternions.push(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+			scales.push(scale.x, scale.y, scale.z);
+		}
+		tracks.push(new THREE.VectorKeyframeTrack(`${object.uuid}.position`, times, positions), new THREE.QuaternionKeyframeTrack(`${object.uuid}.quaternion`, times, quaternions), new THREE.VectorKeyframeTrack(`${object.uuid}.scale`, times, scales));
+	}
+	return tracks;
+}
+function pushVec3Track(tracks, bone, property, samples, channelIndex) {
+	if (!bone || samples.length < 2) return;
+	const times = [];
+	const values = [];
+	for (const sample of samples) {
+		const value = sample.values[channelIndex];
+		if (!value) continue;
+		times.push(sample.time);
+		values.push(value[0], value[1], value[2]);
+	}
+	if (times.length < 2) return;
+	tracks.push(new THREE.VectorKeyframeTrack(`${bone.uuid}.${property}`, times, values));
+}
+function pushQuatTrack(tracks, bone, samples, channelIndex) {
+	if (!bone || samples.length < 2) return;
+	const times = [];
+	const values = [];
+	let previous = null;
+	for (const sample of samples) {
+		const value = sample.values[channelIndex];
+		if (!value) continue;
+		const quaternion = new THREE.Quaternion(value[1], value[2], value[3], value[0]);
+		if (previous && previous.dot(quaternion) < 0) quaternion.set(-quaternion.x, -quaternion.y, -quaternion.z, -quaternion.w);
+		previous = quaternion.clone();
+		times.push(sample.time);
+		values.push(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+	}
+	if (times.length < 2) return;
+	tracks.push(new THREE.QuaternionKeyframeTrack(`${bone.uuid}.quaternion`, times, values));
+}
+function pushMatrixTrack(tracks, bone, samples, jointIndex) {
+	if (!bone || samples.length < 2) return;
+	const times = [];
+	const values = [];
+	for (const sample of samples) {
+		const matrix = sample.values[jointIndex];
+		if (!matrix || matrix.length < 16) continue;
+		times.push(sample.time);
+		values.push(...matrixFromUsd(matrix).toArray());
+	}
+	if (times.length < 2) return;
+	tracks.push(new THREE.NumberKeyframeTrack(`${bone.uuid}.matrix`, times, values));
+}
+function createSkelTracks(animation, data, bonesBySkeletonPath) {
+	const tracks = [];
+	const animationsByPath = new Map(data.skels.animations.map((item) => [item.path, item]));
+	const skeletonsByPath = new Map(data.skels.skeletons.map((item) => [item.path, item]));
+	for (const skelTrack of animation.skelAnimations) {
+		const skeletonInfo = skeletonsByPath.get(skelTrack.skeletonPath);
+		const skelAnimation = animationsByPath.get(skelTrack.animationPath);
+		const bones = bonesBySkeletonPath.get(skelTrack.skeletonPath);
+		if (!skeletonInfo || !skelAnimation || !bones) continue;
+		const skelTransformSamples = skelAnimation.jointSkelTransformSamples?.find((item) => item.skeletonPath === skelTrack.skeletonPath)?.samples;
+		if (skelTransformSamples && skelTransformSamples.length >= 2) {
+			for (let jointIndex = 0; jointIndex < skeletonInfo.joints.length; ++jointIndex) pushMatrixTrack(tracks, bones[jointIndex], skelTransformSamples, jointIndex);
+			continue;
+		}
+		for (let channelIndex = 0; channelIndex < skelAnimation.joints.length; ++channelIndex) {
+			const joint = skelAnimation.joints[channelIndex];
+			const skeletonIndex = joint ? findJointIndex(skeletonInfo.joints, joint) : -1;
+			if (skeletonIndex < 0) continue;
+			const bone = bones[skeletonIndex];
+			pushVec3Track(tracks, bone, "position", skelAnimation.translations, channelIndex);
+			pushQuatTrack(tracks, bone, skelAnimation.rotations, channelIndex);
+			pushVec3Track(tracks, bone, "scale", skelAnimation.scales, channelIndex);
+		}
+	}
+	return tracks;
+}
+function createAnimationClips(animations, objectsByPath, data, bonesBySkeletonPath) {
+	return animations.map((animation, index) => {
+		const tracks = [...createTransformTracks(animation, objectsByPath), ...createSkelTracks(animation, data, bonesBySkeletonPath)];
+		if (tracks.length === 0) return null;
+		const clip = new THREE.AnimationClip(animation.name || `USDAnimation_${index + 1}`, -1, tracks);
+		clip.userData.usd = {
+			kind: "animation",
+			id: animation.id,
+			source: animation.source,
+			variant: animation.variant
+		};
+		return clip;
+	}).filter((clip) => clip !== null);
+}
+//#endregion
+//#region src/three/materials.ts
+const sharedTextureCache = /* @__PURE__ */ new Map();
+function releaseTexturesFromSharedCache(textures) {
+	const released = new Set(textures);
+	for (const [key, texture] of sharedTextureCache) if (released.has(texture)) sharedTextureCache.delete(key);
+}
 function vectorColor(value) {
 	if (!Array.isArray(value) || value.length < 3) return null;
 	const r = Number(value[0]);
@@ -913,22 +733,33 @@ function textureWrap(value) {
 	if (value === "mirror") return THREE.MirroredRepeatWrapping;
 	return THREE.ClampToEdgeWrapping;
 }
-function shaderPathFromConnection(value) {
-	return Array.isArray(value) && typeof value[0] === "string" ? value[0].split(".outputs:")[0] ?? null : null;
+function shaderConnectionInfo(value) {
+	if (!Array.isArray(value) || typeof value[0] !== "string") return null;
+	const [path, outputName] = value[0].split(".outputs:");
+	if (!path) return null;
+	return {
+		path,
+		outputName: outputName || null
+	};
 }
 function findTexture(material, options, connectionSuffixes, fallbackToAnyTexture = false) {
 	if (!material) return null;
-	const connectedPath = shaderPathFromConnection(firstInput(material, connectionSuffixes));
-	const textureShader = material.shaders.find((shader) => shader.id === "UsdUVTexture" && (!connectedPath || shader.path === connectedPath)) ?? (fallbackToAnyTexture ? material.shaders.find((shader) => shader.id === "UsdUVTexture") : null);
+	const connection = shaderConnectionInfo(firstInput(material, connectionSuffixes.map((suffix) => suffix.replace(/\.connect$/, ".resolvedConnect"))) ?? firstInput(material, connectionSuffixes));
+	const connectedPath = connection?.path ?? null;
+	const textureShader = connectedPath ? material.shaders.find((shader) => shader.id === "UsdUVTexture" && shader.path === connectedPath) : fallbackToAnyTexture ? material.shaders.find((shader) => shader.id === "UsdUVTexture") : null;
 	if (!textureShader) return null;
 	const url = publicUrlFromAsset(textureShader.inputs["inputs:file"], options, material, textureShader);
 	if (!url) return null;
 	return {
 		url,
+		outputName: connection?.outputName ?? null,
 		wrapS: textureWrap(textureShader.inputs["inputs:wrapS"]),
 		wrapT: textureWrap(textureShader.inputs["inputs:wrapT"])
 	};
 }
+function isHairLikeSurface(material, element) {
+	return /hair/i.test(element.path) || /hair/i.test(material?.path ?? "");
+}
 function loadTexture(url, options, colorSpace) {
 	const cache = options.textureCache ?? sharedTextureCache;
 	const cacheKey = `${colorSpace}:${url}`;
@@ -945,118 +776,118 @@ function applyTextureWrap(texture, info) {
 	texture.wrapT = info.wrapT;
 }
 function buildMaterial(material, element, options) {
+	const diffuseTexture = options.loadTextures === false ? null : findTexture(material, options, ["diffuseColor.connect", "baseColor.connect"], true);
 	const displayColor = element.geometry.displayColor ? new THREE.Color(...element.geometry.displayColor) : null;
 	const baseColor = vectorColor(firstInput(material, [
 		"diffuseColor",
 		"base_color",
 		"baseColor"
-	])) ?? displayColor ?? new THREE.Color(13158600);
+	])) ?? (diffuseTexture ? new THREE.Color(1, 1, 1) : null) ?? displayColor ?? new THREE.Color(13158600);
 	const opacityInput = firstInput(material, ["opacity", "alpha"]);
 	const opacity = typeof opacityInput === "number" ? opacityInput : element.geometry.displayOpacity ?? 1;
 	const roughness = firstInput(material, ["roughness"]);
 	const metallic = firstInput(material, ["metallic", "metallicFactor"]);
-	const diffuseTexture = options.loadTextures === false ? null : findTexture(material, options, ["diffuseColor.connect", "baseColor.connect"], true);
+	const emissiveColor = vectorColor(firstInput(material, ["emissiveColor", "emission_color"]));
+	const ior = firstInput(material, ["ior"]);
+	const opacityThreshold = firstInput(material, ["opacityThreshold"]);
+	const alphaTexture = options.loadTextures === false ? null : findTexture(material, options, ["opacity.connect", "alpha.connect"]);
 	const normalTexture = options.loadTextures === false ? null : findTexture(material, options, ["normal.connect"]);
 	const metallicTexture = options.loadTextures === false ? null : findTexture(material, options, ["metallic.connect", "metallicFactor.connect"]);
 	const roughnessTexture = options.loadTextures === false ? null : findTexture(material, options, ["roughness.connect"]);
+	const occlusionTexture = options.loadTextures === false ? null : findTexture(material, options, ["occlusion.connect"]);
+	const emissiveTexture = options.loadTextures === false ? null : findTexture(material, options, ["emissiveColor.connect", "emission_color.connect"]);
 	const map = diffuseTexture ? loadTexture(diffuseTexture.url, options, THREE.SRGBColorSpace) : null;
+	const usesMapAlpha = Boolean(alphaTexture && diffuseTexture && alphaTexture.url === diffuseTexture.url && alphaTexture.outputName === "a");
+	const alphaMap = alphaTexture && !usesMapAlpha ? loadTexture(alphaTexture.url, options, THREE.NoColorSpace) : null;
 	const normalMap = normalTexture ? loadTexture(normalTexture.url, options, THREE.NoColorSpace) : null;
 	const metalnessMap = metallicTexture ? loadTexture(metallicTexture.url, options, THREE.NoColorSpace) : null;
 	const roughnessMap = roughnessTexture ? loadTexture(roughnessTexture.url, options, THREE.NoColorSpace) : null;
+	const aoMap = occlusionTexture ? loadTexture(occlusionTexture.url, options, THREE.NoColorSpace) : null;
+	const emissiveMap = emissiveTexture ? loadTexture(emissiveTexture.url, options, THREE.SRGBColorSpace) : null;
 	if (map && diffuseTexture) applyTextureWrap(map, diffuseTexture);
+	if (alphaMap && alphaTexture) applyTextureWrap(alphaMap, alphaTexture);
 	if (normalMap && normalTexture) applyTextureWrap(normalMap, normalTexture);
 	if (metalnessMap && metallicTexture) applyTextureWrap(metalnessMap, metallicTexture);
 	if (roughnessMap && roughnessTexture) applyTextureWrap(roughnessMap, roughnessTexture);
-	return new THREE.MeshStandardMaterial({
+	if (aoMap && occlusionTexture) applyTextureWrap(aoMap, occlusionTexture);
+	if (emissiveMap && emissiveTexture) applyTextureWrap(emissiveMap, emissiveTexture);
+	const materialParameters = {
 		color: baseColor,
 		map,
+		alphaMap,
 		normalMap,
 		metalnessMap,
 		roughnessMap,
+		aoMap,
+		emissive: emissiveColor ?? new THREE.Color(0, 0, 0),
+		emissiveMap,
 		roughness: typeof roughness === "number" ? roughness : .55,
 		metalness: typeof metallic === "number" ? metallic : 0,
 		opacity,
-		transparent: opacity < 1,
-		side: element.doubleSided ? THREE.DoubleSide : THREE.FrontSide
-	});
+		alphaTest: typeof opacityThreshold === "number" ? opacityThreshold : 0,
+		transparent: opacity < 1 || Boolean(alphaTexture),
+		side: element.doubleSided || isHairLikeSurface(material, element) ? THREE.DoubleSide : THREE.FrontSide
+	};
+	return typeof ior === "number" ? new THREE.MeshPhysicalMaterial({
+		...materialParameters,
+		ior
+	}) : new THREE.MeshStandardMaterial(materialParameters);
 }
-function buildGeometry(element) {
-	const geometry = new THREE.BufferGeometry();
-	geometry.setAttribute("position", new THREE.Float32BufferAttribute(element.geometry.positions, 3));
-	if (element.geometry.normals.length > 0 && element.geometry.normals.length === element.geometry.positions.length) geometry.setAttribute("normal", new THREE.Float32BufferAttribute(element.geometry.normals, 3));
-	else geometry.computeVertexNormals();
-	if (element.geometry.uvs.length > 0) geometry.setAttribute("uv", new THREE.Float32BufferAttribute(element.geometry.uvs, 2));
-	geometry.computeBoundingBox();
-	geometry.computeBoundingSphere();
-	return geometry;
+//#endregion
+//#region src/three/scene.ts
+const disposedModels = /* @__PURE__ */ new WeakSet();
+function appendMappedValue(map, key, value) {
+	const values = map.get(key);
+	if (values) values.push(value);
+	else map.set(key, [value]);
+}
+function createUSDSceneIndex(data, objectsByPath, bonesBySkeletonPath, boneHostsBySkeletonPath) {
+	const jointsByBodyPath = /* @__PURE__ */ new Map();
+	for (const joint of data.joints) {
+		if (joint.body0) appendMappedValue(jointsByBodyPath, joint.body0, joint);
+		if (joint.body1) appendMappedValue(jointsByBodyPath, joint.body1, joint);
+	}
+	const variantsByPrimPath = /* @__PURE__ */ new Map();
+	for (const variant of data.variants) appendMappedValue(variantsByPrimPath, variant.primPath, variant);
+	return {
+		objectsByPath,
+		bonesBySkeletonPath,
+		boneHostsBySkeletonPath,
+		primsByPath: new Map(data.view.prims.map((prim) => [prim.path, prim])),
+		meshesByPath: new Map(data.elements.map((element) => [element.path, element])),
+		materialsByPath: new Map(data.materials.map((material) => [material.path, material])),
+		rigidBodiesByPath: new Map(data.physics.rigidBodies.map((body) => [body.path, body])),
+		collidersByPath: new Map(data.physics.colliders.map((collider) => [collider.path, collider])),
+		jointsByPath: new Map(data.joints.map((joint) => [joint.path, joint])),
+		jointsByBodyPath,
+		skelBindingsByPrimPath: new Map(data.skels.bindings.map((binding) => [binding.primPath, binding])),
+		skeletonsByPath: new Map(data.skels.skeletons.map((skeleton) => [skeleton.path, skeleton])),
+		camerasByPath: new Map(data.cameras.map((camera) => [camera.path, camera])),
+		variantsByPrimPath,
+		animationsById: new Map(data.animations.map((animation) => [animation.id, animation]))
+	};
 }
 function makeObjectForPrim(primPath, elementsByPath, materialsByPath, data, options) {
 	const viewPrim = data.view.prims.find((item) => item.path === primPath);
 	const element = elementsByPath.get(primPath);
-	const object = element ? new THREE.Mesh(buildGeometry(element), buildMaterial(element.material ? materialsByPath.get(element.material) : void 0, element, options)) : new THREE.Group();
+	const binding = data.skels.bindings.find((item) => item.primPath === primPath);
+	const skeleton = resolveBindingSkeleton(data, binding);
+	const material = element ? buildMaterial(element.material ? materialsByPath.get(element.material) : void 0, element, options) : void 0;
+	const object = element ? binding && skeleton ? new THREE.SkinnedMesh(buildGeometry(element, binding, skeleton), material) : new THREE.Mesh(buildGeometry(element), material) : new THREE.Group();
 	object.name = viewPrim?.name ?? primPath.split("/").pop() ?? primPath;
 	object.visible = viewPrim?.visibility !== "invisible";
-	object.userData.usdPath = primPath;
-	object.userData.usdTypeName = viewPrim?.typeName ?? "";
+	object.userData.usd = {
+		kind: "prim",
+		path: primPath,
+		typeName: viewPrim?.typeName ?? ""
+	};
 	applyLocalMatrix(object, viewPrim?.localMatrix ?? null);
 	return object;
 }
-function attachJointUserData(data, objectsByPath) {
-	for (const joint of data.joints) {
-		const jointObject = objectsByPath.get(joint.path);
-		if (jointObject) jointObject.userData.usdJoint = joint;
-		for (const bodyPath of [joint.body0, joint.body1]) {
-			if (!bodyPath) continue;
-			const bodyObject = objectsByPath.get(bodyPath);
-			if (!bodyObject) continue;
-			const joints = bodyObject.userData.usdJoints;
-			if (Array.isArray(joints)) joints.push(joint);
-			else bodyObject.userData.usdJoints = [joint];
-		}
-	}
-}
-function createTransformTracks(animation, objectsByPath) {
-	const tracks = [];
-	for (const transform of animation.transforms) {
-		const object = objectsByPath.get(transform.primPath);
-		if (!object || transform.samples.length < 2) continue;
-		const times = [];
-		const positions = [];
-		const quaternions = [];
-		const scales = [];
-		let previousQuaternion = null;
-		for (const sample of transform.samples) {
-			const matrix = matrixFromUsd(sample.localMatrix);
-			const position = new THREE.Vector3();
-			const quaternion = new THREE.Quaternion();
-			const scale = new THREE.Vector3();
-			matrix.decompose(position, quaternion, scale);
-			if (previousQuaternion && previousQuaternion.dot(quaternion) < 0) quaternion.set(-quaternion.x, -quaternion.y, -quaternion.z, -quaternion.w);
-			previousQuaternion = quaternion.clone();
-			times.push(sample.time);
-			positions.push(position.x, position.y, position.z);
-			quaternions.push(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
-			scales.push(scale.x, scale.y, scale.z);
-		}
-		tracks.push(new THREE.VectorKeyframeTrack(`${object.uuid}.position`, times, positions), new THREE.QuaternionKeyframeTrack(`${object.uuid}.quaternion`, times, quaternions), new THREE.VectorKeyframeTrack(`${object.uuid}.scale`, times, scales));
-	}
-	return tracks;
-}
-function createAnimationClips(animations, objectsByPath) {
-	return animations.map((animation, index) => {
-		const tracks = createTransformTracks(animation, objectsByPath);
-		if (tracks.length === 0) return null;
-		return new THREE.AnimationClip(`USDAnimation_${index + 1}`, -1, tracks);
-	}).filter((clip) => clip !== null);
-}
-function buildUSDObject(data, options = {}) {
+function buildUSDScene(data, options = {}) {
 	const sourcePath = options.sourcePath ?? data.stage.sourcePath;
 	const wrapper = new THREE.Group();
 	wrapper.name = `USD:${sourcePath}`;
-	wrapper.userData.usdMetadata = data;
-	wrapper.userData.usdJoints = data.joints;
-	wrapper.userData.usdPath = data.stage.defaultPrim ?? "/";
-	wrapper.userData.usdSource = sourcePath;
 	const elementsByPath = new Map(data.elements.map((element) => [element.path, element]));
 	const materialsByPath = new Map(data.materials.map((material) => [material.path, material]));
 	const objectsByPath = /* @__PURE__ */ new Map();
@@ -1072,25 +903,78 @@ function buildUSDObject(data, options = {}) {
 		else wrapper.add(object);
 	}
 	if (options.convertZUp !== false && data.stage.upAxis === "Z") wrapper.rotation.x = -Math.PI / 2;
-	attachJointUserData(data, objectsByPath);
-	wrapper.userData.usdObjectsByPath = objectsByPath;
-	wrapper.userData.usdAnimations = data.animations;
-	wrapper.animations = createAnimationClips(data.animations, objectsByPath);
-	return wrapper;
+	const skinning = bindSkinnedMeshes(data, objectsByPath, wrapper);
+	wrapper.animations = createAnimationClips(data.animations, objectsByPath, data, skinning.bonesBySkeletonPath);
+	return {
+		scene: wrapper,
+		index: createUSDSceneIndex(data, objectsByPath, skinning.bonesBySkeletonPath, skinning.boneHostsBySkeletonPath)
+	};
 }
-function createUSDLoadedModel(data, pxr, rootLayerIdentifier, options = {}, stage) {
+function createUSDLoadedModel(data, pxr, rootLayerIdentifier, options = {}, stage, resources = {}) {
 	const sourcePath = options.sourcePath ?? data.stage.sourcePath;
-	return {
-		scene: buildUSDObject(data, {
-			...options,
-			sourcePath
-		}),
-		metadata: data,
+	const built = buildUSDScene(data, {
+		...options,
+		sourcePath
+	});
+	const model = {
+		scene: built.scene,
+		data,
+		index: built.index,
+		resources: {
+			usdzTextureURLs: resources.usdzTextureURLs ?? /* @__PURE__ */ new Map(),
+			autoTextureURLs: resources.autoTextureURLs ?? /* @__PURE__ */ new Map()
+		},
 		stage,
 		pxr,
 		sourcePath,
-		rootLayerIdentifier
+		rootLayerIdentifier,
+		dispose() {
+			disposeUSDLoadedModel(model);
+		}
 	};
+	return model;
+}
+function disposePxrObject(value) {
+	if (value && typeof value === "object" && "delete" in value && typeof value.delete === "function") value.delete();
+}
+function disposeTexture(texture, disposed) {
+	if (!texture || disposed.has(texture)) return;
+	disposed.add(texture);
+	texture.dispose();
+}
+function disposeMaterial(material, disposedTextures, disposedMaterials) {
+	if (disposedMaterials.has(material)) return;
+	disposedMaterials.add(material);
+	for (const value of Object.values(material)) if (value instanceof THREE.Texture) disposeTexture(value, disposedTextures);
+	material.dispose();
+}
+function revokeObjectURLs(urls) {
+	if (!(urls instanceof Map) || typeof URL === "undefined" || typeof URL.revokeObjectURL !== "function") return;
+	for (const url of urls.values()) if (typeof url === "string" && url.startsWith("blob:")) URL.revokeObjectURL(url);
+	urls.clear();
+}
+function disposeUSDLoadedModel(model) {
+	if (disposedModels.has(model)) return;
+	disposedModels.add(model);
+	const disposedGeometries = /* @__PURE__ */ new Set();
+	const disposedMaterials = /* @__PURE__ */ new Set();
+	const disposedTextures = /* @__PURE__ */ new Set();
+	model.scene.traverse((object) => {
+		const mesh = object;
+		const geometry = mesh.geometry;
+		if (geometry instanceof THREE.BufferGeometry && !disposedGeometries.has(geometry)) {
+			disposedGeometries.add(geometry);
+			geometry.dispose();
+		}
+		const material = mesh.material;
+		if (Array.isArray(material)) for (const item of material) disposeMaterial(item, disposedTextures, disposedMaterials);
+		else if (material instanceof THREE.Material) disposeMaterial(material, disposedTextures, disposedMaterials);
+	});
+	revokeObjectURLs(model.resources.usdzTextureURLs);
+	revokeObjectURLs(model.resources.autoTextureURLs);
+	releaseTexturesFromSharedCache(disposedTextures);
+	disposePxrObject(model.stage);
+	model.stage = void 0;
 }
 //#endregion
 //#region src/loader.ts
@@ -1151,6 +1035,14 @@ function deleteFileIfExists(pxr, path) {
 		if (pxr.FS.exists(path)) pxr.FS.deleteFile(path);
 	} catch {}
 }
+function deleteDirRecursiveIfExists(pxr, path) {
+	if (!pxr.FS.exists(path)) return;
+	for (const entry of pxr.FS.listDir(path)) if (entry.isDir) deleteDirRecursiveIfExists(pxr, entry.path);
+	else deleteFileIfExists(pxr, entry.path);
+	try {
+		pxr.FS.deleteDir(path);
+	} catch {}
+}
 function createUSDInputDirectory(pxr, workingDirectory) {
 	const directory = joinFsPath(workingDirectory, String(++nextLoadId));
 	pxr.FS.createDir(directory);
@@ -1180,6 +1072,12 @@ function openStage(pxr, filePath, extension, usdzLayer) {
 	}
 	throw new Error(`Failed to open USD stage from ${filePath}`);
 }
+function isAnimationVariantSet(setName) {
+	return setName.toLowerCase().includes("anim");
+}
+function selectionKey(selection) {
+	return `${selection.primPath}\n${selection.setName}`;
+}
 function mergeParseOptions(loaderOptions, parseOptions) {
 	const sourcePath = parseOptions.sourcePath ?? parseOptions.fileName ?? "scene.usda";
 	const extension = extensionForPath(parseOptions.fileName ?? sourcePath);
@@ -1240,47 +1138,112 @@ var USDLoader = class extends Loader {
 			else console.error(error);
 		});
 	}
-	async parseAsync(input, options = {}) {
+	async parseDataAsync(input, options = {}) {
 		const pxr = await this.getPxr();
 		const mergedOptions = mergeParseOptions(this.options, options);
 		const extension = extensionForPath(mergedOptions.fileName);
 		const writableData = await sourceToWritableData(input);
-		const packageTextureResolver = extension === "usdz" && writableData instanceof Uint8Array ? createPackageTextureResolver(writableData) : null;
-		const packageRootLayer = extension === "usdz" && writableData instanceof Uint8Array ? mergedOptions.usdzLayer ?? findPackageRootLayer(writableData) ?? void 0 : mergedOptions.usdzLayer;
 		const rootFileName = sanitizeFileName(mergedOptions.fileName);
 		const directory = createUSDInputDirectory(pxr, mergedOptions.workingDirectory);
-		const filePath = await writeUSDInput(pxr, directory, writableData, {
-			fileName: rootFileName,
-			files: mergedOptions.files
-		});
-		let autoFiles = extension !== "usdz" ? await autoResolveAssetFiles(pxr, filePath, {
-			...mergedOptions,
-			fileName: rootFileName
-		}) : {};
-		await writeUSDFiles(pxr, directory, autoFiles);
-		const { stage, identifier } = openStage(pxr, filePath, extension, packageRootLayer);
+		let filePath = "";
+		let stage = null;
+		let stageReturned = false;
 		try {
-			const metadata = extractUSDModelData(pxr, stage, {
+			filePath = await writeUSDInput(pxr, directory, writableData, {
+				fileName: rootFileName,
+				files: mergedOptions.files
+			});
+			const packageEntries = extension === "usdz" ? extractPackageEntries(pxr, filePath, joinFsPath(directory, ".packages")) : null;
+			const packageTextureResolver = packageEntries ? createTextureResolverFromEntries(packageEntries) : null;
+			const packageRootLayer = extension === "usdz" ? mergedOptions.usdzLayer ?? findPackageRootLayer(pxr, filePath) ?? void 0 : mergedOptions.usdzLayer;
+			if (packageEntries) await writeUSDFiles(pxr, directory, Object.fromEntries(packageEntries));
+			let autoFiles = extension !== "usdz" ? await autoResolveAssetFiles(pxr, filePath, {
+				...mergedOptions,
+				fileName: rootFileName
+			}) : {};
+			await writeUSDFiles(pxr, directory, autoFiles);
+			const opened = openStage(pxr, filePath, extension, packageRootLayer);
+			stage = opened.stage;
+			const identifier = opened.identifier;
+			applyVariantSelections(pxr, stage, mergedOptions.variantSelections);
+			const sceneData = extractUSDSceneData(pxr, stage, {
 				sourcePath: mergedOptions.sourcePath,
 				rootLayerIdentifier: identifier
 			});
+			const originalSelections = new Map(sceneData.variants.map((variant) => [selectionKey(variant), variant.selection]));
+			const currentSelectionByKey = new Map(originalSelections);
+			const animationVariantClips = [];
+			for (const variant of sceneData.variants.filter((item) => isAnimationVariantSet(item.setName))) for (const selection of variant.variantNames) {
+				const key = selectionKey(variant);
+				if (currentSelectionByKey.get(key) !== selection) {
+					setVariantSelection(pxr, stage, {
+						primPath: variant.primPath,
+						setName: variant.setName,
+						selection
+					});
+					currentSelectionByKey.set(key, selection);
+				}
+				const variantData = extractUSDSceneData(pxr, stage, {
+					sourcePath: mergedOptions.sourcePath,
+					rootLayerIdentifier: identifier
+				});
+				for (const animation of variantData.animations) {
+					animation.id = `variant:${variant.primPath}:${variant.setName}:${selection}:${animation.id}`;
+					animation.name = selection;
+					animation.source = "variant";
+					animation.variant = {
+						primPath: variant.primPath,
+						setName: variant.setName,
+						selection
+					};
+					animationVariantClips.push(animation);
+				}
+			}
+			for (const variant of sceneData.variants.filter((item) => isAnimationVariantSet(item.setName))) {
+				const key = selectionKey(variant);
+				const originalSelection = originalSelections.get(key) ?? null;
+				if (currentSelectionByKey.get(key) !== originalSelection) {
+					setVariantSelection(pxr, stage, {
+						primPath: variant.primPath,
+						setName: variant.setName,
+						selection: originalSelection
+					});
+					currentSelectionByKey.set(key, originalSelection);
+				}
+			}
+			if (animationVariantClips.length > 0) sceneData.animations = animationVariantClips;
 			if (extension !== "usdz") autoFiles = {
 				...autoFiles,
-				...await autoResolveTextureFiles(metadata, autoFiles, mergedOptions)
+				...await autoResolveTextureFiles(sceneData, autoFiles, mergedOptions)
 			};
 			const autoTextureResolver = createTextureResolverFromEntries(new Map(Object.entries(autoFiles).map(([path, data]) => [path, normalizeBytes(data)])));
-			const model = createUSDLoadedModel(metadata, pxr, identifier, {
-				...mergedOptions,
-				textureResolver: composeTextureResolver(composeTextureResolver(mergedOptions.textureResolver, packageTextureResolver?.resolve), autoTextureResolver?.resolve)
-			}, mergedOptions.preserveStage ? stage : void 0);
-			if (packageTextureResolver) model.scene.userData.usdzTextureURLs = packageTextureResolver.urls;
-			if (autoTextureResolver) model.scene.userData.autoTextureURLs = autoTextureResolver.urls;
-			return model;
+			const textureResolver = composeTextureResolver(composeTextureResolver(mergedOptions.textureResolver, packageTextureResolver?.resolve), autoTextureResolver?.resolve);
+			stageReturned = Boolean(mergedOptions.preserveStage);
+			return {
+				data: sceneData,
+				pxr,
+				sourcePath: mergedOptions.sourcePath,
+				rootLayerIdentifier: identifier,
+				stage: mergedOptions.preserveStage ? stage ?? void 0 : void 0,
+				textureResolver,
+				usdzTextureURLs: packageTextureResolver?.urls,
+				autoTextureURLs: autoTextureResolver?.urls
+			};
 		} finally {
-			if (!mergedOptions.preserveStage) dispose(stage);
-			if (mergedOptions.cleanupAfterParse && !mergedOptions.preserveStage) deleteFileIfExists(pxr, filePath);
+			if (!stageReturned) dispose(stage);
+			if (mergedOptions.cleanupAfterParse && !stageReturned) deleteDirRecursiveIfExists(pxr, directory);
 		}
 	}
+	async parseAsync(input, options = {}) {
+		const data = await this.parseDataAsync(input, options);
+		return createUSDLoadedModel(data.data, data.pxr, data.rootLayerIdentifier, {
+			...mergeParseOptions(this.options, options),
+			textureResolver: data.textureResolver
+		}, data.stage, {
+			usdzTextureURLs: data.usdzTextureURLs,
+			autoTextureURLs: data.autoTextureURLs
+		});
+	}
 	async getPxr() {
 		if (!this.pxrPromise) {
 			if (!this.options.pxrOptions) throw new Error("USDLoader requires either a pxr instance or pxrOptions");
@@ -1290,459 +1253,4 @@ var USDLoader = class extends Loader {
 	}
 };
 //#endregion
-//#region src/manipulation-controls.ts
-const axisVectors = {
-	X: new THREE.Vector3(1, 0, 0),
-	Y: new THREE.Vector3(0, 1, 0),
-	Z: new THREE.Vector3(0, 0, 1)
-};
-function clamp(value, min, max) {
-	return Math.min(max, Math.max(min, value));
-}
-function limitsForJoint(joint) {
-	if (joint.lowerLimit !== null && joint.upperLimit !== null) return {
-		lower: joint.lowerLimit,
-		upper: joint.upperLimit
-	};
-	return joint.jointType === "revolute" ? {
-		lower: -180,
-		upper: 180
-	} : {
-		lower: -1,
-		upper: 1
-	};
-}
-function initialValueForJoint(joint) {
-	const { lower, upper } = limitsForJoint(joint);
-	return clamp(joint.drive?.targetPosition ?? 0, lower, upper);
-}
-function isManipulableJoint(joint) {
-	return joint.enabled && (joint.jointType === "revolute" || joint.jointType === "prismatic");
-}
-function objectsByPathForRoot(root) {
-	const userDataMap = root.userData.usdObjectsByPath;
-	if (userDataMap instanceof Map) return new Map([...userDataMap.entries()].filter((entry) => {
-		return typeof entry[0] === "string" && entry[1] instanceof THREE.Object3D;
-	}));
-	const objectsByPath = /* @__PURE__ */ new Map();
-	root.traverse((child) => {
-		const usdPath = child.userData.usdPath;
-		if (typeof usdPath === "string") objectsByPath.set(usdPath, child);
-	});
-	return objectsByPath;
-}
-function findUSDModels(scene) {
-	const models = [];
-	scene.traverse((object) => {
-		const metadata = object.userData.usdMetadata;
-		if (!metadata) return;
-		object.updateMatrixWorld(true);
-		models.push({
-			root: object,
-			metadata,
-			objectsByPath: objectsByPathForRoot(object)
-		});
-	});
-	return models;
-}
-function modelStateSignature(models) {
-	return models.map((model) => {
-		const matrix = model.root.matrixWorld.elements.map((value) => value.toFixed(5)).join(",");
-		const stage = model.metadata.stage;
-		return [
-			model.root.uuid,
-			stage.rootLayerIdentifier,
-			stage.defaultPrim ?? "",
-			model.metadata.joints.length,
-			matrix
-		].join(":");
-	}).join("|");
-}
-function jointForObject(models, object) {
-	for (const model of models) for (const joint of model.metadata.joints) {
-		if (!isManipulableJoint(joint) || !joint.body1) continue;
-		const bodyObject = model.objectsByPath.get(joint.body1);
-		if (!bodyObject) continue;
-		let current = object;
-		while (current) {
-			if (current === bodyObject) return {
-				model,
-				joint,
-				object: bodyObject,
-				body0: joint.body0 ? model.objectsByPath.get(joint.body0) ?? null : null
-			};
-			current = current.parent;
-		}
-	}
-	return null;
-}
-function jointValueKey(model, joint) {
-	return `${model.root.uuid}:${joint.path}`;
-}
-function localAxisForJoint(joint) {
-	const axis = axisVectors[joint.axis ?? ""]?.clone() ?? axisVectors.X.clone();
-	const rotation = joint.localRot0;
-	if (!rotation) return axis;
-	const quaternion = new THREE.Quaternion(rotation[1] ?? 0, rotation[2] ?? 0, rotation[3] ?? 0, rotation[0] ?? 1);
-	if (quaternion.lengthSq() < 1e-10) return axis;
-	return axis.applyQuaternion(quaternion.normalize());
-}
-function localPivotForJoint(joint) {
-	return new THREE.Vector3(joint.localPos0[0] ?? 0, joint.localPos0[1] ?? 0, joint.localPos0[2] ?? 0);
-}
-function parentLocalPoint(object, body0, point) {
-	if (!body0) return point.clone();
-	const worldPoint = body0.localToWorld(point.clone());
-	return object.parent ? object.parent.worldToLocal(worldPoint) : worldPoint;
-}
-function parentLocalVectorForJoint(joint, object, body0, delta) {
-	const pivot = localPivotForJoint(joint);
-	const start = parentLocalPoint(object, body0, pivot);
-	return parentLocalPoint(object, body0, pivot.clone().add(localAxisForJoint(joint).multiplyScalar(delta))).sub(start);
-}
-function parentLocalAxisForJoint(joint, object, body0) {
-	const axis = parentLocalVectorForJoint(joint, object, body0, 1);
-	if (axis.lengthSq() < 1e-10) return localAxisForJoint(joint).normalize();
-	return axis.normalize();
-}
-function parentLocalPivotForJoint(joint, object, body0) {
-	return parentLocalPoint(object, body0, localPivotForJoint(joint));
-}
-function parentLocalToWorld(object, point) {
-	return object.parent ? object.parent.localToWorld(point.clone()) : point.clone();
-}
-function projectToClient(point, camera, rect) {
-	const ndc = point.clone().project(camera);
-	return new THREE.Vector2((ndc.x * .5 + .5) * rect.width, (-ndc.y * .5 + .5) * rect.height);
-}
-function prismaticDragMapping(joint, object, body0, camera, rect) {
-	const { lower, upper } = limitsForJoint(joint);
-	const referenceDelta = Math.max(Math.abs(upper - lower), .1);
-	const startPivot = parentLocalPivotForJoint(joint, object, body0);
-	const start = parentLocalToWorld(object, startPivot);
-	const screenVector = projectToClient(parentLocalToWorld(object, startPivot.clone().add(parentLocalVectorForJoint(joint, object, body0, referenceDelta))), camera, rect).sub(projectToClient(start, camera, rect));
-	const screenLength = screenVector.length();
-	if (screenLength < 1) return {
-		screenAxis: new THREE.Vector2(1, 0),
-		valuePerPixel: referenceDelta / 180
-	};
-	return {
-		screenAxis: screenVector.normalize(),
-		valuePerPixel: referenceDelta / screenLength
-	};
-}
-function fallbackRevoluteScreenAxis(pivot, axis, camera, rect) {
-	const projectedAxis = projectToClient(pivot.clone().add(axis), camera, rect).sub(projectToClient(pivot, camera, rect));
-	if (projectedAxis.length() < 1) return new THREE.Vector2(1, -1).normalize();
-	return new THREE.Vector2(-projectedAxis.y, projectedAxis.x).normalize();
-}
-function revoluteDragMapping(joint, object, body0, camera, rect) {
-	const axis = parentLocalAxisForJoint(joint, object, body0);
-	const pivot = parentLocalPivotForJoint(joint, object, body0);
-	const referenceDegrees = 12;
-	const referenceRadians = THREE.MathUtils.degToRad(referenceDegrees);
-	const bounds = new THREE.Box3().setFromObject(object);
-	const center = object.parent ? object.parent.worldToLocal(bounds.getCenter(new THREE.Vector3())) : bounds.getCenter(new THREE.Vector3());
-	const size = bounds.getSize(new THREE.Vector3());
-	const radius = Math.max(size.length() * .25, .05);
-	const radiusVector = center.sub(pivot);
-	radiusVector.addScaledVector(axis, -radiusVector.dot(axis));
-	if (radiusVector.lengthSq() < 1e-8) {
-		const fallback = Math.abs(axis.dot(new THREE.Vector3(0, 1, 0))) > .9 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
-		radiusVector.copy(fallback.cross(axis));
-	}
-	radiusVector.setLength(Math.max(radiusVector.length(), radius));
-	const start = pivot.clone().add(radiusVector);
-	const end = pivot.clone().add(radiusVector.clone().applyAxisAngle(axis, referenceRadians));
-	const startWorld = parentLocalToWorld(object, start);
-	const screenVector = projectToClient(parentLocalToWorld(object, end), camera, rect).sub(projectToClient(startWorld, camera, rect));
-	const screenLength = screenVector.length();
-	if (screenLength < 1) return {
-		screenAxis: fallbackRevoluteScreenAxis(parentLocalToWorld(object, pivot), parentLocalToWorld(object, pivot.clone().add(axis)).sub(parentLocalToWorld(object, pivot)), camera, rect),
-		valuePerPixel: referenceDegrees / 140
-	};
-	return {
-		screenAxis: screenVector.normalize(),
-		valuePerPixel: referenceDegrees / screenLength
-	};
-}
-function updateJointTransform(drag, value) {
-	const delta = value - drag.startValue;
-	const axis = parentLocalAxisForJoint(drag.joint, drag.object, drag.body0);
-	const nextLocal = new THREE.Matrix4();
-	if (drag.joint.jointType === "revolute") {
-		const pivot = parentLocalPivotForJoint(drag.joint, drag.object, drag.body0);
-		const rotation = new THREE.Matrix4().makeRotationAxis(axis, THREE.MathUtils.degToRad(delta));
-		nextLocal.makeTranslation(pivot.x, pivot.y, pivot.z).multiply(rotation).multiply(new THREE.Matrix4().makeTranslation(-pivot.x, -pivot.y, -pivot.z)).multiply(drag.initialLocalMatrix);
-		nextLocal.decompose(drag.object.position, drag.object.quaternion, drag.object.scale);
-		drag.object.updateMatrixWorld(true);
-		return;
-	}
-	const translation = parentLocalVectorForJoint(drag.joint, drag.object, drag.body0, delta);
-	nextLocal.makeTranslation(translation.x, translation.y, translation.z).multiply(drag.initialLocalMatrix);
-	nextLocal.decompose(drag.object.position, drag.object.quaternion, drag.object.scale);
-	drag.object.updateMatrixWorld(true);
-}
-function highlightedMaterials(material, color) {
-	const highlighted = (Array.isArray(material) ? material : [material]).map((item) => {
-		const cloned = item.clone();
-		if ("emissive" in cloned) {
-			const emissiveMaterial = cloned;
-			emissiveMaterial.emissive = color.clone();
-			emissiveMaterial.emissiveIntensity = Math.max(emissiveMaterial.emissiveIntensity, .28);
-		}
-		return cloned;
-	});
-	return Array.isArray(material) ? highlighted : highlighted[0];
-}
-function disposeMaterial(material) {
-	const materials = Array.isArray(material) ? material : [material];
-	for (const item of materials) item.dispose();
-}
-var USDManipulationControls = class {
-	raycaster = new THREE.Raycaster();
-	pointer = new THREE.Vector2();
-	jointValues = /* @__PURE__ */ new Map();
-	highlighted = /* @__PURE__ */ new Map();
-	activeDrag = null;
-	hovered = null;
-	modelStateSignature = null;
-	_enabled;
-	disposed = false;
-	scene;
-	camera;
-	domElement;
-	controls;
-	highlightColor;
-	onChange;
-	onHoverChange;
-	constructor(options) {
-		this.scene = options.scene;
-		this.camera = options.camera;
-		this.domElement = options.domElement;
-		this.controls = options.controls ?? null;
-		this.highlightColor = new THREE.Color(options.highlightColor ?? 16777215);
-		this._enabled = options.enabled ?? true;
-		this.onChange = options.onChange;
-		this.onHoverChange = options.onHoverChange;
-		this.domElement.addEventListener("pointermove", this.onPointerMove);
-		this.domElement.addEventListener("pointerdown", this.onPointerDown);
-		this.domElement.addEventListener("pointerup", this.onPointerUp);
-		this.domElement.addEventListener("pointercancel", this.onPointerUp);
-	}
-	get enabled() {
-		return this._enabled;
-	}
-	set enabled(value) {
-		if (this._enabled === value) return;
-		this._enabled = value;
-		if (!value) {
-			this.endDrag(null);
-			this.clearSelection();
-		}
-	}
-	dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.domElement.removeEventListener("pointermove", this.onPointerMove);
-		this.domElement.removeEventListener("pointerdown", this.onPointerDown);
-		this.domElement.removeEventListener("pointerup", this.onPointerUp);
-		this.domElement.removeEventListener("pointercancel", this.onPointerUp);
-		this.endDrag(null);
-		this.clearSelection();
-		for (const [mesh, state] of this.highlighted) {
-			disposeMaterial(state.highlighted);
-			mesh.material = state.original;
-		}
-		this.highlighted.clear();
-	}
-	update() {
-		this.syncModelState(findUSDModels(this.scene));
-	}
-	clearSelection() {
-		if (!this.hovered) return;
-		this.restoreHighlight(this.hovered.object);
-		this.hovered = null;
-		this.onHoverChange?.({
-			joint: null,
-			object: null
-		});
-	}
-	getJointValue(joint, root) {
-		if (root) return this.jointValues.get(`${root.uuid}:${joint.path}`);
-		for (const [key, value] of this.jointValues) if (key.endsWith(`:${joint.path}`)) return value;
-	}
-	setJointValue(joint, value, root) {
-		const models = findUSDModels(this.scene);
-		this.syncModelState(models);
-		for (const model of models) {
-			if (root && model.root !== root) continue;
-			const modelJoint = model.metadata.joints.find((item) => item.path === joint.path);
-			if (!modelJoint || !isManipulableJoint(modelJoint) || !modelJoint.body1) continue;
-			const object = model.objectsByPath.get(modelJoint.body1);
-			if (!object) continue;
-			object.updateMatrix();
-			object.updateMatrixWorld(true);
-			const body0 = modelJoint.body0 ? model.objectsByPath.get(modelJoint.body0) ?? null : null;
-			body0?.updateMatrixWorld(true);
-			const jointKey = jointValueKey(model, modelJoint);
-			const currentValue = this.jointValues.get(jointKey) ?? initialValueForJoint(modelJoint);
-			const { lower, upper } = limitsForJoint(modelJoint);
-			const nextValue = clamp(value, lower, upper);
-			const drag = {
-				model,
-				joint: modelJoint,
-				object,
-				body0,
-				startX: 0,
-				startY: 0,
-				startValue: currentValue,
-				initialLocalMatrix: object.matrix.clone(),
-				jointKey,
-				controlsWasEnabled: null
-			};
-			this.jointValues.set(jointKey, nextValue);
-			updateJointTransform(drag, nextValue);
-			this.onChange?.({
-				joint: modelJoint,
-				object,
-				body0,
-				value: nextValue,
-				previousValue: currentValue
-			});
-			return true;
-		}
-		return false;
-	}
-	onPointerMove = (event) => {
-		if (!this._enabled || this.disposed) return;
-		const activeDrag = this.activeDrag;
-		if (activeDrag) {
-			const pointerDelta = new THREE.Vector2(event.clientX - activeDrag.startX, event.clientY - activeDrag.startY);
-			let mappedValueDelta;
-			if (activeDrag.joint.jointType === "prismatic" && activeDrag.prismaticScreenAxis && activeDrag.prismaticValuePerPixel !== void 0) mappedValueDelta = pointerDelta.dot(activeDrag.prismaticScreenAxis) * activeDrag.prismaticValuePerPixel;
-			else if (activeDrag.joint.jointType === "revolute" && activeDrag.revoluteScreenAxis && activeDrag.revoluteValuePerPixel !== void 0) mappedValueDelta = pointerDelta.dot(activeDrag.revoluteScreenAxis) * activeDrag.revoluteValuePerPixel;
-			else {
-				const { lower, upper } = limitsForJoint(activeDrag.joint);
-				const range = Math.max(upper - lower, activeDrag.joint.jointType === "revolute" ? 90 : .5);
-				mappedValueDelta = (pointerDelta.x - pointerDelta.y) / 280 * range;
-			}
-			const { lower, upper } = limitsForJoint(activeDrag.joint);
-			const previousValue = this.jointValues.get(activeDrag.jointKey) ?? activeDrag.startValue;
-			const nextValue = clamp(activeDrag.startValue + mappedValueDelta, lower, upper);
-			if (nextValue === previousValue) return;
-			this.jointValues.set(activeDrag.jointKey, nextValue);
-			updateJointTransform(activeDrag, nextValue);
-			this.onChange?.({
-				joint: activeDrag.joint,
-				object: activeDrag.object,
-				body0: activeDrag.body0,
-				value: nextValue,
-				previousValue
-			});
-			return;
-		}
-		const hit = this.pickJoint(event);
-		if (this.hovered && this.hovered.object !== hit?.object) this.clearSelection();
-		if (hit && this.hovered?.object !== hit.object) {
-			this.applyHighlight(hit.object);
-			this.hovered = {
-				joint: hit.joint,
-				object: hit.object
-			};
-			this.onHoverChange?.({
-				joint: hit.joint,
-				object: hit.object
-			});
-		}
-	};
-	onPointerDown = (event) => {
-		if (!this._enabled || this.disposed) return;
-		const hit = this.pickJoint(event);
-		if (!hit) return;
-		event.preventDefault();
-		this.domElement.setPointerCapture?.(event.pointerId);
-		const controlsWasEnabled = this.controls?.enabled ?? null;
-		if (this.controls) this.controls.enabled = false;
-		const jointKey = jointValueKey(hit.model, hit.joint);
-		hit.object.updateMatrix();
-		hit.object.updateMatrixWorld(true);
-		hit.body0?.updateMatrixWorld(true);
-		const currentValue = this.jointValues.get(jointKey) ?? initialValueForJoint(hit.joint);
-		const rect = this.domElement.getBoundingClientRect();
-		const prismaticMapping = hit.joint.jointType === "prismatic" ? prismaticDragMapping(hit.joint, hit.object, hit.body0, this.camera, rect) : null;
-		const revoluteMapping = hit.joint.jointType === "revolute" ? revoluteDragMapping(hit.joint, hit.object, hit.body0, this.camera, rect) : null;
-		this.activeDrag = {
-			...hit,
-			startX: event.clientX,
-			startY: event.clientY,
-			startValue: currentValue,
-			initialLocalMatrix: hit.object.matrix.clone(),
-			jointKey,
-			controlsWasEnabled,
-			revoluteScreenAxis: revoluteMapping?.screenAxis,
-			revoluteValuePerPixel: revoluteMapping?.valuePerPixel,
-			prismaticScreenAxis: prismaticMapping?.screenAxis,
-			prismaticValuePerPixel: prismaticMapping?.valuePerPixel
-		};
-	};
-	onPointerUp = (event) => {
-		this.endDrag(event);
-	};
-	pickJoint(event) {
-		this.updatePointer(event);
-		const models = findUSDModels(this.scene);
-		if (models.length === 0) return null;
-		this.syncModelState(models);
-		this.raycaster.setFromCamera(this.pointer, this.camera);
-		const intersections = this.raycaster.intersectObjects(models.map((model) => model.root), true);
-		for (const intersection of intersections) {
-			const hit = jointForObject(models, intersection.object);
-			if (hit) return hit;
-		}
-		return null;
-	}
-	updatePointer(event) {
-		const rect = this.domElement.getBoundingClientRect();
-		this.pointer.x = (event.clientX - rect.left) / rect.width * 2 - 1;
-		this.pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
-	}
-	syncModelState(models) {
-		const nextSignature = modelStateSignature(models);
-		if (this.modelStateSignature === nextSignature) return;
-		this.endDrag(null);
-		this.clearSelection();
-		this.jointValues.clear();
-		this.modelStateSignature = nextSignature;
-	}
-	endDrag(event) {
-		const activeDrag = this.activeDrag;
-		if (!activeDrag) return;
-		this.activeDrag = null;
-		if (event && this.domElement.hasPointerCapture?.(event.pointerId)) this.domElement.releasePointerCapture(event.pointerId);
-		if (this.controls && activeDrag.controlsWasEnabled !== null) this.controls.enabled = activeDrag.controlsWasEnabled;
-	}
-	applyHighlight(object) {
-		object.traverse((child) => {
-			if (!(child instanceof THREE.Mesh) || this.highlighted.has(child)) return;
-			const highlighted = highlightedMaterials(child.material, this.highlightColor);
-			this.highlighted.set(child, {
-				original: child.material,
-				highlighted
-			});
-			child.material = highlighted;
-		});
-	}
-	restoreHighlight(object) {
-		object.traverse((child) => {
-			if (!(child instanceof THREE.Mesh)) return;
-			const state = this.highlighted.get(child);
-			if (!state) return;
-			child.material = state.original;
-			disposeMaterial(state.highlighted);
-			this.highlighted.delete(child);
-		});
-	}
-};
-//#endregion
-export { USDLoader, USDManipulationControls, buildUSDObject, createUSDLoadedModel, extractUSDModelData };
+export { USDLoader, buildUSDScene, createUSDLoadedModel, disposeUSDLoadedModel, extractUSDSceneData };