Index: binaries/data/mods/public/gui/pregame/MainMenuPage.js
===================================================================
--- binaries/data/mods/public/gui/pregame/MainMenuPage.js
+++ binaries/data/mods/public/gui/pregame/MainMenuPage.js
@@ -9,6 +9,46 @@
 		this.menuHandler = new MainMenuItemHandler(mainMenuItems);
 		this.splashScreenHandler = new SplashScreenHandler(data, hotloadData && hotloadData.splashScreenHandler);
 
+		let toto = Engine.GetGUIObjectByName("mainMenuPage");
+		let doText = (caption, size) => ({
+			"@type": "text",
+			"@size": size,
+			"@style": "ModernLabelText",
+			"@caption": caption,
+		});
+		let added = toto.createChild({
+			"@type": "image",
+			"@size": "200 200 500 500",
+			"@style": "ModernDialog",
+			"@z": 200,
+			"object": [
+				doText("turlututu", "0 0 200 200"),
+				{
+					"@type": "text",
+					"@size": "0 200 200 400",
+					"@style": "ModernLabelText",
+					"@caption": "ChapoPointu",
+					"object": {
+						"@type": "image",
+						"@size": "600 300 100% 600+40",
+						"@style": "ModernDialog",
+						"@z": 250,
+					}
+				}]
+		});
+		added.deleteChild(added.children[0]);
+
+		toto.createChild({
+			"script": {
+				"@file": "not_a_file.js",
+			},
+		});
+
+
+		toto.createChild({
+			"script": "warn('Hey you')",
+		});
+
 		new MusicHandler();
 		new ProjectInformationHandler(projectInformation);
 		new CommunityButtonHandler(communityButtons);
Index: source/gui/CGUI.h
===================================================================
--- source/gui/CGUI.h
+++ source/gui/CGUI.h
@@ -251,6 +251,18 @@
 
 	shared_ptr<ScriptInterface> GetScriptInterface() { return m_ScriptInterface; };
 
+	/**
+	 * The CGUI creates the object and adds it as a child to parent.
+	 * To the created object, this is the same as being created on page open (same events, etc.)
+	 */
+	IGUIObject* CreateChild(const XMBFile& file, const XMBElement& element, IGUIObject* parent);
+
+	/**
+	 * Detach the object from its parent and delete it.
+	 * The object must have a parent - use PopPage to delete the root page object.
+	 */
+	void DetachAndDeleteChild(IGUIObject* child);
+
 private:
 	/**
 	 * The CGUI takes ownership of the child object and links the parent with the child.
@@ -358,7 +370,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths);
+	void Xeromyces_ReadRootObjects(const XMBFile& file, XMBElement element, std::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the root element \<sprites\> (the DOMElement).
@@ -369,7 +381,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadRootSprites(const XMBFile& file, XMBElement element);
 
 	/**
 	 * Reads in the root element \<styles\> (the DOMElement).
@@ -380,7 +392,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadRootStyles(const XMBFile& file, XMBElement element);
 
 	/**
 	 * Reads in the root element \<setup\> (the DOMElement).
@@ -391,7 +403,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadRootSetup(const XMBFile& file, XMBElement element);
 
 	// Read Subs
 
@@ -417,7 +429,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
+	IGUIObject* Xeromyces_ReadObject(const XMBFile& file, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<repeat\>, which repeats its child \<object\>s
@@ -425,7 +437,7 @@
 	 * 'var' enclosed in square brackets) in its descendants' names with "[0]",
 	 * "[1]", etc.
 	 */
-	void Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
+	void Xeromyces_ReadRepeat(const XMBFile& file, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth);
 
 	/**
 	 * Reads in the element \<script\> (the XMBElement) and executes
@@ -438,7 +450,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths);
+	void Xeromyces_ReadScript(const XMBFile& file, XMBElement element, std::unordered_set<VfsPath>& Paths);
 
 	/**
 	 * Reads in the element \<sprite\> (the XMBElement) and stores the
@@ -450,7 +462,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadSprite(const XMBFile& file, XMBElement element);
 
 	/**
 	 * Reads in the element \<image\> (the XMBElement) and stores the
@@ -463,7 +475,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent);
+	void Xeromyces_ReadImage(const XMBFile& file, XMBElement element, CGUISprite& parent);
 
 	/**
 	 * Reads in the element \<effect\> (the XMBElement) and stores the
@@ -476,7 +488,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects);
+	void Xeromyces_ReadEffects(const XMBFile& file, XMBElement element, SGUIImageEffects& effects);
 
 	/**
 	 * Reads in the element \<style\> (the XMBElement) and stores the
@@ -488,7 +500,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadStyle(const XMBFile& file, XMBElement element);
 
 	/**
 	 * Reads in the element \<scrollbar\> (the XMBElement) and stores the
@@ -500,7 +512,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadScrollBarStyle(const XMBFile& file, XMBElement element);
 
 	/**
 	 * Reads in the element \<icon\> (the XMBElement) and stores the
@@ -512,7 +524,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadIcon(const XMBFile& file, XMBElement element);
 
 	/**
 	 * Reads in the element \<tooltip\> (the XMBElement) and stores the
@@ -524,7 +536,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadTooltip(const XMBFile& file, XMBElement element);
 
 	/**
 	 * Reads in the element \<color\> (the XMBElement) and stores the
@@ -536,7 +548,7 @@
 	 *
 	 * @see LoadXmlFile()
 	 */
-	void Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile);
+	void Xeromyces_ReadColor(const XMBFile& file, XMBElement element);
 
 	//@}
 
Index: source/gui/CGUI.cpp
===================================================================
--- source/gui/CGUI.cpp
+++ source/gui/CGUI.cpp
@@ -371,6 +371,37 @@
 	return (*it->second)(*this);
 }
 
+
+IGUIObject* CGUI::CreateChild(const XMBFile& file, const XMBElement& element, IGUIObject* parent)
+{
+	std::unordered_set<VfsPath> paths;
+	std::vector<std::pair<CStr, CStr>> nameSubst;
+	IGUIObject* child = Xeromyces_ReadObject(file, element, parent, nameSubst, paths, 0);
+	if (!child)
+		return nullptr;
+
+	child->RecurseObject(nullptr, &IGUIObject::UpdateCachedSize);
+	SGUIMessage msg(GUIM_LOAD);
+	child->RecurseObject(nullptr, &IGUIObject::HandleMessage, msg);
+	child->ScriptEvent(EventNameLoad);
+
+	return child;
+}
+
+void CGUI::DetachAndDeleteChild(IGUIObject* child)
+{
+	if (!child)
+		return;
+	if (!child->m_pParent)
+	{
+		LOGERROR("Cannot delete the root object of a page");
+		return;
+	}
+	child->m_pParent->RemoveChild(child);
+	m_pAllObjects.erase(child->m_Name);
+	delete child;
+}
+
 bool CGUI::AddObject(IGUIObject& parent, IGUIObject& child)
 {
 	if (child.m_Name.empty())
@@ -386,7 +417,7 @@
 	}
 
 	m_pAllObjects[child.m_Name] = &child;
