dominus-cli 2.0.0 → 2.1.1

package/plugin/Dominus.rbxmx

@@ -0,0 +1,3674 @@
+<roblox version="4">
+  <Item class="Script" referent="0">
+    <Properties>
+      <string name="Name">Dominus</string>
+      <token name="RunContext">0</token>
+      <string name="Source"><![CDATA[local HttpService = game:GetService("HttpService")
+
+local EmbeddedBridgeToken = require(script.BridgeConfig)
+local CommandRouter = require(script.CommandRouter)
+local Protocol = require(script.Protocol)
+local Watcher = require(script.Watcher)
+local WsClient = require(script.WsClient)
+
+local PROTOCOL_VERSION = 2
+local DEFAULT_PORT = 18088
+local MAX_MESSAGE_BYTES = 1024 * 1024
+
+local toolbar = plugin:CreateToolbar("Dominus 2")
+local connectButton = toolbar:CreateButton(
+	"Dominus 2",
+	"Connect this Studio session to the Dominus 2 MCP server",
+	"rbxassetid://12974519994"
+)
+
+local authenticated = false
+local transportOpen = false
+local shouldReconnect = true
+local reconnectScheduled = false
+local reconnectDelay = 1
+local shuttingDown = false
+local connecting = false
+
+local function getSetting(name, default)
+	local ok, value = pcall(function()
+		return plugin:GetSetting(name)
+	end)
+	if ok and value ~= nil then
+		return value
+	end
+	return default
+end
+
+local clientId = getSetting("Dominus2ClientId", nil)
+if type(clientId) ~= "string" then
+	clientId = HttpService:GenerateGUID(false)
+	pcall(function()
+		plugin:SetSetting("Dominus2ClientId", clientId)
+	end)
+end
+local bridgeToken = getSetting("Dominus2BridgeToken", nil)
+if type(EmbeddedBridgeToken) == "string" and EmbeddedBridgeToken ~= "__DOMINUS_BRIDGE_TOKEN__" then
+	bridgeToken = EmbeddedBridgeToken
+	pcall(function()
+		plugin:SetSetting("Dominus2BridgeToken", bridgeToken)
+	end)
+end
+local port = tonumber(getSetting("Dominus2Port", DEFAULT_PORT)) or DEFAULT_PORT
+
+local function log(message)
+	print("[Dominus 2] " .. message)
+end
+
+local function sendEnvelope(message)
+	local encodedOk, encoded = pcall(Protocol.encode, message)
+	if not encodedOk then
+		return false, tostring(encoded)
+	end
+	if #encoded > MAX_MESSAGE_BYTES then
+		return false, "Message exceeds one MiB"
+	end
+	return WsClient.send(encoded)
+end
+
+local function sendResponse(id, payload)
+	return sendEnvelope({ id = id, type = "studio:response", payload = payload, ts = os.time() })
+end
+
+local scheduleReconnect
+
+local function stopSession()
+	authenticated = false
+	transportOpen = false
+	Watcher.stop()
+	connectButton:SetActive(false)
+end
+
+local function handleMessage(rawMessage)
+	if #rawMessage > MAX_MESSAGE_BYTES then
+		warn("[Dominus 2] Rejected an oversized server message")
+		WsClient.disconnect()
+		return
+	end
+	local decodedOk, message = pcall(Protocol.decode, rawMessage)
+	if not decodedOk or type(message) ~= "table" then
+		warn("[Dominus 2] Rejected an invalid server message")
+		return
+	end
+
+	if message.type == "server:authenticated" then
+		local payload = message.payload or {}
+		if payload.protocolVersion ~= PROTOCOL_VERSION or type(payload.connectionId) ~= "string" then
+			warn("[Dominus 2] Server returned an invalid authentication response")
+			WsClient.disconnect()
+			return
+		end
+		if type(payload.token) == "string" then
+			bridgeToken = payload.token
+			pcall(function()
+				plugin:SetSetting("Dominus2BridgeToken", bridgeToken)
+			end)
+		end
+		authenticated = true
+		connectButton:SetActive(true)
+		log("Authenticated as Studio session " .. payload.connectionId)
+		Watcher.start(function(entry)
+			if authenticated then
+				sendEnvelope({ id = Protocol.generateId(), type = "studio:output", payload = entry, ts = os.time() })
+			end
+		end)
+		return
+	end
+
+	if message.type == "server:auth_rejected" then
+		warn("[Dominus 2] Authentication failed. Run dominus-install-plugin and restart Studio.")
+		WsClient.disconnect()
+		return
+	end
+
+	if not authenticated then
+		warn("[Dominus 2] Ignored a command before authentication")
+		return
+	end
+	CommandRouter.handle(message, sendResponse)
+end
+
+local function connect()
+	if shuttingDown or transportOpen then
+		return
+	end
+	if connecting then
+		if shouldReconnect then
+			scheduleReconnect()
+		end
+		return
+	end
+	connecting = true
+	reconnectScheduled = false
+	local success = WsClient.connect("ws://127.0.0.1:" .. port, {
+		onOpen = function()
+			transportOpen = true
+			reconnectDelay = 1
+			connectButton:SetActive(true)
+			local sent, sendErr = sendEnvelope({
+				id = Protocol.generateId(),
+				type = "studio:hello",
+				payload = {
+					protocolVersion = PROTOCOL_VERSION,
+					clientId = clientId,
+					token = bridgeToken,
+					studioVersion = version(),
+					placeId = game.PlaceId,
+					placeName = game.Name,
+				},
+				ts = os.time(),
+			})
+			if not sent then
+				warn("[Dominus 2] Could not send handshake: " .. tostring(sendErr))
+				stopSession()
+				WsClient.disconnect()
+			end
+		end,
+		onMessage = function(message)
+			task.spawn(handleMessage, message)
+		end,
+		onClose = function()
+			local wasOpen = transportOpen
+			stopSession()
+			if wasOpen and not shuttingDown then
+				log("Studio bridge disconnected")
+			end
+			if shouldReconnect then
+				scheduleReconnect()
+			end
+		end,
+		onError = function(statusCode, errorMessage)
+			if transportOpen then
+				warn("[Dominus 2] Bridge error " .. tostring(statusCode) .. ": " .. tostring(errorMessage))
+				stopSession()
+				WsClient.disconnect()
+				if shouldReconnect then
+					scheduleReconnect()
+				end
+			end
+		end,
+	}, 4)
+	connecting = false
+	if not success then
+		stopSession()
+		if shouldReconnect then
+			scheduleReconnect()
+		end
+	end
+end
+
+scheduleReconnect = function()
+	if reconnectScheduled or shuttingDown or not shouldReconnect then
+		return
+	end
+	reconnectScheduled = true
+	local delaySeconds = reconnectDelay
+	reconnectDelay = math.min(reconnectDelay * 2, 30)
+	task.delay(delaySeconds, function()
+		reconnectScheduled = false
+		if shouldReconnect and not shuttingDown then
+			task.spawn(connect)
+		end
+	end)
+end
+
+connectButton.Click:Connect(function()
+	shouldReconnect = true
+	reconnectDelay = 1
+	stopSession()
+	WsClient.disconnect()
+	log("Reconnecting to the Dominus 2 MCP server")
+	task.spawn(function()
+		while connecting and not shuttingDown do
+			task.wait()
+		end
+		connect()
+	end)
+end)
+
+task.delay(1, function()
+	task.spawn(connect)
+end)
+
+plugin.Unloading:Connect(function()
+	shuttingDown = true
+	shouldReconnect = false
+	stopSession()
+	WsClient.disconnect()
+end)
+]]></string>
+    </Properties>
+    <Item class="ModuleScript" referent="1">
+      <Properties>
+        <string name="Name">BridgeConfig</string>
+        <string name="Source"><![CDATA[-- Replaced with a user-specific token by dominus-install-plugin.
+return "__DOMINUS_BRIDGE_TOKEN__"
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="2">
+      <Properties>
+        <string name="Name">CommandRouter</string>
+        <string name="Source"><![CDATA[local Explorer = require(script.Parent.Explorer)
+local InstanceRegistry = require(script.Parent.InstanceRegistry)
+local Mutation = require(script.Parent.Mutation)
+local Properties = require(script.Parent.Properties)
+local Reflection = require(script.Parent.Reflection)
+local TestRunner = require(script.Parent.TestRunner)
+local UIBuilder = require(script.Parent.UIBuilder)
+local Watcher = require(script.Parent.Watcher)
+
+local CommandRouter = {}
+
+local handlers = {
+	["studio:v2:get_tree"] = function(payload)
+		return Explorer.getTreeV2(payload)
+	end,
+	["studio:v2:inspect"] = function(payload)
+		return Properties.inspectV2(payload)
+	end,
+	["studio:v2:get_selection"] = function()
+		local Selection = game:GetService("Selection")
+		local selected = {}
+		for _, instance in Selection:Get() do
+			table.insert(selected, {
+				name = instance.Name,
+				className = instance.ClassName,
+				ref = InstanceRegistry.toRef(instance),
+			})
+		end
+		return { success = true, selection = selected }
+	end,
+	["studio:v2:read_script"] = function(payload)
+		return Explorer.readScriptV2(payload)
+	end,
+	["studio:v2:update_script"] = function(payload)
+		return Explorer.updateScriptV2(payload)
+	end,
+	["studio:v2:apply"] = function(payload)
+		return Mutation.apply(payload)
+	end,
+	["studio:v2:delete"] = function(payload)
+		return Mutation.delete(payload)
+	end,
+	["studio:v2:build_ui"] = function(payload)
+		return UIBuilder.buildV2(payload)
+	end,
+	["studio:v2:snapshot_ui"] = function(payload)
+		return UIBuilder.snapshotV2(payload)
+	end,
+	["studio:v2:run_test"] = function(payload)
+		return TestRunner.executeV2(payload)
+	end,
+	["studio:v2:get_output"] = function(payload)
+		local result = Watcher.getRecentOutput(math.clamp(payload.limit or 100, 1, 500), payload.level)
+		result.success = true
+		return result
+	end,
+	["studio:v2:get_reflection"] = function(payload)
+		if type(payload.className) ~= "string" then
+			return { success = false, error = "className must be a string" }
+		end
+		return Reflection.getClassInfo(payload.className)
+	end,
+}
+
+function CommandRouter.handle(message, sendResponse)
+	if type(message) ~= "table" or type(message.id) ~= "string" or #message.id > 128 then
+		return false, "Invalid Dominus request envelope"
+	end
+	if type(message.type) ~= "string" or type(message.payload) ~= "table" then
+		return false, "Invalid Dominus request type or payload"
+	end
+
+	local handler = handlers[message.type]
+	if not handler then
+		sendResponse(message.id, {
+			success = false,
+			error = "Command is not allowed by the Dominus 2 plugin: " .. message.type,
+		})
+		return true
+	end
+
+	task.spawn(function()
+		local ok, result = pcall(handler, message.payload)
+		if not ok then
+			result = { success = false, error = "Command failed: " .. tostring(result) }
+		elseif type(result) ~= "table" then
+			result = { success = false, error = "Command returned an invalid result" }
+		end
+		sendResponse(message.id, result)
+	end)
+	return true
+end
+
+return CommandRouter
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="3">
+      <Properties>
+        <string name="Name">Explorer</string>
+        <string name="Source"><![CDATA[--[[
+	Explorer module: serialize DataModel tree, read/write scripts, search, manage instances
+]]
+
+local ScriptEditorService = game:GetService("ScriptEditorService")
+local InstanceRegistry = require(script.Parent.InstanceRegistry)
+
+local Explorer = {}
+
+local SCRIPT_CLASSES = {
+	Script = true,
+	LocalScript = true,
+	ModuleScript = true,
+}
+
+function Explorer.getPath(instance)
+	local parts = {}
+	local current = instance
+	while current and current ~= game do
+		table.insert(parts, 1, current.Name)
+		current = current.Parent
+	end
+	return table.concat(parts, ".")
+end
+
+function Explorer.getRef(instance)
+	return InstanceRegistry.toRef(instance)
+end
+
+function Explorer.resolveTarget(target)
+	return InstanceRegistry.resolve(target)
+end
+
+function Explorer.resolveInstance(path)
+	local parts = string.split(path, ".")
+	local current = game
+	for _, part in parts do
+		local child = current:FindFirstChild(part)
+		if not child then
+			return nil
+		end
+		current = child
+	end
+	return current
+end
+
+function Explorer.getTree(rootPath, maxDepth)
+	maxDepth = maxDepth or 3
+
+	local root
+	if rootPath and rootPath ~= "" then
+		root = Explorer.resolveInstance(rootPath)
+		if not root then
+			return {}
+		end
+	else
+		root = game
+	end
+
+	local function serialize(instance, depth)
+		if depth > maxDepth then
+			return nil
+		end
+
+		local node = {
+			name = instance.Name,
+			className = instance.ClassName,
+			path = Explorer.getPath(instance),
+		}
+
+		local children = {}
+		for _, child in instance:GetChildren() do
+			local childNode = serialize(child, depth + 1)
+			if childNode then
+				table.insert(children, childNode)
+			end
+		end
+
+		if #children > 0 then
+			node.children = children
+		end
+
+		return node
+	end
+
+	if root == game then
+		local topLevel = {}
+		for _, service in game:GetChildren() do
+			local ok, node = pcall(serialize, service, 1)
+			if ok and node then
+				table.insert(topLevel, node)
+			end
+		end
+		return topLevel
+	else
+		local node = serialize(root, 0)
+		return node and { node } or {}
+	end
+end
+
+function Explorer.getScriptSource(path)
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	if not SCRIPT_CLASSES[instance.ClassName] then
+		return { success = false, error = "Not a script: " .. path }
+	end
+
+	local ok, source = pcall(function()
+		return ScriptEditorService:GetEditorSource(instance)
+	end)
+
+	if not ok then
+		-- Fallback to .Source property
+		ok, source = pcall(function()
+			return instance.Source
+		end)
+	end
+
+	if not ok then
+		return { success = false, error = "Could not read source: " .. tostring(source) }
+	end
+
+	local lines = select(2, source:gsub("\n", "\n")) + 1
+
+	return {
+		path = path,
+		className = instance.ClassName,
+		source = source,
+		lineCount = lines,
+	}
+end
+
+function Explorer.setScriptSource(path, newSource)
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	if not SCRIPT_CLASSES[instance.ClassName] then
+		return { success = false, error = "Not a script: " .. path }
+	end
+
+	local ok, err = pcall(function()
+		ScriptEditorService:UpdateSourceAsync(instance, function()
+			return newSource
+		end)
+	end)
+
+	if not ok then
+		return { success = false, error = "Failed to update source: " .. tostring(err) }
+	end
+
+	return { success = true }
+end
+
+function Explorer.insertInstance(className, parentPath, name, properties)
+	local parent = Explorer.resolveInstance(parentPath)
+	if not parent then
+		return { success = false, error = "Parent not found: " .. parentPath }
+	end
+
+	local ok, instance = pcall(function()
+		local obj = Instance.new(className)
+		obj.Name = name
+
+		if properties then
+			for key, value in properties do
+				pcall(function()
+					obj[key] = value
+				end)
+			end
+		end
+
+		obj.Parent = parent
+		return obj
+	end)
+
+	if not ok then
+		return { success = false, error = "Failed to create instance: " .. tostring(instance) }
+	end
+
+	return { success = true, path = Explorer.getPath(instance) }
+end
+
+function Explorer.deleteInstance(path)
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	local ok, err = pcall(function()
+		instance:Destroy()
+	end)
+
+	if not ok then
+		return { success = false, error = "Failed to delete: " .. tostring(err) }
+	end
+
+	return { success = true }
+end
+
+function Explorer.searchScripts(query, maxResults)
+	maxResults = maxResults or 20
+	local results = {}
+	local queryLower = string.lower(query)
+
+	local function searchIn(instance)
+		if #results >= maxResults then
+			return
+		end
+
+		if SCRIPT_CLASSES[instance.ClassName] then
+			local ok, source = pcall(function()
+				return ScriptEditorService:GetEditorSource(instance)
+			end)
+
+			if not ok then
+				ok, source = pcall(function()
+					return instance.Source
+				end)
+			end
+
+			if ok and source then
+				local matches = {}
+				local lineNum = 0
+				for line in source:gmatch("[^\n]+") do
+					lineNum = lineNum + 1
+					if string.find(string.lower(line), queryLower, 1, true) then
+						table.insert(matches, { line = lineNum, text = line })
+						if #matches >= 5 then
+							break
+						end
+					end
+				end
+
+				if #matches > 0 then
+					table.insert(results, {
+						path = Explorer.getPath(instance),
+						className = instance.ClassName,
+						matches = matches,
+					})
+				end
+			end
+		end
+
+		for _, child in instance:GetChildren() do
+			if #results >= maxResults then
+				return
+			end
+			pcall(searchIn, child)
+		end
+	end
+
+	pcall(searchIn, game)
+
+	return { results = results }
+end
+
+function Explorer.findReplaceScripts(spec)
+	local find = spec.find
+	local replace = spec.replace
+	local usePattern = spec.usePattern or false
+	local dryRun = spec.dryRun or false
+
+	if not find or find == "" then
+		return { success = false, error = "Missing 'find' parameter" }
+	end
+
+	local root = game
+	if spec.root and spec.root ~= "" then
+		root = Explorer.resolveInstance(spec.root)
+		if not root then
+			local ok, svc = pcall(function()
+				return game:GetService(spec.root)
+			end)
+			if ok then
+				root = svc
+			else
+				return { success = false, error = "Root not found: " .. spec.root }
+			end
+		end
+	end
+
+	local ChangeHistoryService = game:GetService("ChangeHistoryService")
+	local recording = nil
+	if not dryRun then
+		recording = ChangeHistoryService:TryBeginRecording("Dominus: Find/replace in scripts")
+	end
+
+	local modified = {}
+	local totalMatches = 0
+	local totalFiles = 0
+
+	local function processScript(instance)
+		if not SCRIPT_CLASSES[instance.ClassName] then
+			return
+		end
+
+		local ok, source = pcall(function()
+			return ScriptEditorService:GetEditorSource(instance)
+		end)
+		if not ok then
+			ok, source = pcall(function()
+				return instance.Source
+			end)
+		end
+		if not ok or not source then
+			return
+		end
+
+		local count = 0
+		if usePattern then
+			_, count = source:gsub(find, "")
+		else
+			_, count = source:gsub(find, "", nil)
+			-- plain text: count occurrences with plain find
+			count = 0
+			local startPos = 1
+			while true do
+				local foundPos = source:find(find, startPos, true)
+				if not foundPos then
+					break
+				end
+				count = count + 1
+				startPos = foundPos + #find
+			end
+		end
+
+		if count > 0 then
+			totalMatches = totalMatches + count
+			totalFiles = totalFiles + 1
+
+			local path = Explorer.getPath(instance)
+			table.insert(modified, { path = path, matches = count })
+
+			if not dryRun then
+				local newSource
+				if usePattern then
+					newSource = source:gsub(find, replace)
+				else
+					newSource =
+						source:gsub(find:gsub("([%(%)%.%%%+%-%*%?%[%]%^%$])", "%%%1"), replace:gsub("%%", "%%%%"))
+				end
+
+				pcall(function()
+					ScriptEditorService:UpdateSourceAsync(instance, function()
+						return newSource
+					end)
+				end)
+			end
+		end
+	end
+
+	local function walk(instance)
+		processScript(instance)
+		for _, child in instance:GetChildren() do
+			pcall(walk, child)
+		end
+	end
+
+	pcall(walk, root)
+
+	if recording then
+		if totalFiles > 0 then
+			ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Commit)
+		else
+			ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Cancel)
+		end
+	end
+
+	return {
+		success = true,
+		modified = modified,
+		totalMatches = totalMatches,
+		totalFiles = totalFiles,
+	}
+end
+
+local function sourceHash(source)
+	local hash = 5381
+	for index = 1, #source do
+		hash = (hash * 33 + string.byte(source, index)) % 4294967296
+	end
+	return string.format("%d:%08x", #source, hash)
+end
+
+function Explorer.getTreeV2(spec)
+	local root = game
+	if spec.root then
+		local resolved, err = InstanceRegistry.resolve(spec.root)
+		if not resolved then
+			return { success = false, error = err }
+		end
+		root = resolved
+	end
+	local maxDepth = math.clamp(spec.maxDepth or 3, 0, 12)
+	local maxNodes = math.clamp(spec.maxNodes or 1000, 1, 5000)
+	local nodeCount = 0
+	local truncated = false
+
+	local function serialize(instance, depth)
+		if depth > maxDepth or nodeCount >= maxNodes then
+			truncated = true
+			return nil
+		end
+		nodeCount += 1
+		local node = {
+			name = instance.Name,
+			className = instance.ClassName,
+			ref = InstanceRegistry.toRef(instance),
+		}
+		local children = instance:GetChildren()
+		table.sort(children, function(a, b)
+			if a.Name == b.Name then
+				return a.ClassName < b.ClassName
+			end
+			return a.Name < b.Name
+		end)
+		for _, child in children do
+			local childNode = serialize(child, depth + 1)
+			if childNode then
+				node.children = node.children or {}
+				table.insert(node.children, childNode)
+			end
+			if nodeCount >= maxNodes then
+				break
+			end
+		end
+		return node
+	end
+
+	if root == game then
+		local roots = {}
+		local services = game:GetChildren()
+		table.sort(services, function(a, b)
+			return a.Name < b.Name
+		end)
+		for _, service in services do
+			local node = serialize(service, 0)
+			if node then
+				table.insert(roots, node)
+			end
+			if nodeCount >= maxNodes then
+				break
+			end
+		end
+		return { success = true, roots = roots, nodeCount = nodeCount, truncated = truncated }
+	end
+
+	return { success = true, roots = { serialize(root, 0) }, nodeCount = nodeCount, truncated = truncated }
+end
+
+function Explorer.readScriptV2(spec)
+	local instance, err = InstanceRegistry.resolve(spec.target)
+	if not instance then
+		return { success = false, error = err }
+	end
+	if not SCRIPT_CLASSES[instance.ClassName] then
+		return { success = false, error = "Target is not a LuaSourceContainer" }
+	end
+	local ok, source = pcall(function()
+		return ScriptEditorService:GetEditorSource(instance)
+	end)
+	if not ok then
+		return { success = false, error = "Could not read script source: " .. tostring(source) }
+	end
+	return {
+		success = true,
+		target = InstanceRegistry.toRef(instance),
+		className = instance.ClassName,
+		source = source,
+		lineCount = select(2, source:gsub("\n", "\n")) + 1,
+		revision = sourceHash(source),
+	}
+end
+
+function Explorer.updateScriptV2(spec)
+	local instance, err = InstanceRegistry.resolve(spec.target)
+	if not instance then
+		return { success = false, error = err }
+	end
+	if not SCRIPT_CLASSES[instance.ClassName] then
+		return { success = false, error = "Target is not a LuaSourceContainer" }
+	end
+	if type(spec.source) ~= "string" then
+		return { success = false, error = "source must be a string" }
+	end
+	if #spec.source > 750000 then
+		return { success = false, error = "source exceeds 750,000 characters" }
+	end
+	if type(spec.expectedRevision) ~= "string" then
+		return { success = false, error = "expectedRevision is required; call studio_read_script first" }
+	end
+
+	local conflictRevision = nil
+	local ok, updateErr = pcall(function()
+		ScriptEditorService:UpdateSourceAsync(instance, function(oldSource)
+			local currentRevision = sourceHash(oldSource)
+			if currentRevision ~= spec.expectedRevision then
+				conflictRevision = currentRevision
+				return nil
+			end
+			return spec.source
+		end)
+	end)
+	if conflictRevision then
+		return {
+			success = false,
+			conflict = true,
+			error = "Script changed since it was read",
+			currentRevision = conflictRevision,
+		}
+	end
+	if not ok then
+		return { success = false, error = "Script update failed: " .. tostring(updateErr) }
+	end
+
+	local readback = Explorer.readScriptV2({ target = InstanceRegistry.toRef(instance) })
+	return {
+		success = true,
+		target = readback.target,
+		revision = readback.revision,
+		lineCount = readback.lineCount,
+	}
+end
+
+return Explorer
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="4">
+      <Properties>
+        <string name="Name">InstanceRegistry</string>
+        <string name="Source"><![CDATA[local HttpService = game:GetService("HttpService")
+
+local InstanceRegistry = {}
+
+local instanceToId = setmetatable({}, { __mode = "k" })
+local idToInstance = {}
+
+local function register(instance)
+	local existing = instanceToId[instance]
+	if existing then
+		return existing
+	end
+
+	local id = HttpService:GenerateGUID(false)
+	instanceToId[instance] = id
+	idToInstance[id] = instance
+	instance.Destroying:Connect(function()
+		if idToInstance[id] == instance then
+			idToInstance[id] = nil
+		end
+		instanceToId[instance] = nil
+	end)
+	return id
+end
+
+function InstanceRegistry.getPathSegments(instance)
+	local segments = {}
+	local current = instance
+	while current and current ~= game do
+		table.insert(segments, 1, current.Name)
+		current = current.Parent
+	end
+	return segments
+end
+
+function InstanceRegistry.getDisplayPath(instance)
+	local path = "game"
+	for _, segment in InstanceRegistry.getPathSegments(instance) do
+		local escaped = segment:gsub("\\", "\\\\"):gsub('"', '\\"')
+		path ..= '["' .. escaped .. '"]'
+	end
+	return path
+end
+
+function InstanceRegistry.toRef(instance)
+	return {
+		instanceId = register(instance),
+		pathSegments = InstanceRegistry.getPathSegments(instance),
+		displayPath = InstanceRegistry.getDisplayPath(instance),
+	}
+end
+
+local function resolveSegments(segments)
+	if type(segments) ~= "table" or #segments == 0 then
+		return nil, "pathSegments must contain at least one name"
+	end
+
+	local current = game
+	for index, segment in segments do
+		if type(segment) ~= "string" then
+			return nil, "pathSegments[" .. index .. "] must be a string"
+		end
+		local match = nil
+		local count = 0
+		for _, child in current:GetChildren() do
+			if child.Name == segment then
+				match = child
+				count += 1
+			end
+		end
+		if count == 0 and current == game then
+			local ok, service = pcall(function()
+				return game:GetService(segment)
+			end)
+			if ok then
+				match = service
+				count = 1
+			end
+		end
+		if count == 0 then
+			return nil, "Instance path does not exist at segment: " .. segment
+		end
+		if count > 1 then
+			return nil, "Instance path is ambiguous at duplicate sibling name: " .. segment
+		end
+		current = match
+	end
+	return current
+end
+
+function InstanceRegistry.resolve(target)
+	if typeof(target) == "Instance" then
+		return target
+	end
+	if type(target) ~= "table" then
+		return nil, "Target must be an instance reference"
+	end
+
+	if type(target.instanceId) == "string" then
+		local instance = idToInstance[target.instanceId]
+		if instance then
+			return instance
+		end
+		return nil, "Instance reference is stale: " .. target.instanceId
+	end
+
+	if target.pathSegments then
+		local instance, err = resolveSegments(target.pathSegments)
+		if instance then
+			register(instance)
+		end
+		return instance, err
+	end
+
+	return nil, "Target requires instanceId or pathSegments"
+end
+
+function InstanceRegistry.register(instance)
+	return register(instance)
+end
+
+return InstanceRegistry
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="5">
+      <Properties>
+        <string name="Name">Mutation</string>
+        <string name="Source"><![CDATA[local ChangeHistoryService = game:GetService("ChangeHistoryService")
+
+local InstanceRegistry = require(script.Parent.InstanceRegistry)
+local ValueCodec = require(script.Parent.ValueCodec)
+
+local Mutation = {}
+local MAX_OPERATIONS = 100
+local MAX_PROPERTIES = 100
+
+local function resolve(target, label)
+	local instance, err = InstanceRegistry.resolve(target)
+	if not instance then
+		error(label .. ": " .. tostring(err))
+	end
+	return instance
+end
+
+local function setProperties(instance, properties)
+	assert(type(properties) == "table", "properties must be an object")
+	local count = 0
+	local applied = {}
+	for propertyName, value in properties do
+		count += 1
+		if count > MAX_PROPERTIES then
+			error("Too many properties in one operation")
+		end
+		applied[propertyName] = ValueCodec.setProperty(instance, propertyName, value)
+	end
+	return applied
+end
+
+function Mutation.apply(spec)
+	local operations = spec.operations
+	if type(operations) ~= "table" or #operations == 0 then
+		return { success = false, error = "operations must contain at least one mutation" }
+	end
+	if #operations > MAX_OPERATIONS then
+		return { success = false, error = "A mutation batch is limited to " .. MAX_OPERATIONS .. " operations" }
+	end
+
+	local recording = ChangeHistoryService:TryBeginRecording("Dominus 2: Apply mutation batch")
+	if not recording then
+		return { success = false, error = "Another plugin recording is already active" }
+	end
+
+	local results = {}
+	local ok, err = pcall(function()
+		for index, operation in operations do
+			assert(type(operation) == "table", "Operation " .. index .. " must be an object")
+			if operation.op == "setProperties" then
+				local target = resolve(operation.target, "Operation " .. index .. " target")
+				table.insert(results, {
+					op = operation.op,
+					target = InstanceRegistry.toRef(target),
+					properties = setProperties(target, operation.properties),
+				})
+			elseif operation.op == "create" then
+				local parent = resolve(operation.parent, "Operation " .. index .. " parent")
+				assert(type(operation.className) == "string", "create.className must be a string")
+				assert(type(operation.name) == "string", "create.name must be a string")
+				local instance = Instance.new(operation.className)
+				instance.Name = operation.name
+				if operation.properties then
+					setProperties(instance, operation.properties)
+				end
+				instance.Parent = parent
+				table.insert(results, { op = operation.op, created = InstanceRegistry.toRef(instance) })
+			elseif operation.op == "move" then
+				local target = resolve(operation.target, "Operation " .. index .. " target")
+				local parent = resolve(operation.parent, "Operation " .. index .. " parent")
+				assert(target ~= game and target.Parent ~= game, "Services cannot be moved")
+				target.Parent = parent
+				table.insert(results, { op = operation.op, target = InstanceRegistry.toRef(target) })
+			else
+				error("Unsupported mutation operation: " .. tostring(operation.op))
+			end
+		end
+	end)
+
+	if not ok then
+		ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Cancel)
+		return { success = false, error = tostring(err), rolledBack = true }
+	end
+
+	ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Commit)
+	return { success = true, operationCount = #results, results = results }
+end
+
+function Mutation.delete(spec)
+	if spec.confirm ~= true then
+		return { success = false, error = "confirm must be true" }
+	end
+	if type(spec.targets) ~= "table" or #spec.targets == 0 then
+		return { success = false, error = "targets must contain at least one instance reference" }
+	end
+	if #spec.targets > 50 then
+		return { success = false, error = "At most 50 instances can be deleted at once" }
+	end
+
+	local targets = {}
+	local seen = {}
+	for index, targetRef in spec.targets do
+		local target = resolve(targetRef, "Target " .. index)
+		assert(target ~= game and target.Parent ~= game, "Services cannot be deleted")
+		local id = InstanceRegistry.register(target)
+		if not seen[id] then
+			seen[id] = true
+			table.insert(targets, target)
+		end
+	end
+
+	local recording = ChangeHistoryService:TryBeginRecording("Dominus 2: Delete instances")
+	if not recording then
+		return { success = false, error = "Another plugin recording is already active" }
+	end
+	local deleted = {}
+	local ok, err = pcall(function()
+		for _, target in targets do
+			table.insert(deleted, {
+				name = target.Name,
+				className = target.ClassName,
+				pathSegments = InstanceRegistry.getPathSegments(target),
+			})
+			target:Destroy()
+		end
+	end)
+	if not ok then
+		ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Cancel)
+		return { success = false, error = tostring(err), rolledBack = true }
+	end
+	ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Commit)
+	return { success = true, deleted = deleted }
+end
+
+return Mutation
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="6">
+      <Properties>
+        <string name="Name">Properties</string>
+        <string name="Source"><![CDATA[--[[
+	Properties module: read/write instance properties
+	Uses ReflectionService to determine expected types for smart coercion.
+]]
+
+local Explorer = require(script.Parent.Explorer)
+local InstanceRegistry = require(script.Parent.InstanceRegistry)
+local Reflection = require(script.Parent.Reflection)
+local ValueCodec = require(script.Parent.ValueCodec)
+local ReflectionService = game:GetService("ReflectionService")
+
+local Properties = {}
+
+local IGNORED_PROPERTIES = {
+	Parent = true,
+	ClassName = true,
+	Archivable = true,
+}
+
+-- Properties that are read-only / computed / redundant — strip in compact mode
+local COMPACT_SKIP = {
+	-- Read-only computed
+	AbsolutePosition = true,
+	AbsoluteSize = true,
+	AbsoluteRotation = true,
+	AbsoluteCanvasSize = true,
+	TextBounds = true,
+	TextFits = true,
+	IsLoaded = true,
+	ContentText = true,
+	LocalizedText = true,
+	GuiState = true,
+	-- Deprecated / redundant (BrickColor duplicates Color3, Font duplicates FontFace)
+	BackgroundColor = true,
+	BorderColor = true,
+	TextColor = true,
+	Font = true,
+	FontSize = true,
+	-- Internal / security
+	Capabilities = true,
+	Sandboxed = true,
+	archivable = true,
+	className = true,
+	Localize = true,
+	-- Selection navigation (almost always nil/default)
+	NextSelectionDown = true,
+	NextSelectionLeft = true,
+	NextSelectionRight = true,
+	NextSelectionUp = true,
+	SelectionBehaviorDown = true,
+	SelectionBehaviorLeft = true,
+	SelectionBehaviorRight = true,
+	SelectionBehaviorUp = true,
+	SelectionGroup = true,
+	SelectionOrder = true,
+	SelectionImageObject = true,
+	-- Rarely useful defaults
+	Draggable = true,
+	InputSink = true,
+	RootLocalizationTable = true,
+	AutoLocalize = true,
+	OpenTypeFeatures = true,
+	OpenTypeFeaturesError = true,
+	Interactable = true,
+	Style = true,
+	BorderMode = true,
+	SizeConstraint = true,
+}
+
+-- Default values that are not worth reporting in compact mode
+local COMPACT_DEFAULT_VALUES = {
+	["0"] = true,
+	["1"] = true,
+	["false"] = true,
+	["nil"] = true,
+	[""] = true,
+	["Enum.AutomaticSize.None"] = true,
+	["Enum.TextTruncate.None"] = true,
+	["Enum.TextDirection.Auto"] = true,
+	["Enum.ResamplerMode.Default"] = true,
+	["Enum.ScaleType.Stretch"] = true,
+}
+
+-- Cache property type maps per class to avoid repeated reflection calls
+local typeCache = {}
+
+local function getPropertyTypeMap(className)
+	if typeCache[className] then
+		return typeCache[className]
+	end
+
+	local typeMap = {}
+	local ok, props = pcall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if ok and props then
+		for _, prop in props do
+			if prop.Type then
+				typeMap[prop.Name] = tostring(prop.Type)
+			end
+		end
+	end
+	typeCache[className] = typeMap
+	return typeMap
+end
+
+function Properties.get(path, compact)
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	local properties = {}
+
+	local ok, apiData = pcall(function()
+		local info = {}
+		local propData = ReflectionService:GetPropertiesOfClass(instance.ClassName)
+		for _, prop in propData do
+			if not IGNORED_PROPERTIES[prop.Name] then
+				if compact and COMPACT_SKIP[prop.Name] then
+					continue
+				end
+				local valueOk, value = pcall(function()
+					return instance[prop.Name]
+				end)
+				if valueOk then
+					local valueStr = tostring(value)
+					if compact and valueStr == "nil" then
+						continue
+					end
+					table.insert(info, {
+						name = prop.Name,
+						value = valueStr,
+						type = prop.Type and tostring(prop.Type) or typeof(value),
+						category = prop.Display and prop.Display.Category or "Other",
+					})
+				end
+			end
+		end
+		return info
+	end)
+
+	if ok then
+		properties = apiData
+	else
+		local commonProps =
+			{ "Name", "Position", "Size", "Color", "Material", "Transparency", "Anchored", "CanCollide" }
+		for _, propName in commonProps do
+			local valOk, val = pcall(function()
+				return instance[propName]
+			end)
+			if valOk and val ~= nil then
+				table.insert(properties, {
+					name = propName,
+					value = tostring(val),
+					type = typeof(val),
+				})
+			end
+		end
+	end
+
+	return { properties = properties }
+end
+
+function Properties.getDescendants(path, compact)
+	local rootInstance = Explorer.resolveInstance(path)
+	if not rootInstance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	-- In compact mode, skip noisy/default properties to reduce payload size
+	local shouldSkip = compact
+			and function(propName, valueStr)
+				if COMPACT_SKIP[propName] then
+					return true
+				end
+				-- Skip nil-valued properties
+				if valueStr == "nil" then
+					return true
+				end
+				return false
+			end
+		or function()
+			return false
+		end
+
+	-- Extra compact filter: skip properties that are clearly defaults and non-informative
+	local isBoringDefault = compact
+			and function(propName, valueStr)
+				-- These specific properties at default values are noise
+				local boringAtDefault = {
+					Active = "false",
+					Selectable = "false",
+					ClipsDescendants = "false",
+					TextWrap = "false",
+					TextWrapped = "false",
+					RichText = "false",
+					TextScaled = "false",
+					Rotation = "0",
+					LayoutOrder = "0",
+					MaxVisibleGraphemes = "-1",
+					SliceScale = "1",
+					LineHeight = "1",
+					BorderSizePixel = "1",
+					Visible = "true",
+				}
+				return boringAtDefault[propName] == valueStr
+			end
+		or function()
+			return false
+		end
+
+	local function getProps(instance)
+		local properties = {}
+
+		local ok, apiData = pcall(function()
+			local info = {}
+			local propData = ReflectionService:GetPropertiesOfClass(instance.ClassName)
+			for _, prop in propData do
+				if not IGNORED_PROPERTIES[prop.Name] and not shouldSkip(prop.Name, "") then
+					local valueOk, value = pcall(function()
+						return instance[prop.Name]
+					end)
+					if valueOk then
+						local valueStr = tostring(value)
+						if not shouldSkip(prop.Name, valueStr) and not isBoringDefault(prop.Name, valueStr) then
+							table.insert(info, {
+								name = prop.Name,
+								value = valueStr,
+								type = prop.Type and tostring(prop.Type) or typeof(value),
+								category = prop.Display and prop.Display.Category or "Other",
+							})
+						end
+					end
+				end
+			end
+			return info
+		end)
+
+		if ok then
+			properties = apiData
+		else
+			local commonProps =
+				{ "Name", "Position", "Size", "Color", "Material", "Transparency", "Anchored", "CanCollide" }
+			for _, propName in commonProps do
+				local valOk, val = pcall(function()
+					return instance[propName]
+				end)
+				if valOk and val ~= nil then
+					table.insert(properties, {
+						name = propName,
+						value = tostring(val),
+						type = typeof(val),
+					})
+				end
+			end
+		end
+
+		return properties
+	end
+
+	local results = {}
+
+	-- Include the root instance itself
+	table.insert(results, {
+		name = rootInstance.Name,
+		className = rootInstance.ClassName,
+		path = Explorer.getPath(rootInstance),
+		properties = getProps(rootInstance),
+	})
+
+	for _, descendant in rootInstance:GetDescendants() do
+		table.insert(results, {
+			name = descendant.Name,
+			className = descendant.ClassName,
+			path = Explorer.getPath(descendant),
+			properties = getProps(descendant),
+		})
+	end
+
+	return { success = true, descendants = results }
+end
+
+--[[
+	Smart type coercion: converts JSON-friendly values into Roblox types.
+	Uses the expected property type from ReflectionService when available.
+]]
+local function coerceValue(instance, key, value)
+	local expectedType = nil
+	local typeMap = getPropertyTypeMap(instance.ClassName)
+	expectedType = typeMap[key]
+
+	-- If we don't know the expected type, try reading the current value
+	if not expectedType then
+		local curOk, curVal = pcall(function()
+			return instance[key]
+		end)
+		if curOk and curVal ~= nil then
+			expectedType = typeof(curVal)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- UDim2 (GUI Size, Position, etc.)
+	-- ═══════════════════════════════════════════
+	if expectedType == "UDim2" then
+		if type(value) == "table" then
+			-- {xScale, xOffset, yScale, yOffset} or named keys
+			if value.XScale or value.xScale or value.X then
+				return UDim2.new(
+					value.XScale or value.xScale or value.X and value.X.Scale or 0,
+					value.XOffset or value.xOffset or value.X and value.X.Offset or 0,
+					value.YScale or value.yScale or value.Y and value.Y.Scale or 0,
+					value.YOffset or value.yOffset or value.Y and value.Y.Offset or 0
+				)
+			end
+			-- {X = {Scale, Offset}, Y = {Scale, Offset}}
+			if value.X and type(value.X) == "table" then
+				return UDim2.new(
+					value.X.Scale or value.X[1] or 0,
+					value.X.Offset or value.X[2] or 0,
+					value.Y and (value.Y.Scale or value.Y[1]) or 0,
+					value.Y and (value.Y.Offset or value.Y[2]) or 0
+				)
+			end
+			-- Array: {xScale, xOffset, yScale, yOffset}
+			if value[1] ~= nil then
+				return UDim2.new(value[1] or 0, value[2] or 0, value[3] or 0, value[4] or 0)
+			end
+			-- fromScale shorthand: {scale_x, scale_y} when only 2 elements
+			return UDim2.new(0, 0, 0, 0)
+		end
+		if type(value) == "string" then
+			-- "0.5, 0, 0.5, 0" format
+			local a, b, c, d = value:match("([%d%.%-]+)%s*,%s*([%d%.%-]+)%s*,%s*([%d%.%-]+)%s*,%s*([%d%.%-]+)")
+			if a then
+				return UDim2.new(tonumber(a), tonumber(b), tonumber(c), tonumber(d))
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- UDim
+	-- ═══════════════════════════════════════════
+	if expectedType == "UDim" then
+		if type(value) == "table" then
+			return UDim.new(value.Scale or value[1] or 0, value.Offset or value[2] or 0)
+		end
+		if type(value) == "number" then
+			return UDim.new(value, 0)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Vector3
+	-- ═══════════════════════════════════════════
+	if expectedType == "Vector3" then
+		if type(value) == "table" then
+			return Vector3.new(
+				value.X or value.x or value[1] or 0,
+				value.Y or value.y or value[2] or 0,
+				value.Z or value.z or value[3] or 0
+			)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Vector2
+	-- ═══════════════════════════════════════════
+	if expectedType == "Vector2" then
+		if type(value) == "table" then
+			return Vector2.new(value.X or value.x or value[1] or 0, value.Y or value.y or value[2] or 0)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Color3
+	-- ═══════════════════════════════════════════
+	if expectedType == "Color3" then
+		if type(value) == "string" then
+			if value:sub(1, 1) == "#" then
+				return Color3.fromHex(value)
+			end
+			if value:match("^rgb") then
+				local r, g, b = value:match("(%d+)%D+(%d+)%D+(%d+)")
+				if r then
+					return Color3.fromRGB(tonumber(r), tonumber(g), tonumber(b))
+				end
+			end
+			local ok, bc = pcall(BrickColor.new, value)
+			if ok then
+				return bc.Color
+			end
+		end
+		if type(value) == "table" then
+			-- {R, G, B} 0-1 or {r, g, b}
+			if value.R or value.r then
+				return Color3.new(value.R or value.r or 0, value.G or value.g or 0, value.B or value.b or 0)
+			end
+			-- {red, green, blue} 0-255
+			if value.red or value.Red then
+				return Color3.fromRGB(
+					value.red or value.Red or 0,
+					value.green or value.Green or 0,
+					value.blue or value.Blue or 0
+				)
+			end
+			-- Array [r, g, b]
+			if value[1] then
+				if value[1] > 1 or value[2] > 1 or value[3] > 1 then
+					return Color3.fromRGB(value[1], value[2], value[3])
+				end
+				return Color3.new(value[1], value[2], value[3])
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- BrickColor
+	-- ═══════════════════════════════════════════
+	if expectedType == "BrickColor" then
+		if type(value) == "string" then
+			return BrickColor.new(value)
+		end
+		if type(value) == "number" then
+			return BrickColor.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- CFrame
+	-- ═══════════════════════════════════════════
+	if expectedType == "CFrame" then
+		if type(value) == "table" then
+			if value.Position or value.position then
+				local pos = value.Position or value.position
+				local cf = CFrame.new(
+					pos.x or pos.X or pos[1] or 0,
+					pos.y or pos.Y or pos[2] or 0,
+					pos.z or pos.Z or pos[3] or 0
+				)
+				if value.Rotation or value.rotation then
+					local rot = value.Rotation or value.rotation
+					cf = cf
+						* CFrame.Angles(
+							math.rad(rot.x or rot.X or rot[1] or 0),
+							math.rad(rot.y or rot.Y or rot[2] or 0),
+							math.rad(rot.z or rot.Z or rot[3] or 0)
+						)
+				end
+				return cf
+			end
+			-- Simple {x, y, z}
+			if value[1] then
+				return CFrame.new(value[1], value[2] or 0, value[3] or 0)
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Rect (for GUI ImageRectOffset, etc.)
+	-- ═══════════════════════════════════════════
+	if expectedType == "Rect" then
+		if type(value) == "table" then
+			return Rect.new(
+				value[1] or value.Min and value.Min[1] or 0,
+				value[2] or value.Min and value.Min[2] or 0,
+				value[3] or value.Max and value.Max[1] or 0,
+				value[4] or value.Max and value.Max[2] or 0
+			)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- NumberRange
+	-- ═══════════════════════════════════════════
+	if expectedType == "NumberRange" then
+		if type(value) == "table" then
+			return NumberRange.new(value.Min or value[1] or 0, value.Max or value[2] or 1)
+		end
+		if type(value) == "number" then
+			return NumberRange.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- NumberSequence (for transparency gradients, etc.)
+	-- ═══════════════════════════════════════════
+	if expectedType == "NumberSequence" then
+		if type(value) == "table" then
+			if value[1] and type(value[1]) == "table" then
+				local keypoints = {}
+				for _, kp in value do
+					table.insert(
+						keypoints,
+						NumberSequenceKeypoint.new(
+							kp.Time or kp[1] or 0,
+							kp.Value or kp[2] or 0,
+							kp.Envelope or kp[3] or 0
+						)
+					)
+				end
+				return NumberSequence.new(keypoints)
+			end
+			if #value == 2 and type(value[1]) == "number" then
+				return NumberSequence.new(value[1], value[2])
+			end
+		end
+		if type(value) == "number" then
+			return NumberSequence.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- ColorSequence
+	-- ═══════════════════════════════════════════
+	if expectedType == "ColorSequence" then
+		if type(value) == "table" then
+			if value[1] and type(value[1]) == "table" then
+				local keypoints = {}
+				for _, kp in value do
+					local color = Color3.new(1, 1, 1)
+					if kp.Color then
+						if type(kp.Color) == "string" and kp.Color:sub(1, 1) == "#" then
+							color = Color3.fromHex(kp.Color)
+						elseif type(kp.Color) == "table" then
+							color = Color3.new(kp.Color[1] or 0, kp.Color[2] or 0, kp.Color[3] or 0)
+						end
+					end
+					table.insert(keypoints, ColorSequenceKeypoint.new(kp.Time or kp[1] or 0, color))
+				end
+				return ColorSequence.new(keypoints)
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Font
+	-- ═══════════════════════════════════════════
+	if expectedType == "Font" then
+		if type(value) == "table" then
+			local family = value.Family or value.family or "rbxasset://fonts/families/SourceSansPro.json"
+			local weight = Enum.FontWeight.Regular
+			local style = Enum.FontStyle.Normal
+			if value.Weight or value.weight then
+				pcall(function()
+					weight = Enum.FontWeight[value.Weight or value.weight]
+				end)
+			end
+			if value.Style or value.style then
+				pcall(function()
+					style = Enum.FontStyle[value.Style or value.style]
+				end)
+			end
+			return Font.new(family, weight, style)
+		end
+		if type(value) == "string" then
+			return Font.new(value)
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- EnumItem (any enum property)
+	-- ═══════════════════════════════════════════
+	if type(value) == "string" then
+		local currentVal = nil
+		pcall(function()
+			currentVal = instance[key]
+		end)
+		if typeof(currentVal) == "EnumItem" then
+			local enumType = tostring(currentVal.EnumType)
+			local enumOk, enumVal = pcall(function()
+				return Enum[enumType][value]
+			end)
+			if enumOk then
+				return enumVal
+			end
+		end
+	end
+
+	-- ═══════════════════════════════════════════
+	-- Fallback: type-agnostic guesses (no expectedType known)
+	-- ═══════════════════════════════════════════
+	if type(value) == "table" and not expectedType then
+		-- UDim2 guess: has XScale/YScale keys
+		if value.XScale or value.xScale then
+			return UDim2.new(
+				value.XScale or value.xScale or 0,
+				value.XOffset or value.xOffset or 0,
+				value.YScale or value.yScale or 0,
+				value.YOffset or value.yOffset or 0
+			)
+		end
+		-- Vector3 guess: 3 number elements or X/Y/Z keys
+		if (value.X or value.x) and (value.Y or value.y) and (value.Z or value.z) then
+			return Vector3.new(value.X or value.x, value.Y or value.y, value.Z or value.z)
+		end
+		if value[1] and value[2] and value[3] and not value[4] then
+			return Vector3.new(value[1], value[2], value[3])
+		end
+		-- Color3 guess: R/G/B keys
+		if value.R or value.r then
+			return Color3.new(value.R or value.r or 0, value.G or value.g or 0, value.B or value.b or 0)
+		end
+		-- Vector2 guess: 2 number elements
+		if value[1] and value[2] and not value[3] then
+			return Vector2.new(value[1], value[2])
+		end
+	end
+
+	-- String-based color on color properties (fallback)
+	if type(value) == "string" and (key == "Color" or key == "Color3" or key:match("Color$")) then
+		if value:sub(1, 1) == "#" then
+			return Color3.fromHex(value)
+		end
+		local ok, bc = pcall(BrickColor.new, value)
+		if ok then
+			return bc.Color
+		end
+	end
+
+	if type(value) == "string" and key == "BrickColor" then
+		return BrickColor.new(value)
+	end
+
+	return value
+end
+
+function Properties.set(path, propertiesToSet)
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	local errors = {}
+	local set = {}
+
+	for key, value in propertiesToSet do
+		local coerced = coerceValue(instance, key, value)
+		local ok, err = pcall(function()
+			instance[key] = coerced
+		end)
+		if ok then
+			table.insert(set, key)
+		else
+			table.insert(errors, key .. ": " .. tostring(err))
+		end
+	end
+
+	if #errors > 0 then
+		return { success = false, error = table.concat(errors, "; "), set = set }
+	end
+
+	return { success = true, set = set }
+end
+
+function Properties.bulkSet(spec)
+	local ChangeHistoryService = game:GetService("ChangeHistoryService")
+	local recording = ChangeHistoryService:TryBeginRecording("Dominus: Bulk set properties")
+
+	local modified = 0
+	local errors = {}
+
+	if spec.targets and type(spec.targets) == "table" then
+		-- Explicit mode: array of {path, properties}
+		for _, target in ipairs(spec.targets) do
+			local instance = Explorer.resolveInstance(target.path)
+			if not instance then
+				table.insert(errors, "Not found: " .. tostring(target.path))
+			else
+				for key, value in target.properties do
+					local coerced = coerceValue(instance, key, value)
+					local ok, err = pcall(function()
+						instance[key] = coerced
+					end)
+					if not ok then
+						table.insert(errors, target.path .. "." .. key .. ": " .. tostring(err))
+					end
+				end
+				modified = modified + 1
+			end
+		end
+	elseif spec.root and (spec.properties or spec.addChildren) then
+		-- Filter mode: apply to all matching descendants
+		local root = Explorer.resolveInstance(spec.root)
+		if not root then
+			if recording then
+				ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Cancel)
+			end
+			return { success = false, error = "Root not found: " .. tostring(spec.root) }
+		end
+
+		local function processInstance(inst)
+			if spec.className and inst.ClassName ~= spec.className then
+				return
+			end
+			if spec.properties then
+				for key, value in spec.properties do
+					local coerced = coerceValue(inst, key, value)
+					local ok, err = pcall(function()
+						inst[key] = coerced
+					end)
+					if not ok then
+						table.insert(errors, Explorer.getPath(inst) .. "." .. key .. ": " .. tostring(err))
+					end
+				end
+			end
+			-- addChildren: insert new child instances (e.g. UIStroke, UICorner)
+			if spec.addChildren and type(spec.addChildren) == "table" then
+				for _, childSpec in ipairs(spec.addChildren) do
+					local childClass = childSpec.ClassName or childSpec.className
+					if childClass then
+						-- Skip if child of this class already exists (idempotent)
+						local skipIfExists = childSpec.skipIfExists ~= false
+						if skipIfExists then
+							local existing = inst:FindFirstChildOfClass(childClass)
+							if existing then
+								continue
+							end
+						end
+						local ok2, child = pcall(Instance.new, childClass)
+						if ok2 and child then
+							if childSpec.Name or childSpec.name then
+								child.Name = childSpec.Name or childSpec.name
+							end
+							-- Set props on the new child
+							local props = childSpec.properties
+								or childSpec.Properties
+								or childSpec.props
+								or childSpec.Props
+								or {}
+							-- Also check flattened keys
+							for k, v in childSpec do
+								if
+									k ~= "ClassName"
+									and k ~= "className"
+									and k ~= "Name"
+									and k ~= "name"
+									and k ~= "properties"
+									and k ~= "Properties"
+									and k ~= "props"
+									and k ~= "Props"
+									and k ~= "skipIfExists"
+									and k ~= "Children"
+									and k ~= "children"
+								then
+									props[k] = v
+								end
+							end
+							for pk, pv in props do
+								local coerced = coerceValue(child, pk, pv)
+								pcall(function()
+									child[pk] = coerced
+								end)
+							end
+							child.Parent = inst
+						else
+							table.insert(
+								errors,
+								Explorer.getPath(inst) .. ": failed to create " .. tostring(childClass)
+							)
+						end
+					end
+				end
+			end
+			modified = modified + 1
+		end
+
+		-- Include root itself if it matches
+		processInstance(root)
+		for _, desc in root:GetDescendants() do
+			processInstance(desc)
+		end
+	else
+		if recording then
+			ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Cancel)
+		end
+		return { success = false, error = "Provide either 'targets' array or 'root' + 'properties'/'addChildren'" }
+	end
+
+	if recording then
+		ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Commit)
+	end
+
+	return { success = true, modified = modified, errors = errors }
+end
+
+function Properties.inspectV2(spec)
+	if type(spec.targets) ~= "table" or #spec.targets == 0 then
+		return { success = false, error = "targets must contain at least one instance reference" }
+	end
+	if #spec.targets > 20 then
+		return { success = false, error = "At most 20 instances can be inspected at once" }
+	end
+	local compact = spec.compact ~= false
+	local results = {}
+
+	for index, targetRef in spec.targets do
+		local instance, err = InstanceRegistry.resolve(targetRef)
+		if not instance then
+			table.insert(results, { success = false, index = index, error = err })
+			continue
+		end
+
+		local metadata = Reflection.getPropertyMetadata(instance.ClassName)
+		local propertyNames = {}
+		for propertyName in metadata do
+			if not IGNORED_PROPERTIES[propertyName] and (not compact or not COMPACT_SKIP[propertyName]) then
+				table.insert(propertyNames, propertyName)
+			end
+		end
+		table.sort(propertyNames)
+
+		local properties = {}
+		for _, propertyName in propertyNames do
+			local readOk, value = pcall(function()
+				return instance[propertyName]
+			end)
+			if readOk and value ~= nil then
+				table.insert(properties, {
+					name = propertyName,
+					type = metadata[propertyName].type,
+					category = metadata[propertyName].category,
+					writable = metadata[propertyName].writable,
+					value = ValueCodec.encode(value),
+				})
+			end
+		end
+
+		local children = instance:GetChildren()
+		table.sort(children, function(a, b)
+			if a.Name == b.Name then
+				return a.ClassName < b.ClassName
+			end
+			return a.Name < b.Name
+		end)
+		local childRefs = {}
+		for _, child in children do
+			table.insert(childRefs, {
+				name = child.Name,
+				className = child.ClassName,
+				ref = InstanceRegistry.toRef(child),
+			})
+		end
+
+		table.insert(results, {
+			success = true,
+			name = instance.Name,
+			className = instance.ClassName,
+			ref = InstanceRegistry.toRef(instance),
+			properties = properties,
+			children = childRefs,
+		})
+	end
+
+	return { success = true, results = results }
+end
+
+return Properties
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="7">
+      <Properties>
+        <string name="Name">Protocol</string>
+        <string name="Source"><![CDATA[--[[
+	Message protocol: JSON encoding/decoding with unique ID generation
+]]
+
+local HttpService = game:GetService("HttpService")
+
+local Protocol = {}
+
+function Protocol.encode(data)
+	return HttpService:JSONEncode(data)
+end
+
+function Protocol.decode(json)
+	return HttpService:JSONDecode(json)
+end
+
+function Protocol.generateId()
+	return HttpService:GenerateGUID(false)
+end
+
+function Protocol.createMessage(msgType, payload)
+	return {
+		id = Protocol.generateId(),
+		type = msgType,
+		payload = payload,
+		ts = os.clock(),
+	}
+end
+
+return Protocol
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="8">
+      <Properties>
+        <string name="Name">Reflection</string>
+        <string name="Source"><![CDATA[local ReflectionService = game:GetService("ReflectionService")
+
+local Reflection = {}
+
+local function safeCall(callback)
+	local ok, result = pcall(callback)
+	if ok then
+		return result
+	end
+	return nil, result
+end
+
+local function typeName(reflectionType)
+	if reflectionType == nil then
+		return "unknown"
+	end
+	if type(reflectionType) == "table" then
+		return reflectionType.Name or reflectionType.name or reflectionType.Type or tostring(reflectionType)
+	end
+	return tostring(reflectionType)
+end
+
+local function displayCategory(member)
+	if member.Display and member.Display.Category then
+		return member.Display.Category
+	end
+	return "Other"
+end
+
+local function permitString(permits, key)
+	if not permits or permits[key] == nil then
+		return nil
+	end
+	return tostring(permits[key])
+end
+
+function Reflection.getClassInfo(className)
+	local classData, classErr = safeCall(function()
+		return ReflectionService:GetClass(className)
+	end)
+
+	local properties = {}
+	local propData = safeCall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if propData then
+		for _, property in propData do
+			table.insert(properties, {
+				name = property.Name,
+				type = typeName(property.Type),
+				category = displayCategory(property),
+				owner = property.Owner,
+				serialized = property.Serialized,
+				readPermission = permitString(property.Permits, "Read"),
+				writePermission = permitString(property.Permits, "Write"),
+			})
+		end
+	end
+
+	local methods = {}
+	local methodData = safeCall(function()
+		return ReflectionService:GetMethodsOfClass(className)
+	end)
+	if methodData then
+		for _, method in methodData do
+			local parameters = {}
+			for _, parameter in method.Parameters or {} do
+				table.insert(parameters, {
+					name = parameter.Name,
+					type = typeName(parameter.Type),
+					defaultValue = parameter.DefaultValue,
+				})
+			end
+			table.insert(methods, {
+				name = method.Name,
+				parameters = parameters,
+				returnType = typeName(method.ReturnType),
+				canYield = method.CanYield,
+				owner = method.Owner,
+			})
+		end
+	end
+
+	local events = {}
+	local eventData = safeCall(function()
+		return ReflectionService:GetEventsOfClass(className)
+	end)
+	if eventData then
+		for _, event in eventData do
+			local parameters = {}
+			for _, parameter in event.Parameters or {} do
+				table.insert(parameters, { name = parameter.Name, type = typeName(parameter.Type) })
+			end
+			table.insert(events, { name = event.Name, parameters = parameters, owner = event.Owner })
+		end
+	end
+
+	local result = {
+		success = classData ~= nil or #properties > 0,
+		className = className,
+		properties = properties,
+		methods = methods,
+		events = events,
+	}
+	if classData then
+		result.superclass = classData.Superclass and tostring(classData.Superclass) or nil
+		result.newPermission = permitString(classData.Permits, "New")
+		result.creatable = classData.Permits ~= nil and classData.Permits.New ~= nil
+	end
+	if classErr and #properties == 0 then
+		result.error = "Could not reflect class: " .. tostring(classErr)
+	end
+	return result
+end
+
+function Reflection.getPropertyTypes(className)
+	local properties = safeCall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if not properties then
+		return {}
+	end
+	local result = {}
+	for _, property in properties do
+		result[property.Name] = typeName(property.Type)
+	end
+	return result
+end
+
+function Reflection.getPropertyMetadata(className)
+	local properties = safeCall(function()
+		return ReflectionService:GetPropertiesOfClass(className)
+	end)
+	if not properties then
+		return {}
+	end
+	local result = {}
+	for _, property in properties do
+		result[property.Name] = {
+			type = typeName(property.Type),
+			category = displayCategory(property),
+			writable = property.Permits == nil or property.Permits.Write ~= nil,
+		}
+	end
+	return result
+end
+
+function Reflection.listClasses()
+	local classes = safeCall(function()
+		return ReflectionService:GetClasses()
+	end)
+	if not classes then
+		return {}
+	end
+	local result = {}
+	for _, classData in classes do
+		table.insert(result, {
+			name = classData.Name,
+			superclass = classData.Superclass and tostring(classData.Superclass) or nil,
+			creatable = classData.Permits ~= nil and classData.Permits.New ~= nil,
+		})
+	end
+	table.sort(result, function(a, b)
+		return a.name < b.name
+	end)
+	return result
+end
+
+return Reflection
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="9">
+      <Properties>
+        <string name="Name">TestRunner</string>
+        <string name="Source"><![CDATA[local StudioTestService = game:GetService("StudioTestService")
+
+local TestRunner = {}
+local activeRunId = nil
+
+function TestRunner.executeV2(spec)
+	if activeRunId then
+		return { success = false, error = "A Dominus Studio test is already running" }
+	end
+
+	local mode = spec.mode or "run"
+	if mode ~= "run" and mode ~= "play" and mode ~= "multiplayer" then
+		return { success = false, error = "mode must be run, play, or multiplayer" }
+	end
+	local timeoutSeconds = math.clamp((spec.timeoutMs or 120000) / 1000, 5, 600)
+	local players = math.clamp(spec.players or 1, 1, 8)
+	local runId = tostring(os.clock()) .. ":" .. mode
+	activeRunId = runId
+	local timedOut = false
+
+	task.delay(timeoutSeconds, function()
+		if activeRunId ~= runId then
+			return
+		end
+		timedOut = true
+		pcall(function()
+			if StudioTestService:CanLeaveTest() then
+				StudioTestService:LeaveTest()
+			end
+		end)
+	end)
+
+	local startedAt = os.clock()
+	local ok, result = pcall(function()
+		if mode == "run" then
+			return StudioTestService:ExecuteRunModeAsync(spec.args)
+		elseif mode == "play" then
+			return StudioTestService:ExecutePlayModeAsync(spec.args)
+		end
+		return StudioTestService:ExecuteMultiplayerTestAsync(players, spec.args)
+	end)
+	local duration = os.clock() - startedAt
+	if activeRunId == runId then
+		activeRunId = nil
+	end
+
+	if timedOut then
+		return { success = false, timedOut = true, error = "Studio test exceeded its timeout", duration = duration }
+	end
+	if not ok then
+		return { success = false, error = tostring(result), duration = duration }
+	end
+	return {
+		success = true,
+		mode = mode,
+		players = mode == "multiplayer" and players or nil,
+		result = result,
+		duration = duration,
+	}
+end
+
+function TestRunner.endTest(value)
+	local ok, err = pcall(function()
+		StudioTestService:EndTest(value)
+	end)
+	return ok and { success = true } or { success = false, error = tostring(err) }
+end
+
+return TestRunner
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="10">
+      <Properties>
+        <string name="Name">UIBuilder</string>
+        <string name="Source"><![CDATA[--[[
+	UIBuilder: create entire UI trees from a declarative JSON spec in one call.
+	Handles all type coercion natively in Luau — no round trips needed.
+]]
+
+local Explorer = require(script.Parent.Explorer)
+local InstanceRegistry = require(script.Parent.InstanceRegistry)
+local Reflection = require(script.Parent.Reflection)
+local ValueCodec = require(script.Parent.ValueCodec)
+local ChangeHistoryService = game:GetService("ChangeHistoryService")
+
+local UIBuilder = {}
+
+-- Cache property type maps per ClassName to avoid repeated reflection calls
+local propertyTypeCache = {}
+local function getPropertyType(className, propName)
+	if not propertyTypeCache[className] then
+		propertyTypeCache[className] = Reflection.getPropertyTypes(className)
+	end
+	return propertyTypeCache[className][propName]
+end
+
+local function resolveColor(value)
+	if type(value) == "string" then
+		if value:sub(1, 1) == "#" then
+			return Color3.fromHex(value)
+		end
+		local r, g, b = value:match("rgb%s*%((%d+)%D+(%d+)%D+(%d+)%)")
+		if r then
+			return Color3.fromRGB(tonumber(r), tonumber(g), tonumber(b))
+		end
+		local ok, bc = pcall(BrickColor.new, value)
+		if ok then
+			return bc.Color
+		end
+	end
+	if type(value) == "table" then
+		if value[1] then
+			if value[1] > 1 or value[2] > 1 or value[3] > 1 then
+				return Color3.fromRGB(value[1], value[2], value[3])
+			end
+			return Color3.new(value[1], value[2], value[3])
+		end
+		if value.R or value.r then
+			return Color3.new(value.R or value.r or 0, value.G or value.g or 0, value.B or value.b or 0)
+		end
+	end
+	return Color3.new(1, 1, 1)
+end
+
+local function resolveUDim2(value)
+	if type(value) == "table" then
+		if value.XScale or value.xScale then
+			return UDim2.new(
+				value.XScale or value.xScale or 0,
+				value.XOffset or value.xOffset or 0,
+				value.YScale or value.yScale or 0,
+				value.YOffset or value.yOffset or 0
+			)
+		end
+		if value.X and type(value.X) == "table" then
+			return UDim2.new(
+				value.X.Scale or value.X[1] or 0,
+				value.X.Offset or value.X[2] or 0,
+				value.Y and (value.Y.Scale or value.Y[1]) or 0,
+				value.Y and (value.Y.Offset or value.Y[2]) or 0
+			)
+		end
+		if value[1] ~= nil then
+			return UDim2.new(value[1] or 0, value[2] or 0, value[3] or 0, value[4] or 0)
+		end
+	end
+	if type(value) == "string" then
+		local a, b, c, d = value:match("([%d%.%-]+)%s*,%s*([%d%.%-]+)%s*,%s*([%d%.%-]+)%s*,%s*([%d%.%-]+)")
+		if a then
+			return UDim2.new(tonumber(a), tonumber(b), tonumber(c), tonumber(d))
+		end
+	end
+	return UDim2.new(0, 0, 0, 0)
+end
+
+local function resolveUDim(value)
+	if type(value) == "table" then
+		return UDim.new(value.Scale or value[1] or 0, value.Offset or value[2] or 0)
+	end
+	if type(value) == "number" then
+		return UDim.new(0, value)
+	end
+	return UDim.new(0, 0)
+end
+
+local function resolveVector2(value)
+	if type(value) == "table" then
+		return Vector2.new(value.X or value.x or value[1] or 0, value.Y or value.y or value[2] or 0)
+	end
+	return Vector2.new(0, 0)
+end
+
+local function resolveEnum(instance, key, value)
+	if type(value) ~= "string" then
+		return value
+	end
+	local curOk, curVal = pcall(function()
+		return instance[key]
+	end)
+	if curOk and typeof(curVal) == "EnumItem" then
+		local enumType = tostring(curVal.EnumType)
+		local ok, enumVal = pcall(function()
+			return Enum[enumType][value]
+		end)
+		if ok then
+			return enumVal
+		end
+	end
+	return value
+end
+
+local function resolveFont(value)
+	if type(value) == "string" then
+		local ok, font = pcall(function()
+			return Enum.Font[value]
+		end)
+		if ok then
+			return font
+		end
+	end
+	return value
+end
+
+local UDIM2_PROPS = {
+	Size = true,
+	Position = true,
+	CellSize = true,
+	CellPadding = true,
+}
+
+local COLOR3_PROPS = {
+	BackgroundColor3 = true,
+	BorderColor3 = true,
+	TextColor3 = true,
+	ImageColor3 = true,
+	PlaceholderColor3 = true,
+	TextStrokeColor3 = true,
+	ScrollBarImageColor3 = true,
+}
+
+local function resolveColorSequence(value)
+	if type(value) == "table" then
+		-- Array of keypoints: {{time, color}, ...}
+		if type(value[1]) == "table" then
+			local keypoints = {}
+			for _, kp in ipairs(value) do
+				local t = kp[1] or kp.Time or 0
+				local c = resolveColor(kp[2] or kp.Color or kp)
+				table.insert(keypoints, ColorSequenceKeypoint.new(t, c))
+			end
+			return ColorSequence.new(keypoints)
+		end
+		-- Single color as array [r,g,b] → uniform ColorSequence
+		if type(value[1]) == "number" and #value == 3 then
+			local c = resolveColor(value)
+			return ColorSequence.new(c)
+		end
+	end
+	-- String hex/rgb → uniform ColorSequence
+	if type(value) == "string" then
+		return ColorSequence.new(resolveColor(value))
+	end
+	return ColorSequence.new(Color3.new(1, 1, 1))
+end
+
+local function resolveNumberSequence(value)
+	if type(value) == "table" then
+		-- Array of keypoints: {{time, value, envelope?}, ...}
+		if type(value[1]) == "table" then
+			local keypoints = {}
+			for _, kp in ipairs(value) do
+				local t = kp[1] or kp.Time or 0
+				local v = kp[2] or kp.Value or 0
+				local e = kp[3] or kp.Envelope or 0
+				table.insert(keypoints, NumberSequenceKeypoint.new(t, v, e))
+			end
+			return NumberSequence.new(keypoints)
+		end
+	end
+	if type(value) == "number" then
+		return NumberSequence.new(value)
+	end
+	return NumberSequence.new(0)
+end
+
+local VECTOR2_PROPS = {
+	AnchorPoint = true,
+	CanvasSize_v2 = true,
+	AbsoluteSize = true,
+	AbsolutePosition = true,
+}
+
+local UDIM_PROPS = {
+	CornerRadius = true,
+	Padding = true,
+	PaddingTop = true,
+	PaddingBottom = true,
+	PaddingLeft = true,
+	PaddingRight = true,
+	FillDirection = false, -- not UDim
+}
+
+local NUMBER_RANGE_PROPS = {
+	Range = true,
+	RotationRange = true,
+	Size_NR = true, -- particle size range alias
+}
+
+local RECT_PROPS = {
+	SliceCenter = true,
+	ImageRectOffset_Rect = true,
+}
+
+local function resolveNumberRange(value)
+	if type(value) == "table" then
+		return NumberRange.new(value[1] or 0, value[2] or value[1] or 0)
+	end
+	if type(value) == "number" then
+		return NumberRange.new(value)
+	end
+	return NumberRange.new(0)
+end
+
+local function resolveRect(value)
+	if type(value) == "table" then
+		if #value == 4 then
+			return Rect.new(value[1], value[2], value[3], value[4])
+		end
+		return Rect.new(
+			value.Min and value.Min[1] or value.MinX or 0,
+			value.Min and value.Min[2] or value.MinY or 0,
+			value.Max and value.Max[1] or value.MaxX or 0,
+			value.Max and value.Max[2] or value.MaxY or 0
+		)
+	end
+	return Rect.new(0, 0, 0, 0)
+end
+
+-- Disambiguate 2-element arrays: check actual property type on the instance
+local function resolve2ElementArray(instance, key, value)
+	-- First, check our known lookup tables
+	if VECTOR2_PROPS[key] then
+		return resolveVector2(value)
+	end
+	if UDIM_PROPS[key] then
+		return resolveUDim(value)
+	end
+	if NUMBER_RANGE_PROPS[key] then
+		return resolveNumberRange(value)
+	end
+	-- Fall back to runtime type introspection
+	local ok, curVal = pcall(function()
+		return instance[key]
+	end)
+	if ok and curVal ~= nil then
+		local t = typeof(curVal)
+		if t == "Vector2" then
+			return resolveVector2(value)
+		end
+		if t == "UDim" then
+			return resolveUDim(value)
+		end
+		if t == "NumberRange" then
+			return resolveNumberRange(value)
+		end
+	end
+	-- Default: assume UDim for 2-element (more common in UI)
+	return resolveUDim(value)
+end
+
+local function applyProperty(instance, key, value)
+	-- Special handling by property name
+	if key == "Size" or key == "Position" then
+		if instance:IsA("GuiObject") or instance:IsA("UIBase") then
+			instance[key] = resolveUDim2(value)
+			return
+		end
+	end
+
+	if key == "AnchorPoint" then
+		if instance:IsA("GuiObject") then
+			instance[key] = resolveVector2(value)
+			return
+		end
+	end
+
+	if key == "CanvasSize" and instance:IsA("ScrollingFrame") then
+		instance[key] = resolveUDim2(value)
+		return
+	end
+
+	if UDIM_PROPS[key] then
+		instance[key] = resolveUDim(value)
+		return
+	end
+
+	-- Use reflection to distinguish Color3 vs ColorSequence, NumberSequence, etc.
+	local propType = getPropertyType(instance.ClassName, key)
+
+	if propType == "ColorSequence" then
+		instance[key] = resolveColorSequence(value)
+		return
+	end
+
+	if propType == "NumberSequence" then
+		instance[key] = resolveNumberSequence(value)
+		return
+	end
+
+	if COLOR3_PROPS[key] or propType == "Color3" then
+		instance[key] = resolveColor(value)
+		return
+	end
+
+	-- Reflection-based coercion for types not in hardcoded tables
+	if propType == "UDim2" and type(value) == "table" then
+		instance[key] = resolveUDim2(value)
+		return
+	end
+	if propType == "UDim" then
+		instance[key] = resolveUDim(value)
+		return
+	end
+	if propType == "Vector2" then
+		instance[key] = resolveVector2(value)
+		return
+	end
+	if propType == "NumberRange" then
+		instance[key] = resolveNumberRange(value)
+		return
+	end
+	if propType == "Rect" then
+		instance[key] = resolveRect(value)
+		return
+	end
+
+	-- Rect properties (4-element arrays like SliceCenter)
+	if RECT_PROPS[key] then
+		instance[key] = resolveRect(value)
+		return
+	end
+
+	-- NumberRange properties
+	if NUMBER_RANGE_PROPS[key] then
+		instance[key] = resolveNumberRange(value)
+		return
+	end
+
+	if key == "Font" and (instance:IsA("TextLabel") or instance:IsA("TextButton") or instance:IsA("TextBox")) then
+		instance[key] = resolveFont(value)
+		return
+	end
+
+	if key == "FontFace" then
+		if type(value) == "table" then
+			local family = value.Family or "rbxasset://fonts/families/SourceSansPro.json"
+			local weight = Enum.FontWeight.Regular
+			local style = Enum.FontStyle.Normal
+			pcall(function()
+				weight = Enum.FontWeight[value.Weight or "Regular"]
+			end)
+			pcall(function()
+				style = Enum.FontStyle[value.Style or "Normal"]
+			end)
+			instance.FontFace = Font.new(family, weight, style)
+		end
+		return
+	end
+
+	-- Enum properties (string values)
+	if type(value) == "string" then
+		local resolved = resolveEnum(instance, key, value)
+		local ok, err = pcall(function()
+			instance[key] = resolved
+		end)
+		if not ok then
+			-- Maybe it's a direct value
+			pcall(function()
+				instance[key] = value
+			end)
+		end
+		return
+	end
+
+	if UDIM2_PROPS[key] then
+		pcall(function()
+			instance[key] = resolveUDim2(value)
+		end)
+		return
+	end
+
+	-- Smart disambiguation for 2-element table arrays
+	if type(value) == "table" and #value == 2 then
+		local resolved = resolve2ElementArray(instance, key, value)
+		pcall(function()
+			instance[key] = resolved
+		end)
+		return
+	end
+
+	-- 4-element table arrays: try Rect if not already handled as UDim2
+	if type(value) == "table" and #value == 4 then
+		-- Check actual property type
+		local ok, curVal = pcall(function()
+			return instance[key]
+		end)
+		if ok and curVal ~= nil then
+			local t = typeof(curVal)
+			if t == "Rect" then
+				pcall(function()
+					instance[key] = resolveRect(value)
+				end)
+				return
+			elseif t == "UDim2" then
+				pcall(function()
+					instance[key] = resolveUDim2(value)
+				end)
+				return
+			end
+		end
+		-- Default 4-element to UDim2
+		pcall(function()
+			instance[key] = resolveUDim2(value)
+		end)
+		return
+	end
+
+	-- Direct assignment for numbers, booleans, etc.
+	pcall(function()
+		instance[key] = value
+	end)
+end
+
+local RESERVED_KEYS = {
+	ClassName = true,
+	className = true,
+	Name = true,
+	name = true,
+	Children = true,
+	children = true,
+	properties = true,
+	Properties = true,
+	props = true,
+	Props = true,
+}
+
+local function buildNode(spec, parent, animate)
+	local className = spec.ClassName or spec.className or "Frame"
+	local name = spec.Name or spec.name or className
+
+	local instance = Instance.new(className)
+	instance.Name = name
+
+	-- Apply flattened top-level properties
+	for key, value in spec do
+		if not RESERVED_KEYS[key] then
+			applyProperty(instance, key, value)
+		end
+	end
+
+	-- Also accept a nested "properties" / "Properties" / "props" bag for convenience.
+	-- This lets callers group properties explicitly without the key being misread
+	-- as an instance property name.
+	local propBag = spec.properties or spec.Properties or spec.props or spec.Props
+	if type(propBag) == "table" then
+		for key, value in propBag do
+			if not RESERVED_KEYS[key] then
+				applyProperty(instance, key, value)
+			end
+		end
+	end
+
+	-- Set parent after properties to avoid unnecessary layout computations
+	instance.Parent = parent
+
+	-- Build children recursively
+	local children = spec.Children or spec.children
+	if children then
+		for _, childSpec in children do
+			if animate then
+				task.wait(0.05)
+			end
+			buildNode(childSpec, instance, animate)
+		end
+	end
+
+	return instance
+end
+
+function UIBuilder.build(spec)
+	local parentPath = spec.parent or "StarterGui"
+	local parent = Explorer.resolveInstance(parentPath)
+	if not parent then
+		-- Try as a service
+		local ok
+		ok, parent = pcall(function()
+			return game:GetService(parentPath)
+		end)
+		if not ok then
+			return { success = false, error = "Parent not found: " .. parentPath }
+		end
+	end
+
+	-- Clean up existing instance with same name
+	local existingName = spec.tree and (spec.tree.Name or spec.tree.name) or nil
+	if existingName then
+		local existing = parent:FindFirstChild(existingName)
+		if existing then
+			existing:Destroy()
+		end
+	end
+
+	local tree = spec.tree
+	if not tree then
+		return { success = false, error = "No 'tree' provided in spec" }
+	end
+
+	local animate = false
+	if spec.animate ~= nil then
+		animate = spec.animate
+	end
+
+	local ok, result = pcall(function()
+		return buildNode(tree, parent, animate)
+	end)
+
+	if not ok then
+		return { success = false, error = "Build failed: " .. tostring(result) }
+	end
+
+	local path = Explorer.getPath(result)
+	local count = 0
+	local function countDescendants(inst)
+		count = count + 1
+		for _, child in inst:GetChildren() do
+			countDescendants(child)
+		end
+	end
+	countDescendants(result)
+
+	return { success = true, path = path, instanceCount = count }
+end
+
+--[[
+	Serialize: convert an existing instance tree into create_ui-compatible JSON.
+	Reads properties via ReflectionService, converts Roblox types to JSON-friendly values,
+	and skips default/unchanged values to keep output minimal.
+]]
+
+local Reflection = require(script.Parent.Reflection)
+local ReflectionService = game:GetService("ReflectionService")
+
+-- Convert a Roblox value to a JSON-friendly representation
+local function valueToJson(value, propType)
+	local t = typeof(value)
+
+	if t == "UDim2" then
+		return { value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset }
+	end
+	if t == "UDim" then
+		return { value.Scale, value.Offset }
+	end
+	if t == "Vector2" then
+		return { value.X, value.Y }
+	end
+	if t == "Vector3" then
+		return { value.X, value.Y, value.Z }
+	end
+	if t == "Color3" then
+		return "#" .. value:ToHex()
+	end
+	if t == "BrickColor" then
+		return value.Name
+	end
+	if t == "ColorSequence" then
+		local kps = {}
+		for _, kp in value.Keypoints do
+			table.insert(kps, { kp.Time, "#" .. kp.Value:ToHex() })
+		end
+		return kps
+	end
+	if t == "NumberSequence" then
+		local kps = {}
+		for _, kp in value.Keypoints do
+			table.insert(kps, { kp.Time, kp.Value, kp.Envelope })
+		end
+		return kps
+	end
+	if t == "NumberRange" then
+		return { value.Min, value.Max }
+	end
+	if t == "Rect" then
+		return { value.Min.X, value.Min.Y, value.Max.X, value.Max.Y }
+	end
+	if t == "CFrame" then
+		return { value:GetComponents() }
+	end
+	if t == "EnumItem" then
+		return value.Name
+	end
+	if t == "Font" then
+		return {
+			Family = value.Family,
+			Weight = value.Weight.Name,
+			Style = value.Style.Name,
+		}
+	end
+	if t == "boolean" or t == "number" or t == "string" then
+		return value
+	end
+	-- Fallback: tostring
+	return tostring(value)
+end
+
+local SERIALIZE_SKIP = {
+	Parent = true,
+	ClassName = true,
+	Name = true,
+	Archivable = true,
+	AbsolutePosition = true,
+	AbsoluteSize = true,
+	AbsoluteRotation = true,
+	IsLoaded = true,
+}
+
+local function serializeNode(instance, maxDepth, depth)
+	if depth > maxDepth then
+		return nil
+	end
+
+	local node = {
+		ClassName = instance.ClassName,
+		Name = instance.Name,
+	}
+
+	-- Get non-default properties via reflection
+	local ok, propData = pcall(function()
+		return ReflectionService:GetPropertiesOfClass(instance.ClassName)
+	end)
+
+	if ok and propData then
+		-- Create a default instance to compare against
+		local defaultInstance = nil
+		pcall(function()
+			defaultInstance = Instance.new(instance.ClassName)
+		end)
+
+		for _, prop in propData do
+			if not SERIALIZE_SKIP[prop.Name] and not prop.Name:match("^Absolute") then
+				local valOk, value = pcall(function()
+					return instance[prop.Name]
+				end)
+				if valOk and value ~= nil then
+					-- Skip default values
+					local isDefault = false
+					if defaultInstance then
+						local defOk, defVal = pcall(function()
+							return defaultInstance[prop.Name]
+						end)
+						if defOk and defVal == value then
+							isDefault = true
+						end
+					end
+
+					if not isDefault then
+						local jsonVal = valueToJson(value, prop.Type and tostring(prop.Type))
+						if jsonVal ~= nil then
+							node[prop.Name] = jsonVal
+						end
+					end
+				end
+			end
+		end
+
+		if defaultInstance then
+			pcall(function()
+				defaultInstance:Destroy()
+			end)
+		end
+	end
+
+	-- Serialize children
+	local children = instance:GetChildren()
+	if #children > 0 then
+		node.Children = {}
+		for _, child in children do
+			local childNode = serializeNode(child, maxDepth, depth + 1)
+			if childNode then
+				table.insert(node.Children, childNode)
+			end
+		end
+		if #node.Children == 0 then
+			node.Children = nil
+		end
+	end
+
+	return node
+end
+
+function UIBuilder.serialize(spec)
+	local path = spec.path
+	if not path then
+		return { success = false, error = "Missing 'path' parameter" }
+	end
+
+	local instance = Explorer.resolveInstance(path)
+	if not instance then
+		return { success = false, error = "Instance not found: " .. path }
+	end
+
+	local maxDepth = spec.maxDepth or 50
+
+	local ok, tree = pcall(function()
+		return serializeNode(instance, maxDepth, 0)
+	end)
+
+	if not ok then
+		return { success = false, error = "Serialization failed: " .. tostring(tree) }
+	end
+
+	return { success = true, tree = tree }
+end
+
+local function buildStrictNode(spec, state, depth)
+	assert(type(spec) == "table", "Every UI node must be an object")
+	if depth > state.maxDepth then
+		error("UI tree exceeds maximum depth of " .. state.maxDepth)
+	end
+	state.count += 1
+	if state.count > state.maxNodes then
+		error("UI tree exceeds maximum node count of " .. state.maxNodes)
+	end
+
+	local className = spec.ClassName or spec.className
+	assert(type(className) == "string", "Every UI node requires ClassName")
+	local instance = Instance.new(className)
+	instance.Name = spec.Name or spec.name or className
+
+	for key, value in spec do
+		if not RESERVED_KEYS[key] then
+			ValueCodec.setProperty(instance, key, value)
+		end
+	end
+	local properties = spec.properties or spec.Properties or spec.props or spec.Props
+	if properties ~= nil then
+		assert(type(properties) == "table", "UI node properties must be an object")
+		for key, value in properties do
+			ValueCodec.setProperty(instance, key, value)
+		end
+	end
+
+	local children = spec.Children or spec.children
+	if children ~= nil then
+		assert(type(children) == "table", "UI node Children must be an array")
+		for _, childSpec in children do
+			local child = buildStrictNode(childSpec, state, depth + 1)
+			child.Parent = instance
+		end
+	end
+	return instance
+end
+
+function UIBuilder.buildV2(spec)
+	if type(spec.tree) ~= "table" then
+		return { success = false, error = "tree is required" }
+	end
+	local parentRef = spec.parent or { pathSegments = { "StarterGui" } }
+	local parent, parentErr = InstanceRegistry.resolve(parentRef)
+	if not parent then
+		return { success = false, error = "Parent: " .. tostring(parentErr) }
+	end
+
+	local state = {
+		count = 0,
+		maxDepth = math.clamp(spec.maxDepth or 30, 1, 50),
+		maxNodes = math.clamp(spec.maxNodes or 1000, 1, 3000),
+	}
+	local builtOk, rootOrError = pcall(function()
+		return buildStrictNode(spec.tree, state, 0)
+	end)
+	if not builtOk then
+		return { success = false, error = "UI validation failed: " .. tostring(rootOrError) }
+	end
+	local root = rootOrError
+
+	local existing = nil
+	local duplicateCount = 0
+	for _, child in parent:GetChildren() do
+		if child.Name == root.Name then
+			existing = child
+			duplicateCount += 1
+		end
+	end
+	if duplicateCount > 1 then
+		root:Destroy()
+		return {
+			success = false,
+			error = "Replacement target is ambiguous because multiple children share the name " .. root.Name,
+		}
+	end
+	if existing and spec.replaceExisting ~= true then
+		root:Destroy()
+		return {
+			success = false,
+			error = "A child named " .. root.Name .. " already exists; set replaceExisting=true to replace it",
+		}
+	end
+
+	local recording = ChangeHistoryService:TryBeginRecording("Dominus 2: Build UI " .. root.Name)
+	if not recording then
+		root:Destroy()
+		return { success = false, error = "Another plugin recording is already active" }
+	end
+	local commitOk, commitErr = pcall(function()
+		if existing then
+			existing:Destroy()
+		end
+		root.Parent = parent
+	end)
+	if not commitOk then
+		ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Cancel)
+		if root.Parent == nil then
+			root:Destroy()
+		end
+		return { success = false, error = "UI commit failed: " .. tostring(commitErr), rolledBack = true }
+	end
+	ChangeHistoryService:FinishRecording(recording, Enum.FinishRecordingOperation.Commit)
+	return {
+		success = true,
+		root = InstanceRegistry.toRef(root),
+		instanceCount = state.count,
+		replaced = existing ~= nil,
+	}
+end
+
+function UIBuilder.snapshotV2(spec)
+	local instance, err = InstanceRegistry.resolve(spec.target)
+	if not instance then
+		return { success = false, error = err }
+	end
+	local maxDepth = math.clamp(spec.maxDepth or 30, 0, 50)
+	local ok, tree = pcall(function()
+		return serializeNode(instance, maxDepth, 0)
+	end)
+	if not ok then
+		return { success = false, error = "UI serialization failed: " .. tostring(tree) }
+	end
+	return { success = true, target = InstanceRegistry.toRef(instance), tree = tree }
+end
+
+return UIBuilder
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="11">
+      <Properties>
+        <string name="Name">ValueCodec</string>
+        <string name="Source"><![CDATA[local InstanceRegistry = require(script.Parent.InstanceRegistry)
+
+local ValueCodec = {}
+
+local function number(value, label)
+	if type(value) ~= "number" then
+		error(label .. " must be a number")
+	end
+	return value
+end
+
+local function component(value, names, index, default)
+	for _, name in names do
+		if value[name] ~= nil then
+			return number(value[name], name)
+		end
+	end
+	if value[index] ~= nil then
+		return number(value[index], tostring(index))
+	end
+	return default
+end
+
+local function decodeColor3(value)
+	if type(value) == "string" then
+		if value:sub(1, 1) == "#" then
+			return Color3.fromHex(value)
+		end
+		local r, g, b = value:match("rgb%s*%((%d+)%D+(%d+)%D+(%d+)%)")
+		if r then
+			return Color3.fromRGB(tonumber(r), tonumber(g), tonumber(b))
+		end
+		error("Color3 strings must be #RRGGBB or rgb(r,g,b)")
+	end
+	if type(value) ~= "table" then
+		error("Color3 must be a string or array")
+	end
+	local r = component(value, { "R", "r", "red" }, 1, 0)
+	local g = component(value, { "G", "g", "green" }, 2, 0)
+	local b = component(value, { "B", "b", "blue" }, 3, 0)
+	if r > 1 or g > 1 or b > 1 then
+		return Color3.fromRGB(r, g, b)
+	end
+	return Color3.new(r, g, b)
+end
+
+local function decodeEnum(current, value)
+	if typeof(value) == "EnumItem" then
+		return value
+	end
+	if type(value) ~= "string" then
+		error("Enum value must be a string")
+	end
+	local itemName = value:match("Enum%.[^.]+%.(.+)") or value
+	for _, item in current.EnumType:GetEnumItems() do
+		if item.Name == itemName then
+			return item
+		end
+	end
+	error("Invalid enum value " .. value .. " for " .. tostring(current.EnumType))
+end
+
+function ValueCodec.decodeForCurrent(current, value)
+	local expectedType = typeof(current)
+	if expectedType == "UDim2" then
+		assert(type(value) == "table", "UDim2 must be an array or object")
+		return UDim2.new(
+			component(value, { "XScale", "xScale" }, 1, 0),
+			component(value, { "XOffset", "xOffset" }, 2, 0),
+			component(value, { "YScale", "yScale" }, 3, 0),
+			component(value, { "YOffset", "yOffset" }, 4, 0)
+		)
+	elseif expectedType == "UDim" then
+		assert(type(value) == "table", "UDim must be an array or object")
+		return UDim.new(component(value, { "Scale", "scale" }, 1, 0), component(value, { "Offset", "offset" }, 2, 0))
+	elseif expectedType == "Vector2" then
+		assert(type(value) == "table", "Vector2 must be an array or object")
+		return Vector2.new(component(value, { "X", "x" }, 1, 0), component(value, { "Y", "y" }, 2, 0))
+	elseif expectedType == "Vector3" then
+		assert(type(value) == "table", "Vector3 must be an array or object")
+		return Vector3.new(
+			component(value, { "X", "x" }, 1, 0),
+			component(value, { "Y", "y" }, 2, 0),
+			component(value, { "Z", "z" }, 3, 0)
+		)
+	elseif expectedType == "Color3" then
+		return decodeColor3(value)
+	elseif expectedType == "BrickColor" then
+		return BrickColor.new(value)
+	elseif expectedType == "EnumItem" then
+		return decodeEnum(current, value)
+	elseif expectedType == "Rect" then
+		assert(type(value) == "table", "Rect must be a four-number array")
+		return Rect.new(number(value[1], "1"), number(value[2], "2"), number(value[3], "3"), number(value[4], "4"))
+	elseif expectedType == "NumberRange" then
+		if type(value) == "number" then
+			return NumberRange.new(value)
+		end
+		assert(type(value) == "table", "NumberRange must be a number or two-number array")
+		return NumberRange.new(number(value[1], "1"), number(value[2] or value[1], "2"))
+	elseif expectedType == "CFrame" then
+		assert(type(value) == "table", "CFrame must be an array")
+		if #value == 3 then
+			return CFrame.new(value[1], value[2], value[3])
+		elseif #value == 12 then
+			return CFrame.new(table.unpack(value))
+		end
+		error("CFrame requires 3 or 12 numbers")
+	elseif expectedType == "NumberSequence" then
+		if type(value) == "number" then
+			return NumberSequence.new(value)
+		end
+		assert(type(value) == "table", "NumberSequence must be a number or keypoint array")
+		local keypoints = {}
+		for _, keypoint in value do
+			table.insert(keypoints, NumberSequenceKeypoint.new(keypoint[1], keypoint[2], keypoint[3] or 0))
+		end
+		return NumberSequence.new(keypoints)
+	elseif expectedType == "ColorSequence" then
+		if type(value) == "string" then
+			return ColorSequence.new(decodeColor3(value))
+		end
+		assert(type(value) == "table", "ColorSequence must be a color or keypoint array")
+		local keypoints = {}
+		for _, keypoint in value do
+			table.insert(keypoints, ColorSequenceKeypoint.new(keypoint[1], decodeColor3(keypoint[2])))
+		end
+		return ColorSequence.new(keypoints)
+	elseif expectedType == "Font" then
+		assert(type(value) == "table", "Font must be an object")
+		local weight = Enum.FontWeight[value.Weight or value.weight or "Regular"]
+		local style = Enum.FontStyle[value.Style or value.style or "Normal"]
+		assert(weight and style, "Invalid Font weight or style")
+		return Font.new(value.Family or value.family, weight, style)
+	elseif expectedType == "Instance" then
+		local resolved, err = InstanceRegistry.resolve(value)
+		if not resolved then
+			error(err)
+		end
+		return resolved
+	elseif expectedType == "number" then
+		return number(value, "Property")
+	elseif expectedType == "boolean" then
+		assert(type(value) == "boolean", "Property must be a boolean")
+		return value
+	elseif expectedType == "string" then
+		assert(type(value) == "string", "Property must be a string")
+		return value
+	end
+	return value
+end
+
+function ValueCodec.encode(value)
+	local valueType = typeof(value)
+	if valueType == "UDim2" then
+		return { value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset }
+	end
+	if valueType == "UDim" then
+		return { value.Scale, value.Offset }
+	end
+	if valueType == "Vector2" then
+		return { value.X, value.Y }
+	end
+	if valueType == "Vector3" then
+		return { value.X, value.Y, value.Z }
+	end
+	if valueType == "Color3" then
+		return "#" .. value:ToHex()
+	end
+	if valueType == "BrickColor" then
+		return value.Name
+	end
+	if valueType == "EnumItem" then
+		return tostring(value)
+	end
+	if valueType == "Rect" then
+		return { value.Min.X, value.Min.Y, value.Max.X, value.Max.Y }
+	end
+	if valueType == "NumberRange" then
+		return { value.Min, value.Max }
+	end
+	if valueType == "CFrame" then
+		return { value:GetComponents() }
+	end
+	if valueType == "NumberSequence" then
+		local result = {}
+		for _, keypoint in value.Keypoints do
+			table.insert(result, { keypoint.Time, keypoint.Value, keypoint.Envelope })
+		end
+		return result
+	end
+	if valueType == "ColorSequence" then
+		local result = {}
+		for _, keypoint in value.Keypoints do
+			table.insert(result, { keypoint.Time, "#" .. keypoint.Value:ToHex() })
+		end
+		return result
+	end
+	if valueType == "Font" then
+		return { Family = value.Family, Weight = value.Weight.Name, Style = value.Style.Name }
+	end
+	if valueType == "Instance" then
+		return InstanceRegistry.toRef(value)
+	end
+	if valueType == "boolean" or valueType == "number" or valueType == "string" then
+		return value
+	end
+	return tostring(value)
+end
+
+function ValueCodec.setProperty(instance, propertyName, value)
+	if propertyName == "Parent" or propertyName == "ClassName" then
+		error("Property cannot be changed through setProperties: " .. propertyName)
+	end
+	local readOk, current = pcall(function()
+		return instance[propertyName]
+	end)
+	if not readOk then
+		error("Unknown or unreadable property: " .. propertyName)
+	end
+	local decoded = ValueCodec.decodeForCurrent(current, value)
+	local writeOk, writeErr = pcall(function()
+		instance[propertyName] = decoded
+	end)
+	if not writeOk then
+		error("Failed to set " .. propertyName .. ": " .. tostring(writeErr))
+	end
+	return ValueCodec.encode(instance[propertyName])
+end
+
+return ValueCodec
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="12">
+      <Properties>
+        <string name="Name">Watcher</string>
+        <string name="Source"><![CDATA[--[[
+	Watcher: monitors LogService output and forwards to CLI
+]]
+
+local LogService = game:GetService("LogService")
+
+local Watcher = {}
+
+local outputBuffer = {}
+local MAX_BUFFER = 500
+local connection = nil
+local outputCallback = nil
+
+local function classifyLevel(messageType)
+	if messageType == Enum.MessageType.MessageOutput then
+		return "info"
+	elseif messageType == Enum.MessageType.MessageWarning then
+		return "warn"
+	elseif messageType == Enum.MessageType.MessageError then
+		return "error"
+	end
+	return "info"
+end
+
+function Watcher.start(callback)
+	outputCallback = callback
+
+	if connection then
+		connection:Disconnect()
+	end
+
+	connection = LogService.MessageOut:Connect(function(message, messageType)
+		-- Skip every Dominus-prefixed message, including transport errors.
+		if string.find(message, "[Dominus", 1, true) then
+			return
+		end
+
+		local entry = {
+			message = message,
+			level = classifyLevel(messageType),
+			timestamp = os.clock(),
+		}
+
+		-- Buffer for get_output requests
+		table.insert(outputBuffer, entry)
+		if #outputBuffer > MAX_BUFFER then
+			table.remove(outputBuffer, 1)
+		end
+
+		-- Forward to CLI
+		if outputCallback then
+			outputCallback(entry)
+		end
+	end)
+end
+
+function Watcher.stop()
+	if connection then
+		connection:Disconnect()
+		connection = nil
+	end
+	outputCallback = nil
+end
+
+function Watcher.getRecentOutput(limit, levelFilter)
+	limit = limit or 50
+	local result = {}
+
+	for i = math.max(1, #outputBuffer - limit + 1), #outputBuffer do
+		local entry = outputBuffer[i]
+		if entry then
+			if not levelFilter or entry.level == levelFilter then
+				table.insert(result, entry)
+			end
+		end
+	end
+
+	return { entries = result }
+end
+
+function Watcher.clearBuffer()
+	outputBuffer = {}
+end
+
+return Watcher
+]]></string>
+      </Properties>
+    </Item>
+    <Item class="ModuleScript" referent="13">
+      <Properties>
+        <string name="Name">WsClient</string>
+        <string name="Source"><![CDATA[local HttpService = game:GetService("HttpService")
+
+local WsClient = {}
+
+local currentConnection = nil
+local currentSignals = {}
+local currentCancel = nil
+local generation = 0
+
+local function disconnectSignals()
+	for _, signal in currentSignals do
+		signal:Disconnect()
+	end
+	currentSignals = {}
+end
+
+local function closeCandidate(candidate)
+	pcall(function()
+		candidate:Close()
+	end)
+end
+
+function WsClient.connect(url, callbacks, timeoutSeconds)
+	WsClient.disconnect()
+	generation += 1
+	local attempt = generation
+	local completion = Instance.new("BindableEvent")
+	local completed = false
+	local opened = false
+
+	local ok, candidateOrError = pcall(function()
+		return HttpService:CreateWebStreamClient(Enum.WebStreamClientType.WebSocket, { Url = url })
+	end)
+	if not ok then
+		completion:Destroy()
+		if callbacks.onError then
+			callbacks.onError(0, tostring(candidateOrError))
+		end
+		return false, tostring(candidateOrError)
+	end
+	local candidate = candidateOrError
+
+	local function finish(success, reason)
+		if completed then
+			return
+		end
+		completed = true
+		completion:Fire(success, reason)
+	end
+	local function cancelPending()
+		finish(false, "Connection cancelled")
+	end
+	currentCancel = cancelPending
+
+	table.insert(
+		currentSignals,
+		candidate.Opened:Connect(function(statusCode, headers)
+			if attempt ~= generation then
+				return
+			end
+			opened = true
+			currentConnection = candidate
+			if callbacks.onOpen then
+				callbacks.onOpen(statusCode, headers)
+			end
+			finish(true)
+		end)
+	)
+
+	table.insert(
+		currentSignals,
+		candidate.MessageReceived:Connect(function(message)
+			if attempt == generation and opened and callbacks.onMessage then
+				callbacks.onMessage(message)
+			end
+		end)
+	)
+
+	table.insert(
+		currentSignals,
+		candidate.Error:Connect(function(statusCode, errorMessage)
+			if attempt ~= generation then
+				return
+			end
+			if callbacks.onError then
+				callbacks.onError(statusCode, errorMessage)
+			end
+			if not opened then
+				finish(false, errorMessage)
+			end
+		end)
+	)
+
+	table.insert(
+		currentSignals,
+		candidate.Closed:Connect(function()
+			if attempt ~= generation then
+				return
+			end
+			local wasOpened = opened
+			currentConnection = nil
+			opened = false
+			if callbacks.onClose then
+				callbacks.onClose()
+			end
+			if not wasOpened then
+				finish(false, "Connection closed before opening")
+			end
+		end)
+	)
+
+	task.delay(timeoutSeconds or 4, function()
+		if attempt == generation and not completed then
+			closeCandidate(candidate)
+			finish(false, "Connection timed out")
+		end
+	end)
+
+	local success, reason = completion.Event:Wait()
+	if currentCancel == cancelPending then
+		currentCancel = nil
+	end
+	completion:Destroy()
+	if not success then
+		closeCandidate(candidate)
+		if attempt == generation then
+			currentConnection = nil
+			disconnectSignals()
+		end
+	end
+	return success, reason
+end
+
+function WsClient.send(message)
+	if not currentConnection then
+		return false, "WebSocket is not open"
+	end
+	local ok, err = pcall(function()
+		currentConnection:Send(message)
+	end)
+	if not ok then
+		return false, tostring(err)
+	end
+	return true
+end
+
+function WsClient.disconnect()
+	generation += 1
+	local cancelPending = currentCancel
+	currentCancel = nil
+	if cancelPending then
+		cancelPending()
+	end
+	local connection = currentConnection
+	currentConnection = nil
+	disconnectSignals()
+	if connection then
+		closeCandidate(connection)
+	end
+end
+
+function WsClient.isConnected()
+	return currentConnection ~= nil
+end
+
+return WsClient
+]]></string>
+      </Properties>
+    </Item>
+  </Item>
+</roblox>