fixed

.cargo/config.toml

@@ -1,2 +0,0 @@
-[registries.strafesnet]
-index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"

Cargo.lock

@@ -402,7 +402,7 @@ dependencies = [
 
 [[package]]
 name = "roblox_emulator"
-version = "0.4.7"
+version = "0.4.1"
 dependencies = [
  "glam",
  "mlua",

Cargo.toml

@@ -1,16 +1,12 @@
 [package]
 name = "roblox_emulator"
-version = "0.4.7"
+version = "0.4.1"
 edition = "2021"
 repository = "https://git.itzana.me/StrafesNET/roblox_emulator"
 license = "MIT OR Apache-2.0"
 description = "Run embedded Luau scripts which manipulate the DOM."
 authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
-[features]
-default=["run-service"]
-run-service=[]
-
 [dependencies]
 glam = "0.29.0"
 mlua = { version = "0.10.0-beta", features = ["luau"] }

src/context.rs

@@ -60,19 +60,10 @@ impl Context{
 
 		//insert services
 		let game=self.dom.root_ref();
-		let terrain_bldr=InstanceBuilder::new("Terrain");
 		let workspace=self.dom.insert(game,
 			InstanceBuilder::new("Workspace")
-				//Set Workspace.Terrain property equal to Terrain
-				.with_property("Terrain",terrain_bldr.referent())
-				.with_child(terrain_bldr)
+			.with_child(InstanceBuilder::new("Terrain"))
 		);
-		{
-			//Lowercase and upper case workspace property!
-			let game=self.dom.root_mut();
-			game.properties.insert("workspace".to_owned(),rbx_types::Variant::Ref(workspace));
-			game.properties.insert("Workspace".to_owned(),rbx_types::Variant::Ref(workspace));
-		}
 		self.dom.insert(game,InstanceBuilder::new("Lighting"));
 
 		//transfer original root instances into workspace

src/lib.rs

@@ -1,7 +1,5 @@
 pub mod runner;
 pub mod context;
-#[cfg(feature="run-service")]
-pub(crate) mod scheduler;
 
 #[cfg(test)]
 mod tests;

src/runner/color_sequence.rs

@@ -1,31 +0,0 @@
-#[derive(Clone,Copy)]
-pub struct ColorSequence{}
-impl ColorSequence{
-	pub const fn new()->Self{
-		Self{}
-	}
-}
-impl Into<rbx_types::ColorSequence> for ColorSequence{
-	fn into(self)->rbx_types::ColorSequence{
-		rbx_types::ColorSequence{
-			keypoints:Vec::new()
-		}
-	}
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let number_sequence_table=lua.create_table()?;
-
-	number_sequence_table.raw_set("new",
-		lua.create_function(|_,_:mlua::MultiValue|
-			Ok(ColorSequence::new())
-		)?
-	)?;
-
-	globals.set("ColorSequence",number_sequence_table)?;
-
-	Ok(())
-}
-
-impl mlua::UserData for ColorSequence{}
-type_from_lua_userdata!(ColorSequence);

src/runner/instance.rs

@@ -0,0 +1,411 @@
+use std::collections::{hash_map::Entry,HashMap};
+
+use mlua::{FromLuaMulti,IntoLua,IntoLuaMulti};
+use rbx_types::Ref;
+use rbx_dom_weak::{InstanceBuilder,WeakDom};
+
+use super::vector3::Vector3;
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	//class functions store
+	lua.set_app_data(ClassFunctions::default());
+
+	lua.register_userdata_type(<Instance as mlua::UserData>::register)?;
+
+	let instance_table=lua.create_table()?;
+
+	//Instance.new
+	instance_table.raw_set("new",
+		lua.create_function(|lua,(class_name,parent):(mlua::String,Option<Instance>)|{
+			let class_name_str=&*class_name.to_str()?;
+			let parent=parent.ok_or(mlua::Error::runtime("Nil Parent not yet supported"))?;
+			dom_mut(lua,|dom|{
+				//TODO: Nil instances
+				Ok(Instance::new(dom.insert(parent.referent,InstanceBuilder::new(class_name_str))))
+			})
+		})?
+	)?;
+
+	globals.set("Instance",instance_table)?;
+
+	Ok(())
+}
+
+// LMAO look at this function!
+fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>)->mlua::Result<T>{
+	let mut dom=lua.app_data_mut::<&'static mut WeakDom>().ok_or(mlua::Error::runtime("DataModel missing"))?;
+	f(&mut *dom)
+}
+fn class_functions_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut ClassFunctions)->mlua::Result<T>)->mlua::Result<T>{
+	let mut cf=lua.app_data_mut::<ClassFunctions>().ok_or(mlua::Error::runtime("ClassFunctions missing"))?;
+	f(&mut *cf)
+}
+
+fn coerce_float32(value:&mlua::Value)->Option<f32>{
+	match value{
+		&mlua::Value::Integer(i)=>Some(i as f32),
+		&mlua::Value::Number(f)=>Some(f as f32),
+		_=>None,
+	}
+}
+
+fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->String{
+	let mut full_name=instance.name.clone();
+	let mut pref=instance.parent();
+	while let Some(parent)=dom.get_by_ref(pref){
+		full_name.insert(0,'.');
+		full_name.insert_str(0,parent.name.as_str());
+		pref=parent.parent();
+	}
+	full_name
+}
+//helper function for script
+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("Source"){
+			Some(rbx_dom_weak::types::Variant::String(s))=>s.clone(),
+			_=>Err(mlua::Error::external("Missing script.Source"))?,
+		};
+		Ok((get_full_name(dom,instance),source))
+	})
+}
+
+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,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,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,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
+	dom.descendants_of(instance.referent()).find(|&inst|inst.class==class)
+}
+
+#[derive(Clone,Copy)]
+pub struct Instance{
+	referent:Ref,
+}
+impl Instance{
+	pub const fn new(referent:Ref)->Self{
+		Self{referent}
+	}
+	pub fn get<'a>(&self,dom:&'a WeakDom)->mlua::Result<&'a rbx_dom_weak::Instance>{
+		dom.get_by_ref(self.referent).ok_or(mlua::Error::runtime("Instance missing"))
+	}
+	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(mlua::Error::runtime("Instance missing"))
+	}
+}
+type_from_lua_userdata!(Instance);
+
+//TODO: update rbx_reflection and use dom.superclasses_iter
+pub struct SuperClassIter<'a> {
+    database: &'a rbx_reflection::ReflectionDatabase<'a>,
+    descriptor: Option<&'a rbx_reflection::ClassDescriptor<'a>>,
+}
+impl<'a> SuperClassIter<'a> {
+    fn next_descriptor(&self) -> Option<&'a rbx_reflection::ClassDescriptor<'a>> {
+        let superclass = self.descriptor?.superclass.as_ref()?;
+        self.database.classes.get(superclass)
+    }
+}
+impl<'a> Iterator for SuperClassIter<'a> {
+    type Item = &'a rbx_reflection::ClassDescriptor<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let next_descriptor = self.next_descriptor();
+        std::mem::replace(&mut self.descriptor, next_descriptor)
+    }
+}
+
+impl mlua::UserData for Instance{
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
+		fields.add_field_method_get("Parent",|lua,this|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(Instance::new(instance.parent()))
+			})
+		});
+		fields.add_field_method_set("Parent",|lua,this,val:Option<Instance>|{
+			let parent=val.ok_or(mlua::Error::runtime("Nil Parent not yet supported"))?;
+			dom_mut(lua,|dom|{
+				dom.transfer_within(this.referent,parent.referent);
+				Ok(())
+			})
+		});
+		fields.add_field_method_get("Name",|lua,this|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(instance.name.clone())
+			})
+		});
+		fields.add_field_method_set("Name",|lua,this,val:mlua::String|{
+			dom_mut(lua,|dom|{
+				let instance=this.get_mut(dom)?;
+				//Why does this need to be cloned?
+				instance.name=val.to_str()?.to_owned();
+				Ok(())
+			})
+		});
+		fields.add_field_method_get("ClassName",|lua,this|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(instance.class.clone())
+			})
+		});
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_method("GetChildren",|lua,this,_:()|
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				let children:Vec<_>=instance
+					.children()
+					.iter()
+					.copied()
+					.map(Instance::new)
+					.collect();
+				Ok(children)
+			})
+		);
+		fn ffc(lua:&mlua::Lua,this:&Instance,(name,search_descendants):(mlua::String,Option<bool>))->mlua::Result<Option<Instance>>{
+			let name_str=&*name.to_str()?;
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(
+					match search_descendants.unwrap_or(false){
+						true=>find_first_descendant(dom,instance,name_str),
+						false=>find_first_child(dom,instance,name_str),
+					}
+					.map(|instance|
+						Instance::new(instance.referent())
+					)
+				)
+			})
+		}
+		methods.add_method("FindFirstChild",ffc);
+		methods.add_method("WaitForChild",ffc);
+		methods.add_method("FindFirstChildOfClass",|lua,this,(class,search_descendants):(mlua::String,Option<bool>)|{
+			let class_str=&*class.to_str()?;
+			dom_mut(lua,|dom|{
+				Ok(
+					match search_descendants.unwrap_or(false){
+						true=>find_first_descendant_of_class(dom,this.get(dom)?,class_str),
+						false=>find_first_child_of_class(dom,this.get(dom)?,class_str),
+					}
+					.map(|instance|
+						Instance::new(instance.referent())
+					)
+				)
+			})
+		});
+		methods.add_method("GetDescendants",|lua,this,_:()|
+			dom_mut(lua,|dom|{
+				let children:Vec<_>=dom
+					.descendants_of(this.referent)
+					.map(|instance|
+						Instance::new(instance.referent())
+					)
+					.collect();
+				Ok(children)
+			})
+		);
+		methods.add_method("IsA",|lua,this,classname:mlua::String|
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(crate::context::class_is_a(instance.class.as_str(),&*classname.to_str()?))
+			})
+		);
+		methods.add_method("Destroy",|lua,this,()|
+			dom_mut(lua,|dom|{
+				dom.destroy(this.referent);
+				Ok(())
+			})
+		);
+		methods.add_meta_function(mlua::MetaMethod::ToString,|lua,this:Instance|{
+			dom_mut(lua,|dom|{
+				let instance=this.get(dom)?;
+				Ok(instance.name.clone())
+			})
+		});
+		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(this,index):(Instance,mlua::String)|{
+			let index_str=&*index.to_str()?;
+			dom_mut(lua,|dom|{
+				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.as_str()).ok_or(mlua::Error::runtime("Class missing"))?;
+				//Find existing property
+				match instance.properties.get(index_str)
+					//Find default value
+					.or_else(||db.find_default_property(class,index_str))
+				{
+					Some(&rbx_types::Variant::Int32(val))=>return Ok(val.into_lua(lua)),
+					Some(&rbx_types::Variant::Int64(val))=>return Ok(val.into_lua(lua)),
+					Some(&rbx_types::Variant::Float32(val))=>return Ok(val.into_lua(lua)),
+					Some(&rbx_types::Variant::Float64(val))=>return Ok(val.into_lua(lua)),
+					Some(&rbx_types::Variant::CFrame(cf))=>return Ok(Into::<super::cframe::CFrame>::into(cf).into_lua(lua)),
+					Some(&rbx_types::Variant::Vector3(v))=>return Ok(Into::<super::vector3::Vector3>::into(v).into_lua(lua)),
+					other=>println!("instance.properties.get(i)={other:?}"),
+				}
+				//find a function with a matching name
+				if let Some(function)=class_functions_mut(lua,|cf|{
+					let mut iter=SuperClassIter{
+						database:db,
+						descriptor:Some(class),
+					};
+					Ok(loop{
+						match iter.next(){
+							Some(class)=>match cf.get_or_create_class_function(lua,&class.name,index_str)?{
+								Some(function)=>break Some(function),
+								None=>(),
+							},
+							None=>break None,
+						}
+					})
+				})?{
+					return Ok(function.into_lua(lua));
+				}
+				//find a child with a matching name
+				Ok(
+					find_first_child(dom,instance,index_str)
+					.map(|instance|Instance::new(instance.referent()))
+					.into_lua(lua)
+				)
+			})
+		});
+		methods.add_meta_function(mlua::MetaMethod::NewIndex,|lua,(this,index,value):(Instance,mlua::String,mlua::Value)|{
+			dom_mut(lua,|dom|{
+				let instance=this.get_mut(dom)?;
+				//println!("__newindex t={} i={index:?} v={value:?}",instance.name);
+				let index_str=&*index.to_str()?;
+				let db=rbx_reflection_database::get();
+				let class=db.classes.get(instance.class.as_str()).ok_or(mlua::Error::runtime("Class missing"))?;
+				let mut iter=SuperClassIter{
+					database:db,
+					descriptor:Some(class),
+				};
+				let property=iter.find_map(|cls|cls.properties.get(index_str)).ok_or(mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name)))?;
+				match &property.data_type{
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Vector3)=>{
+						let typed_value:Vector3=value.as_userdata().ok_or(mlua::Error::runtime("Expected Userdata"))?.take()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Vector3(typed_value.into()));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Float32)=>{
+						let typed_value:f32=coerce_float32(&value).ok_or(mlua::Error::runtime("Expected f32"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Float32(typed_value));
+					},
+					rbx_reflection::DataType::Enum(enum_name)=>{
+						let typed_value=match &value{
+							&mlua::Value::Integer(int)=>Ok(rbx_types::Enum::from_u32(int as u32)),
+							&mlua::Value::Number(num)=>Ok(rbx_types::Enum::from_u32(num as u32)),
+							mlua::Value::String(s)=>{
+								let e=db.enums.get(enum_name).ok_or(mlua::Error::runtime("Database DataType Enum name  does not exist"))?;
+								Ok(rbx_types::Enum::from_u32(*e.items.get(&*s.to_str()?).ok_or(mlua::Error::runtime("Invalid enum item"))?))
+							},
+							mlua::Value::UserData(any_user_data)=>{
+								let e:super::r#enum::Enum=any_user_data.take()?;
+								Ok(e.into())
+							},
+							_=>Err(mlua::Error::runtime("Expected Enum")),
+						}?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Enum(typed_value));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Color3)=>{
+						let typed_value:super::color3::Color3=value.as_userdata().ok_or(mlua::Error::runtime("Expected Color3"))?.take()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Color3(typed_value.into()));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Bool)=>{
+						let typed_value=value.as_boolean().ok_or(mlua::Error::runtime("Expected boolean"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Bool(typed_value));
+					},
+					rbx_reflection::DataType::Value(rbx_types::VariantType::String)=>{
+						let typed_value=value.as_str().ok_or(mlua::Error::runtime("Expected boolean"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::String(typed_value.to_owned()));
+					},
+					other=>return Err(mlua::Error::runtime(format!("Unimplemented property type: {other:?}"))),
+				}
+				Ok(())
+			})
+		});
+	}
+}
+
+fn get_service(lua:&mlua::Lua,tuple:mlua::MultiValue)->mlua::Result<mlua::MultiValue>{
+	let (_game,service):(Instance,mlua::String)=FromLuaMulti::from_lua_multi(tuple,lua)?;
+	dom_mut(lua,|dom|{
+		match &*service.to_str()?{
+			"Lighting"=>{
+				let referent=find_first_child_of_class(dom,dom.root(),"Lighting")
+        				.map(|instance|instance.referent())
+				.unwrap_or_else(||
+					dom.insert(dom.root_ref(),InstanceBuilder::new("Lighting"))
+				);
+				Instance::new(referent).into_lua_multi(lua)
+			},
+			other=>Err::<mlua::MultiValue,_>(mlua::Error::runtime(format!("Service '{other}' not supported"))),
+		}
+	})
+}
+type FPointer=fn(&mlua::Lua,mlua::MultiValue)->mlua::Result<mlua::MultiValue>;
+/// A double hash map of function pointers.
+/// The class tree is walked by the Instance.__index metamethod to find available class methods.
+static CLASS_FUNCTION_DATABASE:phf::Map<&str,phf::Map<&str,FPointer>>=phf::phf_map!{
+	"DataModel"=>phf::phf_map!{
+		"GetService"=>get_service as FPointer,
+	}
+};
+
+/// A store of created functions for each Roblox class.
+/// Functions are created the first time they are accessed and stored in this data structure.
+#[derive(Default)]
+struct ClassFunctions{
+	classes:HashMap<&'static str,//ClassName
+		HashMap<&'static str,//Function name
+			mlua::Function
+		>
+	>
+}
+impl ClassFunctions{
+	/// Someone please rewrite this, all it's supposed to do is
+	/// return self.classes[class][index] or create the function in the hashmap and then return it
+	fn get_or_create_class_function(&mut self,lua:&mlua::Lua,class:&str,index:&str)->mlua::Result<Option<mlua::Function>>{
+		// Use get_entry to get the &'static str key of the database
+		// and use it as a key for the classes hashmap
+		let f=match CLASS_FUNCTION_DATABASE.get_entry(class){
+			Some((&static_class_str,class_functions))=>{
+				match self.classes.entry(static_class_str){
+					Entry::Occupied(mut occupied_entry)=>{
+						match class_functions.get_entry(index){
+							Some((&static_index_str,function_pointer))=>{
+								match occupied_entry.get_mut().entry(static_index_str){
+									Entry::Occupied(occupied_entry)=>{
+										Some(occupied_entry.get().clone())
+									},
+									Entry::Vacant(vacant_entry)=>{
+										Some(vacant_entry.insert(lua.create_function(function_pointer)?).clone())
+									},
+								}
+							},
+							None=>None,
+						}
+					},
+					Entry::Vacant(vacant_entry)=>{
+						match class_functions.get_entry(index){
+							Some((&static_index_str,function_pointer))=>{
+								let mut h=HashMap::new();
+								h.entry(static_index_str).or_insert(lua.create_function(function_pointer)?);
+								vacant_entry.insert(h).get(static_index_str).map(|f|f.clone())
+							},
+							None=>None,
+						}
+					},
+				}
+			},
+			None=>None,
+		};
+		Ok(f)
+	}
+}

