debug

physics: use Bounds
integer: export Parity trait
2025-05-14 18:16:07 -07:00 · 2025-05-14 18:15:26 -07:00 · 2025-05-14 17:26:41 -07:00 · 2025-05-14 17:26:41 -07:00 · 2025-05-14 16:52:51 -07:00 · 2025-05-14 16:52:51 -07:00
23 changed files with 501 additions and 365 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -46,18 +46,6 @@ dependencies = [
 "zerocopy 0.7.35",
 ]

-[[package]]
-name = "ahash_macro"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e73c78bacfd5857793b9b6813ab94605bb1699de9915f3285472f6633748e773"
-dependencies = [
- "ahash",
- "proc-macro2",
- "quote",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@ -73,12 +61,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4aa90d7ce82d4be67b64039a3d588d38dbcc6736577de4a847025ce5b0c468d1"

-[[package]]
-name = "allocator-api2"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
-
 [[package]]
 name = "android-activity"
 version = "0.6.0"
@ -1269,27 +1251,12 @@ dependencies = [
 "num-traits",
 ]

-[[package]]
-name = "hash_str"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "deb4f3e9ad2b19e6290ea4c648770a69ac4687c692a2a6175aaef2a398552da4"
-dependencies = [
- "ahash",
- "ahash_macro",
- "bumpalo",
- "hashbrown",
- "serde",
-]
-
 [[package]]
 name = "hashbrown"
 version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
 dependencies = [
- "allocator-api2",
- "equivalent",
 "foldhash",
 ]

@ -3131,10 +3098,11 @@ dependencies = [

 [[package]]
 name = "rbx_binary"
-version = "1.0.0"
+version = "1.1.0-sn4"
+source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+checksum = "dc304e66f18316b8ee8729cec639528c9c5182aacbef1f8967619bd8b2363be4"
 dependencies = [
 "ahash",
- "hash_str",
 "log",
 "lz4",
 "profiling",
@ -3147,12 +3115,15 @@ dependencies = [

 [[package]]
 name = "rbx_dom_weak"
-version = "3.0.0"
+version = "3.1.0-sn4"
+source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+checksum = "5fcb44ffa83385055a42e5e499be3a4cce04b2ceb9af2b9825f70dcc4d2578ce"
 dependencies = [
 "ahash",
- "hash_str",
+ "mlua",
 "rbx_types",
 "serde",
+ "ustr",
 ]

 [[package]]
@ -3168,8 +3139,9 @@ dependencies = [
 [[package]]
 name = "rbx_reflection"
 version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b6d0d62baa613556b058a5f94a53b01cf0ccde0ea327ce03056e335b982e77e"
 dependencies = [
- "hash_str",
 "rbx_types",
 "serde",
 "thiserror 1.0.69",
@ -3177,7 +3149,9 @@ dependencies = [

 [[package]]
 name = "rbx_reflection_database"
-version = "1.0.3+roblox-670"
+version = "1.0.2+roblox-670"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5349b19e5e94fbcaba7a52175263ab64011e0a13f17ff57729f2f560ccdec615"
 dependencies = [
 "lazy_static",
 "rbx_reflection",
@ -3188,6 +3162,8 @@ dependencies = [
 [[package]]
 name = "rbx_types"
 version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78e4fdde46493def107e5f923d82e813dec9b3eef52c2f75fbad3a716023eda2"
 dependencies = [
 "base64 0.13.1",
 "bitflags 1.3.2",
@ -3200,11 +3176,12 @@ dependencies = [

 [[package]]
 name = "rbx_xml"
-version = "1.0.0"
+version = "1.1.0-sn4"
+source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+checksum = "08750f2f23366cda4a71d05c11c40b55bfeccd4bbc22037264b510c90809f7bd"
 dependencies = [
 "ahash",
 "base64 0.13.1",
- "hash_str",
 "log",
 "rbx_dom_weak",
 "rbx_reflection",
@ -4338,6 +4315,19 @@ dependencies = [
 "percent-encoding",
 ]

+[[package]]
+name = "ustr"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18b19e258aa08450f93369cf56dd78063586adf19e92a75b338a800f799a0208"
+dependencies = [
+ "ahash",
+ "byteorder 1.5.0",
+ "lazy_static",
+ "parking_lot",
+ "serde",
+]
+
 [[package]]
 name = "utf16_iter"
 version = "1.0.5"
--- a/engine/physics/src/face_crawler.rs
+++ b/engine/physics/src/face_crawler.rs
@ -1,7 +1,10 @@
-use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
+use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
 use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
 use crate::physics::{Time,Body};

+use core::ops::Bound;
+
+#[derive(Debug)]
 enum Transition<M:MeshQuery>{
 	Miss,
 	Next(FEV<M>,GigaTime),
@ -27,17 +30,60 @@ impl<M:MeshQuery> CrawlResult<M>{
 	}
 }

+// TODO: move predict_collision_face_out algorithm in here or something
+
+/// check_lower_bound
+pub fn low<LhsNum,LhsDen,RhsNum,RhsDen,T>(lower_bound:&Bound<Ratio<LhsNum,LhsDen>>,dt:&Ratio<RhsNum,RhsDen>)->bool
+where
+	RhsNum:Copy,
+	RhsDen:Copy,
+	LhsNum:Copy,
+	LhsDen:Copy,
+	LhsDen:strafesnet_common::integer::Parity,
+	RhsDen:strafesnet_common::integer::Parity,
+	LhsNum:core::ops::Mul<RhsDen,Output=T>,
+	LhsDen:core::ops::Mul<RhsNum,Output=T>,
+	T:Ord+Copy,
+{
+	match lower_bound{
+		Bound::Included(time)=>time.le_ratio(*dt),
+		Bound::Excluded(time)=>time.lt_ratio(*dt),
+		Bound::Unbounded=>true,
+	}
+}
+/// check_upper_bound
+pub fn upp<LhsNum,LhsDen,RhsNum,RhsDen,T>(dt:&Ratio<LhsNum,LhsDen>,upper_bound:&Bound<Ratio<RhsNum,RhsDen>>)->bool
+where
+	RhsNum:Copy,
+	RhsDen:Copy,
+	LhsNum:Copy,
+	LhsDen:Copy,
+	LhsDen:strafesnet_common::integer::Parity,
+	RhsDen:strafesnet_common::integer::Parity,
+	LhsNum:core::ops::Mul<RhsDen,Output=T>,
+	LhsDen:core::ops::Mul<RhsNum,Output=T>,
+	T:Ord+Copy,
+{
+	match upper_bound{
+		Bound::Included(time)=>dt.le_ratio(*time),
+		Bound::Excluded(time)=>dt.lt_ratio(*time),
+		Bound::Unbounded=>true,
+	}
+}
+
 impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
 		M::Edge:Copy,
 		M::Vert:Copy,
+		M:std::fmt::Debug,
+		F:std::fmt::Display,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
-		<M as MeshQuery>::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
+		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition(&self,body_time:GigaTime,mesh:&M,body:&Body,mut best_time:GigaTime)->Transition<M>{
+	fn next_transition(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@ -47,11 +93,16 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				//n=face.normal d=face.dot
 				//n.a t^2+n.v t+n.p-d==0
 				let (n,d)=mesh.face_nd(face_id);
+				println!("Face n={} d={}",n,d);
 				//TODO: use higher precision d value?
 				//use the mesh transform translation instead of baking it into the d value.
 				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-					if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-						best_time=dt;
+					let low=low(&lower_bound,&dt);
+					let upp=upp(&dt,&upper_bound);
+					let into=n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative();
+					println!("dt={} low={low} upp={upp} into={into}",dt.divide());
+					if low&&upp&&into{
+						upper_bound=Bound::Included(dt);
 						best_transition=Transition::Hit(face_id,dt);
 						break;
 					}
@ -65,8 +116,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//WARNING: precision is swept under the rug!
 					//wrap for speed
 					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							best_time=dt;
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
@ -84,11 +135,17 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					let face_n=mesh.face_nd(edge_face_id).0;
 					//edge_n gets parity from the order of edge_faces
 					let n=face_n.cross(edge_n)*((i as i64)*2-1);
+					let d=n.dot(delta_pos).wrap_4();
+					println!("Edge Face={:?} boundary_n={} boundary_d={}",edge_face_id,n,d>>1);
 					//WARNING yada yada d *2
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							best_time=dt;
+					for dt in Fixed::<4,128>::zeroes2(d,n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
+						let low=low(&lower_bound,&dt);
+						let upp=upp(&dt,&upper_bound);
+						let into=n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative();
+						println!("dt={} low={low} upp={upp} into={into}",dt.divide());
+						if low&&upp&&into{
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
 						}
@ -99,9 +156,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
-							best_time=dt;
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
 							break;
 						}
@ -115,9 +172,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//edge is directed away from vertex, but we want the dot product to turn out negative
 					let n=-mesh.directed_edge_n(directed_edge_id);
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
-							best_time=dt;
+							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
@ -128,19 +185,16 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		}
 		best_transition
 	}
-	pub fn crawl(mut self,mesh:&M,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<M>{
-		let mut body_time={
-			let r=(start_time-relative_body.time).to_ratio();
-			Ratio::new(r.num.widen_4(),r.den.widen_4())
-		};
-		let time_limit={
-			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.widen_4(),r.den.widen_4())
-		};
+	pub fn crawl(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
+		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
+		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
+		println!("crawl begin={self:?}");
 		for _ in 0..20{
-			match self.next_transition(body_time,mesh,relative_body,time_limit){
+			let transition=self.next_transition(mesh,relative_body,lower_bound,upper_bound);
+			println!("transition={transition:?}");
+			match transition{
 				Transition::Miss=>return CrawlResult::Miss(self),
-				Transition::Next(next_fev,next_time)=>(self,body_time)=(next_fev,next_time),
+				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
 			}
 		}
--- a/engine/physics/src/model.rs
+++ b/engine/physics/src/model.rs
@ -1,5 +1,5 @@
 use std::collections::{HashSet,HashMap};
-use core::ops::Range;
+use core::ops::{Bound,RangeBounds};
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
@ -68,16 +68,17 @@ pub enum FEV<M:MeshQuery>{
 }

 //use Unit32 #[repr(C)] for map files
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 struct Face{
 	normal:Planar64Vec3,
 	dot:Planar64,
 }
+#[derive(Debug)]
 struct Vert(Planar64Vec3);
 pub trait MeshQuery{
-	type Face:Copy;
-	type Edge:Copy+DirectedEdge;
-	type Vert:Copy;
+	type Face:Copy+std::fmt::Debug;
+	type Edge:Copy+DirectedEdge+std::fmt::Debug;
+	type Vert:Copy+std::fmt::Debug;
 	// Vertex must be Planar64Vec3 because it represents an actual position
 	type Normal;
 	type Offset;
@ -97,18 +98,22 @@ pub trait MeshQuery{
 	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
 	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
 }
+#[derive(Debug)]
 struct FaceRefs{
 	edges:Vec<SubmeshDirectedEdgeId>,
 	//verts:Vec<VertId>,
 }
+#[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
 	verts:[SubmeshVertId;2],//bottom, top
 }
+#[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
+#[derive(Debug)]
 pub struct PhysicsMeshData{
 	//this contains all real and virtual faces used in both the complete mesh and convex submeshes
 	//faces are sorted such that all faces that belong to the complete mesh appear first, and then
@ -118,6 +123,7 @@ pub struct PhysicsMeshData{
 	faces:Vec<Face>,//MeshFaceId indexes this list
 	verts:Vec<Vert>,//MeshVertId indexes this list
 }
+#[derive(Debug)]
 pub struct PhysicsMeshTopology{
 	//mapping of local ids to PhysicsMeshData ids
 	faces:Vec<MeshFaceId>,//SubmeshFaceId indexes this list
@ -143,10 +149,12 @@ impl From<MeshId> for PhysicsMeshId{
 pub struct PhysicsSubmeshId(u32);
 pub struct PhysicsMesh{
 	data:PhysicsMeshData,
-	complete_mesh:PhysicsMeshTopology,
-	//Most objects in roblox maps are already convex, so the list length is 0
-	//as soon as the mesh is divided into 2 submeshes, the list length jumps to 2.
-	//length 1 is unnecessary since the complete mesh would be a duplicate of the only submesh, but would still function properly
+	// The complete mesh is unused at this time.
+	// complete_mesh:PhysicsMeshTopology,
+	// Submeshes are guaranteed to be convex and may contain
+	// "virtual" faces which are not part of the complete mesh.
+	// Physics calculations should never resolve to hitting
+	// a virtual face.
 	submeshes:Vec<PhysicsMeshTopology>,
 }
 impl PhysicsMesh{
@ -210,19 +218,24 @@ impl PhysicsMesh{
 		};
 		Self{
 			data,
-			complete_mesh:mesh_topology,
-			submeshes:Vec::new(),
+			// complete_mesh:mesh_topology.clone(),
+			submeshes:vec![mesh_topology],
 		}
 	}
 	pub fn unit_cylinder()->Self{
 		Self::unit_cube()
 	}
 	#[inline]
-	pub const fn complete_mesh(&self)->&PhysicsMeshTopology{
-		&self.complete_mesh
+	pub fn complete_mesh(&self)->&PhysicsMeshTopology{
+		// If there is exactly one submesh, then the complete mesh is identical to it.
+		if self.submeshes.len()==1{
+			self.submeshes.first().unwrap()
+		}else{
+			panic!("PhysicsMesh complete mesh is not known");
+		}
 	}
 	#[inline]
-	pub const fn complete_mesh_view(&self)->PhysicsMeshView{
+	pub fn complete_mesh_view(&self)->PhysicsMeshView{
 		PhysicsMeshView{
 			data:&self.data,
 			topology:self.complete_mesh(),
@ -230,12 +243,7 @@ impl PhysicsMesh{
 	}
 	#[inline]
 	pub fn submeshes(&self)->&[PhysicsMeshTopology]{
-		//the complete mesh is already a convex mesh when len()==0, len()==1 is invalid but will still work
-		if self.submeshes.len()==0{
-			std::slice::from_ref(&self.complete_mesh)
-		}else{
-			&self.submeshes.as_slice()
-		}
+		&self.submeshes
 	}
 	#[inline]
 	pub fn submesh_view(&self,submesh_id:PhysicsSubmeshId)->PhysicsMeshView{
@ -313,14 +321,20 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 		if mesh.unique_pos.len()==0{
 			return Err(PhysicsMeshError::ZeroVertices);
 		}
+		// An empty physics mesh is a waste of resources
+		if mesh.physics_groups.len()==0{
+			return Err(PhysicsMeshError::NoPhysicsGroups);
+		}
 		let verts=mesh.unique_pos.iter().copied().map(Vert).collect();
 		//TODO: fix submeshes
 		//flat map mesh.physics_groups[$1].groups.polys()[$2] as face_id
 		//lower face_id points to upper face_id
 		//the same face is not allowed to be in multiple polygon groups
+		// because SubmeshFaceId -> CompleteMeshFaceId -> SubmeshFaceId is ambiguous
+		// when multiple SubmeshFaceId point to one MeshFaceId
 		let mut faces=Vec::new();
 		let mut face_id_from_face=HashMap::new();
-		let mut mesh_topologies:Vec<PhysicsMeshTopology>=mesh.physics_groups.iter().map(|physics_group|{
+		let mesh_topologies:Vec<PhysicsMeshTopology>=mesh.physics_groups.iter().map(|physics_group|{
 			//construct submesh
 			let mut submesh_faces=Vec::new();//these contain a map from submeshId->meshId
 			let mut submesh_verts=Vec::new();
@ -381,15 +395,11 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 						normal:(normal/len as i64).divide().narrow_1().unwrap(),
 						dot:(dot/(len*len) as i64).narrow_1().unwrap(),
 					};
-					let face_id=match face_id_from_face.get(&face){
-						Some(&face_id)=>face_id,
-						None=>{
-							let face_id=MeshFaceId::new(faces.len() as u32);
-							face_id_from_face.insert(face.clone(),face_id);
-							faces.push(face);
-							face_id
-						}
-					};
+					let face_id=*face_id_from_face.entry(face).or_insert_with(||{
+						let face_id=MeshFaceId::new(faces.len() as u32);
+						faces.push(face);
+						face_id
+					});
 					submesh_faces.push(face_id);
 					face_ref_guys.push(FaceRefEdges(face_edges));
 				}
@ -397,16 +407,16 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 			PhysicsMeshTopology{
 				faces:submesh_faces,
 				verts:submesh_verts,
-				face_topology:face_ref_guys.into_iter().map(|face_ref_guy|{
-					FaceRefs{edges:face_ref_guy.0}
+				face_topology:face_ref_guys.into_iter().map(|FaceRefEdges(edges)|{
+					FaceRefs{edges}
 				}).collect(),
-				edge_topology:edge_pool.edge_guys.into_iter().map(|(edge_ref_verts,edge_ref_faces)|
-					EdgeRefs{faces:edge_ref_faces.0,verts:edge_ref_verts.0}
+				edge_topology:edge_pool.edge_guys.into_iter().map(|(EdgeRefVerts(verts),EdgeRefFaces(faces))|
+					EdgeRefs{faces,verts}
 				).collect(),
-				vert_topology:vert_ref_guys.into_iter().map(|vert_ref_guy|
+				vert_topology:vert_ref_guys.into_iter().map(|VertRefGuy{edges,faces}|
 					VertRefs{
-						edges:vert_ref_guy.edges.into_iter().collect(),
-						faces:vert_ref_guy.faces.into_iter().collect(),
+						edges:edges.into_iter().collect(),
+						faces:faces.into_iter().collect(),
 					}
 				).collect(),
 			}
@ -416,12 +426,13 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 				faces,
 				verts,
 			},
-			complete_mesh:mesh_topologies.pop().ok_or(PhysicsMeshError::NoPhysicsGroups)?,
+			// complete_mesh:None,
 			submeshes:mesh_topologies,
 		})
 	}
 }

+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@ -458,6 +469,7 @@ impl MeshQuery for PhysicsMeshView<'_>{
 	}
 }

+#[derive(Debug)]
 pub struct PhysicsMeshTransform{
 	pub vertex:integer::Planar64Affine3,
 	pub normal:integer::mat3::Matrix3<Fixed<2,64>>,
@ -473,6 +485,7 @@ impl PhysicsMeshTransform{
 	}
 }

+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@ -598,6 +611,7 @@ pub enum MinkowskiFace{
 	//FaceFace
 }

+#[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
 	mesh0:TransformedMesh<'a>,
 	mesh1:TransformedMesh<'a>,
@ -615,6 +629,10 @@ enum EV{
 }

 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
+pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
+	let r=(time-relative_to).to_ratio();
+	Ratio::new(r.num.widen_4(),r.den.widen_4())
+}

 impl MinkowskiMesh<'_>{
 	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
@ -730,44 +748,46 @@ impl MinkowskiMesh<'_>{
 	//
 	// Most of the calculation time is just calculating the starting point
 	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
-	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Time)->Option<FEV<MinkowskiMesh>>{
+	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Bound<&Time>)->Option<FEV<MinkowskiMesh>>{
 		infinity_body.infinity_dir().and_then(|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			// TODO: change crawl_fev args to delta time? Optional values?
-			infinity_fev.crawl(self,&infinity_body,Time::MIN/4,start_time).miss()
+			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
+	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		println!("@@@BEGIN SETUP@@@");
+		self.closest_fev_not_inside(relative_body.clone(),range.start_bound()).and_then(|fev|{
+			println!("@@@BEGIN REAL CRAWL@@@");
 			//continue forwards along the body parabola
-			fev.crawl(self,relative_body,start_time,time_limit).hit()
+			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		//create an extrapolated body at time_limit
+	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// swap and negate bounds to do a time inversion
+		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
 		let infinity_body=-relative_body.clone();
-		self.closest_fev_not_inside(infinity_body,-time_limit).and_then(|fev|{
+		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
 			//continue backwards along the body parabola
-			fev.crawl(self,&infinity_body,-time_limit,-start_time).hit()
+			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
 				//no need to test -time<time_limit because of the first step
 				.map(|(face,time)|(face,-time))
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
+	pub fn predict_collision_face_out(&self,relative_body:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
+		// TODO: make better
+		use crate::face_crawler::{low,upp};
 		//no algorithm needed, there is only one state and two cases (Edge,None)
 		//determine when it passes an edge ("sliding off" case)
-		let start_time={
-			let r=(start_time-relative_body.time).to_ratio();
+		let start_time=range.start_bound().map(|&t|{
+			let r=(t-relative_body.time).to_ratio();
 			Ratio::new(r.num,r.den)
-		};
-		let mut best_time={
-			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.widen_4(),r.den.widen_4())
-		};
+		});
+		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.time));
 		let mut best_edge=None;
 		let face_n=self.face_nd(contact_face_id).0;
 		for &directed_edge_id in self.face_edges(contact_face_id).as_ref(){
@ -780,18 +800,19 @@ impl MinkowskiMesh<'_>{
 			//WARNING: truncated precision
 			//wrap for speed
 			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).wrap_4(),n.dot(relative_body.velocity).wrap_4()*2,n.dot(relative_body.acceleration).wrap_4()){
-				if start_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-					best_time=dt;
-					best_edge=Some(directed_edge_id);
+				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					best_time=Bound::Included(dt);
+					best_edge=Some((directed_edge_id,dt));
 					break;
 				}
 			}
 		}
-		best_edge.map(|e|(e.as_undirected(),best_time))
+		best_edge
 	}
 	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		infinity_fev.crawl(self,&infinity_body,Time::MIN/4,infinity_body.time).hit()
+		// Bound::Included means that the surface of the mesh is included in the mesh
+		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
 		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
@ -929,10 +950,10 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	}
 	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
 		AsRefHelper(match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>(*self.mesh1.edge_verts(e1).as_ref()).map(|vert_id1|
+			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
 				MinkowskiVert::VertVert(v0,vert_id1)
 			),
-			MinkowskiEdge::EdgeVert(e0,v1)=>(*self.mesh0.edge_verts(e0).as_ref()).map(|vert_id0|
+			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
 				MinkowskiVert::VertVert(vert_id0,v1)
 			),
 		})
@ -942,38 +963,43 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			MinkowskiVert::VertVert(v0,v1)=>{
 				let mut edges=Vec::new();
 				//detect shared volume when the other mesh is mirrored along a test edge dir
-				let v0f=self.mesh0.vert_faces(v0);
-				let v1f=self.mesh1.vert_faces(v1);
-				let v0f_n:Vec<_>=v0f.as_ref().iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<_>=v1f.as_ref().iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
-				let the_len=v0f.as_ref().len()+v1f.as_ref().len();
+				let v0f_thing=self.mesh0.vert_faces(v0);
+				let v1f_thing=self.mesh1.vert_faces(v1);
+				let v0f=v0f_thing.as_ref();
+				let v1f=v1f_thing.as_ref();
+				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
+				// scratch vector
+				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
+				face_normals.clone_from(&v0f_n);
 				for &directed_edge_id in self.mesh0.vert_edges(v0).as_ref(){
 					let n=self.mesh0.directed_edge_n(directed_edge_id);
 					let nn=n.dot(n);
 					// TODO: there's gotta be a better way to do this
-					//make a set of faces
-					let mut face_normals=Vec::with_capacity(the_len);
-					//add mesh0 faces as-is
-					face_normals.clone_from(&v0f_n);
+					// drop faces beyond v0f_n
+					face_normals.truncate(v0f.len());
+					// make a set of faces from mesh0's perspective
 					for face_n in &v1f_n{
 						//add reflected mesh1 faces
 						//wrap for speed
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
-					if is_empty_volume(face_normals){
+					if is_empty_volume(&face_normals){
 						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
 					}
 				}
+				face_normals.clone_from(&v1f_n);
 				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
 					let n=self.mesh1.directed_edge_n(directed_edge_id);
 					let nn=n.dot(n);
-					let mut face_normals=Vec::with_capacity(the_len);
-					face_normals.clone_from(&v1f_n);
+					// drop faces beyond v1f_n
+					face_normals.truncate(v1f.len());
+					// make a set of faces from mesh1's perspective
 					for face_n in &v0f_n{
 						//wrap for speed
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
-					if is_empty_volume(face_normals){
+					if is_empty_volume(&face_normals){
 						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
 					}
 				}
@ -987,7 +1013,7 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	}
 }

-fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
+fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
 	let len=normals.len();
 	for i in 0..len-1{
 		for j in i+1..len{
@ -1013,6 +1039,6 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{

 #[test]
 fn test_is_empty_volume(){
-	assert!(!is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()].to_vec()));
-	assert!(is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()].to_vec()));
+	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
+	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
 }
--- a/engine/physics/src/physics.rs
+++ b/engine/physics/src/physics.rs
@ -417,7 +417,7 @@ impl HitboxMesh{
 		}
 	}
 	#[inline]
-	const fn transformed_mesh(&self)->TransformedMesh{
+	fn transformed_mesh(&self)->TransformedMesh{
 		TransformedMesh::new(self.mesh.complete_mesh_view(),&self.transform)
 	}
 }
@ -1193,7 +1193,7 @@ fn recalculate_touching(
 		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(contact.model_id),contact)
 	}
 	while let Some(&intersect)=touching.intersects.iter().next(){
-		collision_end_intersect(touching,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
+		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
 	}
 	//find all models in the teleport region
 	let mut aabb=aabb::Aabb::default();
@ -1605,6 +1605,7 @@ fn collision_start_intersect(
 			None=>(),
 		}
 	}
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	run_teleport_behaviour(intersect.model_id.into(),attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
 }

@ -1637,7 +1638,14 @@ fn collision_end_contact(
 	}
 }
 fn collision_end_intersect(
+	move_state:&mut MoveState,
+	body:&mut Body,
 	touching:&mut TouchingState,
+	models:&PhysicsModels,
+	hitbox_mesh:&HitboxMesh,
+	style:&StyleModifiers,
+	camera:&PhysicsCamera,
+	input_state:&InputState,
 	mode:Option<&gameplay_modes::Mode>,
 	run:&mut run::Run,
 	_attr:&gameplay_attributes::IntersectAttributes,
@ -1645,6 +1653,7 @@ fn collision_end_intersect(
 	time:Time,
 ){
 	touching.remove(&Collision::Intersect(intersect));
+	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	if let Some(mode)=mode{
 		let zone=mode.get_zone(intersect.model_id.into());
 		match zone{
@ -1701,7 +1710,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 					contact
 				),
 				Collision::Intersect(intersect)=>collision_end_intersect(
-					&mut state.touching,
+					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
 					data.modes.get_mode(state.mode_state.get_mode_id()),
 					&mut state.run,
 					data.models.intersect_attr(intersect.model_id),
@ -1924,6 +1933,15 @@ mod test{
 		),Some(Time::from_secs(2)));
 	}
 	#[test]
+	fn test_collision_small_mv(){
+		test_collision(Body::new(
+			int3(0,5,0),
+			int3(0,-1,0)+(vec3::X>>32),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)));
+	}
+	#[test]
 	fn test_collision_degenerate_east(){
 		test_collision(Body::new(
 			int3(3,5,0),
--- a/lib/bsp_loader/src/bsp.rs
+++ b/lib/bsp_loader/src/bsp.rs
@ -349,7 +349,7 @@ pub struct PartialMap1{
 impl PartialMap1{
 	pub fn add_prop_meshes<'a>(
 		self,
-		prop_meshes:Meshes,
+		prop_meshes:Meshes<model::Mesh>,
 	)->PartialMap2{
 		PartialMap2{
 			attributes:self.attributes,
--- a/lib/common/src/integer.rs
+++ b/lib/common/src/integer.rs
@ -1,5 +1,5 @@
 pub use fixed_wide::fixed::*;
-pub use ratio_ops::ratio::{Ratio,Divide};
+pub use ratio_ops::ratio::{Ratio,Divide,Parity};

 //integer units

@ -132,20 +132,21 @@ impl<T> std::ops::Mul for Time<T>{
 		Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
 	}
 }
-impl<T> std::ops::Div<i64> for Time<T>{
-	type Output=Self;
-	#[inline]
-	fn div(self,rhs:i64)->Self::Output{
-		Self::raw(self.0/rhs)
-	}
-}
-impl<T> std::ops::Mul<i64> for Time<T>{
-	type Output=Self;
-	#[inline]
-	fn mul(self,rhs:i64)->Self::Output{
-		Self::raw(self.0*rhs)
+macro_rules! impl_time_i64_rhs_operator {
+	($op:ident,$method:ident)=>{
+		impl<T> core::ops::$op<i64> for Time<T>{
+			type Output=Self;
+			#[inline]
+			fn $method(self,rhs:i64)->Self::Output{
+				Self::raw(self.0.$method(rhs))
+			}
+		}
 	}
 }
+impl_time_i64_rhs_operator!(Div,div);
+impl_time_i64_rhs_operator!(Mul,mul);
+impl_time_i64_rhs_operator!(Shr,shr);
+impl_time_i64_rhs_operator!(Shl,shl);
 impl<T> core::ops::Mul<Time<T>> for Planar64{
 	type Output=Ratio<Fixed<2,64>,Planar64>;
 	fn mul(self,rhs:Time<T>)->Self::Output{
@ -656,7 +657,7 @@ pub mod mat3{
 	}
 }

-#[derive(Clone,Copy,Default,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Default,Hash,Eq,PartialEq)]
 pub struct Planar64Affine3{
 	pub matrix3:Planar64Mat3,//includes scale above 1
 	pub translation:Planar64Vec3,
--- a/lib/deferred_loader/src/deferred_loader.rs
+++ b/lib/deferred_loader/src/deferred_loader.rs
@ -2,7 +2,7 @@ use std::collections::HashMap;
 use crate::loader::Loader;
 use crate::mesh::Meshes;
 use crate::texture::{RenderConfigs,Texture};
-use strafesnet_common::model::{Mesh,MeshId,RenderConfig,RenderConfigId,TextureId};
+use strafesnet_common::model::{MeshId,RenderConfig,RenderConfigId,TextureId};

 #[derive(Clone,Copy,Debug)]
 pub enum LoadFailureMode{
@ -93,7 +93,7 @@ impl<H:core::hash::Hash+Eq> MeshDeferredLoader<H>{
 	pub fn into_indices(self)->impl Iterator<Item=H>{
 		self.mesh_id_from_asset_id.into_keys()
 	}
-	pub fn into_meshes<'a,L:Loader<Resource=Mesh,Index<'a>=H>+'a>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes,L::Error>{
+	pub fn into_meshes<'a,M:Clone,L:Loader<Resource=M,Index<'a>=H>+'a>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes<M>,L::Error>{
 		let mut mesh_list=vec![None;self.mesh_id_from_asset_id.len()];
 		for (index,mesh_id) in self.mesh_id_from_asset_id{
 			let resource_result=loader.load(index);
--- a/lib/deferred_loader/src/mesh.rs
+++ b/lib/deferred_loader/src/mesh.rs
@ -1,15 +1,15 @@
-use strafesnet_common::model::{Mesh,MeshId};
+use strafesnet_common::model::MeshId;

-pub struct Meshes{
-	meshes:Vec<Option<Mesh>>,
+pub struct Meshes<M>{
+	meshes:Vec<Option<M>>,
 }
-impl Meshes{
-	pub(crate) const fn new(meshes:Vec<Option<Mesh>>)->Self{
+impl<M> Meshes<M>{
+	pub(crate) const fn new(meshes:Vec<Option<M>>)->Self{
 		Self{
 			meshes,
 		}
 	}
-	pub fn consume(self)->impl Iterator<Item=(MeshId,Mesh)>{
+	pub fn consume(self)->impl Iterator<Item=(MeshId,M)>{
 		self.meshes.into_iter().enumerate().filter_map(|(mesh_id,maybe_mesh)|
 			maybe_mesh.map(|mesh|(MeshId::new(mesh_id as u32),mesh))
 		)
--- a/lib/rbx_loader/Cargo.toml
+++ b/lib/rbx_loader/Cargo.toml
@ -13,11 +13,11 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 bytemuck = "1.14.3"
 glam = "0.30.0"
 lazy-regex = "3.1.0"
+rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
 rbx_mesh = "0.3.1"
-rbx_binary  = { path = "../../../../git/rbx-dom/rbx_binary", registry = "strafesnet" }
-rbx_dom_weak =  { path = "../../../../git/rbx-dom/rbx_dom_weak", registry = "strafesnet" }
-rbx_reflection_database = { path = "../../../../git/rbx-dom/rbx_reflection_database"}
-rbx_xml = { path = "../../../../git/rbx-dom/rbx_xml", registry = "strafesnet" }
+rbx_reflection_database = "1.0.0"
+rbx_xml  = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.0", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
 strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
--- a/lib/rbx_loader/src/lib.rs
+++ b/lib/rbx_loader/src/lib.rs
@ -21,19 +21,19 @@ pub mod data{
 	}
 }

-pub struct Model<'a>{
-	dom:WeakDom<'a>,
+pub struct Model{
+	dom:WeakDom,
 }
-impl<'a> Model<'a>{
-	fn new(dom:WeakDom<'a>)->Self{
+impl Model{
+	fn new(dom:WeakDom)->Self{
 		Self{dom}
 	}
 	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
 		to_snf(self,failure_mode)
 	}
 }
-impl<'a> AsRef<WeakDom<'a>> for Model<'a>{
-	fn as_ref(&self)->&WeakDom<'a>{
+impl AsRef<WeakDom> for Model{
+	fn as_ref(&self)->&WeakDom{
 		&self.dom
 	}
 }
@ -95,7 +95,7 @@ pub fn read<R:Read>(input:R)->Result<Model,ReadError>{
 	let mut buf=std::io::BufReader::new(input);
 	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?;
 	match peek.get(0..8){
-		Some(b"<roblox!")=>rbx_binary::from_reader_default(buf).map(Model::new).map_err(ReadError::RbxBinary),
+		Some(b"<roblox!")=>rbx_binary::from_reader(buf).map(Model::new).map_err(ReadError::RbxBinary),
 		Some(b"<roblox ")=>rbx_xml::from_reader_default(buf).map(Model::new).map_err(ReadError::RbxXml),
 		_=>Err(ReadError::UnknownFileFormat),
 	}
--- a/lib/rbx_loader/src/loader.rs
+++ b/lib/rbx_loader/src/loader.rs
@ -6,7 +6,10 @@ use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
 use crate::data::RobloxMeshBytes;
 use crate::rbx::RobloxPartDescription;

-use rbx_dom_weak::hstr;
+// disallow non-static lifetimes
+fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
+	rbx_dom_weak::ustr(s)
+}

 fn read_entire_file(path:impl AsRef<std::path::Path>)->Result<Vec<u8>,std::io::Error>{
 	let mut file=std::fs::File::open(path)?;
@ -140,6 +143,12 @@ impl MeshIndex<'_>{
 	}
 }

+#[derive(Clone)]
+pub struct MeshWithSize{
+	pub(crate) mesh:Mesh,
+	pub(crate) size:strafesnet_common::integer::Planar64Vec3,
+}
+
 pub struct MeshLoader;
 impl MeshLoader{
 	pub fn new()->Self{
@ -149,7 +158,7 @@ impl MeshLoader{
 impl Loader for MeshLoader{
 	type Error=MeshError;
 	type Index<'a>=MeshIndex<'a>;
-	type Resource=Mesh;
+	type Resource=MeshWithSize;
 	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let mesh=match index.mesh_type{
 			MeshType::FileMesh=>{
@ -165,7 +174,7 @@ impl Loader for MeshLoader{
 					let RobloxAssetId(asset_id)=index.content.parse()?;
 					let file_name=format!("unions/{}",asset_id);
 					let data=read_entire_file(file_name)?;
-					let dom=rbx_binary::from_reader_default(data.as_slice())?;
+					let dom=rbx_binary::from_reader(std::io::Cursor::new(data))?;
 					let &[referent]=dom.root().children()else{
 						return Err(MeshError::OneChildPolicy);
 					};
@ -173,12 +182,12 @@ impl Loader for MeshLoader{
 						return Err(MeshError::MissingInstance);
 					};
 					if physics_data.is_empty(){
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get(hstr!("PhysicsData")){
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get(&static_ustr("PhysicsData")){
 							physics_data=data.as_ref();
 						}
 					}
 					if mesh_data.is_empty(){
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get(hstr!("MeshData")){
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get(&static_ustr("MeshData")){
 							mesh_data=data.as_ref();
 						}
 					}
--- a/lib/rbx_loader/src/mesh.rs
+++ b/lib/rbx_loader/src/mesh.rs
@ -1,7 +1,11 @@
 use std::collections::HashMap;

 use rbx_mesh::mesh::{Vertex2,Vertex2Truncated};
-use strafesnet_common::{integer::vec3,model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId}};
+use strafesnet_common::aabb::Aabb;
+use strafesnet_common::integer::vec3;
+use strafesnet_common::model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId};
+
+use crate::loader::MeshWithSize;

 #[allow(dead_code)]
 #[derive(Debug)]
@ -95,7 +99,7 @@ fn ingest_faces2_lods3(
 	))
 }

-pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Mesh,Error>{
+pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithSize,Error>{
 	//generate that mesh boi
 	let mut unique_pos=Vec::new();
 	let mut pos_id_from=HashMap::new();
@ -108,8 +112,10 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Me
 	let mut unique_vertices=Vec::new();
 	let mut vertex_id_from=HashMap::new();
 	let mut polygon_groups=Vec::new();
+	let mut aabb=Aabb::default();
 	let mut acquire_pos_id=|pos|{
 		let p=vec3::try_from_f32_array(pos).map_err(Error::Planar64Vec3)?;
+		aabb.grow(p);
 		Ok(PositionId::new(*pos_id_from.entry(p).or_insert_with(||{
 			let pos_id=unique_pos.len();
 			unique_pos.push(p);
@ -197,7 +203,7 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Me
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
 	}
-	Ok(model::Mesh{
+	let mesh=model::Mesh{
 		unique_pos,
 		unique_normal,
 		unique_tex,
@ -213,5 +219,6 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Me
 		}],
 		//disable physics
 		physics_groups:Vec::new(),
-	})
+	};
+	Ok(MeshWithSize{mesh,size:aabb.size()})
 }
--- a/lib/rbx_loader/src/primitives.rs
+++ b/lib/rbx_loader/src/primitives.rs
@ -56,7 +56,7 @@ const CUBE_DEFAULT_TEXTURE_COORDS:[TextureCoordinate;4]=[
 	TextureCoordinate::new(1.0,1.0),
 	TextureCoordinate::new(0.0,1.0),
 ];
-const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
+pub const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
 	vec3::int(-1,-1, 1),//0 left bottom back
 	vec3::int( 1,-1, 1),//1 right bottom back
 	vec3::int( 1, 1, 1),//2 right top back
@ -66,7 +66,7 @@ const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
 	vec3::int( 1,-1,-1),//6 right bottom front
 	vec3::int(-1,-1,-1),//7 left bottom front
 ];
-const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
+pub const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
 	vec3::int( 1, 0, 0),//CubeFace::Right
 	vec3::int( 0, 1, 0),//CubeFace::Top
 	vec3::int( 0, 0, 1),//CubeFace::Back
@ -121,8 +121,7 @@ impl FaceDescription{
 		}
 	}
 }
-pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Mesh{
-	const CUBE_DEFAULT_POLYS:[[[u32;2];4];6]=[
+pub const CUBE_DEFAULT_POLYS:[[[u32;2];4];6]=[
 		// right (1, 0, 0)
 		[
 			[6,2],//[vertex,tex]
@ -166,6 +165,7 @@ pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Me
 			[7,2],
 		],
 	];
+pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Mesh{
 	let mut generated_pos=Vec::new();
 	let mut generated_tex=Vec::new();
 	let mut generated_normal=Vec::new();
--- a/lib/rbx_loader/src/rbx.rs
+++ b/lib/rbx_loader/src/rbx.rs
@ -1,7 +1,6 @@
 use std::collections::HashMap;
-use crate::loader::MeshIndex;
+use crate::loader::{MeshWithSize,MeshIndex};
 use crate::primitives::{self,CubeFace,CubeFaceDescription,WedgeFaceDescription,CornerWedgeFaceDescription,FaceDescription,Primitives};
-use strafesnet_common::aabb::Aabb;
 use strafesnet_common::map;
 use strafesnet_common::model;
 use strafesnet_common::gameplay_modes::{NormalizedModes,Mode,ModeId,ModeUpdate,ModesBuilder,Stage,StageElement,StageElementBehaviour,StageId,Zone};
@ -13,13 +12,16 @@ use strafesnet_deferred_loader::deferred_loader::{RenderConfigDeferredLoader,Mes
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};

-use rbx_dom_weak::{hstr,HashStr};
+// disallow non-static lifetimes
+fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
+	rbx_dom_weak::ustr(s)
+}

 fn recursive_collect_superclass(
 	objects:&mut std::vec::Vec<rbx_dom_weak::types::Ref>,
 	dom:&rbx_dom_weak::WeakDom,
 	instance:&rbx_dom_weak::Instance,
-	superclass:&HashStr,
+	superclass:&str
 ){
 	let instance=instance;
 	let db=rbx_reflection_database::get();
@ -28,7 +30,7 @@ fn recursive_collect_superclass(
 	};
 	objects.extend(
 		dom.descendants_of(instance.referent()).filter_map(|instance|{
-			let class=db.classes.get(instance.class)?;
+			let class=db.classes.get(instance.class.as_str())?;
 			db.has_superclass(class,superclass).then(||instance.referent())
 		})
 	);
@ -54,15 +56,19 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 	let mut contacting=attr::ContactingAttributes::default();
 	let mut force_can_collide=can_collide;
 	let mut force_intersecting=false;
+	let mut allow_booster=true;
 	match name{
 		"Water"=>{
 			force_can_collide=false;
+			allow_booster=false;
 			//TODO: read stupid CustomPhysicalProperties
 			intersecting.water=Some(attr::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,velocity});
 		},
 		"Accelerator"=>{
 			//although the new game supports collidable accelerators, this is a roblox compatability map loader
 			force_can_collide=false;
+			// Accelerator is not allowed to be booster in roblox
+			allow_booster=false;
 			general.accelerator=Some(attr::Accelerator{acceleration:velocity});
 		},
 		// "UnorderedCheckpoint"=>general.teleport_behaviour=Some(model::TeleportBehaviour::StageElement(attr::StageElement{
@ -71,7 +77,10 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		// 	force:false,
 		// 	behaviour:model::StageElementBehaviour::Unordered
 		// })),
-		"SetVelocity"=>general.trajectory=Some(attr::SetTrajectory::Velocity(velocity)),
+		"SetVelocity"=>{
+			allow_booster=false;
+			general.trajectory=Some(attr::SetTrajectory::Velocity(velocity));
+		},
 		"MapStart"=>{
 			force_can_collide=false;
 			force_intersecting=true;
@ -231,7 +240,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}
 	}
 	//need some way to skip this
-	if velocity!=vec3::ZERO{
+	if allow_booster&&velocity!=vec3::ZERO{
 		general.booster=Some(attr::Booster::Velocity(velocity));
 	}
 	match force_can_collide{
@ -407,7 +416,7 @@ fn get_texture_description<'a>(
 	//use the biggest one and cut it down later...
 	let mut part_texture_description=RobloxPartDescription::default();
 	temp_objects.clear();
-	recursive_collect_superclass(temp_objects,&dom,object,hstr!("Decal"));
+	recursive_collect_superclass(temp_objects,&dom,object,"Decal");
 	for &mut decal_ref in temp_objects{
 		let Some(decal)=dom.get_by_ref(decal_ref) else{
 			println!("Decal get_by_ref failed");
@ -419,10 +428,10 @@ fn get_texture_description<'a>(
 			Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
 			Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
 		)=(
-			decal.properties.get(hstr!("TextureContent")),
-			decal.properties.get(hstr!("Face")),
-			decal.properties.get(hstr!("Color3")),
-			decal.properties.get(hstr!("Transparency")),
+			decal.properties.get(&static_ustr("TextureContent")),
+			decal.properties.get(&static_ustr("Face")),
+			decal.properties.get(&static_ustr("Color3")),
+			decal.properties.get(&static_ustr("Transparency")),
 		)else{
 			println!("Decal is missing a required property");
 			continue;
@ -444,10 +453,10 @@ fn get_texture_description<'a>(
 					Some(&rbx_dom_weak::types::Variant::Float32(studs_per_tile_u)),
 					Some(&rbx_dom_weak::types::Variant::Float32(studs_per_tile_v)),
 				) = (
-					decal.properties.get(hstr!("OffsetStudsU")),
-					decal.properties.get(hstr!("OffsetStudsV")),
-					decal.properties.get(hstr!("StudsPerTileU")),
-					decal.properties.get(hstr!("StudsPerTileV")),
+					decal.properties.get(&static_ustr("OffsetStudsU")),
+					decal.properties.get(&static_ustr("OffsetStudsV")),
+					decal.properties.get(&static_ustr("StudsPerTileU")),
+					decal.properties.get(&static_ustr("StudsPerTileV")),
 				)
 			{
 				let (size_u,size_v)=match cube_face{
@ -534,7 +543,7 @@ pub fn convert<'a>(

 	let mut object_refs=Vec::new();
 	let mut temp_objects=Vec::new();
-	recursive_collect_superclass(&mut object_refs, &dom, dom.root(),hstr!("BasePart"));
+	recursive_collect_superclass(&mut object_refs, &dom, dom.root(),"BasePart");
 	for object_ref in object_refs {
 		if let Some(object)=dom.get_by_ref(object_ref){
 			if let (
@ -545,12 +554,12 @@ pub fn convert<'a>(
 					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
 					Some(rbx_dom_weak::types::Variant::Bool(can_collide)),
 				) = (
-					object.properties.get(hstr!("CFrame")),
-					object.properties.get(hstr!("Size")),
-					object.properties.get(hstr!("Velocity")),
-					object.properties.get(hstr!("Transparency")),
-					object.properties.get(hstr!("Color")),
-					object.properties.get(hstr!("CanCollide")),
+					object.properties.get(&static_ustr("CFrame")),
+					object.properties.get(&static_ustr("Size")),
+					object.properties.get(&static_ustr("Velocity")),
+					object.properties.get(&static_ustr("Transparency")),
+					object.properties.get(&static_ustr("Color")),
+					object.properties.get(&static_ustr("CanCollide")),
 				)
 			{
 				let model_transform=planar64_affine3_from_roblox(cf,size);
@ -569,7 +578,7 @@ pub fn convert<'a>(

 				//TODO: also detect "CylinderMesh" etc here
 				let shape=match object.class.as_str(){
-					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get(hstr!("Shape")){
+					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get(&static_ustr("Shape")){
 						Shape::Primitive(shape.to_u32().try_into().expect("Funky roblox PartType"))
 					}else{
 						panic!("Part has no Shape!");
@ -643,11 +652,11 @@ pub fn convert<'a>(
 						Some(rbx_dom_weak::types::Variant::Content(texture_content)),
 					)=(
 						// mesh must exist
-						object.properties.get(hstr!("MeshContent")),
+						object.properties.get(&static_ustr("MeshContent")),
 						// texture is allowed to be none
-						object.properties.get(hstr!("TextureContent")),
+						object.properties.get(&static_ustr("TextureContent")),
 					){
-						let mesh_asset_id=get_content_url(mesh_content).expect("MeshPart Mesh is not a Uri");
+						let mesh_asset_id=get_content_url(mesh_content).unwrap_or_default();
 						let texture_asset_id=get_content_url(texture_content);
 						(
 							MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(texture_asset_id)),
@ -660,13 +669,13 @@ pub fn convert<'a>(
 						let mut content="";
 						let mut mesh_data:&[u8]=&[];
 						let mut physics_data:&[u8]=&[];
-						if let Some(rbx_dom_weak::types::Variant::ContentId(asset_id))=object.properties.get(hstr!("AssetId")){
+						if let Some(rbx_dom_weak::types::Variant::ContentId(asset_id))=object.properties.get(&static_ustr("AssetId")){
 							content=asset_id.as_ref();
 						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(hstr!("MeshData")){
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("MeshData")){
 							mesh_data=data.as_ref();
 						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(hstr!("PhysicsData")){
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get(&static_ustr("PhysicsData")){
 							physics_data=data.as_ref();
 						}
 						let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
@ -706,23 +715,23 @@ pub fn convert<'a>(
 		deferred_unions_deferred_attributes,
 	}
 }
-struct MeshWithAabb{
-	mesh:model::Mesh,
-	aabb:Aabb,
+struct MeshIdWithSize{
+	mesh:model::MeshId,
+	size:Planar64Vec3,
 }
 fn acquire_mesh_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	mesh_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RenderConfigId,model::MeshId>>,
-	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_mesh_id:model::MeshId,
 	render:RenderConfigId,
-)->Option<(model::MeshId,&'a Aabb)>{
+)->Option<MeshIdWithSize>{
 	//ignore meshes that fail to load completely for now
-	loaded_meshes.get(&old_mesh_id).map(|mesh_with_aabb|(
-		*mesh_id_from_render_config_id.entry(old_mesh_id).or_insert_with(||HashMap::new())
+	loaded_meshes.get(&old_mesh_id).map(|&MeshWithSize{ref mesh,size}|MeshIdWithSize{
+		mesh:*mesh_id_from_render_config_id.entry(old_mesh_id).or_insert_with(||HashMap::new())
 		.entry(render).or_insert_with(||{
 			let mesh_id=model::MeshId::new(primitive_meshes.len() as u32);
-			let mut mesh_clone=mesh_with_aabb.mesh.clone();
+			let mut mesh_clone=mesh.clone();
 			//set the render group lool
 			if let Some(graphics_group)=mesh_clone.graphics_groups.first_mut(){
 				graphics_group.render=render;
@ -730,22 +739,22 @@ fn acquire_mesh_id_from_render_config_id<'a>(
 			primitive_meshes.push(mesh_clone);
 			mesh_id
 		}),
-		&mesh_with_aabb.aabb,
-	))
+		size,
+	})
 }
 fn acquire_union_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	union_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RobloxPartDescription,model::MeshId>>,
-	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_union_id:model::MeshId,
 	part_texture_description:RobloxPartDescription,
-)->Option<(model::MeshId,&'a Aabb)>{
+)->Option<MeshIdWithSize>{
 	//ignore uniones that fail to load completely for now
-	loaded_meshes.get(&old_union_id).map(|union_with_aabb|(
-		*union_id_from_render_config_id.entry(old_union_id).or_insert_with(||HashMap::new())
+	loaded_meshes.get(&old_union_id).map(|&MeshWithSize{ref mesh,size}|MeshIdWithSize{
+		mesh:*union_id_from_render_config_id.entry(old_union_id).or_insert_with(||HashMap::new())
 		.entry(part_texture_description.clone()).or_insert_with(||{
 			let union_id=model::MeshId::new(primitive_meshes.len() as u32);
-			let mut union_clone=union_with_aabb.mesh.clone();
+			let mut union_clone=mesh.clone();
 			//set the render groups
 			for (graphics_group,maybe_face_texture_description) in union_clone.graphics_groups.iter_mut().zip(part_texture_description.0){
 				if let Some(face_texture_description)=maybe_face_texture_description{
@ -755,8 +764,8 @@ fn acquire_union_id_from_render_config_id<'a>(
 			primitive_meshes.push(union_clone);
 			union_id
 		}),
-		&union_with_aabb.aabb,
-	))
+		size,
+	})
 }
 pub struct PartialMap1<'a>{
 	primitive_meshes:Vec<model::Mesh>,
@ -767,7 +776,7 @@ pub struct PartialMap1<'a>{
 impl PartialMap1<'_>{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
 		mut self,
-		meshpart_meshes:Meshes,
+		meshpart_meshes:Meshes<MeshWithSize>,
 	)->PartialMap2{
 		//calculate attributes
 		let mut modes_builder=ModesBuilder::default();
@ -779,17 +788,8 @@ impl PartialMap1<'_>{

 		//decode roblox meshes
 		//generate mesh_id_map based on meshes that failed to load
-		let loaded_meshes:HashMap<model::MeshId,MeshWithAabb>=
-		meshpart_meshes.consume().map(|(old_mesh_id,mesh)|{
-			let mut aabb=strafesnet_common::aabb::Aabb::default();
-			for &pos in &mesh.unique_pos{
-				aabb.grow(pos);
-			}
-			(old_mesh_id,MeshWithAabb{
-				mesh,
-				aabb,
-			})
-		}).collect();
+		let loaded_meshes:HashMap<model::MeshId,MeshWithSize>=
+		meshpart_meshes.consume().collect();

 		// SAFETY: I have no idea what I'm doing and this is definitely unsound in some subtle way
 		// I just want to chain iterators together man
@ -802,23 +802,22 @@ impl PartialMap1<'_>{
 		self.deferred_models_deferred_attributes.into_iter().flat_map(|deferred_model_deferred_attributes|{
 			//meshes need to be cloned from loaded_meshes with a new id when they are used with a new render_id
 			//insert into primitive_meshes
-			let (mesh,aabb)=acquire_mesh_id_from_render_config_id(
+			let MeshIdWithSize{mesh,size:mesh_size}=acquire_mesh_id_from_render_config_id(
 				unsafe{*aint_no_way.get()},
 				&mut mesh_id_from_render_config_id,
 				&loaded_meshes,
 				deferred_model_deferred_attributes.model.mesh,
 				deferred_model_deferred_attributes.render
 			)?;
-			let size=aabb.size();
 			Some(ModelDeferredAttributes{
 				mesh,
 				deferred_attributes:deferred_model_deferred_attributes.model.deferred_attributes,
 				color:deferred_model_deferred_attributes.model.color,
 				transform:Planar64Affine3::new(
 					Planar64Mat3::from_cols([
-						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().narrow_1().unwrap(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().narrow_1().unwrap(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/mesh_size.x).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/mesh_size.y).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/mesh_size.z).divide().narrow_1().unwrap(),
 					]),
 					deferred_model_deferred_attributes.model.transform.translation
 				),
@ -826,14 +825,13 @@ impl PartialMap1<'_>{
 		}).chain(self.deferred_unions_deferred_attributes.into_iter().flat_map(|deferred_union_deferred_attributes|{
 			//meshes need to be cloned from loaded_meshes with a new id when they are used with a new render_id
 			//insert into primitive_meshes
-			let (mesh,aabb)=acquire_union_id_from_render_config_id(
+			let MeshIdWithSize{mesh,size}=acquire_union_id_from_render_config_id(
 				unsafe{*aint_no_way.get()},
 				&mut union_id_from_render_config_id,
 				&loaded_meshes,
 				deferred_union_deferred_attributes.model.mesh,
 				deferred_union_deferred_attributes.render
 			)?;
-			let size=aabb.size();
 			Some(ModelDeferredAttributes{
 				mesh,
 				deferred_attributes:deferred_union_deferred_attributes.model.deferred_attributes,
--- a/lib/rbx_loader/src/union.rs
+++ b/lib/rbx_loader/src/union.rs
@ -1,4 +1,8 @@
-use rbx_mesh::mesh_data::{NormalId2 as MeshDataNormalId2,VertexId as MeshDataVertexId};
+use crate::loader::MeshWithSize;
+use crate::rbx::RobloxPartDescription;
+use crate::primitives::{CUBE_DEFAULT_VERTICES,CUBE_DEFAULT_POLYS};
+
+use rbx_mesh::mesh_data::{VertexId as MeshDataVertexId,NormalId2 as MeshDataNormalId2};
 use rbx_mesh::physics_data::VertexId as PhysicsDataVertexId;
 use strafesnet_common::model::{self,IndexedVertex,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId};
 use strafesnet_common::integer::vec3;
@ -57,10 +61,10 @@ pub fn convert(
 	roblox_physics_data:&[u8],
 	roblox_mesh_data:&[u8],
 	size:glam::Vec3,
-	crate::rbx::RobloxPartDescription(part_texture_description):crate::rbx::RobloxPartDescription,
-)->Result<model::Mesh,Error>{
+	RobloxPartDescription(part_texture_description):RobloxPartDescription,
+)->Result<MeshWithSize,Error>{
 	const NORMAL_FACES:usize=6;
-	let mut polygon_groups_normal_id=vec![Vec::new();NORMAL_FACES];
+	let mut polygon_groups_normal_id:[_;NORMAL_FACES]=[vec![],vec![],vec![],vec![],vec![],vec![]];

 	// build graphics and physics meshes
 	let mut mb=strafesnet_common::model::MeshBuilder::new();
@ -80,6 +84,15 @@ pub fn convert(
 			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL2(mesh_data2))=>mesh_data2.mesh,
 			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL4(mesh_data4))=>mesh_data4.mesh,
 		};
+		//autoscale to size, idk what roblox is doing with the graphics mesh size
+		let mut pos_min=glam::Vec3::MAX;
+		let mut pos_max=glam::Vec3::MIN;
+		for vertex in &graphics_mesh.vertices{
+			let p=vertex.pos.into();
+			pos_min=pos_min.min(p);
+			pos_max=pos_max.max(p);
+		}
+		let graphics_size=pos_max-pos_min;
 		for [MeshDataVertexId(vertex_id0),MeshDataVertexId(vertex_id1),MeshDataVertexId(vertex_id2)] in graphics_mesh.faces{
 			let face=[
 				graphics_mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
@ -89,7 +102,8 @@ pub fn convert(
 			let mut normal_agreement_checker=MeshDataNormalChecker::new();
 			let face=face.into_iter().map(|vertex|{
 				normal_agreement_checker.check(vertex.normal_id);
-				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?);
+				let pos=glam::Vec3::from_array(vertex.pos)/graphics_size;
+				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(pos.to_array())?);
 				let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?);
 				let tex_coord=glam::Vec2::from_array(vertex.tex);
 				let maybe_face_description=&cube_face_description[vertex.normal_id as usize-1];
@ -126,7 +140,11 @@ pub fn convert(
 	};

 	//physics
-	let physics_convex_meshes=if !roblox_physics_data.is_empty(){
+	let polygon_groups_normal_it=polygon_groups_normal_id.into_iter().map(|faces|
+		// graphics polygon groups (to be rendered)
+		Ok(PolygonGroup::PolygonList(PolygonList::new(faces)))
+	);
+	let polygon_groups:Vec<PolygonGroup>=if !roblox_physics_data.is_empty(){
 		let physics_data=rbx_mesh::read_physics_data_versioned(
 			std::io::Cursor::new(roblox_physics_data)
 		).map_err(Error::RobloxPhysicsData)?;
@ -140,39 +158,48 @@ pub fn convert(
 			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
 			=>vec![pim.mesh],
 		};
-		physics_convex_meshes
+		let physics_convex_meshes_it=physics_convex_meshes.into_iter().map(|mesh|{
+			// this can be factored out of the loop but I am lazy
+			let color=mb.acquire_color_id(glam::Vec4::ONE);
+			let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
+			// physics polygon groups (to do physics)
+			Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[PhysicsDataVertexId(vertex_id0),PhysicsDataVertexId(vertex_id1),PhysicsDataVertexId(vertex_id2)]|{
+				let face=[
+					mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
+					mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
+					mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
+				].map(|v|glam::Vec3::from_slice(v)/size);
+				let vertex_norm=(face[1]-face[0])
+				          .cross(face[2]-face[0]);
+				let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex_norm.to_array()).map_err(Error::Planar64Vec3)?);
+				face.into_iter().map(|vertex_pos|{
+					let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex_pos.to_array()).map_err(Error::Planar64Vec3)?);
+					Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
+				}).collect()
+			}).collect::<Result<_,_>>()?)))
+		});
+		polygon_groups_normal_it.chain(physics_convex_meshes_it).collect::<Result<_,_>>()?
 	}else{
-		Vec::new()
-	};
-	let polygon_groups:Vec<PolygonGroup>=polygon_groups_normal_id.into_iter().map(|faces|
-		// graphics polygon groups (to be rendered)
-		Ok(PolygonGroup::PolygonList(PolygonList::new(faces)))
-	).chain(physics_convex_meshes.into_iter().map(|mesh|{
-		// this can be factored out of the loop but I am lazy
-		let color=mb.acquire_color_id(glam::Vec4::ONE);
+		// generate a unit cube as default physics
+		let pos_list=CUBE_DEFAULT_VERTICES.map(|pos|mb.acquire_pos_id(pos>>1));
 		let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
-		// physics polygon groups (to do physics)
-		Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[PhysicsDataVertexId(vertex_id0),PhysicsDataVertexId(vertex_id1),PhysicsDataVertexId(vertex_id2)]|{
-			let face=[
-				mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
-				mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
-				mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
-			].map(|v|glam::Vec3::from_slice(v)/size);
-			let vertex_norm=(face[1]-face[0])
-			          .cross(face[2]-face[0]);
-			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex_norm.to_array()).map_err(Error::Planar64Vec3)?);
-			face.into_iter().map(|vertex_pos|{
-				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex_pos.to_array()).map_err(Error::Planar64Vec3)?);
-				Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
-			}).collect()
-		}).collect::<Result<_,_>>()?)))
-	})).collect::<Result<_,_>>()?;
+		let normal=mb.acquire_normal_id(vec3::ZERO);
+		let color=mb.acquire_color_id(glam::Vec4::ONE);
+		let polygon_group=PolygonGroup::PolygonList(PolygonList::new(CUBE_DEFAULT_POLYS.map(|poly|poly.map(|[pos_id,_]|
+			mb.acquire_vertex_id(IndexedVertex{pos:pos_list[pos_id as usize],tex,normal,color})
+		).to_vec()).to_vec()));
+		polygon_groups_normal_it.chain([Ok(polygon_group)]).collect::<Result<_,_>>()?
+	};
 	let physics_groups=(NORMAL_FACES..polygon_groups.len()).map(|id|model::IndexedPhysicsGroup{
 		groups:vec![PolygonGroupId::new(id as u32)]
 	}).collect();
-	Ok(mb.build(
+	let mesh=mb.build(
 		polygon_groups,
 		graphics_groups,
 		physics_groups,
-	))
+	);
+	Ok(MeshWithSize{
+		mesh,
+		size:vec3::ONE,
+	})
 }
--- a/lib/roblox_emulator/Cargo.toml
+++ b/lib/roblox_emulator/Cargo.toml
@ -8,14 +8,14 @@ description = "Run embedded Luau scripts which manipulate the DOM."
 authors = ["Rhys Lloyd <krakow20@gmail.com>"]

 [features]
-default=[]
+default=["run-service"]
 run-service=[]

 [dependencies]
 glam = "0.30.0"
 mlua = { version = "0.10.1", features = ["luau"] }
 phf = { version = "0.11.2", features = ["macros"] }
-rbx_dom_weak = { path = "../../../../git/rbx-dom/rbx_dom_weak", registry = "strafesnet" }
-rbx_reflection = { path = "../../../../git/rbx-dom/rbx_reflection" }
-rbx_reflection_database = { path = "../../../../git/rbx-dom/rbx_reflection_database" }
-rbx_types = { path = "../../../../git/rbx-dom/rbx_types" }
+rbx_dom_weak = { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
+rbx_reflection = "5.0.0"
+rbx_reflection_database = "1.0.0"
+rbx_types = "2.0.0"
--- a/lib/roblox_emulator/src/context.rs
+++ b/lib/roblox_emulator/src/context.rs
@ -1,4 +1,5 @@
-use rbx_dom_weak::{hstr,types::Ref,InstanceBuilder,WeakDom,UnhashedStr};
+use crate::util::static_ustr;
+use rbx_dom_weak::{types::Ref,InstanceBuilder,WeakDom};

 #[derive(Debug)]
 pub enum ServicesError{
@ -27,36 +28,36 @@ impl Services{
 	}
 }

-pub type LuaAppData=&'static mut WeakDom<'static>;
-pub struct Context<'a>{
-	pub(crate)dom:WeakDom<'a>,
+pub type LuaAppData=&'static mut WeakDom;
+pub struct Context{
+	pub(crate)dom:WeakDom,
 	pub(crate)services:Services,
 }

-impl<'a> Context<'a>{
-	pub fn from_place(dom:WeakDom<'a>)->Result<Context<'a>,ServicesError>{
+impl Context{
+	pub fn from_place(dom:WeakDom)->Result<Context,ServicesError>{
 		let services=Services::find_services(&dom)?;
 		Ok(Self{dom,services})
 	}
-	pub fn script_singleton(source:String)->(Context<'a>,crate::runner::instance::Instance){
-		let script=InstanceBuilder::new(hstr!("Script"))
-			.with_property(hstr!("Source"),rbx_types::Variant::String(source));
+	pub fn script_singleton(source:String)->(Context,crate::runner::instance::Instance){
+		let script=InstanceBuilder::new("Script")
+			.with_property("Source",rbx_types::Variant::String(source));
 		let script_ref=script.referent();
 		let dom=WeakDom::new(
-			InstanceBuilder::new(hstr!("DataModel"))
+			InstanceBuilder::new("DataModel")
 			.with_child(script)
 		);
 		let context=Self::from_model(dom);
 		(context,crate::runner::instance::Instance::new_unchecked(script_ref))
 	}
 	/// Creates an iterator over all items of a particular class.
-	pub fn superclass_iter<'b>(&'b self,superclass:&'b str)->impl Iterator<Item=Ref>+'b{
+	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
 		let db=rbx_reflection_database::get();
-		let Some(superclass)=db.classes.get(UnhashedStr::from_ref(superclass))else{
+		let Some(superclass)=db.classes.get(superclass)else{
 			panic!("Invalid class");
 		};
 		self.dom.descendants().filter_map(|instance|{
-			let class=db.classes.get(instance.class)?;
+			let class=db.classes.get(instance.class.as_str())?;
 			db.has_superclass(class,superclass).then(||instance.referent())
 		})
 	}
@ -64,7 +65,7 @@ impl<'a> Context<'a>{
 		self.superclass_iter("Script")
 			.filter_map(|script_ref|{
 				let script=self.dom.get_by_ref(script_ref)?;
-				if let None|Some(rbx_dom_weak::types::Variant::Bool(false))=script.properties.get(hstr!("Disabled")){
+				if let None|Some(rbx_dom_weak::types::Variant::Bool(false))=script.properties.get(&static_ustr("Disabled")){
 					return Some(crate::runner::instance::Instance::new_unchecked(script_ref));
 				}
 				None
@ -72,17 +73,17 @@ impl<'a> Context<'a>{
 			.collect()
 	}

-	pub fn from_model(mut dom:WeakDom<'a>)->Context<'a>{
+	pub fn from_model(mut dom:WeakDom)->Context{
 		//snapshot root instances
 		let children=dom.root().children().to_owned();

 		//insert services
 		let game=dom.root_ref();
-		let terrain_bldr=InstanceBuilder::new(hstr!("Terrain"));
+		let terrain_bldr=InstanceBuilder::new("Terrain");
 		let workspace=dom.insert(game,
-			InstanceBuilder::new(hstr!("Workspace"))
+			InstanceBuilder::new("Workspace")
 				//Set Workspace.Terrain property equal to Terrain
-				.with_property(hstr!("Terrain"),terrain_bldr.referent())
+				.with_property("Terrain",terrain_bldr.referent())
 				.with_child(terrain_bldr)
 		);

@ -95,18 +96,18 @@ impl<'a> Context<'a>{
 			//Lowercase and upper case workspace property!
 			let game=dom.root_mut();
 			// TODO: DELETE THIS!
-			game.properties.insert(hstr!("workspace"),rbx_types::Variant::Ref(workspace));
-			game.properties.insert(hstr!("Workspace"),rbx_types::Variant::Ref(workspace));
+			game.properties.insert(static_ustr("workspace"),rbx_types::Variant::Ref(workspace));
+			game.properties.insert(static_ustr("Workspace"),rbx_types::Variant::Ref(workspace));
 		}
-		dom.insert(game,InstanceBuilder::new(hstr!("Lighting")));
+		dom.insert(game,InstanceBuilder::new("Lighting"));

 		let services=Services{game,workspace};
 		Self{dom,services}
 	}
 }

-impl<'a> AsRef<WeakDom<'a>> for Context<'a>{
-	fn as_ref(&self)->&WeakDom<'a>{
+impl AsRef<WeakDom> for Context{
+	fn as_ref(&self)->&WeakDom{
 		&self.dom
 	}
 }
--- a/lib/roblox_emulator/src/lib.rs
+++ b/lib/roblox_emulator/src/lib.rs
@ -1,3 +1,4 @@
+mod util;
 pub mod runner;
 pub mod context;
 #[cfg(feature="run-service")]
--- a/lib/roblox_emulator/src/runner/enum.rs
+++ b/lib/roblox_emulator/src/runner/enum.rs
@ -1,13 +1,11 @@
-use rbx_dom_weak::{HashStr, UnhashedStr};
-
 #[derive(Clone,Copy)]
 pub struct EnumItem<'a>{
-	name:Option<&'a HashStr>,
+	name:Option<&'a str>,
 	value:u32,
 }
 impl<'a> EnumItem<'a>{
-	fn known_name((name,&value):(&&'a HashStr,&u32))->Self{
-		Self{name:Some(name),value}
+	fn known_name((name,&value):(&'a std::borrow::Cow<'a,str>,&u32))->Self{
+		Self{name:Some(name.as_ref()),value}
 	}
 }
 impl<'a> From<rbx_types::Enum> for EnumItem<'a>{
@ -40,7 +38,7 @@ pub struct Enums;
 impl Enums{
 	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
 		let db=rbx_reflection_database::get();
-		db.enums.get(UnhashedStr::from_ref(index)).map(|ed|EnumItems{ed})
+		db.enums.get(index).map(|ed|EnumItems{ed})
 	}
 }
 #[derive(Clone,Copy)]
@ -53,7 +51,7 @@ impl<'a> EnumItems<'a>{
 		self.ed.items.iter().find(|&(_,&v)|v==value).map(EnumItem::known_name)
 	}
 	pub fn from_name(&self,name:&str)->Option<EnumItem<'a>>{
-		self.ed.items.get_key_value(UnhashedStr::from_ref(name)).map(EnumItem::known_name)
+		self.ed.items.get_key_value(name).map(EnumItem::known_name)
 	}
 	pub fn from_enum(&self,enum_item:EnumItem)->Option<EnumItem<'a>>{
 		match enum_item.name{
@ -107,7 +105,7 @@ impl mlua::UserData for EnumItems<'static>{
 		});
 		methods.add_meta_function(mlua::MetaMethod::Index,|_,(this,val):(EnumItems,mlua::String)|{
 			let index=&*val.to_str()?;
-			Ok(this.ed.items.get_key_value(UnhashedStr::from_ref(index)).map(EnumItem::known_name))
+			Ok(this.ed.items.get_key_value(index).map(EnumItem::known_name))
 		});
 	}
 }
@ -126,7 +124,7 @@ type_from_lua_userdata!(Enums);

 impl mlua::UserData for EnumItem<'_>{
 	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("Name",|_,this|Ok(this.name.map(|s|s.as_str())));
+		fields.add_field_method_get("Name",|_,this|Ok(this.name));
 		fields.add_field_method_get("Value",|_,this|Ok(this.value));
 	}
 	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
--- a/lib/roblox_emulator/src/runner/instance/instance.rs
+++ b/lib/roblox_emulator/src/runner/instance/instance.rs
@ -2,8 +2,9 @@ use std::collections::{hash_map::Entry,HashMap};

 use mlua::{FromLua,FromLuaMulti,IntoLua,IntoLuaMulti};
 use rbx_types::Ref;
-use rbx_dom_weak::{hstr,HashStr,UnhashedStr,InstanceBuilder,WeakDom};
+use rbx_dom_weak::{Ustr,InstanceBuilder,WeakDom};

+use crate::util::static_ustr;
 use crate::runner::vector3::Vector3;
 use crate::runner::number::Number;

@ -37,7 +38,7 @@ pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>

 pub fn class_is_a(class:&str,superclass:&str)->bool{
 	let db=rbx_reflection_database::get();
-	let (Some(class),Some(superclass))=(db.classes.get(UnhashedStr::from_ref(class)),db.classes.get(UnhashedStr::from_ref(superclass)))else{
+	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
 		return false;
 	};
 	db.has_superclass(class,superclass)
@ -56,7 +57,7 @@ fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->S
 pub fn get_name_source(lua:&mlua::Lua,script:Instance)->Result<(String,String),mlua::Error>{
 	dom_mut(lua,|dom|{
 		let instance=script.get(dom)?;
-		let source=match instance.properties.get(hstr!("Source")){
+		let source=match instance.properties.get(&static_ustr("Source")){
 			Some(rbx_dom_weak::types::Variant::String(s))=>s.clone(),
 			_=>Err(mlua::Error::external("Missing script.Source"))?,
 		};
@ -64,32 +65,32 @@ pub fn get_name_source(lua:&mlua::Lua,script:Instance)->Result<(String,String),m
 	})
 }

-pub fn find_first_child<'a>(dom:&'a rbx_dom_weak::WeakDom<'a>,instance:&rbx_dom_weak::Instance<'a>,name:&str)->Option<&'a rbx_dom_weak::Instance<'a>>{
+pub fn find_first_child<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.name==name)
 }
-pub fn find_first_descendant<'a>(dom:&'a rbx_dom_weak::WeakDom<'a>,instance:&rbx_dom_weak::Instance<'a>,name:&str)->Option<&'a rbx_dom_weak::Instance<'a>>{
+pub fn find_first_descendant<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
 	dom.descendants_of(instance.referent()).find(|&inst|inst.name==name)
 }

-pub fn find_first_child_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom<'a>,instance:&rbx_dom_weak::Instance<'a>,class:&str)->Option<&'a rbx_dom_weak::Instance<'a>>{
+pub fn find_first_child_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.class==class)
 }
-pub fn find_first_descendant_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom<'a>,instance:&rbx_dom_weak::Instance<'a>,class:&str)->Option<&'a rbx_dom_weak::Instance<'a>>{
+pub fn find_first_descendant_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
 	dom.descendants_of(instance.referent()).find(|&inst|inst.class==class)
 }

-pub fn find_first_child_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom<'a>,instance:&rbx_dom_weak::Instance<'a>,superclass:&str)->Option<&'a rbx_dom_weak::Instance<'a>>{
+pub fn find_first_child_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
 	let db=rbx_reflection_database::get();
-	let superclass_descriptor=db.classes.get(UnhashedStr::from_ref(superclass))?;
+	let superclass_descriptor=db.classes.get(superclass)?;
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
-		db.classes.get(inst.class).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
+		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }
-pub fn find_first_descendant_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom<'a>,instance:&rbx_dom_weak::Instance<'a>,superclass:&str)->Option<&'a rbx_dom_weak::Instance<'a>>{
+pub fn find_first_descendant_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
 	let db=rbx_reflection_database::get();
-	let superclass_descriptor=db.classes.get(UnhashedStr::from_ref(superclass))?;
+	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
-		db.classes.get(inst.class).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
+		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }

@ -104,10 +105,10 @@ impl Instance{
 	pub fn new(referent:Ref)->Option<Self>{
 		referent.is_some().then_some(Self{referent})
 	}
-	pub fn get<'a>(&self,dom:&'a WeakDom<'a>)->mlua::Result<&'a rbx_dom_weak::Instance<'a>>{
+	pub fn get<'a>(&self,dom:&'a WeakDom)->mlua::Result<&'a rbx_dom_weak::Instance>{
 		dom.get_by_ref(self.referent).ok_or_else(||mlua::Error::runtime("Instance missing"))
 	}
-	pub fn get_mut<'a,'b>(&self,dom:&'a mut WeakDom<'b>)->mlua::Result<&'a mut rbx_dom_weak::Instance<'b>>{
+	pub fn get_mut<'a>(&self,dom:&'a mut WeakDom)->mlua::Result<&'a mut rbx_dom_weak::Instance>{
 		dom.get_by_ref_mut(self.referent).ok_or_else(||mlua::Error::runtime("Instance missing"))
 	}
 }
@ -149,7 +150,7 @@ impl mlua::UserData for Instance{
 		fields.add_field_method_get("ClassName",|lua,this|{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
-				Ok(instance.class.as_str().to_owned())
+				Ok(instance.class.to_owned())
 			})
 		});
 	}
@ -282,7 +283,7 @@ impl mlua::UserData for Instance{
 				let instance=this.get(dom)?;
 				//println!("__index t={} i={index:?}",instance.name);
 				let db=rbx_reflection_database::get();
-				let class=db.classes.get(instance.class).ok_or_else(||mlua::Error::runtime("Class missing"))?;
+				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				// Find existing property
 				// Interestingly, ustr can know ahead of time if
 				// a property does not exist in any runtime instance
@ -341,7 +342,7 @@ impl mlua::UserData for Instance{
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
 				let db=rbx_reflection_database::get();
-				let class=db.classes.get(instance.class).ok_or_else(||mlua::Error::runtime("Class missing"))?;
+				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				let property=db.superclasses_iter(class).find_map(|cls|
 					cls.properties.get(index_str)
 				).ok_or_else(||
@ -559,7 +560,7 @@ fn class_methods_store_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut ClassMethodsS
 /// A virtual property pointer definition shorthand.
 type VirtualPropertyFunctionPointer=fn(&rbx_types::Variant)->Option<rbx_types::Variant>;
 const fn vpp(
-	property:&'static HashStr,
+	property:&'static str,
 	pointer:VirtualPropertyFunctionPointer,
 )->VirtualProperty{
 	VirtualProperty{
@ -568,7 +569,7 @@ const fn vpp(
 	}
 }
 struct VirtualProperty{
-	property:&'static HashStr,// Source property name
+	property:&'static str,// Source property name
 	pointer:VirtualPropertyFunctionPointer,
 }
 type VPD=phf::Map<&'static str,// Class name
@ -576,10 +577,9 @@ type VPD=phf::Map<&'static str,// Class name
 		VirtualProperty
 	>
 >;
-static CFRAME:&HashStr=hstr!("CFrame");
 static VIRTUAL_PROPERTY_DATABASE:VPD=phf::phf_map!{
 	"BasePart"=>phf::phf_map!{
-		"Position"=>vpp(CFRAME,|c:&rbx_types::Variant|{
+		"Position"=>vpp("CFrame",|c:&rbx_types::Variant|{
 			let c=match c{
 				rbx_types::Variant::CFrame(c)=>c,
 				_=>return None,//fail silently and ungracefully
@ -590,7 +590,7 @@ static VIRTUAL_PROPERTY_DATABASE:VPD=phf::phf_map!{
 };

 fn find_virtual_property(
-	properties:&rbx_dom_weak::HashStrMap<rbx_types::Variant>,
+	properties:&rbx_dom_weak::UstrMap<rbx_types::Variant>,
 	class:&rbx_reflection::ClassDescriptor,
 	index:&str,
 )->Option<rbx_types::Variant>{
@ -599,7 +599,7 @@ fn find_virtual_property(
 	let virtual_property=class_virtual_properties.get(index)?;

 	//Get source property
-	let variant=properties.get(virtual_property.property)?;
+	let variant=properties.get(&static_ustr(virtual_property.property))?;

 	//Transform Source property with provided function
 	(virtual_property.pointer)(variant)
@ -641,15 +641,16 @@ static LAZY_USER_DATA:LUD=phf::phf_map!{
 fn get_or_create_userdata(instance:&mut rbx_dom_weak::Instance,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
 	use std::collections::hash_map::Entry;
 	let db=rbx_reflection_database::get();
-	let Some(class)=db.classes.get(instance.class)else{
+	let Some(class)=db.classes.get(instance.class.as_str())else{
 		return Ok(None)
 	};
-	if let Some((hstr,create_userdata))=db.superclasses_iter(class).find_map(|superclass|
+	if let Some((&static_str,create_userdata))=db.superclasses_iter(class).find_map(|superclass|
 		// find pair (class,index)
 		LAZY_USER_DATA.get(&superclass.name)
-		.and_then(|map|map.get(index)).map(|f|(superclass.name,f))
+		.and_then(|map|map.get_entry(index))
 	){
-		return Ok(Some(match instance.userdata.entry(hstr){
+		let index_ustr=static_ustr(static_str);
+		return Ok(Some(match instance.userdata.entry(index_ustr){
 			Entry::Occupied(entry)=>entry.get().clone(),
 			Entry::Vacant(entry)=>entry.insert(create_userdata(lua)?).clone(),
 		}));
--- a/lib/roblox_emulator/src/runner/runner.rs
+++ b/lib/roblox_emulator/src/runner/runner.rs
@ -1,4 +1,5 @@
 use crate::context::Context;
+use crate::util::static_ustr;
 #[cfg(feature="run-service")]
 use crate::scheduler::scheduler_mut;

@ -58,7 +59,7 @@ impl Runner{
 		init(&runner.lua).map_err(Error::RustLua)?;
 		Ok(runner)
 	}
-	pub fn runnable_context<'a>(self,context:&'a mut Context<'a>)->Result<Runnable<'a>,Error>{
+	pub fn runnable_context<'a>(self,context:&'a mut Context)->Result<Runnable<'a>,Error>{
 		{
 			let globals=self.lua.globals();
 			globals.set("game",super::instance::Instance::new_unchecked(context.services.game)).map_err(Error::RustLua)?;
@ -67,7 +68,8 @@ impl Runner{
 		// SAFETY: This is not a &'static mut WeakDom,
 		// but as long as Runnable<'a> holds the lifetime of &'a mut Context
 		// it is a valid unique reference.
-		self.lua.set_app_data::<crate::context::LuaAppData>(unsafe{core::mem::transmute(&mut context.dom)});
+		let ptr=&mut context.dom as *mut rbx_dom_weak::WeakDom;
+		self.lua.set_app_data::<crate::context::LuaAppData>(unsafe{&mut*ptr});
 		#[cfg(feature="run-service")]
 		self.lua.set_app_data::<crate::scheduler::Scheduler>(crate::scheduler::Scheduler::default());
 		Ok(Runnable{
--- a/lib/roblox_emulator/src/util.rs
+++ b/lib/roblox_emulator/src/util.rs
@ -0,0 +1,3 @@
+pub fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
+	rbx_dom_weak::ustr(s)
+}
--- a/map-tool/Cargo.toml
+++ b/map-tool/Cargo.toml
@ -14,10 +14,10 @@ image = "0.25.2"
 image_dds = "0.7.1"
 lazy-regex = "3.1.0"
 rbx_asset = { version = "0.4.4", registry = "strafesnet" }
-rbx_binary  = { path = "../../../git/rbx-dom/rbx_binary", registry = "strafesnet" }
-rbx_dom_weak =  { path = "../../../git/rbx-dom/rbx_dom_weak", registry = "strafesnet" }
-rbx_reflection_database = { path = "../../../git/rbx-dom/rbx_reflection_database"}
-rbx_xml = { path = "../../../git/rbx-dom/rbx_xml", registry = "strafesnet" }
+rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet" }
+rbx_reflection_database = "1.0.0"
+rbx_xml = { version = "1.1.0-sn4", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_bsp_loader = { version = "0.3.0", path = "../lib/bsp_loader", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.0", path = "../lib/deferred_loader", registry = "strafesnet" }
Author	SHA1	Message	Date
Quaternions	d0f7799448	debug	2025-05-14 18:16:07 -07:00
Quaternions	81c9e3470b	physics: use Bounds	2025-05-14 18:15:26 -07:00
Quaternions	b45e02c487	integer: export Parity trait	2025-05-14 17:26:41 -07:00
Quaternions	8698ca4a7e	integer: time bitshift operations	2025-05-14 17:26:41 -07:00
Quaternions	8f04953326	physics: simplify face crawler trait bound	2025-05-14 16:52:51 -07:00
Quaternions	ae81d8ceaf	derive Debug for many structs	2025-05-14 16:52:51 -07:00
Quaternions	2ecaeb1615	physics: test_collision_small_mv	2025-05-14 13:51:14 -07:00
Quaternions	768cd4ad1a	physics: deref can be coerced	2025-05-13 17:26:10 -07:00
Quaternions	708462441a	physics: clean up PhysicsMesh generation	2025-05-13 16:08:51 -07:00
Quaternions	da3ab52fe0	physics: do not require complete_mesh as first submesh This removes a silent assumption about the input meshes and moves the branching from submeshes() to complete_mesh()	2025-05-13 15:45:30 -07:00
Quaternions	20f3e79cde	rbx_loader: anything that uses velocity property should not be a booster	2025-05-09 20:56:42 -07:00
Quaternions	217f7fd7c3	physics: recalculate acceleration in collision_{start\|end}_intersect	2025-05-09 20:56:42 -07:00
Quaternions	1e4d98f386	physics: use scratch vector in vert_edges	2025-05-09 20:56:42 -07:00
Quaternions	71bce361e6	rbx_loader: default meshpart mesh to empty string	2025-05-08 16:02:22 -07:00
Quaternions	d36c184f7e	rbx_loader: auto-scale union graphics to fit size	2025-05-08 15:33:37 -07:00
Quaternions	2c3f257f0e	rbx_loader: move mesh size detection into mesh convert	2025-05-08 15:33:37 -07:00
Quaternions	9e7e115809	deferred_loader: load generic mesh	2025-05-08 15:31:32 -07:00
Quaternions	2ea60b07fe	rbx_loader: default physics for unions	2025-05-08 15:31:32 -07:00
Quaternions	2fe884175e	rbx_loader: export primitive cube info	2025-05-07 15:57:19 -07:00
Quaternions	9f570d0f3e	rbx_loader: prepare union convert for default physics	2025-05-07 15:57:19 -07:00