-	parent.AddChild(child);
+	parent.AddChild(&child);
 	return true;
 }
 
@@ -527,21 +558,21 @@
 {
 	Paths.insert(Filename);
 
-	CXeromyces XeroFile;
-	if (XeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
+	CXeromyces xeroFile;
+	if (xeroFile.Load(g_VFS, Filename, "gui") != PSRETURN_OK)
 		return;
 
-	XMBElement node = XeroFile.GetRoot();
-	CStr root_name(XeroFile.GetElementString(node.GetNodeName()));
+	XMBElement node = xeroFile.GetRoot();
+	CStr root_name(xeroFile.GetElementString(node.GetNodeName()));
 
 	if (root_name == "objects")
-		Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
+		Xeromyces_ReadRootObjects(xeroFile, node, Paths);
 	else if (root_name == "sprites")
-		Xeromyces_ReadRootSprites(node, &XeroFile);
+		Xeromyces_ReadRootSprites(xeroFile, node);
 	else if (root_name == "styles")
-		Xeromyces_ReadRootStyles(node, &XeroFile);
+		Xeromyces_ReadRootStyles(xeroFile, node);
 	else if (root_name == "setup")
-		Xeromyces_ReadRootSetup(node, &XeroFile);
+		Xeromyces_ReadRootSetup(xeroFile, node);
 	else
 		LOGERROR("CGUI::LoadXmlFile encountered an unknown XML root node type: %s", root_name.c_str());
 }
@@ -560,63 +591,63 @@
 //	XML Reading Xeromyces Specific Sub-Routines
 //===================================================================
 
-void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths)
+void CGUI::Xeromyces_ReadRootObjects(const XMBFile& file, XMBElement element, std::unordered_set<VfsPath>& Paths)
 {
-	int el_script = pFile->GetElementID("script");
+	int el_script = file.GetElementID("script");
 
 	std::vector<std::pair<CStr, CStr> > subst;
 
 	// Iterate main children
 	//  they should all be <object> or <script> elements
-	for (XMBElement child : Element.GetChildNodes())
+	for (XMBElement child : element.GetChildNodes())
 	{
 		if (child.GetNodeName() == el_script)
 			// Execute the inline script
-			Xeromyces_ReadScript(child, pFile, Paths);
+			Xeromyces_ReadScript(file, child, Paths);
 		else
 			// Read in this whole object into the GUI
-			Xeromyces_ReadObject(child, pFile, m_BaseObject.get(), subst, Paths, 0);
+			Xeromyces_ReadObject(file, child, m_BaseObject.get(), subst, Paths, 0);
 	}
 }
 
-void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadRootSprites(const XMBFile& file, XMBElement element)
 {
-	for (XMBElement child : Element.GetChildNodes())
-		Xeromyces_ReadSprite(child, pFile);
+	for (XMBElement child : element.GetChildNodes())
+		Xeromyces_ReadSprite(file, child);
 }
 
-void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadRootStyles(const XMBFile& file, XMBElement element)
 {
-	for (XMBElement child : Element.GetChildNodes())
-		Xeromyces_ReadStyle(child, pFile);
+	for (XMBElement child : element.GetChildNodes())
+		Xeromyces_ReadStyle(file, child);
 }
 
-void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadRootSetup(const XMBFile& file, XMBElement element)
 {
-	for (XMBElement child : Element.GetChildNodes())
+	for (XMBElement child : element.GetChildNodes())
 	{
-		CStr name(pFile->GetElementString(child.GetNodeName()));
+		CStr name(file.GetElementString(child.GetNodeName()));
 
 		if (name == "scrollbar")
-			Xeromyces_ReadScrollBarStyle(child, pFile);
+			Xeromyces_ReadScrollBarStyle(file, child);
 		else if (name == "icon")
-			Xeromyces_ReadIcon(child, pFile);
+			Xeromyces_ReadIcon(file, child);
 		else if (name == "tooltip")
-			Xeromyces_ReadTooltip(child, pFile);
+			Xeromyces_ReadTooltip(file, child);
 		else if (name == "color")
-			Xeromyces_ReadColor(child, pFile);
+			Xeromyces_ReadColor(file, child);
 		else
 			debug_warn(L"Invalid data - DTD shouldn't allow this");
 	}
 }
 
-void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
+IGUIObject* CGUI::Xeromyces_ReadObject(const XMBFile& file, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
 	ENSURE(pParent);
 
-	XMBAttributeList attributes = Element.GetAttributes();
+	XMBAttributeList attributes = element.GetAttributes();
 
-	CStr type(attributes.GetNamedItem(pFile->GetAttributeID("type")));
+	CStr type(attributes.GetNamedItem(file.GetAttributeID("type")));
 	if (type.empty())
 		type = "empty";
 
@@ -628,12 +659,12 @@
 	if (!object)
 	{
 		LOGERROR("GUI: Unrecognized object type \"%s\"", type.c_str());
-		return;
+		return nullptr;
 	}
 
 	// Cache some IDs for element attribute names, to avoid string comparisons
-	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
-	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
+	#define ELMT(x) int elmt_##x = file.GetElementID(#x)
+	#define ATTR(x) int attr_##x = file.GetAttributeID(#x)
 	ELMT(object);
 	ELMT(action);
 	ELMT(script);
@@ -696,7 +727,7 @@
 		if (attr.Name == attr_z)
 			ManuallySetZ = true;
 
-		object->SetSettingFromString(pFile->GetAttributeString(attr.Name), attr.Value.FromUTF8(), false);
+		object->SetSettingFromString(file.GetAttributeString(attr.Name), attr.Value.FromUTF8(), false);
 	}
 
 	// Check if name isn't set, generate an internal name in that case.
@@ -706,11 +737,11 @@
 		++m_InternalNameNumber;
 	}
 
-	CStrW caption(Element.GetText().FromUTF8());
+	CStrW caption(element.GetText().FromUTF8());
 	if (!caption.empty())
 		object->SetSettingFromString("caption", caption, false);
 