src/runner/instance/instance.rs

@@ -1,557 +0,0 @@
-use std::collections::{hash_map::Entry,HashMap};
-
-use mlua::{FromLua,FromLuaMulti,IntoLua,IntoLuaMulti};
-use rbx_types::Ref;
-use rbx_dom_weak::{InstanceBuilder,WeakDom};
-
-use crate::runner::vector3::Vector3;
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	//class functions store
-	lua.set_app_data(ClassMethodsStore::default());
-	lua.set_app_data(InstanceValueStore::default());
-
-	let instance_table=lua.create_table()?;
-
-	//Instance.new
-	instance_table.raw_set("new",
-		lua.create_function(|lua,(class_name,parent):(mlua::String,Option<Instance>)|{
-			let class_name_str=&*class_name.to_str()?;
-			let parent=parent.ok_or_else(||mlua::Error::runtime("Nil Parent not yet supported"))?;
-			dom_mut(lua,|dom|{
-				//TODO: Nil instances
-				Ok(Instance::new(dom.insert(parent.referent,InstanceBuilder::new(class_name_str))))
-			})
-		})?
-	)?;
-
-	globals.set("Instance",instance_table)?;
-
-	Ok(())
-}
-
-// LMAO look at this function!
-pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>)->mlua::Result<T>{
-	let mut dom=lua.app_data_mut::<&'static mut WeakDom>().ok_or_else(||mlua::Error::runtime("DataModel missing"))?;
-	f(&mut *dom)
-}
-
-fn coerce_float32(value:&mlua::Value)->Option<f32>{
-	match value{
-		&mlua::Value::Integer(i)=>Some(i as f32),
-		&mlua::Value::Number(f)=>Some(f as f32),
-		_=>None,
-	}
-}
-
-fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->String{
-	let mut full_name=instance.name.clone();
-	let mut pref=instance.parent();
-	while let Some(parent)=dom.get_by_ref(pref){
-		full_name.insert(0,'.');
-		full_name.insert_str(0,parent.name.as_str());
-		pref=parent.parent();
-	}
-	full_name
-}
-//helper function for script
-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("Source"){
-			Some(rbx_dom_weak::types::Variant::String(s))=>s.clone(),
-			_=>Err(mlua::Error::external("Missing script.Source"))?,
-		};
-		Ok((get_full_name(dom,instance),source))
-	})
-}
-
-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,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,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,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
-	dom.descendants_of(instance.referent()).find(|&inst|inst.class==class)
-}
-
-#[derive(Clone,Copy)]
-pub struct Instance{
-	referent:Ref,
-}
-impl Instance{
-	pub const fn new(referent:Ref)->Self{
-		Self{referent}
-	}
-	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>(&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"))
-	}
-}
-type_from_lua_userdata!(Instance);
-
-//TODO: update rbx_reflection and use dom.superclasses_iter
-pub struct SuperClassIter<'a> {
-    database: &'a rbx_reflection::ReflectionDatabase<'a>,
-    descriptor: Option<&'a rbx_reflection::ClassDescriptor<'a>>,
-}
-impl<'a> SuperClassIter<'a> {
-    fn next_descriptor(&self) -> Option<&'a rbx_reflection::ClassDescriptor<'a>> {
-        let superclass = self.descriptor?.superclass.as_ref()?;
-        self.database.classes.get(superclass)
-    }
-}
-impl<'a> Iterator for SuperClassIter<'a> {
-    type Item = &'a rbx_reflection::ClassDescriptor<'a>;
-    fn next(&mut self) -> Option<Self::Item> {
-        let next_descriptor = self.next_descriptor();
-        std::mem::replace(&mut self.descriptor, next_descriptor)
-    }
-}
-
-impl mlua::UserData for Instance{
-	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("Parent",|lua,this|{
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(Instance::new(instance.parent()))
-			})
-		});
-		fields.add_field_method_set("Parent",|lua,this,val:Option<Instance>|{
-			let parent=val.ok_or_else(||mlua::Error::runtime("Nil Parent not yet supported"))?;
-			dom_mut(lua,|dom|{
-				dom.transfer_within(this.referent,parent.referent);
-				Ok(())
-			})
-		});
-		fields.add_field_method_get("Name",|lua,this|{
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(instance.name.clone())
-			})
-		});
-		fields.add_field_method_set("Name",|lua,this,val:mlua::String|{
-			dom_mut(lua,|dom|{
-				let instance=this.get_mut(dom)?;
-				//Why does this need to be cloned?
-				instance.name=val.to_str()?.to_owned();
-				Ok(())
-			})
-		});
-		fields.add_field_method_get("ClassName",|lua,this|{
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(instance.class.clone())
-			})
-		});
-	}
-	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_method("GetChildren",|lua,this,_:()|
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				let children:Vec<_>=instance
-					.children()
-					.iter()
-					.copied()
-					.map(Instance::new)
-					.collect();
-				Ok(children)
-			})
-		);
-		fn ffc(lua:&mlua::Lua,this:&Instance,(name,search_descendants):(mlua::String,Option<bool>))->mlua::Result<Option<Instance>>{
-			let name_str=&*name.to_str()?;
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(
-					match search_descendants.unwrap_or(false){
-						true=>find_first_descendant(dom,instance,name_str),
-						false=>find_first_child(dom,instance,name_str),
-					}
-					.map(|instance|
-						Instance::new(instance.referent())
-					)
-				)
-			})
-		}
-		methods.add_method("FindFirstChild",ffc);
-		methods.add_method("WaitForChild",ffc);
-		methods.add_method("FindFirstChildOfClass",|lua,this,(class,search_descendants):(mlua::String,Option<bool>)|{
-			let class_str=&*class.to_str()?;
-			dom_mut(lua,|dom|{
-				Ok(
-					match search_descendants.unwrap_or(false){
-						true=>find_first_descendant_of_class(dom,this.get(dom)?,class_str),
-						false=>find_first_child_of_class(dom,this.get(dom)?,class_str),
-					}
-					.map(|instance|
-						Instance::new(instance.referent())
-					)
-				)
-			})
-		});
-		methods.add_method("GetDescendants",|lua,this,_:()|
-			dom_mut(lua,|dom|{
-				let children:Vec<_>=dom
-					.descendants_of(this.referent)
-					.map(|instance|
-						Instance::new(instance.referent())
-					)
-					.collect();
-				Ok(children)
-			})
-		);
-		methods.add_method("IsA",|lua,this,classname:mlua::String|
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(crate::context::class_is_a(instance.class.as_str(),&*classname.to_str()?))
-			})
-		);
-		methods.add_method("Destroy",|lua,this,()|
-			dom_mut(lua,|dom|{
-				dom.destroy(this.referent);
-				Ok(())
-			})
-		);
-		methods.add_meta_function(mlua::MetaMethod::ToString,|lua,this:Instance|{
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(instance.name.clone())
-			})
-		});
-		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(this,index):(Instance,mlua::String)|{
-			let index_str=&*index.to_str()?;
-			dom_mut(lua,|dom|{
-				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.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
-				//Find existing property
-				match instance.properties.get(index_str)
-					.cloned()
-					//Find default value
-					.or_else(||db.find_default_property(class,index_str).cloned())
-					//Find virtual property
-					.or_else(||{
-						SuperClassIter{
-							database:db,
-							descriptor:Some(class),
-						}
-						.find_map(|class|
-							find_virtual_property(&instance.properties,class,index_str)
-						)
-					})
-				{
-					Some(rbx_types::Variant::Int32(val))=>return val.into_lua(lua),
-					Some(rbx_types::Variant::Int64(val))=>return val.into_lua(lua),
-					Some(rbx_types::Variant::Float32(val))=>return val.into_lua(lua),
-					Some(rbx_types::Variant::Float64(val))=>return val.into_lua(lua),
-					Some(rbx_types::Variant::Ref(val))=>return Instance::new(val).into_lua(lua),
-					Some(rbx_types::Variant::CFrame(cf))=>return Into::<crate::runner::cframe::CFrame>::into(cf).into_lua(lua),
-					Some(rbx_types::Variant::Vector3(v))=>return Into::<crate::runner::vector3::Vector3>::into(v).into_lua(lua),
-					None=>(),
-					other=>return Err(mlua::Error::runtime(format!("Instance.__index Unsupported property type instance={} index={index_str} value={other:?}",instance.name))),
-				}
-				//find a function with a matching name
-				if let Some(function)=class_methods_store_mut(lua,|cf|{
-					let mut iter=SuperClassIter{
-						database:db,
-						descriptor:Some(class),
-					};
-					iter.find_map(|class|{
-						let mut class_methods=cf.get_or_create_class_methods(&class.name)?;
-						class_methods.get_or_create_function(lua,index_str)
-							.transpose()
-					}).transpose()
-				})?{
-					return function.into_lua(lua);
-				}
-
-				//find or create an associated userdata object
-				if let Some(value)=instance_value_store_mut(lua,|ivs|{
-					//TODO: walk class tree somehow
-					match ivs.get_or_create_instance_values(&instance){
-						Some(mut instance_values)=>instance_values.get_or_create_value(lua,index_str),
-						None=>Ok(None)
-					}
-				})?{
-					return value.into_lua(lua);
-				}
-				//find a child with a matching name
-				find_first_child(dom,instance,index_str)
-				.map(|instance|Instance::new(instance.referent()))
-				.into_lua(lua)
-			})
-		});
-		methods.add_meta_function(mlua::MetaMethod::NewIndex,|lua,(this,index,value):(Instance,mlua::String,mlua::Value)|{
-			dom_mut(lua,|dom|{
-				let instance=this.get_mut(dom)?;
-				//println!("__newindex t={} i={index:?} v={value:?}",instance.name);
-				let index_str=&*index.to_str()?;
-				let db=rbx_reflection_database::get();
-				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
-				let mut iter=SuperClassIter{
-					database:db,
-					descriptor:Some(class),
-				};
-				let property=iter.find_map(|cls|cls.properties.get(index_str)).ok_or_else(||mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name)))?;
-				match &property.data_type{
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Vector3)=>{
-						let typed_value:Vector3=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Userdata"))?.borrow()?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Vector3(typed_value.into()));
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Float32)=>{
-						let typed_value:f32=coerce_float32(&value).ok_or_else(||mlua::Error::runtime("Expected f32"))?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Float32(typed_value));
-					},
-					rbx_reflection::DataType::Enum(enum_name)=>{
-						let typed_value=match &value{
-							&mlua::Value::Integer(int)=>Ok(rbx_types::Enum::from_u32(int as u32)),
-							&mlua::Value::Number(num)=>Ok(rbx_types::Enum::from_u32(num as u32)),
-							mlua::Value::String(s)=>{
-								let e=db.enums.get(enum_name).ok_or_else(||mlua::Error::runtime("Database DataType Enum name  does not exist"))?;
-								Ok(rbx_types::Enum::from_u32(*e.items.get(&*s.to_str()?).ok_or_else(||mlua::Error::runtime("Invalid enum item"))?))
-							},
-							mlua::Value::UserData(any_user_data)=>{
-								let e:crate::runner::r#enum::Enum=*any_user_data.borrow()?;
-								Ok(e.into())
-							},
-							_=>Err(mlua::Error::runtime("Expected Enum")),
-						}?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Enum(typed_value));
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Color3)=>{
-						let typed_value:crate::runner::color3::Color3=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Color3"))?.borrow()?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Color3(typed_value.into()));
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Bool)=>{
-						let typed_value=value.as_boolean().ok_or_else(||mlua::Error::runtime("Expected boolean"))?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Bool(typed_value));
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::String)=>{
-						let typed_value=value.as_str().ok_or_else(||mlua::Error::runtime("Expected boolean"))?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::String(typed_value.to_owned()));
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::NumberSequence)=>{
-						let typed_value:crate::runner::number_sequence::NumberSequence=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected NumberSequence"))?.borrow()?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::NumberSequence(typed_value.into()));
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::ColorSequence)=>{
-						let typed_value:crate::runner::color_sequence::ColorSequence=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected ColorSequence"))?.borrow()?;
-						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::ColorSequence(typed_value.into()));
-					},
-					other=>return Err(mlua::Error::runtime(format!("Unimplemented property type: {other:?}"))),
-				}
-				Ok(())
-			})
-		});
-	}
-}
-
-/// A class function definition shorthand.
-macro_rules! cf{
-	($f:expr)=>{
-		|lua,mut args|{
-			let this=Instance::from_lua(args.pop_front().unwrap_or(mlua::Value::Nil),lua)?;
-			$f(lua,this,FromLuaMulti::from_lua_multi(args,lua)?)?.into_lua_multi(lua)
-		}
-	};
-}
-type ClassFunctionPointer=fn(&mlua::Lua,mlua::MultiValue)->mlua::Result<mlua::MultiValue>;
-// TODO: use macros to define these with better organization
-/// A double hash map of function pointers.
-/// The class tree is walked by the Instance.__index metamethod to find available class methods.
-type CFD=phf::Map<&'static str,// Class name
-	phf::Map<&'static str,// Method name
-		ClassFunctionPointer
-	>
->;
-static CLASS_FUNCTION_DATABASE:CFD=phf::phf_map!{
-	"DataModel"=>phf::phf_map!{
-		"GetService"=>cf!(|lua,_this,service:mlua::String|{
-			dom_mut(lua,|dom|{
-				//dom.root_ref()==this.referent ?
-				let service=&*service.to_str()?;
-				match service{
-					"Lighting"|"RunService"=>{
-						let referent=find_first_child_of_class(dom,dom.root(),service)
-        				.map(|instance|instance.referent())
-						.unwrap_or_else(||
-							dom.insert(dom.root_ref(),InstanceBuilder::new(service))
-						);
-						Ok(Instance::new(referent))
-					},
-					other=>Err::<Instance,_>(mlua::Error::runtime(format!("Service '{other}' not supported"))),
-				}
-			})
-		}),
-	},
-	"Terrain"=>phf::phf_map!{
-		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Vector3,crate::runner::r#enum::Enum)|mlua::Result::Ok(()))
-	},
-};
-
-/// A store of created functions for each Roblox class.
-/// Functions are created the first time they are accessed and stored in this data structure.
-#[derive(Default)]
-struct ClassMethodsStore{
-	classes:HashMap<&'static str,//ClassName
-		HashMap<&'static str,//Method name
-			mlua::Function
-		>
-	>
-}
-impl ClassMethodsStore{
-	/// return self.classes[class] or create the ClassMethods and then return it
-	fn get_or_create_class_methods(&mut self,class:&str)->Option<ClassMethods>{
-		// Use get_entry to get the &'static str keys of the database
-		// and use it as a key for the classes hashmap
-		CLASS_FUNCTION_DATABASE.get_entry(class)
-			.map(|(&static_class_str,method_pointers)|
-				ClassMethods{
-					method_pointers,
-					methods:self.classes.entry(static_class_str)
-					.or_insert_with(||HashMap::new()),
-				}
-			)
-	}
-}
-struct ClassMethods<'a>{
-	method_pointers:&'static phf::Map<&'static str,ClassFunctionPointer>,
-	methods:&'a mut HashMap<&'static str,mlua::Function>,
-}
-impl ClassMethods<'_>{
-	/// return self.methods[index] or create the function in the hashmap and then return it
-	fn get_or_create_function(&mut self,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::Function>>{
-		Ok(match self.method_pointers.get_entry(index){
-			Some((&static_index_str,&function_pointer))=>Some(
-				match self.methods.entry(static_index_str){
-					Entry::Occupied(entry)=>entry.get().clone(),
-					Entry::Vacant(entry)=>entry.insert(
-						lua.create_function(function_pointer)?
-					).clone(),
-				}
-			),
-			None=>None,
-		})
-	}
-}
-fn class_methods_store_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut ClassMethodsStore)->mlua::Result<T>)->mlua::Result<T>{
-	let mut cf=lua.app_data_mut::<ClassMethodsStore>().ok_or_else(||mlua::Error::runtime("ClassMethodsStore missing"))?;
-	f(&mut *cf)
-}
-
-/// A virtual property pointer definition shorthand.
-type VirtualPropertyFunctionPointer=fn(&rbx_types::Variant)->Option<rbx_types::Variant>;
-const fn vpp(
-	property:&'static str,
-	pointer:VirtualPropertyFunctionPointer,
-)->VirtualProperty{
-	VirtualProperty{
-		property,
-		pointer,
-	}
-}
-struct VirtualProperty{
-	property:&'static str,// Source property name
-	pointer:VirtualPropertyFunctionPointer,
-}
-type VPD=phf::Map<&'static str,// Class name
-	phf::Map<&'static str,// Virtual property name
-		VirtualProperty
-	>
->;
-static VIRTUAL_PROPERTY_DATABASE:VPD=phf::phf_map!{
-	"BasePart"=>phf::phf_map!{
-		"Position"=>vpp("CFrame",|c:&rbx_types::Variant|{
-			let c=match c{
-				rbx_types::Variant::CFrame(c)=>c,
-				_=>return None,//fail silently and ungracefully
-			};
-			Some(rbx_types::Variant::Vector3(c.position))
-		}),
-	},
-};
-
-fn find_virtual_property(
-	properties:&HashMap<String,rbx_types::Variant>,
-	class:&rbx_reflection::ClassDescriptor,
-	index:&str
-)->Option<rbx_types::Variant>{
-	//Find virtual property
-	let class_virtual_properties=VIRTUAL_PROPERTY_DATABASE.get(&class.name)?;
-	let virtual_property=class_virtual_properties.get(index)?;
-
-	//Get source property
-	let variant=properties.get(virtual_property.property)?;
-
-	//Transform Source property with provided function
-	(virtual_property.pointer)(variant)
-}
-
-// lazy-loaded per-instance userdata values
-// This whole thing is a bad idea and a garbage collection nightmare.
-// TODO: recreate rbx_dom_weak with my own instance type that owns this data.
-type CreateUserData=fn(&mlua::Lua)->mlua::Result<mlua::AnyUserData>;
-type LUD=phf::Map<&'static str,// Class name
-	phf::Map<&'static str,// Value name
-		CreateUserData
-	>
->;
-static LAZY_USER_DATA:LUD=phf::phf_map!{
-	"RunService"=>phf::phf_map!{
-		"RenderStepped"=>|lua|{
-			lua.create_any_userdata(crate::runner::script_signal::ScriptSignal::new())
-		},
-	},
-};
-#[derive(Default)]
-pub struct InstanceValueStore{
-	values:HashMap<Ref,
-		HashMap<&'static str,
-			mlua::AnyUserData
-		>
-	>,
-}
-pub struct InstanceValues<'a>{
-	named_values:&'static phf::Map<&'static str,CreateUserData>,
-	values:&'a mut HashMap<&'static str,mlua::AnyUserData>,
-}
-impl InstanceValueStore{
-	pub fn get_or_create_instance_values(&mut self,instance:&rbx_dom_weak::Instance)->Option<InstanceValues>{
-		LAZY_USER_DATA.get(instance.class.as_str())
-			.map(|named_values|
-				InstanceValues{
-					named_values,
-					values:self.values.entry(instance.referent())
-					.or_insert_with(||HashMap::new()),
-				}
-			)
-	}
-}
-impl InstanceValues<'_>{
-	pub fn get_or_create_value(&mut self,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
-		Ok(match self.named_values.get_entry(index){
-			Some((&static_index_str,&function_pointer))=>Some(
-				match self.values.entry(static_index_str){
-					Entry::Occupied(entry)=>entry.get().clone(),
-					Entry::Vacant(entry)=>entry.insert(
-						function_pointer(lua)?
-					).clone(),
-				}
-			),
-			None=>None,
-		})
-	}
-}
-
-pub fn instance_value_store_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut InstanceValueStore)->mlua::Result<T>)->mlua::Result<T>{
-	let mut cf=lua.app_data_mut::<InstanceValueStore>().ok_or_else(||mlua::Error::runtime("InstanceValueStore missing"))?;
-	f(&mut *cf)
-}

src/runner/instance/mod.rs

@@ -1,2 +0,0 @@
-pub mod instance;
-pub use instance::Instance;

src/runner/mod.rs

@@ -7,8 +7,5 @@ mod color3;
 mod cframe;
 mod vector3;
 pub mod instance;
-mod script_signal;
-mod color_sequence;
-mod number_sequence;
 
-pub use runner::{Runner,Runnable,Error};
+pub use runner::{Runner,Error};

src/runner/number_sequence.rs

@@ -1,31 +0,0 @@
-#[derive(Clone,Copy)]
-pub struct NumberSequence{}
-impl NumberSequence{
-	pub const fn new()->Self{
-		Self{}
-	}
-}
-impl Into<rbx_types::NumberSequence> for NumberSequence{
-	fn into(self)->rbx_types::NumberSequence{
-		rbx_types::NumberSequence{
-			keypoints:Vec::new()
-		}
-	}
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let number_sequence_table=lua.create_table()?;
-
-	number_sequence_table.raw_set("new",
-		lua.create_function(|_,_:mlua::MultiValue|
-			Ok(NumberSequence::new())
-		)?
-	)?;
-
-	globals.set("NumberSequence",number_sequence_table)?;
-
-	Ok(())
-}
-
-impl mlua::UserData for NumberSequence{}
-type_from_lua_userdata!(NumberSequence);