-	for (XMBElement child : Element.GetChildNodes())
+	for (XMBElement child : element.GetChildNodes())
 	{
 		// Check what name the elements got
 		int element_name = child.GetNodeName();
@@ -718,7 +749,7 @@
 		if (element_name == elmt_object)
 		{
 			// Call this function on the child
-			Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths, nesting_depth);
+			Xeromyces_ReadObject(file, child, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_action)
 		{
@@ -761,11 +792,11 @@
 		}
 		else if (child.GetNodeName() == elmt_script)
 		{
-			Xeromyces_ReadScript(child, pFile, Paths);
+			Xeromyces_ReadScript(file, child, Paths);
 		}
 		else if (element_name == elmt_repeat)
 		{
-			Xeromyces_ReadRepeat(child, pFile, object, NameSubst, Paths, nesting_depth);
+			Xeromyces_ReadRepeat(file, child, object, NameSubst, Paths, nesting_depth);
 		}
 		else if (element_name == elmt_translatableAttribute)
 		{
@@ -822,15 +853,15 @@
 
 				Paths.insert(filename);
 
-				CXeromyces XeroIncluded;
-				if (XeroIncluded.Load(g_VFS, filename, "gui") != PSRETURN_OK)
+				CXeromyces xeroIncluded;
+				if (xeroIncluded.Load(g_VFS, filename, "gui") != PSRETURN_OK)
 				{
 					LOGERROR("GUI: Error reading included XML: '%s'", utf8_from_wstring(filename));
 					continue;
 				}
 
-				XMBElement node = XeroIncluded.GetRoot();
-				if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
+				XMBElement node = xeroIncluded.GetRoot();
+				if (node.GetNodeName() != xeroIncluded.GetElementID("object"))
 				{
 					LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", utf8_from_wstring(filename));
 					continue;
@@ -842,7 +873,7 @@
 					continue;
 				}
 
-				Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
+				Xeromyces_ReadObject(xeroIncluded, node, object, NameSubst, Paths, nesting_depth+1);
 			}
 			else if (!directory.empty())
 			{
@@ -859,20 +890,20 @@
 					// as opposed to loading scripts, don't care if it's loaded before
 					// one might use the same parts of the GUI in different situations
 					Paths.insert(path);
-					CXeromyces XeroIncluded;
-					if (XeroIncluded.Load(g_VFS, path, "gui") != PSRETURN_OK)
+					CXeromyces xeroIncluded;
+					if (xeroIncluded.Load(g_VFS, path, "gui") != PSRETURN_OK)
 					{
 						LOGERROR("GUI: Error reading included XML: '%s'", path.string8());
 						continue;
 					}
 
-					XMBElement node = XeroIncluded.GetRoot();
-					if (node.GetNodeName() != XeroIncluded.GetElementID("object"))
+					XMBElement node = xeroIncluded.GetRoot();
+					if (node.GetNodeName() != xeroIncluded.GetElementID("object"))
 					{
 						LOGERROR("GUI: Error reading included XML: '%s', root element must have be of type 'object'.", path.string8());
 						continue;
 					}
-					Xeromyces_ReadObject(node, &XeroIncluded, object, NameSubst, Paths, nesting_depth+1);
+					Xeromyces_ReadObject(xeroIncluded, node, object, NameSubst, Paths, nesting_depth+1);
 				}
 
 			}
@@ -882,7 +913,7 @@
 		else
 		{
 			// Try making the object read the tag.
-			if (!object->HandleAdditionalChildren(child, pFile))
+			if (!object->HandleAdditionalChildren(file, child))
 				LOGERROR("GUI: (object: %s) Reading unknown children for its type", object->GetPresentableName().c_str());
 		}
 	}
@@ -902,18 +933,22 @@
 	}
 
 	if (!AddObject(*pParent, *object))
+	{
 		delete object;
+		return nullptr;
+	}
+	return object;
 }
 
-void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
+void CGUI::Xeromyces_ReadRepeat(const XMBFile& file, XMBElement element, IGUIObject* pParent, std::vector<std::pair<CStr, CStr> >& NameSubst, std::unordered_set<VfsPath>& Paths, u32 nesting_depth)
 {
-	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
-	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
+	#define ELMT(x) int elmt_##x = file.GetElementID(#x)
+	#define ATTR(x) int attr_##x = file.GetAttributeID(#x)
 	ELMT(object);
 	ATTR(count);
 	ATTR(var);
 
-	XMBAttributeList attributes = Element.GetAttributes();
+	XMBAttributeList attributes = element.GetAttributes();
 
 	int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
 	CStr var("["+attributes.GetNamedItem(attr_var)+"]");
@@ -924,40 +959,40 @@
 	{
 		NameSubst.emplace_back(var, "[" + CStr::FromInt(n) + "]");
 
-		XERO_ITER_EL(Element, child)
+		XERO_ITER_EL(element, child)
 		{
 			if (child.GetNodeName() == elmt_object)
-				Xeromyces_ReadObject(child, pFile, pParent, NameSubst, Paths, nesting_depth);
+				Xeromyces_ReadObject(file, child, pParent, NameSubst, Paths, nesting_depth);
 		}
 		NameSubst.pop_back();
 	}
 }
 
-void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, std::unordered_set<VfsPath>& Paths)
+void CGUI::Xeromyces_ReadScript(const XMBFile& file, XMBElement element, std::unordered_set<VfsPath>& Paths)
 {
 	// Check for a 'file' parameter
-	CStrW file(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("file")).FromUTF8());
+	CStrW fileAttr(element.GetAttributes().GetNamedItem(file.GetAttributeID("file")).FromUTF8());
 
 	// If there is a file specified, open and execute it
-	if (!file.empty())
+	if (!fileAttr.empty())
 	{
-		if (!VfsPath(file).IsDirectory())
+		if (!VfsPath(fileAttr).IsDirectory())
 		{
-			Paths.insert(file);
-			m_ScriptInterface->LoadGlobalScriptFile(file);
+			Paths.insert(fileAttr);
+			m_ScriptInterface->LoadGlobalScriptFile(fileAttr);
 		}
 		else
-			LOGERROR("GUI: Script path %s is not a file path", file.ToUTF8().c_str());
+			LOGERROR("GUI: Script path %s is not a file path", fileAttr.ToUTF8().c_str());
 	}
 
 	// If it has a directory attribute, read all JS files in that directory
-	CStrW directory(Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("directory")).FromUTF8());
-	if (!directory.empty())
+	CStrW directoryAttr(element.GetAttributes().GetNamedItem(file.GetAttributeID("directory")).FromUTF8());
+	if (!directoryAttr.empty())
 	{
-		if (VfsPath(directory).IsDirectory())
+		if (VfsPath(directoryAttr).IsDirectory())
 		{
 			VfsPaths pathnames;
-			vfs::GetPathnames(g_VFS, directory, L"*.js", pathnames);
+			vfs::GetPathnames(g_VFS, directoryAttr, L"*.js", pathnames);
 			for (const VfsPath& path : pathnames)
 			{
 				// Only load new files (so when the insert succeeds)
@@ -966,20 +1001,20 @@
 			}
 		}
 		else
-			LOGERROR("GUI: Script path %s is not a directory path", directory.ToUTF8().c_str());
+			LOGERROR("GUI: Script path %s is not a directory path", directoryAttr.ToUTF8().c_str());
 	}
 