src/runner/runner.rs

@@ -1,6 +1,4 @@
 use crate::context::Context;
-#[cfg(feature="run-service")]
-use crate::scheduler::scheduler_mut;
 
 pub struct Runner{
 	lua:mlua::Lua,
@@ -31,16 +29,11 @@ fn init(lua:&mlua::Lua)->mlua::Result<()>{
 	//global environment
 	let globals=lua.globals();
 
-	#[cfg(feature="run-service")]
-	crate::scheduler::set_globals(lua,&globals)?;
-	super::script_signal::set_globals(lua,&globals)?;
 	super::r#enum::set_globals(lua,&globals)?;
 	super::color3::set_globals(lua,&globals)?;
 	super::vector3::set_globals(lua,&globals)?;
 	super::cframe::set_globals(lua,&globals)?;
-	super::instance::instance::set_globals(lua,&globals)?;
-	super::number_sequence::set_globals(lua,&globals)?;
-	super::color_sequence::set_globals(lua,&globals)?;
+	super::instance::set_globals(lua,&globals)?;
 
 	Ok(())
 }
@@ -65,8 +58,6 @@ impl Runner{
 		}
 		//this makes set_app_data shut up about the lifetime
 		self.lua.set_app_data::<&'static mut rbx_dom_weak::WeakDom>(unsafe{core::mem::transmute(&mut context.dom)});
-		#[cfg(feature="run-service")]
-		self.lua.set_app_data::<crate::scheduler::Scheduler>(crate::scheduler::Scheduler::default());
 		Ok(Runnable{
 			lua:self.lua,
 			_lifetime:&std::marker::PhantomData
@@ -82,62 +73,15 @@ pub struct Runnable<'a>{
 impl Runnable<'_>{
 	pub fn drop_context(self)->Runner{
 		self.lua.remove_app_data::<&'static mut rbx_dom_weak::WeakDom>();
-		#[cfg(feature="run-service")]
-		self.lua.remove_app_data::<crate::scheduler::Scheduler>();
 		Runner{
 			lua:self.lua,
 		}
 	}
 	pub fn run_script(&self,script:super::instance::Instance)->Result<(),Error>{
-		let (name,source)=super::instance::instance::get_name_source(&self.lua,script).map_err(Error::RustLua)?;
-		self.lua.globals().raw_set("script",script).map_err(Error::RustLua)?;
-		let f=self.lua.load(source.as_str())
-		.set_name(name).into_function().map_err(Error::RustLua)?;
-		// TODO: set_environment without losing the ability to print from Lua
-		let thread=self.lua.create_thread(f).map_err(Error::RustLua)?;
-		thread.resume::<mlua::MultiValue>(()).map_err(|error|Error::Lua{source,error})?;
-		// wait() is called from inside Lua and goes to a rust function that schedules the thread and then yields
-		// No need to schedule the thread here
-		Ok(())
-	}
-	#[cfg(feature="run-service")]
-	pub fn has_scheduled_threads(&self)->Result<bool,mlua::Error>{
-		scheduler_mut(&self.lua,|scheduler|
-			Ok(scheduler.has_scheduled_threads())
-		)
-	}
-	#[cfg(feature="run-service")]
-	pub fn game_tick(&self)->Result<(),mlua::Error>{
-		if let Some(threads)=scheduler_mut(&self.lua,|scheduler|Ok(scheduler.tick_threads()))?{
-			for thread in threads{
-				//TODO: return dt and total run time
-				let result=thread.resume::<mlua::MultiValue>((1.0/30.0,0.0))
-					.map_err(|error|Error::Lua{source:"source unavailable".to_owned(),error});
-				match result{
-					Ok(_)=>(),
-					Err(e)=>println!("game_tick Error: {e}"),
-				}
-			}
-		}
-		Ok(())
-	}
-	#[cfg(feature="run-service")]
-	pub fn run_service_step(&self)->Result<(),mlua::Error>{
-		let render_stepped=super::instance::instance::dom_mut(&self.lua,|dom|{
-			let run_service=super::instance::instance::find_first_child_of_class(dom,dom.root(),"RunService").ok_or_else(||mlua::Error::runtime("RunService missing"))?;
-			super::instance::instance::instance_value_store_mut(&self.lua,|instance_value_store|{
-				//unwrap because I trust my find_first_child_of_class function to
-				let mut instance_values=instance_value_store.get_or_create_instance_values(run_service).ok_or_else(||mlua::Error::runtime("RunService InstanceValues missing"))?;
-				let render_stepped=instance_values.get_or_create_value(&self.lua,"RenderStepped")?;
-				//let stepped=instance_values.get_or_create_value(&self.lua,"Stepped")?;
-				//let heartbeat=instance_values.get_or_create_value(&self.lua,"Heartbeat")?;
-				Ok(render_stepped)
-			})
-		})?;
-		if let Some(render_stepped)=render_stepped{
-			let signal:&super::script_signal::ScriptSignal=&*render_stepped.borrow()?;
-			signal.fire(&mlua::MultiValue::new());
-		}
-		Ok(())
+		let (name,source)=super::instance::get_name_source(&self.lua,script).map_err(Error::RustLua)?;
+		self.lua.globals().set("script",script).map_err(Error::RustLua)?;
+		self.lua.load(source.as_str())
+		.set_name(name)
+		.exec().map_err(|error|Error::Lua{source,error})
 	}
 }

src/runner/script_signal.rs

@@ -1,172 +0,0 @@
-use std::{cell::RefCell,rc::Rc};
-
-use mlua::UserDataFields;
-
-#[derive(Clone)]
-struct FunctionList{
-	functions:Vec<mlua::Function>,
-}
-impl FunctionList{
-	pub fn new()->Self{
-		Self{
-			functions:Vec::new(),
-		}
-	}
-	// This eats the Lua error
-	pub fn fire(self,args:&mlua::MultiValue){
-		// Make a copy of the list in case Lua attempts to modify it during the loop
-		for function in self.functions{
-			//wee let's allocate for our function calls
-			if let Err(e)=function.call::<mlua::MultiValue>(args.clone()){
-				println!("Script Signal Error: {e}");
-			}
-		}
-	}
-}
-#[derive(Clone)]
-struct RcFunctionList{
-	functions:Rc<RefCell<FunctionList>>,
-}
-impl RcFunctionList{
-	pub fn new()->Self{
-		Self{
-			functions:Rc::new(RefCell::new(FunctionList::new())),
-		}
-	}
-	pub fn fire(&self,args:&mlua::MultiValue){
-		// Make a copy of the list in case Lua attempts to modify it during the loop
-		self.functions.borrow().clone().fire(args)
-	}
-}
-#[derive(Clone)]
-pub struct ScriptSignal{
-	// Emulate the garbage roblox api.
-	// ScriptConnection should not exist.
-	// :Disconnect should be a method on ScriptSignal, and this would be avoided entirely.
-	connections:RcFunctionList,
-	once:RcFunctionList,
-	wait:Rc<RefCell<Vec<mlua::Thread>>>,
-}
-pub struct ScriptConnection{
-	connection:RcFunctionList,
-	function:mlua::Function,
-}
-impl ScriptSignal{
-	pub fn new()->Self{
-		Self{
-			connections:RcFunctionList::new(),
-			once:RcFunctionList::new(),
-			wait:Rc::new(RefCell::new(Vec::new())),
-		}
-	}
-	pub fn fire(&self,args:&mlua::MultiValue){
-		self.connections.fire(args);
-		//Replace the FunctionList with an empty one and drop the borrow
-		let once=std::mem::replace(&mut *self.once.functions.borrow_mut(),FunctionList::new());
-		once.fire(args);
-		//resume threads waiting for this signal
-		let threads=std::mem::replace(&mut *self.wait.borrow_mut(),Vec::new());
-		for thread in threads{
-			if let Err(e)=thread.resume::<mlua::MultiValue>(args.clone()){
-				println!("Script Signal thread resume Error: {e}");
-			}
-		}
-	}
-	pub fn connect(&self,function:mlua::Function)->ScriptConnection{
-		self.connections.functions.borrow_mut().functions.push(function.clone());
-		ScriptConnection{
-			connection:self.connections.clone(),
-			function,
-		}
-	}
-	pub fn once(&self,function:mlua::Function)->ScriptConnection{
-		self.once.functions.borrow_mut().functions.push(function.clone());
-		ScriptConnection{
-			connection:self.once.clone(),
-			function,
-		}
-	}
-	pub fn wait(&self,thread:mlua::Thread){
-		self.wait.borrow_mut().push(thread);
-	}
-}
-impl ScriptConnection{
-	pub fn position(&self)->Option<usize>{
-		self.connection.functions.borrow().functions.iter().position(|function|function==&self.function)
-	}
-}
-
-impl mlua::UserData for ScriptSignal{
-	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_method("Connect",|_lua,this,f:mlua::Function|
-			Ok(this.connect(f))
-		);
-		methods.add_method("Once",|_lua,this,f:mlua::Function|
-			Ok(this.once(f))
-		);
-		// Fire is not allowed to be called from Lua
-		// methods.add_method("Fire",|_lua,this,args:mlua::MultiValue|
-		// 	Ok(this.fire(args))
-		// );
-	}
-}
-impl mlua::FromLua for ScriptSignal{
-	fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
-		match value{
-			mlua::Value::UserData(ud)=>Ok(ud.borrow::<Self>()?.clone()),
-			other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!(ScriptSignal),other))),
-		}
-	}
-}
-
-impl mlua::UserData for ScriptConnection{
-	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("Connected",|_,this|{
-			Ok(this.position().is_some())
-		});
-	}
-	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_method("Disconnect",|_,this,_:()|{
-			if let Some(index)=this.position(){
-				this.connection.functions.borrow_mut().functions.remove(index);
-			}
-			Ok(())
-		});
-	}
-}
-
-fn wait_thread(lua:&mlua::Lua,this:ScriptSignal)->Result<(),mlua::Error>{
-	Ok(this.wait(lua.current_thread()))
-}
-
-// This is used to avoid calling coroutine.yield from the rust side.
-const LUA_WAIT:&str=
-"local coroutine_yield=coroutine.yield
-local wait_thread=wait_thread
-return function(signal)
-	wait_thread(signal)
-	return coroutine_yield()
-end";
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let coroutine_table=globals.get::<mlua::Table>("coroutine")?;
-	let wait_thread=lua.create_function(wait_thread)?;
-
-	//create wait function environment
-	let wait_env=lua.create_table()?;
-	wait_env.raw_set("coroutine",coroutine_table)?;
-	wait_env.raw_set("wait_thread",wait_thread)?;
-
-	//construct wait function from Lua code
-	let wait=lua.load(LUA_WAIT)
-	.set_name("wait")
-	.set_environment(wait_env)
-	.call::<mlua::Function>(())?;
-
-	lua.register_userdata_type::<ScriptSignal>(|reg|{
-		reg.add_field("Wait",wait);
-		mlua::UserData::register(reg);
-	})?;
-
-	Ok(())
-}