-	CStr code(Element.GetText());
+	CStr code(element.GetText());
 	if (!code.empty())
 		m_ScriptInterface->LoadGlobalScript(L"Some XML file", code);
 }
 
-void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadSprite(const XMBFile& file, XMBElement element)
 {
 	CGUISprite* Sprite = new CGUISprite;
 
 	// Get name, we know it exists because of DTD requirements
-	CStr name = Element.GetAttributes().GetNamedItem(pFile->GetAttributeID("name"));
+	CStr name = element.GetAttributes().GetNamedItem(file.GetAttributeID("name"));
 
 	if (m_Sprites.find(name) != m_Sprites.end())
 		LOGWARNING("GUI sprite name '%s' used more than once; first definition will be discarded", name.c_str());
@@ -987,12 +1022,12 @@
 	// shared_ptr to link the effect to every image, faster than copy.
 	std::shared_ptr<SGUIImageEffects> effects;
 
-	for (XMBElement child : Element.GetChildNodes())
+	for (XMBElement child : element.GetChildNodes())
 	{
-		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
+		CStr ElementName(file.GetElementString(child.GetNodeName()));
 
 		if (ElementName == "image")
-			Xeromyces_ReadImage(child, pFile, *Sprite);
+			Xeromyces_ReadImage(file, child, *Sprite);
 		else if (ElementName == "effect")
 		{
 			if (effects)
@@ -1000,7 +1035,7 @@
 			else
 			{
 				effects = std::make_shared<SGUIImageEffects>();
-				Xeromyces_ReadEffects(child, pFile, *effects);
+				Xeromyces_ReadEffects(file, child, *effects);
 			}
 		}
 		else
@@ -1018,15 +1053,15 @@
 	m_Sprites.emplace(name, Sprite);
 }
 
-void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite& parent)
+void CGUI::Xeromyces_ReadImage(const XMBFile& file, XMBElement element, CGUISprite& parent)
 {
 	SGUIImage* Image = new SGUIImage();
 
 	// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
 
-	for (XMBAttribute attr : Element.GetAttributes())
+	for (XMBAttribute attr : element.GetAttributes())
 	{
-		CStr attr_name(pFile->GetAttributeString(attr.Name));
+		CStr attr_name(file.GetAttributeString(attr.Name));
 		CStrW attr_value(attr.Value.FromUTF8());
 
 		if (attr_name == "texture")
@@ -1107,9 +1142,9 @@
 	}
 
 	// Look for effects
-	for (XMBElement child : Element.GetChildNodes())
+	for (XMBElement child : element.GetChildNodes())
 	{
-		CStr ElementName(pFile->GetElementString(child.GetNodeName()));
+		CStr ElementName(file.GetElementString(child.GetNodeName()));
 		if (ElementName == "effect")
 		{
 			if (Image->m_Effects)
@@ -1117,7 +1152,7 @@
 			else
 			{
 				Image->m_Effects = std::make_shared<SGUIImageEffects>();
-				Xeromyces_ReadEffects(child, pFile, *Image->m_Effects);
+				Xeromyces_ReadEffects(file, child, *Image->m_Effects);
 			}
 		}
 		else
@@ -1127,11 +1162,11 @@
 	parent.AddImage(Image);
 }
 
-void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects& effects)
+void CGUI::Xeromyces_ReadEffects(const XMBFile& file, XMBElement element, SGUIImageEffects& effects)
 {
-	for (XMBAttribute attr : Element.GetAttributes())
+	for (XMBAttribute attr : element.GetAttributes())
 	{
-		CStr attr_name(pFile->GetAttributeString(attr.Name));
+		CStr attr_name(file.GetAttributeString(attr.Name));
 
 		if (attr_name == "add_color")
 		{
@@ -1145,14 +1180,14 @@
 	}
 }
 
-void CGUI::Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadStyle(const XMBFile& file, XMBElement element)
 {
 	SGUIStyle style;
 	CStr name;
 
-	for (XMBAttribute attr : Element.GetAttributes())
+	for (XMBAttribute attr : element.GetAttributes())
 	{
-		CStr attr_name(pFile->GetAttributeString(attr.Name));
+		CStr attr_name(file.GetAttributeString(attr.Name));
 
 		// The "name" setting is actually the name of the style
 		//  and not a new default
@@ -1166,7 +1201,7 @@
 	m_Styles.emplace(name, std::move(style));
 }
 
-void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadScrollBarStyle(const XMBFile& file, XMBElement element)
 {
 	SGUIScrollBarStyle scrollbar;
 	CStr name;
@@ -1177,9 +1212,9 @@
 	scrollbar.m_MaximumBarSize = 1.0e10;
 	scrollbar.m_UseEdgeButtons = false;
 
-	for (XMBAttribute attr : Element.GetAttributes())
+	for (XMBAttribute attr : element.GetAttributes())
 	{
-		CStr attr_name = pFile->GetAttributeString(attr.Name);
+		CStr attr_name = file.GetAttributeString(attr.Name);
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
@@ -1249,14 +1284,14 @@
 	m_ScrollBarStyles.emplace(name, std::move(scrollbar));
 }
 
-void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadIcon(const XMBFile& file, XMBElement element)
 {
 	SGUIIcon icon;
 	CStr name;
 
-	for (XMBAttribute attr : Element.GetAttributes())
+	for (XMBAttribute attr : element.GetAttributes())
 	{
-		CStr attr_name(pFile->GetAttributeString(attr.Name));
+		CStr attr_name(file.GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_value == "null")
@@ -1282,13 +1317,13 @@
 	m_Icons.emplace(name, std::move(icon));
 }
 
-void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadTooltip(const XMBFile& file, XMBElement element)
 {
 	IGUIObject* object = new CTooltip(*this);
 
-	for (XMBAttribute attr : Element.GetAttributes())
+	for (XMBAttribute attr : element.GetAttributes())
 	{
-		CStr attr_name(pFile->GetAttributeString(attr.Name));
+		CStr attr_name(file.GetAttributeString(attr.Name));
 		CStr attr_value(attr.Value);
 
 		if (attr_name == "name")
@@ -1301,13 +1336,13 @@
 		delete object;
 }
 
-void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
+void CGUI::Xeromyces_ReadColor(const XMBFile& file, XMBElement element)
 {
-	XMBAttributeList attributes = Element.GetAttributes();
-	CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
+	XMBAttributeList attributes = element.GetAttributes();
+	CStr name = attributes.GetNamedItem(file.GetAttributeID("name"));
 
 	// Try parsing value
-	CStr value(Element.GetText());
+	CStr value(element.GetText());
 	if (value.empty())
 		return;
 
Index: source/gui/ObjectBases/IGUIObject.h
===================================================================
--- source/gui/ObjectBases/IGUIObject.h
+++ source/gui/ObjectBases/IGUIObject.h
@@ -107,9 +107,16 @@
 	CStr GetPresentableName() const;
 
 	/**
-	 * Builds the object hierarchy with references.
+	 * Create a child object from the given definition.
+	 * @return nullptr on failure.
 	 */
-	void AddChild(IGUIObject& pChild);
+	IGUIObject* CreateChild(JS::HandleValue);
+
+	/**
+	 * Remove a child & delete it.
+	 * @return whether the child was deleted.
+	 */
+	bool DeleteChild(IGUIObject* child);
 
 	/**
 	 * Return all child objects of the current object.
@@ -247,8 +254,7 @@
 	 * Methods that the CGUI will call using
 	 * its friendship, these should not
 	 * be called by user.
-	 * These functions' security are a lot
-	 * what constitutes the GUI's
+	 * TODO: this comment is old and the following interface should be cleaned up.
 	 */
 	//--------------------------------------------------------
 	//@{
@@ -333,6 +339,16 @@
 	 */
 	virtual float GetBufferedZ() const;
 
+	/**
+	 * Builds the object hierarchy with references.
+	 */
+	void AddChild(IGUIObject* child);
+
+	/**
+	 * Remove an object from the hierarchy.
+	 */
+	void RemoveChild(IGUIObject* child);
+
 	/**
 	 * Set parent of this object
 	 */
@@ -378,7 +394,7 @@
 	 * Notice 'false' is default, because an object not using this function, should not
 	 * have any additional children (and this function should never be called).
 	 */
-	virtual bool HandleAdditionalChildren(const XMBElement& UNUSED(child), CXeromyces* UNUSED(pFile))
+	virtual bool HandleAdditionalChildren(const XMBFile& UNUSED(file), const XMBElement& UNUSED(child))
 	{
 		return false;
 	}
Index: source/gui/ObjectBases/IGUIObject.cpp
===================================================================
--- source/gui/ObjectBases/IGUIObject.cpp
+++ source/gui/ObjectBases/IGUIObject.cpp
@@ -86,10 +86,39 @@
 	// m_Children is deleted along all other GUI Objects in the CGUI destructor
 }
 
-void IGUIObject::AddChild(IGUIObject& pChild)
+IGUIObject* IGUIObject::CreateChild(JS::HandleValue value)
 {
-	pChild.SetParent(this);
-	m_Children.push_back(&pChild);
+	CXeromyces spec;
+	spec.LoadJSValue(*m_pGUI.GetScriptInterface().get(), value, "object");
+	return m_pGUI.CreateChild(spec, spec.GetRoot(), this);
+}
+
+bool IGUIObject::DeleteChild(IGUIObject* child)
+{
+	// Don't delete someone else's child.
+	std::vector<IGUIObject*>::iterator it = std::find(m_Children.begin(), m_Children.end(), child);
+	if (it == m_Children.end())
+		return false;
+
+	// Calls RemoveChild();
+	m_pGUI.DetachAndDeleteChild(child);
+	return true;
+}
+
+void IGUIObject::AddChild(IGUIObject* child)
+{
+	child->SetParent(this);
+	m_Children.push_back(child);
+}
+
+void IGUIObject::RemoveChild(IGUIObject* child)
+{
+	std::vector<IGUIObject*>::iterator it = std::find(m_Children.begin(), m_Children.end(), child);
+	if (it != m_Children.end())
+	{
+		(*it)->m_pParent = nullptr;
+		m_Children.erase(it);
+	}
 }
 
 template<typename T>
Index: source/gui/ObjectTypes/CList.h
===================================================================
--- source/gui/ObjectTypes/CList.h
+++ source/gui/ObjectTypes/CList.h
@@ -99,7 +99,7 @@
 	/**
 	 * Handle the \<item\> tag.
 	 */
-	virtual bool HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile);
+	virtual bool HandleAdditionalChildren(const XMBFile& file, const XMBElement& child);
 
 	// Called every time the auto-scrolling should be checked.
 	void UpdateAutoScroll();
Index: source/gui/ObjectTypes/CList.cpp
===================================================================
--- source/gui/ObjectTypes/CList.cpp
+++ source/gui/ObjectTypes/CList.cpp
@@ -412,9 +412,9 @@
 	AddItem(strAndData, strAndData);
 }
 
-bool CList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
+bool CList::HandleAdditionalChildren(const XMBFile& file, const XMBElement& child)
 {
-	int elmt_item = pFile->GetElementID("item");
+	int elmt_item = file.GetElementID("item");
 
 	if (child.GetNodeName() == elmt_item)
 	{
Index: source/gui/ObjectTypes/COList.h
===================================================================
--- source/gui/ObjectTypes/COList.h
+++ source/gui/ObjectTypes/COList.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2021 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -61,7 +61,7 @@
 	/**
 	 * Handle the \<item\> tag.
 	 */
-	virtual bool HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile);
+	virtual bool HandleAdditionalChildren(const XMBFile& file, const XMBElement& child);
 	virtual void AdditionalChildrenHandled();
 
 	void DrawList(const int& selected, const CGUISpriteInstance& sprite, const CGUISpriteInstance& sprite_selected, const CGUIColor& textcolor);
Index: source/gui/ObjectTypes/COList.cpp
===================================================================
--- source/gui/ObjectTypes/COList.cpp
+++ source/gui/ObjectTypes/COList.cpp
@@ -180,10 +180,10 @@
 	}
 }
 
-bool COList::HandleAdditionalChildren(const XMBElement& child, CXeromyces* pFile)
+bool COList::HandleAdditionalChildren(const XMBFile& file, const XMBElement& child)
 {
-	#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
-	#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
+	#define ELMT(x) int elmt_##x = file.GetElementID(#x)
+	#define ATTR(x) int attr_##x = file.GetAttributeID(#x)
 	ELMT(item);
 	ELMT(column);
 	ELMT(translatableAttribute);
@@ -203,7 +203,7 @@
 
 		for (XMBAttribute attr : child.GetAttributes())
 		{
-			CStr attr_name(pFile->GetAttributeString(attr.Name));
+			CStr attr_name(file.GetAttributeString(attr.Name));
 			CStr attr_value(attr.Value);
 
 			if (attr_name == "color")
Index: source/gui/Scripting/GuiScriptConversions.cpp
===================================================================
--- source/gui/Scripting/GuiScriptConversions.cpp
+++ source/gui/Scripting/GuiScriptConversions.cpp
@@ -22,6 +22,7 @@
 #include "gui/SettingTypes/CGUIList.h"
 #include "gui/SettingTypes/CGUISeries.h"
 #include "gui/SettingTypes/CGUISize.h"
+#include "gui/Scripting/JSInterface_GUIProxy.h"
 #include "lib/external_libraries/libsdl.h"
 #include "maths/Size2D.h"
 #include "maths/Vector2D.h"
@@ -136,6 +137,22 @@
 		ret.setObject(*val->GetJSObject());
 }
 
+template<> bool ScriptInterface::FromJSVal<IGUIObject*>(const ScriptRequest& rq, JS::HandleValue v, IGUIObject*& out)
+{
+	if (!v.isObject())
+	{
+		ScriptException::Raise(rq, "Value is not an IGUIObject.");
+		return false;
+	}
+	out = IGUIProxyObject::FromPrivateSlot<IGUIObject>(v.toObjectOrNull());
+	if (!out)
+	{
+		ScriptException::Raise(rq, "Value is not an IGUIObject.");
+		return false;
+	}
+	return true;
+}
+
 template<> void ScriptInterface::ToJSVal<CGUIString>(const ScriptRequest& rq, JS::MutableHandleValue ret, const CGUIString& val)
 {
 	ScriptInterface::ToJSVal(rq, ret, val.GetOriginalString());
Index: source/gui/Scripting/JSInterface_GUIProxy.h
===================================================================
--- source/gui/Scripting/JSInterface_GUIProxy.h
+++ source/gui/Scripting/JSInterface_GUIProxy.h
@@ -54,13 +54,19 @@
 	}
 
 	using PrivateData = IGUIObject*;
+
 	template<typename T>
 	static T* FromPrivateSlot(JSObject* obj)
+	{
+		return static_cast<T*>(FromPrivateSlot<IGUIObject>(obj));
+	}
+protected:
+	template<typename T>
+	static T* UnsafeFromPrivateSlot(JSObject* obj)
 	{
 		return static_cast<T*>(static_cast<PrivateData>(js::GetProxyPrivate(obj).toPrivate()));
 	}
 
-protected:
 	IGUIProxyObject() = default;
 	IGUIProxyObject(const IGUIProxyObject&) = delete;
 	IGUIProxyObject(IGUIProxyObject&&) = delete;
@@ -68,6 +74,8 @@
 	JS::PersistentRootedObject m_Object;
 	PrivateData m_Ptr;
 };
+// Declare the IGUIObject* specialization - it's defined in _impl.h
+template<> IGUIObject* IGUIProxyObject::FromPrivateSlot<IGUIObject>(JSObject*);
 
 /**
  * Proxies need to store some data whose lifetime is tied to an interface.
@@ -114,9 +122,6 @@
 	template<typename T>
 	friend class JSI_GUIProxy;
 public:
-	// Access the js::Class of the Proxy.
-	static JSClass& ClassDefinition();
-
 	// For convenience, this is the single instantiated JSI_GUIProxy.
 	static JSI_GUIProxy& Singleton();
 
@@ -133,6 +138,8 @@
 	// This also enforces making proxy handlers dataless static variables.
 	~JSI_GUIProxy() {};
 
+	static GUIObjectType* FromPrivateSlot(const ScriptRequest&, JS::CallArgs& args);
+
 	// The default implementations need to know the type of the GUIProxyProps for this proxy type.
 	// This is done by specializing this struct's alias type.
 	struct PropCache;
Index: source/gui/Scripting/JSInterface_GUIProxy.cpp
===================================================================
--- source/gui/Scripting/JSInterface_GUIProxy.cpp
+++ source/gui/Scripting/JSInterface_GUIProxy.cpp
@@ -33,7 +33,10 @@
 	CreateFunction<&IGUIObject::SetFocus>(rq, cache, "focus");
 	CreateFunction<&IGUIObject::ReleaseFocus>(rq, cache, "blur");
 	CreateFunction<&IGUIObject::GetComputedSize>(rq, cache, "getComputedSize");
+	CreateFunction<&IGUIObject::CreateChild>(rq, cache, "createChild");
+	CreateFunction<&IGUIObject::DeleteChild>(rq, cache, "deleteChild");
 }
+
 DECLARE_GUIPROXY(IGUIObject);
 
 // Implement derived types below.
Index: source/gui/Scripting/JSInterface_GUIProxy_impl.h
===================================================================
--- source/gui/Scripting/JSInterface_GUIProxy_impl.h
+++ source/gui/Scripting/JSInterface_GUIProxy_impl.h
@@ -29,13 +29,6 @@
 
 #include <string>
 
-template <typename T>
-JSClass& JSI_GUIProxy<T>::ClassDefinition()
-{
-	static JSClass c = PROXY_CLASS_DEF("GUIObjectProxy", JSCLASS_HAS_CACHED_PROTO(JSProto_Proxy) | JSCLASS_HAS_RESERVED_SLOTS(1));
-	return c;
-}
-
 template <typename T>
 JSI_GUIProxy<T>& JSI_GUIProxy<T>::Singleton()
 {
@@ -56,10 +49,11 @@
 // Use a common namespace to avoid duplicating the symbols un-necessarily.
 namespace JSInterface_GUIProxy
 {
-template<typename T>
-inline T* GuiObjectGetter(const ScriptRequest&, JS::CallArgs& args)
+// All proxy objects share a class definition.
+JSClass& ClassDefinition()
 {
-	return IGUIProxyObject::FromPrivateSlot<T>(args.thisv().toObjectOrNull());
+	static JSClass c = PROXY_CLASS_DEF("GUIObjectProxy", JSCLASS_HAS_CACHED_PROTO(JSProto_Proxy) | JSCLASS_HAS_RESERVED_SLOTS(1));
+	return c;
 }
 
 // Default implementation of the cache via unordered_map
@@ -89,6 +83,16 @@
 };
 }
 
+template<>
+IGUIObject* IGUIProxyObject::FromPrivateSlot<IGUIObject>(JSObject* obj)
+{
+	if (!obj)
+		return nullptr;
+	if (JS_GetClass(obj) != &JSInterface_GUIProxy::ClassDefinition())
+		return nullptr;
+	return UnsafeFromPrivateSlot<IGUIObject>(obj);
+}
+
 // The default propcache is a MapCache.
 template<typename T>
 struct JSI_GUIProxy<T>::PropCache
@@ -96,6 +100,13 @@
 	using type = JSInterface_GUIProxy::MapCache;
 };
 
+template <typename T>
+T* JSI_GUIProxy<T>::FromPrivateSlot(const ScriptRequest&, JS::CallArgs& args)
+{
+	// Call the unsafe version - this is only ever called from actual proxy objects.
+	return IGUIProxyObject::UnsafeFromPrivateSlot<T>(args.thisv().toObjectOrNull());
+}
+
 template <typename T>
 bool JSI_GUIProxy<T>::PropGetter(JS::HandleObject proxy, const std::string& propName, JS::MutableHandleValue vp) const
 {
@@ -130,14 +141,14 @@
 template<auto callable>
 void JSI_GUIProxy<T>::CreateFunction(const ScriptRequest& rq, GUIProxyProps* cache, const std::string& name)
 {
-	cache->setFunction(rq, name, ScriptFunction::Create<callable, JSInterface_GUIProxy::GuiObjectGetter<T>>(rq, name.c_str()));
+	cache->setFunction(rq, name, ScriptFunction::Create<callable, FromPrivateSlot>(rq, name.c_str()));
 }
 
 template<typename T>
 std::unique_ptr<IGUIProxyObject> JSI_GUIProxy<T>::CreateJSObject(const ScriptRequest& rq, T* ptr, GUIProxyProps* dataPtr)
 {
 	js::ProxyOptions options;
-	options.setClass(&ClassDefinition());
+	options.setClass(&JSInterface_GUIProxy::ClassDefinition());
 
 	auto ret = std::make_unique<IGUIProxyObject>();
 	ret->m_Ptr = static_cast<IGUIObject*>(ptr);
Index: source/ps/XML/Xeromyces.h
===================================================================
--- source/ps/XML/Xeromyces.h
+++ source/ps/XML/Xeromyces.h
@@ -34,6 +34,8 @@
 
 #include "lib/file/vfs/vfs.h"
 
+#include "scriptinterface/ScriptForward.h"
+
 class RelaxNGValidator;
 class WriteBuffer;
 
@@ -54,6 +56,11 @@
 	 */
 	PSRETURN LoadString(const char* xml, const std::string& validatorName = "");
 
+	/**
+	 * Load from a JS value
+	 */
+	PSRETURN LoadJSValue(const ScriptInterface& scriptInterface, JS::HandleValue value, const std::string& rootName);
+
 	/**
 	 * Convert the given XML file into an XMB in the archive cache.
 	 * Returns the XMB path in @p archiveCachePath.
Index: source/ps/XML/Xeromyces.cpp
===================================================================
--- source/ps/XML/Xeromyces.cpp
+++ source/ps/XML/Xeromyces.cpp
@@ -28,6 +28,9 @@
 #include "ps/CacheLoader.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
+#include "scriptinterface/ScriptExtraHeaders.h"
+#include "scriptinterface/ScriptInterface.h"
+
 #include "RelaxNG.h"
 #include "Xeromyces.h"
 
@@ -256,7 +259,6 @@
 	return PSRETURN_OK;
 }
 
-
 static void FindNames(const xmlNodePtr node, std::set<std::string>& elementNames, std::set<std::string>& attributeNames)
 {
 	elementNames.insert((const char*)node->name);
@@ -424,3 +426,266 @@
 
 	return PSRETURN_OK;
 }
+
+struct TempXMB;
+
+struct TempXMBEl
+{
+	TempXMBEl() = delete;
+	TempXMBEl(const TempXMB& xmb, JS::HandleValue val) : file(xmb), val(val) {}
+	const TempXMB& file;
+
+	u32 name = 0;
+	JS::Heap<JS::Value> val;
+	std::vector<std::pair<u32, std::string>> attributes;
+	std::vector<TempXMBEl> children;
+};
+
+struct TempXMB
+{
+	TempXMB(const std::string& rootName, JS::HandleValue rootValue) : root(*this, rootValue)
+	{
+		root.name = 0;
+		elementIDs[rootName] = 0;
+	}
+	std::set<std::string> elementNames;
+	std::set<std::string> attributeNames;
+	std::map<std::string, u32> elementIDs;
+	std::map<std::string, u32> attributeIDs;
+	TempXMBEl root;
+};
+
+
+bool PrepareXMBElement(const ScriptInterface& scriptInterface, const ScriptRequest& rq, JS::HandleValue value,
+				   TempXMB& xmb, TempXMBEl& el)
+{
+	JSType valType = JS_TypeOfValue(rq.cx, value);
+	if (valType != JSTYPE_OBJECT)
+		return true;
+
+	std::vector<std::string> props;
+	if (!scriptInterface.EnumeratePropertyNames(value, true, props))
+	{
+		LOGERROR("Failed to enumerate component properties.");
+		return false;
+	}
+
+	for (const std::string& prop : props)
+	{
+		bool attrib = !prop.empty() && prop.front() == '@';
+
+		std::string_view name = prop;
+		if (!attrib && !prop.empty() && prop.back() == '@')
+		{
+			size_t idx = prop.substr(0, prop.size()-1).find_last_of('@');
+			if (idx == std::string::npos)
+			{
+				LOGERROR("object key name cannot end with an '@' unless it is an index specifier.");
+				return false;
+			}
+			name = std::string_view(prop.c_str(), idx);
+		}
+		else if (attrib)
+			name = std::string_view(prop.c_str()+1, prop.length()-1);
+
+		JS::RootedValue child(rq.cx);
+		if (!scriptInterface.GetProperty(value, prop.c_str(), &child))
+			return false;
+
+		if (!attrib)
+		{
+			std::map<std::string, u32>& names = xmb.elementIDs;
+			u32 nameIdx = names.size();
+			nameIdx = names.try_emplace(std::string(name), nameIdx).first->second;
+
+			bool isArray = false;
+			if (!JS::IsArrayObject(rq.cx, child, &isArray))
+				return false;
+			if (isArray)
+			{
+				// Parse each array object as a child.
+				JS::RootedObject obj(rq.cx);
+				JS_ValueToObject(rq.cx, child, &obj);
+				u32 length;
+				JS::GetArrayLength(rq.cx, obj, &length);
+				for (size_t i = 0; i < length; ++i)
+				{
+					JS::RootedValue arrayChild(rq.cx);
+					scriptInterface.GetPropertyInt(child, i, &arrayChild);
+					TempXMBEl& childNode = el.children.emplace_back(xmb, arrayChild);
+					childNode.name = nameIdx;
+					PrepareXMBElement(scriptInterface, rq, arrayChild, xmb, childNode);
+				}
+				continue;
+			}
+			TempXMBEl& childNode = el.children.emplace_back(xmb, child);
+			childNode.name = nameIdx;
+			PrepareXMBElement(scriptInterface, rq, child, xmb, childNode);
+			continue;
+		}
+
+		std::string attrVal;
+		if (!ScriptInterface::FromJSVal(rq, child, attrVal))
+		{
+			LOGERROR("Attributes must be convertible to string");
+			return false;
+		}
+		std::map<std::string, u32>& names = xmb.attributeIDs;
+		u32 nameIdx = names.size();
+		nameIdx = names.try_emplace(std::string(name), nameIdx).first->second;
+		el.attributes.emplace_back(nameIdx, attrVal);
+	}
+	return true;
+}
+
+bool OutputElement(const ScriptInterface& scriptInterface, const ScriptRequest& rq, WriteBuffer& writeBuffer, const TempXMB& xmb, const TempXMBEl& el)
+{
+	size_t posLength = writeBuffer.Size();
+	// Filled in later with the length of the element
+	writeBuffer.Append("????", 4);
+
+	writeBuffer.Append(&el.name, 4);
+
+	u32 attrCount = static_cast<u32>(el.attributes.size());
+	writeBuffer.Append(&attrCount, 4);
+
+	u32 childCount = el.children.size();
+	writeBuffer.Append(&childCount, 4);
+
+	// Filled in later with the offset to the list of child elements
+	size_t posChildrenOffset = writeBuffer.Size();
+	writeBuffer.Append("????", 4);
+
+	JS::RootedValue value(rq.cx, el.val.get());
+	switch (JS_TypeOfValue(rq.cx, value))
+	{
+		case JSTYPE_UNDEFINED:
+		case JSTYPE_NULL:
+		case JSTYPE_OBJECT:
+		{
+			writeBuffer.Append("\0\0\0\0", 4);
+			break;
+		}
+		case JSTYPE_STRING:
+		case JSTYPE_NUMBER:
+		{
+			std::string text;
+			if (!ScriptInterface::FromJSVal(rq, value, text))
+				return false;
+
+			// Output text, prefixed by length in bytes
+			if (text.length() == 0)
+			{
+				// No text; don't write much
+				writeBuffer.Append("\0\0\0\0", 4);
+			}
+			else
+			{
+				// Write length and line number and null-terminated text
+				u32 nodeLen = u32(4 + text.length()+1);
+				writeBuffer.Append(&nodeLen, 4);
+				writeBuffer.Append("\0\0\0\0", 4);
+				writeBuffer.Append((void*)text.c_str(), nodeLen-4);
+			}
+
+			break;
+		}
+		default:
+		{
+			LOGERROR("Unsupported JS construct when parsing ParamNode");
+			return false;
+		}
+	}
+
+	// Output attributes
+	for (const std::pair<u32, std::string> attr : el.attributes)
+	{
+		writeBuffer.Append(&attr.first, 4);
+		u32 attrLen = u32(attr.second.size())+1;
+		writeBuffer.Append(&attrLen, 4);
+		writeBuffer.Append((void*)attr.second.c_str(), attrLen);
+	}
+
+	// Go back and fill in the child-element offset
+	u32 childrenOffset = (u32)(writeBuffer.Size() - (posChildrenOffset+4));
+	writeBuffer.Overwrite(&childrenOffset, 4, posChildrenOffset);
+
+	// Output all child elements
+	for (const TempXMBEl& child :  el.children)
+		if (!OutputElement(scriptInterface, rq, writeBuffer, xmb, child))
+			return false;
+
+	// Go back and fill in the length
+	u32 length = (u32)(writeBuffer.Size() - posLength);
+	writeBuffer.Overwrite(&length, 4, posLength);
+
+	return true;
+}
+PSRETURN CXeromyces::LoadJSValue(const ScriptInterface& scriptInterface, JS::HandleValue value, const std::string& rootName)
+{
+	ENSURE(g_XeromycesStarted);
+
+	WriteBuffer writeBuffer;
+
+	// Header
+	writeBuffer.Append(UnfinishedHeaderMagicStr, 4);
+	// Version
+	writeBuffer.Append(&XMBVersion, 4);
+
+	u32 i;
+
+	ScriptRequest rq(scriptInterface);
+
+	TempXMB xmb(rootName, value);
+
+	if (!PrepareXMBElement(scriptInterface, rq, value, xmb, xmb.root))
+		return PSRETURN_Xeromyces_XMLParseError;
+
+	// Output element names
+	{
+		i = 0;
+		u32 elementCount = (u32)xmb.elementIDs.size();
+		writeBuffer.Append(&elementCount, 4);
+		std::vector<std::pair<std::string, u32>> orderedElements;
+		for (const std::pair<std::string, u32>& n : xmb.elementIDs)
+			orderedElements.emplace_back(n);
+		std::sort(orderedElements.begin(), orderedElements.end(), [](const auto& a, const auto&b) { return a.second < b.second; });
+		for (const std::pair<std::string, u32>& n : orderedElements)
+		{
+			u32 textLen = (u32)n.first.length()+1;
+			writeBuffer.Append(&textLen, 4);
+			writeBuffer.Append((void*)n.first.c_str(), textLen);
+		}
+	}
+
+	// Output attribute names
+	{
+		i = 0;
+		u32 elementCount = (u32)xmb.attributeIDs.size();
+		writeBuffer.Append(&elementCount, 4);
+		std::vector<std::pair<std::string, u32>> orderedElements;
+		for (const std::pair<std::string, u32>& n : xmb.attributeIDs)
+			orderedElements.emplace_back(n);
+		std::sort(orderedElements.begin(), orderedElements.end(), [](const auto& a, const auto&b) { return a.second < b.second; });
+		for (const std::pair<std::string, u32>& n : orderedElements)
+		{
+			u32 textLen = (u32)n.first.length()+1;
+			writeBuffer.Append(&textLen, 4);
+			writeBuffer.Append((void*)n.first.c_str(), textLen);
+		}
+	}
+
+	if (!OutputElement(scriptInterface, rq, writeBuffer, xmb, xmb.root))
+		return PSRETURN_Xeromyces_XMLParseError;
+
+	// file is now valid, so insert correct magic string
+	writeBuffer.Overwrite(HeaderMagicStr, 4, 0);
+
+	m_XMBBuffer = writeBuffer.Data(); // add a reference
+
+	// Set up the XMBFile
+	const bool ok = Initialise((const char*)m_XMBBuffer.get());
+	ENSURE(ok);
+
+	return PSRETURN_OK;
+}