src/scheduler.rs

@@ -1,106 +0,0 @@
-pub use tick::Tick;
-mod tick{
-	#[derive(Clone,Copy,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
-	pub struct Tick(u64);
-	impl std::ops::Add<u64> for Tick{
-		type Output=Self;
-		fn add(self,rhs:u64)->Self::Output{
-			Self(self.0+rhs)
-		}
-	}
-	impl std::ops::Sub<u64> for Tick{
-		type Output=Self;
-		fn sub(self,rhs:u64)->Self::Output{
-			Self(self.0-rhs)
-		}
-	}
-	impl std::ops::AddAssign<u64> for Tick{
-		fn add_assign(&mut self,rhs:u64){
-			self.0+=rhs;
-		}
-	}
-	impl std::ops::SubAssign<u64> for Tick{
-		fn sub_assign(&mut self,rhs:u64){
-			self.0-=rhs;
-		}
-	}
-}
-#[derive(Default)]
-pub struct Scheduler{
-	tick:Tick,
-	schedule:std::collections::HashMap<Tick,Vec<mlua::Thread>>,
-}
-
-impl Scheduler{
-	pub fn has_scheduled_threads(&self)->bool{
-		!self.schedule.is_empty()
-	}
-	pub fn schedule_thread(&mut self,delay:u64,thread:mlua::Thread){
-		self.schedule.entry(self.tick+delay.max(1))
-		.or_insert(Vec::new())
-		.push(thread);
-	}
-	pub fn tick_threads(&mut self)->Option<Vec<mlua::Thread>>{
-		self.tick+=1;
-		self.schedule.remove(&self.tick)
-	}
-}
-
-pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut crate::scheduler::Scheduler)->mlua::Result<T>)->mlua::Result<T>{
-	let mut scheduler=lua.app_data_mut::<crate::scheduler::Scheduler>().ok_or_else(||mlua::Error::runtime("Scheduler missing"))?;
-	f(&mut *scheduler)
-}
-
-fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
-	let delay=match dt{
-		mlua::Value::Integer(i)=>i.max(0) as u64*60,
-		mlua::Value::Number(f)=>{
-			let delay=f.max(0.0)*60.0;
-			match delay.classify(){
-				std::num::FpCategory::Nan=>Err(mlua::Error::runtime("NaN"))?,
-				// cases where the number is too large to schedule
-				std::num::FpCategory::Infinite=>return Ok(()),
-				std::num::FpCategory::Normal=>if (u64::MAX as f64)<delay{
-					return Ok(());
-				},
-				_=>(),
-			}
-			delay as u64
-		},
-		mlua::Value::Nil=>0,
-		_=>Err(mlua::Error::runtime("Expected float"))?,
-	};
-	scheduler_mut(lua,|scheduler|{
-		scheduler.schedule_thread(delay.max(2),lua.current_thread());
-		Ok(())
-	})
-}
-
-// This is used to avoid calling coroutine.yield from the rust side.
-const LUA_WAIT:&str=
-"local coroutine_yield=coroutine.yield
-local schedule_thread=schedule_thread
-return function(dt)
-	schedule_thread(dt)
-	return coroutine_yield()
-end";
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let coroutine_table=globals.get::<mlua::Table>("coroutine")?;
-	let schedule_thread=lua.create_function(schedule_thread)?;
-
-	//create wait function environment
-	let wait_env=lua.create_table()?;
-	wait_env.raw_set("coroutine",coroutine_table)?;
-	wait_env.raw_set("schedule_thread",schedule_thread)?;
-
-	//construct wait function from Lua code
-	let wait=lua.load(LUA_WAIT)
-	.set_name("wait")
-	.set_environment(wait_env)
-	.call::<mlua::Function>(())?;
-
-	globals.raw_set("wait",wait)?;
-
-	Ok(())
-}