@caspertech/node-metaverse 0.7.40 → 0.7.51

package/dist/lib/classes/commands/RegionCommands.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegionCommands = void 0;
 const LLSD = require("@caspertech/llsd");
@@ -34,34 +25,35 @@ const Utils_1 = require("../Utils");
 const UUID_1 = require("../UUID");
 const Vector3_1 = require("../Vector3");
 const CommandsBase_1 = require("./CommandsBase");
+const PrimFacesHelper_1 = require("../PrimFacesHelper");
+const Logger_1 = require("../Logger");
+const AssetType_1 = require("../../enums/AssetType");
 class RegionCommands extends CommandsBase_1.CommandsBase {
-    getRegionHandle(regionID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const circuit = this.currentRegion.circuit;
-            const msg = new RegionHandleRequest_1.RegionHandleRequestMessage();
-            msg.RequestBlock = {
-                RegionID: regionID,
-            };
-            circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
-            const responseMsg = yield circuit.waitForMessage(Message_1.Message.RegionIDAndHandleReply, 10000, (filterMsg) => {
-                if (filterMsg.ReplyBlock.RegionID.toString() === regionID.toString()) {
-                    return FilterResponse_1.FilterResponse.Finish;
-                }
-                else {
-                    return FilterResponse_1.FilterResponse.NoMatch;
-                }
-            });
-            return responseMsg.ReplyBlock.RegionHandle;
+    async getRegionHandle(regionID) {
+        const { circuit } = this.currentRegion;
+        const msg = new RegionHandleRequest_1.RegionHandleRequestMessage();
+        msg.RequestBlock = {
+            RegionID: regionID,
+        };
+        circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
+        const responseMsg = await circuit.waitForMessage(Message_1.Message.RegionIDAndHandleReply, 10000, (filterMsg) => {
+            if (filterMsg.ReplyBlock.RegionID.toString() === regionID.toString()) {
+                return FilterResponse_1.FilterResponse.Finish;
+            }
+            else {
+                return FilterResponse_1.FilterResponse.NoMatch;
+            }
         });
+        return responseMsg.ReplyBlock.RegionHandle;
     }
-    waitForHandshake(timeout = 10000) {
+    async waitForHandshake(timeout = 10000) {
         return new Promise((resolve, reject) => {
             if (this.currentRegion.handshakeComplete) {
                 resolve();
             }
             else {
-                let handshakeSubscription;
-                let timeoutTimer;
+                let handshakeSubscription = undefined;
+                let timeoutTimer = undefined;
                 handshakeSubscription = this.currentRegion.handshakeCompleteEvent.subscribe(() => {
                     if (timeoutTimer !== undefined) {
                         clearTimeout(timeoutTimer);
@@ -98,7 +90,7 @@ class RegionCommands extends CommandsBase_1.CommandsBase {
             }
         });
     }
-    estateMessage(method, params) {
+    async estateMessage(method, params) {
         const msg = new EstateOwnerMessage_1.EstateOwnerMessageMessage();
         msg.AgentData = {
             AgentID: this.agent.agentID,
@@ -118,10 +110,10 @@ class RegionCommands extends CommandsBase_1.CommandsBase {
         const sequenceID = this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
         return this.circuit.waitForAck(sequenceID, 10000);
     }
-    restartRegion(secs) {
+    async restartRegion(secs) {
         return this.estateMessage('restart', [String(secs)]);
     }
-    simulatorMessage(message) {
+    async simulatorMessage(message) {
         return this.estateMessage('simulatormessage', [
             '-1',
             '-1',
@@ -130,56 +122,54 @@ class RegionCommands extends CommandsBase_1.CommandsBase {
             message
         ]);
     }
-    cancelRestart() {
+    async cancelRestart() {
         return this.restartRegion(-1);
     }
     getAvatarsInRegion() {
-        return Object.values(this.currentRegion.agents);
+        return Array.from(this.currentRegion.agents.values());
     }
-    deselectObjects(objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const selectLimit = 255;
-            if (objects.length > selectLimit) {
-                for (let x = 0; x < objects.length; x += selectLimit) {
-                    const selectList = [];
-                    for (let y = 0; y < selectLimit; y++) {
-                        if (x + y < objects.length) {
-                            selectList.push(objects[x + y]);
-                        }
+    async deselectObjects(objects) {
+        const selectLimit = 255;
+        if (objects.length > selectLimit) {
+            for (let x = 0; x < objects.length; x += selectLimit) {
+                const selectList = [];
+                for (let y = 0; y < selectLimit; y++) {
+                    if (x + y < objects.length) {
+                        selectList.push(objects[x + y]);
                     }
-                    yield this.deselectObjects(selectList);
                 }
-                return;
+                await this.deselectObjects(selectList);
             }
-            else {
-                const deselectObject = new ObjectDeselect_1.ObjectDeselectMessage();
-                deselectObject.AgentData = {
-                    AgentID: this.agent.agentID,
-                    SessionID: this.circuit.sessionID
-                };
-                deselectObject.ObjectData = [];
-                const uuidMap = {};
-                let skipped = 0;
-                for (const obj of objects) {
-                    if (!(obj instanceof GameObject_1.GameObject)) {
-                        skipped++;
-                        continue;
-                    }
-                    const uuidStr = obj.FullID.toString();
-                    if (!uuidMap[uuidStr]) {
-                        uuidMap[uuidStr] = obj;
-                        deselectObject.ObjectData.push({
-                            ObjectLocalID: obj.ID
-                        });
-                    }
-                }
-                if (skipped > 0) {
-                    console.log('Skipped ' + String(skipped) + ' bad objects during deselection');
+            return;
+        }
+        else {
+            const deselectObject = new ObjectDeselect_1.ObjectDeselectMessage();
+            deselectObject.AgentData = {
+                AgentID: this.agent.agentID,
+                SessionID: this.circuit.sessionID
+            };
+            deselectObject.ObjectData = [];
+            const uuidMap = new Set();
+            let skipped = 0;
+            for (const obj of objects) {
+                if (!(obj instanceof GameObject_1.GameObject)) {
+                    skipped++;
+                    continue;
+                }
+                const uuidStr = obj.FullID.toString();
+                if (!uuidMap.has(uuidStr)) {
+                    uuidMap.add(uuidStr);
+                    deselectObject.ObjectData.push({
+                        ObjectLocalID: obj.ID
+                    });
                 }
-                const sequenceID = this.circuit.sendMessage(deselectObject, PacketFlags_1.PacketFlags.Reliable);
-                return this.circuit.waitForAck(sequenceID, 10000);
             }
-        });
+            if (skipped > 0) {
+                console.log('Skipped ' + String(skipped) + ' bad objects during deselection');
+            }
+            const sequenceID = this.circuit.sendMessage(deselectObject, PacketFlags_1.PacketFlags.Reliable);
+            return this.circuit.waitForAck(sequenceID, 10000);
+        }
     }
     countObjects() {
         return this.currentRegion.objects.getNumberOfObjects();
@@ -195,152 +185,612 @@ class RegionCommands extends CommandsBase_1.CommandsBase {
     exportSettings() {
         return this.currentRegion.exportXML();
     }
-    getTerrain() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.currentRegion.waitForTerrain();
-            const buf = Buffer.allocUnsafe(262144);
-            let pos = 0;
-            for (let x = 0; x < 256; x++) {
-                for (let y = 0; y < 256; y++) {
-                    buf.writeFloatLE(this.currentRegion.terrain[x][y], pos);
-                    pos = pos + 4;
-                }
+    async getTerrain() {
+        await this.currentRegion.waitForTerrain();
+        const buf = Buffer.allocUnsafe(262144);
+        let pos = 0;
+        for (let x = 0; x < 256; x++) {
+            for (let y = 0; y < 256; y++) {
+                buf.writeFloatLE(this.currentRegion.terrain[x][y], pos);
+                pos = pos + 4;
             }
-            return buf;
-        });
+        }
+        return buf;
     }
-    selectObjects(objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const selectLimit = 255;
-            if (objects.length > selectLimit) {
-                for (let x = 0; x < objects.length; x += selectLimit) {
-                    const selectList = [];
-                    for (let y = 0; y < selectLimit; y++) {
-                        if (x + y < objects.length) {
-                            selectList.push(objects[x + y]);
+    async selectObjects(objects) {
+        const selectLimit = 255;
+        if (objects.length > selectLimit) {
+            for (let x = 0; x < objects.length; x += selectLimit) {
+                const selectList = [];
+                for (let y = 0; y < selectLimit; y++) {
+                    if (x + y < objects.length) {
+                        selectList.push(objects[x + y]);
+                    }
+                }
+                await this.selectObjects(selectList);
+            }
+            return;
+        }
+        else {
+            const selectObject = new ObjectSelect_1.ObjectSelectMessage();
+            selectObject.AgentData = {
+                AgentID: this.agent.agentID,
+                SessionID: this.circuit.sessionID
+            };
+            selectObject.ObjectData = [];
+            const uuidMap = new Map();
+            let skipped = 0;
+            for (const obj of objects) {
+                if (!(obj instanceof GameObject_1.GameObject)) {
+                    skipped++;
+                    continue;
+                }
+                const uuidStr = obj.FullID.toString();
+                if (!uuidMap.has(uuidStr)) {
+                    uuidMap.set(uuidStr, obj);
+                    selectObject.ObjectData.push({
+                        ObjectLocalID: obj.ID
+                    });
+                }
+            }
+            if (skipped > 0) {
+                console.log('Skipped ' + String(skipped) + ' bad objects during deselection');
+            }
+            this.circuit.sendMessage(selectObject, PacketFlags_1.PacketFlags.Reliable);
+            try {
+                await this.circuit.waitForMessage(Message_1.Message.ObjectProperties, 10000, (propertiesMessage) => {
+                    let found = false;
+                    for (const objData of propertiesMessage.ObjectData) {
+                        const objDataUUID = objData.ObjectID.toString();
+                        const obj = uuidMap.get(objDataUUID);
+                        if (obj !== undefined) {
+                            obj.creatorID = objData.CreatorID;
+                            obj.creationDate = objData.CreationDate;
+                            obj.baseMask = objData.BaseMask;
+                            obj.ownerMask = objData.OwnerMask;
+                            obj.groupMask = objData.GroupMask;
+                            obj.everyoneMask = objData.EveryoneMask;
+                            obj.nextOwnerMask = objData.NextOwnerMask;
+                            obj.ownershipCost = objData.OwnershipCost;
+                            obj.saleType = objData.SaleType;
+                            obj.salePrice = objData.SalePrice;
+                            obj.aggregatePerms = objData.AggregatePerms;
+                            obj.aggregatePermTextures = objData.AggregatePermTextures;
+                            obj.aggregatePermTexturesOwner = objData.AggregatePermTexturesOwner;
+                            obj.category = objData.Category;
+                            obj.inventorySerial = objData.InventorySerial;
+                            obj.itemID = objData.ItemID;
+                            obj.folderID = objData.FolderID;
+                            obj.fromTaskID = objData.FromTaskID;
+                            obj.groupID = objData.GroupID;
+                            obj.OwnerID = objData.OwnerID;
+                            obj.lastOwnerID = objData.LastOwnerID;
+                            obj.name = Utils_1.Utils.BufferToStringSimple(objData.Name);
+                            obj.description = Utils_1.Utils.BufferToStringSimple(objData.Description);
+                            obj.touchName = Utils_1.Utils.BufferToStringSimple(objData.TouchName);
+                            obj.sitName = Utils_1.Utils.BufferToStringSimple(objData.SitName);
+                            obj.textureID = Utils_1.Utils.BufferToStringSimple(objData.TextureID);
+                            obj.resolvedAt = new Date().getTime() / 1000;
+                            uuidMap.delete(objDataUUID);
+                            found = true;
                         }
                     }
-                    yield this.selectObjects(selectList);
+                    if (Object.keys(uuidMap).length === 0) {
+                        return FilterResponse_1.FilterResponse.Finish;
+                    }
+                    if (!found) {
+                        return FilterResponse_1.FilterResponse.NoMatch;
+                    }
+                    else {
+                        return FilterResponse_1.FilterResponse.Match;
+                    }
+                });
+            }
+            catch (_error) {
+            }
+        }
+    }
+    getName() {
+        return this.currentRegion.regionName;
+    }
+    async resolveObject(object, options) {
+        return this.currentRegion.resolver.resolveObjects([object], options);
+    }
+    async resolveObjects(objects, options) {
+        return this.currentRegion.resolver.resolveObjects(objects, options);
+    }
+    async fetchObjectInventory(object) {
+        return this.currentRegion.resolver.getInventory(object);
+    }
+    async fetchObjectInventories(objects) {
+        return this.currentRegion.resolver.getInventories(objects);
+    }
+    async fetchObjectCost(object) {
+        return this.currentRegion.resolver.getCosts([object]);
+    }
+    async fetchObjectCosts(objects) {
+        return this.currentRegion.resolver.getCosts(objects);
+    }
+    async buildObjectNew(obj, map, callback, costOnly = false, skipMove = false) {
+        const buildMap = new BuildMap_1.BuildMap(map, callback, costOnly);
+        this.gatherAssets(obj, buildMap);
+        const bomTextures = [
+            '5a9f4a74-30f2-821c-b88d-70499d3e7183',
+            'ae2de45c-d252-50b8-5c6e-19f39ce79317',
+            '24daea5f-0539-cfcf-047f-fbc40b2786ba',
+            '52cc6bb6-2ee5-e632-d3ad-50197b1dcb8a',
+            '43529ce8-7faa-ad92-165a-bc4078371687',
+            '09aac1fb-6bce-0bee-7d44-caac6dbb6c63',
+            'ff62763f-d60a-9855-890b-0c96f8f8cd98',
+            '8e915e25-31d1-cc95-ae08-d58a47488251',
+            '9742065b-19b5-297c-858a-29711d539043',
+            '03642e83-2bd1-4eb9-34b4-4c47ed586d2d',
+            'edd51b77-fc10-ce7a-4b3d-011dfc349e4f',
+            'c228d1cf-4b5d-4ba8-84f4-899a0796aa97'
+        ];
+        for (const bomTexture of bomTextures) {
+            buildMap.assetMap.textures.delete(bomTexture);
+        }
+        await callback(map);
+        if (costOnly) {
+            return null;
+        }
+        let agentPos = new Vector3_1.Vector3([128, 128, 2048]);
+        try {
+            const agentLocalID = this.currentRegion.agent.localID;
+            const agentObject = this.currentRegion.objects.getObjectByLocalID(agentLocalID);
+            if (agentObject.Position !== undefined) {
+                agentPos = new Vector3_1.Vector3(agentObject.Position);
+            }
+            else {
+                throw new Error('Agent position is undefined');
+            }
+        }
+        catch (_error) {
+            console.warn('Unable to find avatar location, rezzing at ' + agentPos.toString());
+        }
+        agentPos.z += 2.0;
+        buildMap.rezLocation = agentPos;
+        const campos = new Vector3_1.Vector3(agentPos);
+        campos.z += 2.0;
+        this.currentRegion.clientCommands.agent.setCamera(campos, agentPos, 10, new Vector3_1.Vector3([-1.0, 0, 0]), new Vector3_1.Vector3([0.0, 1.0, 0]));
+        if (buildMap.primsNeeded > 0) {
+            buildMap.primReservoir = await this.createPrims(buildMap.primsNeeded, agentPos);
+        }
+        let storedPosition = undefined;
+        if (skipMove) {
+            storedPosition = obj.Position;
+            obj.Position = new Vector3_1.Vector3(buildMap.rezLocation);
+        }
+        const parts = [];
+        parts.push(async () => {
+            return {
+                index: 1,
+                object: await this.buildPart(obj, Vector3_1.Vector3.getZero(), Quaternion_1.Quaternion.getIdentity(), buildMap, true)
+            };
+        });
+        if (obj.children) {
+            if (obj.Position === undefined) {
+                obj.Position = Vector3_1.Vector3.getZero();
+            }
+            if (obj.Rotation === undefined) {
+                obj.Rotation = Quaternion_1.Quaternion.getIdentity();
+            }
+            let childIndex = 2;
+            for (const child of obj.children) {
+                if (child.Position !== undefined && child.Rotation !== undefined) {
+                    const index = childIndex++;
+                    parts.push(async () => {
+                        return {
+                            index,
+                            object: await this.buildPart(child, new Vector3_1.Vector3(obj.Position), new Quaternion_1.Quaternion(obj.Rotation), buildMap, false)
+                        };
+                    });
                 }
-                return;
+            }
+        }
+        let results = {
+            results: [],
+            errors: []
+        };
+        results = await Utils_1.Utils.promiseConcurrent(parts, 5, 0);
+        if (results.errors.length > 0) {
+            for (const err of results.errors) {
+                console.error(err);
+            }
+        }
+        let rootObj = null;
+        for (const childObject of results.results) {
+            if (childObject.object.isMarkedRoot) {
+                rootObj = childObject.object;
+                break;
+            }
+        }
+        if (rootObj === null) {
+            throw new Error('Failed to find root prim..');
+        }
+        const childPrims = [];
+        results.results.sort((a, b) => {
+            return a.index - b.index;
+        });
+        for (const childObject of results.results) {
+            if (childObject.object !== rootObj) {
+                childPrims.push(childObject.object);
+            }
+        }
+        try {
+            await rootObj.linkFrom(childPrims);
+        }
+        catch (err) {
+            console.error('Link failed:');
+            console.error(err);
+        }
+        if (storedPosition !== undefined) {
+            obj.Position = storedPosition;
+        }
+        return rootObj;
+    }
+    async getObjectByLocalID(id, resolve, waitFor = 0) {
+        let obj = null;
+        try {
+            obj = this.currentRegion.objects.getObjectByLocalID(id);
+        }
+        catch (error) {
+            if (waitFor > 0) {
+                obj = await this.waitForObjectByLocalID(id, waitFor);
             }
             else {
-                const selectObject = new ObjectSelect_1.ObjectSelectMessage();
-                selectObject.AgentData = {
-                    AgentID: this.agent.agentID,
-                    SessionID: this.circuit.sessionID
-                };
-                selectObject.ObjectData = [];
-                const uuidMap = {};
-                let skipped = 0;
-                for (const obj of objects) {
-                    if (!(obj instanceof GameObject_1.GameObject)) {
-                        skipped++;
-                        continue;
+                throw (error);
+            }
+        }
+        if (resolve) {
+            await this.currentRegion.resolver.resolveObjects([obj], {});
+        }
+        return obj;
+    }
+    async getObjectByUUID(id, resolve, waitFor = 0) {
+        let obj = null;
+        try {
+            obj = this.currentRegion.objects.getObjectByUUID(id);
+        }
+        catch (error) {
+            if (waitFor > 0) {
+                obj = await this.waitForObjectByUUID(id, waitFor);
+            }
+            else {
+                throw (error);
+            }
+        }
+        if (resolve) {
+            await this.currentRegion.resolver.resolveObjects([obj], {});
+        }
+        return obj;
+    }
+    async findObjectsByName(pattern, minX, maxX, minY, maxY, minZ, maxZ) {
+        let objects = [];
+        if (minX !== undefined && maxX !== undefined && minY !== undefined && maxY !== undefined && minZ !== undefined && maxZ !== undefined) {
+            objects = await this.getObjectsInArea(minX, maxX, minY, maxY, minZ, maxZ, true);
+        }
+        else {
+            objects = await this.getAllObjects({ resolve: true });
+        }
+        const idCheck = {};
+        const matches = [];
+        const it = function (go) {
+            if (go.name !== undefined) {
+                let match = false;
+                if (pattern instanceof RegExp) {
+                    if (pattern.test(go.name)) {
+                        match = true;
                     }
-                    const uuidStr = obj.FullID.toString();
-                    if (!uuidMap[uuidStr]) {
-                        uuidMap[uuidStr] = obj;
-                        selectObject.ObjectData.push({
-                            ObjectLocalID: obj.ID
-                        });
+                }
+                else {
+                    match = micromatch.isMatch(go.name, pattern, { nocase: true });
+                }
+                if (match) {
+                    const fullID = go.FullID.toString();
+                    if (!idCheck[fullID]) {
+                        matches.push(go);
+                        idCheck[fullID] = true;
                     }
                 }
-                if (skipped > 0) {
-                    console.log('Skipped ' + String(skipped) + ' bad objects during deselection');
+            }
+            if (go.children && go.children.length > 0) {
+                for (const child of go.children) {
+                    it(child);
                 }
-                this.circuit.sendMessage(selectObject, PacketFlags_1.PacketFlags.Reliable);
-                try {
-                    yield this.circuit.waitForMessage(Message_1.Message.ObjectProperties, 10000, (propertiesMessage) => {
-                        let found = false;
-                        for (const objData of propertiesMessage.ObjectData) {
-                            const objDataUUID = objData.ObjectID.toString();
-                            if (uuidMap[objDataUUID] !== undefined) {
-                                const obj = uuidMap[objDataUUID];
-                                obj.creatorID = objData.CreatorID;
-                                obj.creationDate = objData.CreationDate;
-                                obj.baseMask = objData.BaseMask;
-                                obj.ownerMask = objData.OwnerMask;
-                                obj.groupMask = objData.GroupMask;
-                                obj.everyoneMask = objData.EveryoneMask;
-                                obj.nextOwnerMask = objData.NextOwnerMask;
-                                obj.ownershipCost = objData.OwnershipCost;
-                                obj.saleType = objData.SaleType;
-                                obj.salePrice = objData.SalePrice;
-                                obj.aggregatePerms = objData.AggregatePerms;
-                                obj.aggregatePermTextures = objData.AggregatePermTextures;
-                                obj.aggregatePermTexturesOwner = objData.AggregatePermTexturesOwner;
-                                obj.category = objData.Category;
-                                obj.inventorySerial = objData.InventorySerial;
-                                obj.itemID = objData.ItemID;
-                                obj.folderID = objData.FolderID;
-                                obj.fromTaskID = objData.FromTaskID;
-                                obj.groupID = objData.GroupID;
-                                obj.OwnerID = objData.OwnerID;
-                                obj.lastOwnerID = objData.LastOwnerID;
-                                obj.name = Utils_1.Utils.BufferToStringSimple(objData.Name);
-                                obj.description = Utils_1.Utils.BufferToStringSimple(objData.Description);
-                                obj.touchName = Utils_1.Utils.BufferToStringSimple(objData.TouchName);
-                                obj.sitName = Utils_1.Utils.BufferToStringSimple(objData.SitName);
-                                obj.textureID = Utils_1.Utils.BufferToStringSimple(objData.TextureID);
-                                obj.resolvedAt = new Date().getTime() / 1000;
-                                delete uuidMap[objDataUUID];
-                                found = true;
-                            }
-                        }
-                        if (Object.keys(uuidMap).length === 0) {
-                            return FilterResponse_1.FilterResponse.Finish;
-                        }
-                        if (!found) {
-                            return FilterResponse_1.FilterResponse.NoMatch;
-                        }
-                        else {
-                            return FilterResponse_1.FilterResponse.Match;
-                        }
-                    });
+            }
+        };
+        for (const go of objects) {
+            it(go);
+        }
+        return matches;
+    }
+    async getParcelAt(x, y) {
+        return this.currentRegion.getParcelProperties(x, y);
+    }
+    async getParcels() {
+        return this.currentRegion.getParcels();
+    }
+    async getAllObjects(options) {
+        const objs = this.currentRegion.objects.getAllObjects();
+        if (options.resolve === true) {
+            await this.currentRegion.resolver.resolveObjects(objs, options);
+        }
+        return objs;
+    }
+    async getObjectsInArea(minX, maxX, minY, maxY, minZ, maxZ, resolve = false) {
+        const objs = this.currentRegion.objects.getObjectsInArea(minX, maxX, minY, maxY, minZ, maxZ);
+        if (resolve) {
+            await this.currentRegion.resolver.resolveObjects(objs, {});
+        }
+        return objs;
+    }
+    async pruneObjects(checkList) {
+        let uuids = [];
+        let objects = [];
+        const stillAlive = {};
+        const checkObjects = async (uuidList, objectList) => {
+            const objRef = {};
+            for (const obj of objectList) {
+                objRef[obj.FullID.toString()] = obj;
+            }
+            const result = await this.currentRegion.caps.capsPostXML('GetObjectCost', {
+                'object_ids': uuidList
+            });
+            for (const u of Object.keys(result)) {
+                stillAlive[u] = objRef[u];
+            }
+        };
+        for (const o of checkList) {
+            if (o.FullID !== undefined) {
+                uuids.push(new LLSD.UUID(o.FullID));
+                objects.push(o);
+                if (uuids.length > 256) {
+                    await checkObjects(uuids, objects);
+                    uuids = [];
+                    objects = [];
                 }
-                catch (error) {
+            }
+        }
+        if (uuids.length > 0) {
+            await checkObjects(uuids, objects);
+        }
+        const deadObjects = [];
+        for (const o of checkList) {
+            let found = false;
+            if (o.FullID !== undefined) {
+                const fullID = o.FullID.toString();
+                if (stillAlive[fullID] !== undefined) {
+                    found = true;
                 }
             }
-        });
+            if (!found) {
+                deadObjects.push(o);
+            }
+        }
+        return deadObjects;
     }
-    getName() {
-        return this.currentRegion.regionName;
+    setPersist(persist) {
+        this.currentRegion.objects.setPersist(persist);
     }
-    resolveObject(object, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.currentRegion.resolver.resolveObjects([object], options);
-        });
+    async grabObject(localID, grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
+        if (localID instanceof UUID_1.UUID) {
+            const obj = this.currentRegion.objects.getObjectByUUID(localID);
+            localID = obj.ID;
+        }
+        const msg = new ObjectGrab_1.ObjectGrabMessage();
+        msg.AgentData = {
+            AgentID: this.agent.agentID,
+            SessionID: this.circuit.sessionID
+        };
+        msg.ObjectData = {
+            LocalID: localID,
+            GrabOffset: grabOffset
+        };
+        msg.SurfaceInfo = [
+            {
+                UVCoord: uvCoordinate,
+                STCoord: stCoordinate,
+                FaceIndex: faceIndex,
+                Position: position,
+                Normal: normal,
+                Binormal: binormal
+            }
+        ];
+        const seqID = this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
+        return this.circuit.waitForAck(seqID, 10000);
     }
-    resolveObjects(objects, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.currentRegion.resolver.resolveObjects(objects, options);
-        });
+    async deGrabObject(localID, _grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
+        if (localID instanceof UUID_1.UUID) {
+            const obj = this.currentRegion.objects.getObjectByUUID(localID);
+            localID = obj.ID;
+        }
+        const msg = new ObjectDeGrab_1.ObjectDeGrabMessage();
+        msg.AgentData = {
+            AgentID: this.agent.agentID,
+            SessionID: this.circuit.sessionID
+        };
+        msg.ObjectData = {
+            LocalID: localID
+        };
+        msg.SurfaceInfo = [
+            {
+                UVCoord: uvCoordinate,
+                STCoord: stCoordinate,
+                FaceIndex: faceIndex,
+                Position: position,
+                Normal: normal,
+                Binormal: binormal
+            }
+        ];
+        const seqID = this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
+        return this.circuit.waitForAck(seqID, 10000);
     }
-    fetchObjectInventory(object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.currentRegion.resolver.getInventory(object);
-        });
+    async dragGrabbedObject(localID, grabPosition, grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
+        if (!(localID instanceof UUID_1.UUID)) {
+            const obj = this.currentRegion.objects.getObjectByLocalID(localID);
+            localID = obj.FullID;
+        }
+        const msg = new ObjectGrabUpdate_1.ObjectGrabUpdateMessage();
+        msg.AgentData = {
+            AgentID: this.agent.agentID,
+            SessionID: this.circuit.sessionID
+        };
+        msg.ObjectData = {
+            ObjectID: localID,
+            GrabOffsetInitial: grabOffset,
+            GrabPosition: grabPosition,
+            TimeSinceLast: 0
+        };
+        msg.SurfaceInfo = [
+            {
+                UVCoord: uvCoordinate,
+                STCoord: stCoordinate,
+                FaceIndex: faceIndex,
+                Position: position,
+                Normal: normal,
+                Binormal: binormal
+            }
+        ];
+        const seqID = this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
+        return this.circuit.waitForAck(seqID, 10000);
     }
-    fetchObjectInventories(objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.currentRegion.resolver.getInventories(objects);
-        });
+    async touchObject(localID, grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
+        if (localID instanceof UUID_1.UUID) {
+            const obj = this.currentRegion.objects.getObjectByUUID(localID);
+            localID = obj.ID;
+        }
+        await this.grabObject(localID, grabOffset, uvCoordinate, stCoordinate, faceIndex, position, normal, binormal);
+        return this.deGrabObject(localID, grabOffset, uvCoordinate, stCoordinate, faceIndex, position, normal, binormal);
     }
-    fetchObjectCost(object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.currentRegion.resolver.getCosts([object]);
-        });
+    async rezPrims(count) {
+        let agentPos = new Vector3_1.Vector3([128, 128, 2048]);
+        try {
+            const agentLocalID = this.currentRegion.agent.localID;
+            const agentObject = this.currentRegion.objects.getObjectByLocalID(agentLocalID);
+            if (agentObject.Position !== undefined) {
+                agentPos = new Vector3_1.Vector3(agentObject.Position);
+            }
+            else {
+                throw new Error('Agent position is undefined');
+            }
+        }
+        catch (_error) {
+            console.warn('Unable to find avatar location, rezzing at ' + agentPos.toString());
+        }
+        agentPos.z += 2.0;
+        const campos = new Vector3_1.Vector3(agentPos);
+        campos.z += 2.0;
+        this.currentRegion.clientCommands.agent.setCamera(campos, agentPos, 10, new Vector3_1.Vector3([-1.0, 0, 0]), new Vector3_1.Vector3([0.0, 1.0, 0]));
+        return this.createPrims(count, agentPos);
     }
-    fetchObjectCosts(objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.currentRegion.resolver.getCosts(objects);
+    async createPrims(count, position) {
+        return new Promise((resolve, reject) => {
+            const gatheredPrims = [];
+            let objSub = undefined;
+            let timeout = setTimeout(() => {
+                if (objSub !== undefined) {
+                    objSub.unsubscribe();
+                    objSub = undefined;
+                }
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                    timeout = undefined;
+                }
+                reject(new Error('Failed to gather ' + count + ' prims - only gathered ' + gatheredPrims.length));
+            }, 30000);
+            objSub = this.currentRegion.clientEvents.onNewObjectEvent.subscribe((evt) => {
+                (async () => {
+                    if (evt.object.resolvedAt === undefined) {
+                        await this.resolveObject(evt.object, {});
+                    }
+                    if (evt.createSelected && !evt.object.claimedForBuild) {
+                        if (evt.object.itemID === undefined || evt.object.itemID.isZero()) {
+                            if (evt.object.PCode === PCode_1.PCode.Prim &&
+                                evt.object.Material === 3 &&
+                                evt.object.PathCurve === 16 &&
+                                evt.object.ProfileCurve === 1 &&
+                                evt.object.PathBegin === 0 &&
+                                evt.object.PathEnd === 1 &&
+                                evt.object.PathScaleX === 1 &&
+                                evt.object.PathScaleY === 1 &&
+                                evt.object.PathShearX === 0 &&
+                                evt.object.PathShearY === 0 &&
+                                evt.object.PathTwist === 0 &&
+                                evt.object.PathTwistBegin === 0 &&
+                                evt.object.PathRadiusOffset === 0 &&
+                                evt.object.PathTaperX === 0 &&
+                                evt.object.PathTaperY === 0 &&
+                                evt.object.PathRevolutions === 1 &&
+                                evt.object.PathSkew === 0 &&
+                                evt.object.ProfileBegin === 0 &&
+                                evt.object.ProfileHollow === 0) {
+                                evt.object.claimedForBuild = true;
+                                gatheredPrims.push(evt.object);
+                                if (gatheredPrims.length === count) {
+                                    if (objSub !== undefined) {
+                                        objSub.unsubscribe();
+                                        objSub = undefined;
+                                    }
+                                    if (timeout !== undefined) {
+                                        clearTimeout(timeout);
+                                        timeout = undefined;
+                                    }
+                                    resolve(gatheredPrims);
+                                }
+                            }
+                        }
+                    }
+                })().catch((_e) => {
+                });
+            });
+            for (let x = 0; x < count; x++) {
+                const msg = new ObjectAdd_1.ObjectAddMessage();
+                msg.AgentData = {
+                    AgentID: this.agent.agentID,
+                    SessionID: this.circuit.sessionID,
+                    GroupID: UUID_1.UUID.zero()
+                };
+                msg.ObjectData = {
+                    PCode: PCode_1.PCode.Prim,
+                    Material: 3,
+                    AddFlags: PrimFlags_1.PrimFlags.CreateSelected,
+                    PathCurve: 16,
+                    ProfileCurve: 1,
+                    PathBegin: 0,
+                    PathEnd: 0,
+                    PathScaleX: 100,
+                    PathScaleY: 100,
+                    PathShearX: 0,
+                    PathShearY: 0,
+                    PathTwist: 0,
+                    PathTwistBegin: 0,
+                    PathRadiusOffset: 0,
+                    PathTaperX: 0,
+                    PathTaperY: 0,
+                    PathRevolutions: 0,
+                    PathSkew: 0,
+                    ProfileBegin: 0,
+                    ProfileEnd: 0,
+                    ProfileHollow: 0,
+                    BypassRaycast: 1,
+                    RayStart: position,
+                    RayEnd: position,
+                    RayTargetID: UUID_1.UUID.zero(),
+                    RayEndIsIntersection: 0,
+                    Scale: new Vector3_1.Vector3([0.5, 0.5, 0.5]),
+                    Rotation: Quaternion_1.Quaternion.getIdentity(),
+                    State: 0
+                };
+                this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
+            }
         });
     }
-    waitForObjectByLocalID(localID, timeout) {
+    async waitForObjectByLocalID(localID, timeout) {
         return new Promise((resolve, reject) => {
             let tmr = null;
-            const subscription = this.currentRegion.clientEvents.onNewObjectEvent.subscribe((event) => __awaiter(this, void 0, void 0, function* () {
+            const subscription = this.currentRegion.clientEvents.onNewObjectEvent.subscribe((event) => {
                 if (event.localID === localID) {
                     if (tmr !== null) {
                         clearTimeout(tmr);
@@ -348,17 +798,17 @@ class RegionCommands extends CommandsBase_1.CommandsBase {
                     subscription.unsubscribe();
                     resolve(event.object);
                 }
-            }));
+            });
             tmr = setTimeout(() => {
                 subscription.unsubscribe();
                 reject(new Error('Timeout'));
             }, timeout);
         });
     }
-    waitForObjectByUUID(objectID, timeout) {
+    async waitForObjectByUUID(objectID, timeout) {
         return new Promise((resolve, reject) => {
             let tmr = null;
-            const subscription = this.currentRegion.clientEvents.onNewObjectEvent.subscribe((event) => __awaiter(this, void 0, void 0, function* () {
+            const subscription = this.currentRegion.clientEvents.onNewObjectEvent.subscribe((event) => {
                 if (event.objectID.equals(objectID)) {
                     if (tmr !== null) {
                         clearTimeout(tmr);
@@ -366,1122 +816,587 @@ class RegionCommands extends CommandsBase_1.CommandsBase {
                     subscription.unsubscribe();
                     resolve(event.object);
                 }
-            }));
+            });
             tmr = setTimeout(() => {
                 subscription.unsubscribe();
                 reject(new Error('Timeout'));
             }, timeout);
         });
     }
-    buildPart(obj_1, posOffset_1, rotOffset_1, buildMap_1) {
-        return __awaiter(this, arguments, void 0, function* (obj, posOffset, rotOffset, buildMap, markRoot = false) {
-            const objectPosition = new Vector3_1.Vector3(obj.Position);
-            const objectRotation = new Quaternion_1.Quaternion(obj.Rotation);
-            const objectScale = new Vector3_1.Vector3(obj.Scale);
-            let finalPos = Vector3_1.Vector3.getZero();
-            let finalRot = Quaternion_1.Quaternion.getIdentity();
-            if (posOffset.x === 0.0 && posOffset.y === 0.0 && posOffset.z === 0.0 && objectPosition !== undefined) {
-                finalPos = new Vector3_1.Vector3(objectPosition);
-                finalRot = new Quaternion_1.Quaternion(objectRotation);
-            }
-            else {
-                const adjustedPos = new Vector3_1.Vector3(objectPosition).multiplyByTSMQuat(new Quaternion_1.Quaternion(rotOffset));
-                finalPos = new Vector3_1.Vector3(new Vector3_1.Vector3(posOffset).add(adjustedPos));
-                const baseRot = new Quaternion_1.Quaternion(rotOffset);
-                finalRot = new Quaternion_1.Quaternion(baseRot.multiply(new Quaternion_1.Quaternion(objectRotation)));
-            }
-            let object = null;
-            let rezzedMesh = false;
-            if (obj.extraParams !== undefined && obj.extraParams.meshData !== null) {
-                if (buildMap.assetMap.mesh[obj.extraParams.meshData.meshData.toString()] !== undefined) {
-                    const meshEntry = buildMap.assetMap.mesh[obj.extraParams.meshData.meshData.toString()];
-                    const rezLocation = new Vector3_1.Vector3(buildMap.rezLocation);
-                    rezLocation.z += (objectScale.z / 2);
-                    if (meshEntry.item !== null) {
-                        try {
-                            object = yield meshEntry.item.rezInWorld(rezLocation);
-                        }
-                        catch (err) {
-                            console.error('Failed to rez object ' + obj.name + ' in-world');
-                            console.error(err);
-                        }
-                        rezzedMesh = true;
-                    }
-                    else {
-                        console.error('Unable to rez mesh item from inventory - item is null');
-                    }
-                }
-            }
-            else if (buildMap.primReservoir.length > 0) {
-                const newPrim = buildMap.primReservoir.shift();
-                if (newPrim !== undefined) {
-                    object = newPrim;
+    async buildPart(obj, posOffset, rotOffset, buildMap, markRoot = false) {
+        const objectPosition = new Vector3_1.Vector3(obj.Position);
+        const objectRotation = new Quaternion_1.Quaternion(obj.Rotation);
+        const objectScale = new Vector3_1.Vector3(obj.Scale);
+        let finalPos = Vector3_1.Vector3.getZero();
+        let finalRot = Quaternion_1.Quaternion.getIdentity();
+        if (posOffset.x === 0.0 && posOffset.y === 0.0 && posOffset.z === 0.0 && objectPosition !== undefined) {
+            finalPos = new Vector3_1.Vector3(objectPosition);
+            finalRot = new Quaternion_1.Quaternion(objectRotation);
+        }
+        else {
+            const adjustedPos = new Vector3_1.Vector3(objectPosition).multiplyQuaternion(new Quaternion_1.Quaternion(rotOffset));
+            finalPos = new Vector3_1.Vector3(new Vector3_1.Vector3(posOffset).add(adjustedPos));
+            const baseRot = new Quaternion_1.Quaternion(rotOffset);
+            finalRot = new Quaternion_1.Quaternion(baseRot.multiply(new Quaternion_1.Quaternion(objectRotation)));
+        }
+        let object = null;
+        let rezzedMesh = false;
+        if (obj.extraParams?.meshData !== null && obj.extraParams?.meshData.type === SculptType_1.SculptType.Mesh) {
+            const meshEntry = buildMap.assetMap.mesh.get(obj.extraParams.meshData.meshData.toString());
+            if (meshEntry !== undefined) {
+                const rezLocation = new Vector3_1.Vector3(buildMap.rezLocation);
+                rezLocation.z += (objectScale.z / 2);
+                if (meshEntry.item !== undefined) {
                     try {
-                        yield object.setShape(obj.PathCurve, obj.ProfileCurve, obj.PathBegin, obj.PathEnd, obj.PathScaleX, obj.PathScaleY, obj.PathShearX, obj.PathShearY, obj.PathTwist, obj.PathTwistBegin, obj.PathRadiusOffset, obj.PathTaperX, obj.PathTaperY, obj.PathRevolutions, obj.PathSkew, obj.ProfileBegin, obj.ProfileEnd, obj.ProfileHollow);
+                        object = await meshEntry.item.rezInWorld(rezLocation);
+                        rezzedMesh = true;
                     }
                     catch (err) {
-                        console.error('Error setting shape on ' + obj.name);
+                        console.error('Failed to rez object ' + obj.name + ' in-world');
                         console.error(err);
                     }
                 }
+                else {
+                    console.error('Unable to rez mesh item from inventory - item is null');
+                }
             }
-            else {
-                console.error('Exhausted prim reservoir!!');
-            }
-            if (object === null) {
-                console.error('Failed to acquire prim for build');
-                throw new Error('Failed to acquire prim for build');
-            }
-            if (markRoot) {
-                object.isMarkedRoot = true;
+        }
+        if (!rezzedMesh && buildMap.primReservoir.length > 0) {
+            const newPrim = buildMap.primReservoir.shift();
+            if (newPrim !== undefined) {
+                object = newPrim;
+                try {
+                    await object.setShape(obj.PathCurve, obj.ProfileCurve, obj.PathBegin, obj.PathEnd, obj.PathScaleX, obj.PathScaleY, obj.PathShearX, obj.PathShearY, obj.PathTwist, obj.PathTwistBegin, obj.PathRadiusOffset, obj.PathTaperX, obj.PathTaperY, obj.PathRevolutions, obj.PathSkew, obj.ProfileBegin, obj.ProfileEnd, obj.ProfileHollow);
+                }
+                catch (err) {
+                    console.error('Error setting shape on ' + obj.name);
+                    console.error(err);
+                }
             }
-            try {
-                yield object.setGeometry(finalPos, finalRot, objectScale);
+        }
+        else if (!rezzedMesh) {
+            console.error('Exhausted prim reservoir!!');
+        }
+        if (object === null) {
+            console.error('Failed to acquire prim for build');
+            throw new Error('Failed to acquire prim for build');
+        }
+        if (markRoot) {
+            object.isMarkedRoot = true;
+        }
+        try {
+            await object.setGeometry(finalPos, finalRot, objectScale);
+        }
+        catch (err) {
+            console.error('Error setting geometry on ' + obj.name);
+            console.error(err);
+        }
+        if (obj.extraParams.sculptData !== null) {
+            if (obj.extraParams.sculptData.type !== SculptType_1.SculptType.Mesh) {
+                const oldTextureID = obj.extraParams.sculptData.texture.toString();
+                const item = buildMap.assetMap.textures.get(oldTextureID);
+                if (item?.item) {
+                    obj.extraParams.sculptData.texture = item.item.assetID;
+                }
             }
-            catch (err) {
-                console.error('Error setting geometry on ' + obj.name);
-                console.error(err);
+        }
+        if (obj.extraParams.lightImageData !== null) {
+            const oldTextureID = obj.extraParams.lightImageData.texture.toString();
+            const item = buildMap.assetMap.textures.get(oldTextureID);
+            if (item?.item) {
+                obj.extraParams.lightImageData.texture = item.item.assetID;
             }
-            if (obj.extraParams.sculptData !== null) {
-                if (obj.extraParams.sculptData.type !== SculptType_1.SculptType.Mesh) {
-                    const oldTextureID = obj.extraParams.sculptData.texture.toString();
-                    const item = buildMap.assetMap.textures[oldTextureID];
-                    if (item !== null && item !== undefined && item.item !== null) {
-                        obj.extraParams.sculptData.texture = item.item.assetID;
-                    }
+        }
+        if (obj.extraParams.renderMaterialData !== null) {
+            for (const entry of obj.extraParams.renderMaterialData.params) {
+                const oldTextureID = entry.textureUUID.toString();
+                const item = buildMap.assetMap.gltfMaterials.get(oldTextureID);
+                if (item?.item) {
+                    entry.textureUUID = item.item.assetID;
                 }
             }
-            if (rezzedMesh) {
-                obj.extraParams.meshData = object.extraParams.meshData;
-                obj.extraParams.sculptData = object.extraParams.sculptData;
+        }
+        if (rezzedMesh) {
+            obj.extraParams.meshData = object.extraParams.meshData;
+            obj.extraParams.sculptData = object.extraParams.sculptData;
+        }
+        try {
+            await object.setExtraParams(obj.extraParams);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw (err);
             }
-            try {
-                yield object.setExtraParams(obj.extraParams);
+            else if (typeof err === 'string') {
+                throw new Error(err);
             }
-            catch (err) {
-                if (err instanceof Error) {
-                    throw (err);
+            else {
+                throw new Error('Error setting ExtraParams on ' + obj.name);
+            }
+        }
+        if (obj.TextureEntry !== undefined) {
+            const materialUpload = {
+                'FullMaterialsPerFace': []
+            };
+            let defaultMaterial = null;
+            const materialFaces = {};
+            if (obj.TextureEntry.defaultTexture !== undefined && obj.TextureEntry.defaultTexture !== null) {
+                const { materialID } = obj.TextureEntry.defaultTexture;
+                if (!materialID.isZero()) {
+                    const storedMat = buildMap.assetMap.materials.get(materialID.toString());
+                    if (storedMat?.item) {
+                        defaultMaterial = {
+                            ID: object.ID,
+                            Material: storedMat.item.toLLSDObject()
+                        };
+                    }
                 }
-                else if (typeof err === 'string') {
-                    throw new Error(err);
+            }
+            for (let face = 0; face < obj.TextureEntry.faces.length; face++) {
+                const { materialID } = obj.TextureEntry.faces[face];
+                if (!materialID.isZero()) {
+                    const storedMat = buildMap.assetMap.materials.get(materialID.toString());
+                    if (storedMat?.item) {
+                        materialUpload.FullMaterialsPerFace.push({
+                            Face: face,
+                            ID: object.ID,
+                            Material: storedMat.item.toLLSDObject()
+                        });
+                        materialFaces[face] = {
+                            added: true,
+                            complete: false
+                        };
+                    }
                 }
-                else {
-                    throw new Error('Error setting ExtraParams on ' + obj.name);
+            }
+            if (defaultMaterial) {
+                Logger_1.Logger.Info('Inserting script to determine face count..');
+                const helper = new PrimFacesHelper_1.PrimFacesHelper(this.bot, object);
+                const sides = await helper.getFaces();
+                Logger_1.Logger.Info(String(sides) + ' faces');
+                for (let side = 0; side < sides; side++) {
+                    if (!materialFaces[side]) {
+                        materialUpload.FullMaterialsPerFace.push({
+                            Face: side,
+                            ...defaultMaterial
+                        });
+                        materialFaces[side] = {
+                            added: true,
+                            complete: false
+                        };
+                    }
                 }
             }
-            if (obj.TextureEntry !== undefined) {
-                const materialUpload = {
-                    'FullMaterialsPerFace': []
+            if (Object.keys(materialFaces).length > 0) {
+                const zipped = await Utils_1.Utils.deflate(Buffer.from(LLSD.LLSD.formatBinary(materialUpload).octets));
+                const newMat = {
+                    'Zipped': new LLSD.Binary(Array.from(zipped), 'BASE64')
                 };
-                const materialFaces = {};
-                if (obj.TextureEntry.defaultTexture !== undefined && obj.TextureEntry.defaultTexture !== null) {
-                    const materialID = obj.TextureEntry.defaultTexture.materialID;
-                    if (!materialID.isZero()) {
-                        const storedMat = buildMap.assetMap.materials[materialID.toString()];
-                        if (storedMat !== null && storedMat !== undefined) {
-                            materialUpload.FullMaterialsPerFace.push({
-                                ID: object.ID,
-                                Material: storedMat.toLLSDObject()
-                            });
-                            materialFaces[-1] = true;
+                const result = await this.currentRegion.caps.capsPutXML('RenderMaterials', newMat);
+                if (result.Zipped) {
+                    const resultUnzipped = await Utils_1.Utils.inflate(Buffer.from(result.Zipped.octets));
+                    const binData = new LLSD.Binary(Array.from(resultUnzipped), 'BASE64');
+                    const llsdResult = LLSD.LLSD.parseBinary(binData);
+                    for (const result2 of llsdResult.result) {
+                        const face = result2.Face;
+                        if (materialFaces[face] !== undefined) {
+                            materialFaces[face].complete = true;
                         }
                     }
-                }
-                for (let face = 0; face < obj.TextureEntry.faces.length; face++) {
-                    const materialID = obj.TextureEntry.faces[face].materialID;
-                    if (!materialID.isZero()) {
-                        const storedMat = buildMap.assetMap.materials[materialID.toString()];
-                        if (storedMat !== null && storedMat !== undefined) {
-                            materialUpload.FullMaterialsPerFace.push({
-                                Face: face,
-                                ID: object.ID,
-                                Material: storedMat.toLLSDObject()
-                            });
-                            materialFaces[face] = true;
+                    for (const face of Object.keys(materialFaces)) {
+                        if (!materialFaces[face].complete) {
+                            console.error('Failed to update material on face ' + String(face));
                         }
                     }
                 }
-                if (Object.keys(materialFaces).length > 0) {
-                    const zipped = yield Utils_1.Utils.deflate(Buffer.from(LLSD.LLSD.formatBinary(materialUpload).octets));
-                    const newMat = {
-                        'Zipped': new LLSD.Binary(Array.from(zipped), 'BASE64')
-                    };
-                    this.currentRegion.caps.capsPutXML('RenderMaterials', newMat).then(() => {
-                    }).catch((err) => {
-                        console.error(err);
-                    });
-                    try {
-                        let complete = false;
-                        do {
-                            complete = true;
-                            yield object.waitForTextureUpdate(10000);
-                            for (const materialFace of Object.keys(materialFaces)) {
-                                const entry = object.TextureEntry;
-                                if (entry === undefined) {
-                                    complete = false;
-                                }
-                                else if (parseInt(materialFace, 10) === -1) {
-                                    const def = entry.defaultTexture;
-                                    if (def === undefined || def === null) {
-                                        complete = false;
-                                    }
-                                    else {
-                                        if (def.materialID.equals(UUID_1.UUID.zero())) {
-                                            complete = false;
-                                        }
-                                    }
-                                }
-                                else {
-                                    const fc = parseInt(materialFace, 10);
-                                    const thisFace = entry.faces[fc];
-                                    if (thisFace === undefined) {
-                                        complete = false;
-                                    }
-                                    else {
-                                        if (thisFace.materialID.equals(UUID_1.UUID.zero())) {
-                                            complete = false;
-                                        }
-                                    }
-                                }
-                            }
-                        } while (!complete);
-                    }
-                    catch (error) {
-                        console.error(obj.name + ':Timed out while waiting for RenderMaterials update');
-                    }
-                    if (object.TextureEntry !== undefined) {
-                        for (let face = 0; face < object.TextureEntry.faces.length; face++) {
-                            const oldFace = obj.TextureEntry.faces[face];
-                            if (!oldFace.materialID.isZero()) {
-                                obj.TextureEntry.faces[face].materialID = object.TextureEntry.faces[face].materialID;
-                                if (obj.TextureEntry.defaultTexture !== null) {
-                                    if (oldFace.materialID.equals(obj.TextureEntry.defaultTexture.materialID)) {
-                                        obj.TextureEntry.defaultTexture.materialID = obj.TextureEntry.faces[face].materialID;
-                                    }
-                                }
-                            }
-                        }
-                        if (obj.TextureEntry.defaultTexture !== null && object.TextureEntry.defaultTexture !== null) {
-                            obj.TextureEntry.defaultTexture.materialID = object.TextureEntry.defaultTexture.materialID;
-                        }
-                    }
+            }
+            if (obj.TextureEntry.defaultTexture !== null) {
+                const oldTextureID = obj.TextureEntry.defaultTexture.textureID.toString();
+                const item = buildMap.assetMap.textures.get(oldTextureID);
+                if (item?.item) {
+                    obj.TextureEntry.defaultTexture.textureID = item.item.assetID;
                 }
-                if (obj.TextureEntry.defaultTexture !== null) {
-                    const oldTextureID = obj.TextureEntry.defaultTexture.textureID.toString();
-                    const item = buildMap.assetMap.textures[oldTextureID];
-                    if (item !== null && item !== undefined && item.item !== null) {
-                        obj.TextureEntry.defaultTexture.textureID = item.item.assetID;
-                    }
+            }
+            for (const j of obj.TextureEntry.faces) {
+                const oldTextureID = j.textureID.toString();
+                const item = buildMap.assetMap.textures.get(oldTextureID);
+                if (item?.item) {
+                    j.textureID = item.item.assetID;
                 }
-                for (const j of obj.TextureEntry.faces) {
-                    const oldTextureID = j.textureID.toString();
-                    const item = buildMap.assetMap.textures[oldTextureID];
-                    if (item !== null && item !== undefined && item.item !== null) {
-                        j.textureID = item.item.assetID;
-                    }
+            }
+            try {
+                await object.setTextureEntry(obj.TextureEntry);
+            }
+            catch (error) {
+                console.error('Error setting TextureEntry on ' + obj.name);
+                console.error(error);
+            }
+        }
+        if (obj.name !== undefined) {
+            try {
+                await object.setName(obj.name);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw error;
                 }
-                try {
-                    yield object.setTextureEntry(obj.TextureEntry);
+                else if (typeof error === 'string') {
+                    throw new Error(error);
                 }
-                catch (error) {
-                    console.error('Error setting TextureEntry on ' + obj.name);
-                    console.error(error);
+                else {
+                    throw new Error('Error setting name on ' + obj.name);
                 }
             }
-            if (obj.name !== undefined) {
-                try {
-                    yield object.setName(obj.name);
-                }
-                catch (error) {
-                    if (error instanceof Error) {
-                        throw error;
-                    }
-                    else if (typeof error === 'string') {
-                        throw new Error(error);
-                    }
-                    else {
-                        throw new Error('Error setting name on ' + obj.name);
-                    }
-                }
+        }
+        if (obj.description !== undefined) {
+            try {
+                await object.setDescription(obj.description);
             }
-            if (obj.description !== undefined) {
-                try {
-                    yield object.setDescription(obj.description);
+            catch (error) {
+                if (error instanceof Error) {
+                    throw error;
                 }
-                catch (error) {
-                    if (error instanceof Error) {
-                        throw error;
-                    }
-                    else if (typeof error === 'string') {
-                        throw new Error(error);
-                    }
-                    else {
-                        throw new Error('Error setting name on ' + obj.name);
-                    }
+                else if (typeof error === 'string') {
+                    throw new Error(error);
+                }
+                else {
+                    throw new Error('Error setting name on ' + obj.name);
                 }
             }
-            for (const invItem of obj.inventory) {
-                try {
-                    if (invItem.inventoryType === InventoryType_1.InventoryType.Object && invItem.assetID.isZero()) {
-                        invItem.assetID = invItem.itemID;
-                    }
-                    switch (invItem.inventoryType) {
-                        case InventoryType_1.InventoryType.Clothing:
-                            {
-                                if (buildMap.assetMap.clothing[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.clothing[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
+        }
+        const fixedInventory = [...obj.inventory];
+        for (const invItem of fixedInventory) {
+            try {
+                if (invItem.inventoryType === InventoryType_1.InventoryType.Object && invItem.assetID.isZero()) {
+                    invItem.assetID = invItem.itemID;
+                }
+                switch (invItem.inventoryType) {
+                    case InventoryType_1.InventoryType.Settings:
+                        {
+                            const item = buildMap.assetMap.settings.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Settings:
-                            {
-                                if (buildMap.assetMap.settings[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.settings[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Wearable:
+                        {
+                            const item = buildMap.assetMap.wearables.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Wearable:
-                        case InventoryType_1.InventoryType.Bodypart:
-                            {
-                                if (buildMap.assetMap.bodyparts[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.bodyparts[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Notecard:
+                        {
+                            const item = buildMap.assetMap.notecards.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Notecard:
-                            {
-                                if (buildMap.assetMap.notecards[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.notecards[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Sound:
+                        {
+                            const item = buildMap.assetMap.sounds.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Sound:
-                            {
-                                if (buildMap.assetMap.sounds[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.sounds[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Gesture:
+                        {
+                            const item = buildMap.assetMap.gestures.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Gesture:
-                            {
-                                if (buildMap.assetMap.gestures[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.gestures[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.LSL:
+                        {
+                            const item = buildMap.assetMap.scripts.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions = invItem.permissions;
+                                        await taskItem.rename(invItem.name);
+                                        if (taskItem.type === AssetType_1.AssetType.LSLText) {
+                                            let compileQueue = buildMap.assetMap.scriptsToCompile.get(object.FullID.toString());
+                                            if (compileQueue === undefined) {
+                                                compileQueue = {
+                                                    gameObject: object,
+                                                    scripts: []
+                                                };
                                             }
+                                            compileQueue.scripts.push({
+                                                item: taskItem,
+                                                oldAssetID: invItem.assetID,
+                                                shouldStart: invItem.scriptRunning === true,
+                                                mono: invItem.scriptMono !== false
+                                            });
+                                            buildMap.assetMap.scriptsToCompile.set(object.FullID.toString(), compileQueue);
                                         }
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Script:
-                        case InventoryType_1.InventoryType.LSL:
-                            {
-                                if (buildMap.assetMap.scripts[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.scripts[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Material:
+                        {
+                            const item = buildMap.assetMap.gltfMaterials.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Animation:
-                            {
-                                if (buildMap.assetMap.animations[invItem.assetID.toString()] !== undefined) {
-                                    const item = buildMap.assetMap.animations[invItem.assetID.toString()].item;
-                                    if (item !== null) {
-                                        yield object.dropInventoryIntoContents(item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Animation:
+                        {
+                            const item = buildMap.assetMap.animations.get(invItem.assetID.toString());
+                            if (item?.item) {
+                                await object.dropInventoryIntoContents(item.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === item.item.name) {
+                                        taskItem.permissions = invItem.permissions;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Object:
-                            {
-                                if (buildMap.assetMap.objects[invItem.itemID.toString()] !== undefined) {
-                                    const inventoryItem = buildMap.assetMap.objects[invItem.itemID.toString()];
-                                    if (inventoryItem !== null) {
-                                        yield object.dropInventoryIntoContents(inventoryItem);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === inventoryItem.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
-                                    }
-                                    else {
-                                        console.error('Unable to drop object: item is null');
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Object:
+                        {
+                            const inventoryItem = buildMap.assetMap.objects.get(invItem.itemID.toString());
+                            if (inventoryItem?.item) {
+                                await object.dropInventoryIntoContents(inventoryItem.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === inventoryItem.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        case InventoryType_1.InventoryType.Texture:
-                        case InventoryType_1.InventoryType.Snapshot:
-                            {
-                                if (buildMap.assetMap.textures[invItem.assetID.toString()] !== undefined) {
-                                    const texItem = buildMap.assetMap.textures[invItem.assetID.toString()];
-                                    if (texItem.item !== null) {
-                                        yield object.dropInventoryIntoContents(texItem.item);
-                                        yield object.updateInventory();
-                                        for (const taskItem of object.inventory) {
-                                            if (taskItem.name === texItem.item.name) {
-                                                taskItem.permissions = invItem.permissions;
-                                                yield taskItem.renameInTask(object, invItem.name);
-                                            }
-                                        }
-                                    }
-                                    else {
-                                        console.error('Unable to drop object: item is null');
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Texture:
+                    case InventoryType_1.InventoryType.Snapshot:
+                        {
+                            const texItem = buildMap.assetMap.textures.get(invItem.assetID);
+                            if (texItem?.item) {
+                                await object.dropInventoryIntoContents(texItem.item);
+                                await object.updateInventory();
+                                for (const taskItem of object.inventory) {
+                                    if (taskItem.name === texItem.item.name) {
+                                        taskItem.permissions.nextOwnerMask = invItem.permissions.nextOwnerMask;
+                                        await taskItem.rename(invItem.name);
                                     }
                                 }
-                                break;
                             }
-                        default:
-                            console.error('Unsupported inventory type: ' + invItem.inventoryType);
                             break;
-                    }
-                }
-                catch (error) {
-                    console.error(error);
+                        }
+                    default:
+                        console.error('Unsupported inventory type: ' + invItem.inventoryType);
+                        break;
                 }
             }
-            return object;
-        });
+            catch (error) {
+                console.error(error);
+            }
+        }
+        return object;
     }
     gatherAssets(obj, buildMap) {
         if (obj.extraParams !== undefined) {
             if (obj.extraParams.meshData !== null) {
-                if (buildMap.assetMap.mesh[obj.extraParams.meshData.meshData.toString()] === undefined) {
-                    buildMap.assetMap.mesh[obj.extraParams.meshData.meshData.toString()] = {
-                        name: obj.name || 'Object',
-                        description: obj.description || '(no description)',
-                        item: null
-                    };
-                }
+                buildMap.assetMap.mesh.request(obj.extraParams.meshData.meshData, {
+                    name: obj.name ?? 'Object',
+                    description: obj.description ?? '(no description)'
+                });
             }
             else {
                 buildMap.primsNeeded++;
             }
             if (obj.extraParams.sculptData !== null) {
                 if (obj.extraParams.sculptData.type !== SculptType_1.SculptType.Mesh) {
-                    if (buildMap.assetMap.textures[obj.extraParams.sculptData.texture.toString()] === undefined) {
-                        buildMap.assetMap.textures[obj.extraParams.sculptData.texture.toString()] = {
-                            item: null
-                        };
-                    }
+                    buildMap.assetMap.textures.request(obj.extraParams.sculptData.texture);
                 }
             }
-            if (obj.TextureEntry !== undefined) {
-                for (const j of obj.TextureEntry.faces) {
-                    const textureID = j.textureID;
-                    if (buildMap.assetMap.textures[textureID.toString()] === undefined) {
-                        buildMap.assetMap.textures[textureID.toString()] = {
-                            item: null
-                        };
-                    }
-                    const materialID = j.materialID;
-                    if (!materialID.isZero()) {
-                        if (buildMap.assetMap.materials[materialID.toString()] === undefined) {
-                            buildMap.assetMap.materials[materialID.toString()] = null;
-                        }
-                    }
-                }
-                if (obj.TextureEntry.defaultTexture !== null) {
-                    const textureID = obj.TextureEntry.defaultTexture.textureID;
-                    if (buildMap.assetMap.textures[textureID.toString()] === undefined) {
-                        buildMap.assetMap.textures[textureID.toString()] = {
-                            item: null
-                        };
-                    }
-                    const materialID = obj.TextureEntry.defaultTexture.materialID;
-                    if (!materialID.isZero()) {
-                        if (buildMap.assetMap.materials[materialID.toString()] === undefined) {
-                            buildMap.assetMap.materials[materialID.toString()] = null;
-                        }
-                    }
-                }
+            if (obj.extraParams.lightImageData != null && !obj.extraParams.lightImageData.texture.isZero()) {
+                buildMap.assetMap.textures.request(obj.extraParams.lightImageData.texture);
             }
-            if (obj.inventory !== undefined) {
-                for (const j of obj.inventory) {
-                    const assetID = j.assetID;
-                    switch (j.inventoryType) {
-                        case InventoryType_1.InventoryType.Animation:
-                            {
-                                if (buildMap.assetMap.animations[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.animations[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Wearable:
-                        case InventoryType_1.InventoryType.Bodypart:
-                            {
-                                if (buildMap.assetMap.bodyparts[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.bodyparts[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.CallingCard:
-                            {
-                                if (buildMap.assetMap.callingcards[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.callingcards[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Clothing:
-                            {
-                                if (buildMap.assetMap.clothing[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.clothing[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Gesture:
-                            {
-                                if (buildMap.assetMap.gestures[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.gestures[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Script:
-                        case InventoryType_1.InventoryType.LSL:
-                            {
-                                if (buildMap.assetMap.scripts[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.scripts[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Texture:
-                        case InventoryType_1.InventoryType.Snapshot:
-                            {
-                                if (buildMap.assetMap.textures[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.textures[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Notecard:
-                            {
-                                if (buildMap.assetMap.notecards[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.notecards[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Sound:
-                            {
-                                if (buildMap.assetMap.sounds[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.sounds[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Object:
-                            {
-                                if (buildMap.assetMap.objects[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.objects[assetID.toString()] = null;
-                                }
-                                break;
-                            }
-                        case InventoryType_1.InventoryType.Settings:
-                            {
-                                if (buildMap.assetMap.settings[assetID.toString()] === undefined) {
-                                    buildMap.assetMap.settings[assetID.toString()] = {
-                                        name: j.name,
-                                        description: j.description,
-                                        item: null
-                                    };
-                                }
-                                break;
-                            }
-                        default:
-                            console.error('Unsupported inventory type: ' + j.inventoryType);
-                            break;
+            if (obj.extraParams.renderMaterialData != null) {
+                for (const item of obj.extraParams.renderMaterialData.params) {
+                    if (!item.textureUUID.isZero()) {
+                        buildMap.assetMap.gltfMaterials.request(item.textureUUID);
                     }
                 }
             }
         }
-        if (obj.children) {
-            for (const child of obj.children) {
-                this.gatherAssets(child, buildMap);
-            }
-        }
-    }
-    buildObjectNew(obj_1, map_1, callback_1) {
-        return __awaiter(this, arguments, void 0, function* (obj, map, callback, costOnly = false, skipMove = false) {
-            const buildMap = new BuildMap_1.BuildMap(map, callback, costOnly);
-            this.gatherAssets(obj, buildMap);
-            const bomTextures = [
-                '5a9f4a74-30f2-821c-b88d-70499d3e7183',
-                'ae2de45c-d252-50b8-5c6e-19f39ce79317',
-                '24daea5f-0539-cfcf-047f-fbc40b2786ba',
-                '52cc6bb6-2ee5-e632-d3ad-50197b1dcb8a',
-                '43529ce8-7faa-ad92-165a-bc4078371687',
-                '09aac1fb-6bce-0bee-7d44-caac6dbb6c63',
-                'ff62763f-d60a-9855-890b-0c96f8f8cd98',
-                '8e915e25-31d1-cc95-ae08-d58a47488251',
-                '9742065b-19b5-297c-858a-29711d539043',
-                '03642e83-2bd1-4eb9-34b4-4c47ed586d2d',
-                'edd51b77-fc10-ce7a-4b3d-011dfc349e4f',
-                'c228d1cf-4b5d-4ba8-84f4-899a0796aa97'
-            ];
-            for (const bomTexture of bomTextures) {
-                if (buildMap.assetMap.textures[bomTexture] !== undefined) {
-                    delete buildMap.assetMap.textures[bomTexture];
+        if (obj.TextureEntry !== undefined) {
+            for (const j of obj.TextureEntry.faces) {
+                const { textureID } = j;
+                buildMap.assetMap.textures.request(textureID);
+                const { materialID } = j;
+                if (!materialID.isZero()) {
+                    buildMap.assetMap.materials.request(materialID);
                 }
             }
-            yield callback(map);
-            if (costOnly) {
-                return null;
-            }
-            let agentPos = new Vector3_1.Vector3([128, 128, 2048]);
-            try {
-                const agentLocalID = this.currentRegion.agent.localID;
-                const agentObject = this.currentRegion.objects.getObjectByLocalID(agentLocalID);
-                if (agentObject.Position !== undefined) {
-                    agentPos = new Vector3_1.Vector3(agentObject.Position);
-                }
-                else {
-                    throw new Error('Agent position is undefined');
+            if (obj.TextureEntry.defaultTexture !== null) {
+                const { textureID } = obj.TextureEntry.defaultTexture;
+                buildMap.assetMap.textures.request(textureID);
+                const { materialID } = obj.TextureEntry.defaultTexture;
+                if (!materialID.isZero()) {
+                    buildMap.assetMap.materials.request(materialID);
                 }
             }
-            catch (error) {
-                console.warn('Unable to find avatar location, rezzing at ' + agentPos.toString());
-            }
-            agentPos.z += 2.0;
-            buildMap.rezLocation = agentPos;
-            const campos = new Vector3_1.Vector3(agentPos);
-            campos.z += 2.0;
-            yield this.currentRegion.clientCommands.agent.setCamera(campos, agentPos, 10, new Vector3_1.Vector3([-1.0, 0, 0]), new Vector3_1.Vector3([0.0, 1.0, 0]));
-            if (buildMap.primsNeeded > 0) {
-                buildMap.primReservoir = yield this.createPrims(buildMap.primsNeeded, agentPos);
-            }
-            let storedPosition = undefined;
-            if (skipMove) {
-                storedPosition = obj.Position;
-                obj.Position = new Vector3_1.Vector3(buildMap.rezLocation);
-            }
-            const parts = [];
-            parts.push(() => __awaiter(this, void 0, void 0, function* () {
-                return {
-                    index: 1,
-                    object: yield this.buildPart(obj, Vector3_1.Vector3.getZero(), Quaternion_1.Quaternion.getIdentity(), buildMap, true)
-                };
-            }));
-            if (obj.children) {
-                if (obj.Position === undefined) {
-                    obj.Position = Vector3_1.Vector3.getZero();
-                }
-                if (obj.Rotation === undefined) {
-                    obj.Rotation = Quaternion_1.Quaternion.getIdentity();
-                }
-                let childIndex = 2;
-                for (const child of obj.children) {
-                    if (child.Position !== undefined && child.Rotation !== undefined) {
-                        const index = childIndex++;
-                        parts.push(() => __awaiter(this, void 0, void 0, function* () {
-                            return {
-                                index,
-                                object: yield this.buildPart(child, new Vector3_1.Vector3(obj.Position), new Quaternion_1.Quaternion(obj.Rotation), buildMap, false)
-                            };
-                        }));
-                    }
-                }
-            }
-            let results = {
-                results: [],
-                errors: []
-            };
-            results = yield Utils_1.Utils.promiseConcurrent(parts, 5, 0);
-            if (results.errors.length > 0) {
-                for (const err of results.errors) {
-                    console.error(err);
-                }
-            }
-            let rootObj = null;
-            for (const childObject of results.results) {
-                if (childObject.object.isMarkedRoot) {
-                    rootObj = childObject.object;
-                    break;
-                }
-            }
-            if (rootObj === null) {
-                throw new Error('Failed to find root prim..');
-            }
-            const childPrims = [];
-            results.results.sort((a, b) => {
-                return a.index - b.index;
-            });
-            for (const childObject of results.results) {
-                if (childObject.object !== rootObj) {
-                    childPrims.push(childObject.object);
-                }
-            }
-            try {
-                yield rootObj.linkFrom(childPrims);
-            }
-            catch (err) {
-                console.error('Link failed:');
-                console.error(err);
-            }
-            if (storedPosition !== undefined) {
-                obj.Position = storedPosition;
-            }
-            return rootObj;
-        });
-    }
-    createPrims(count, position) {
-        return new Promise((resolve, reject) => {
-            const gatheredPrims = [];
-            let objSub = undefined;
-            let timeout = setTimeout(() => {
-                if (objSub !== undefined) {
-                    objSub.unsubscribe();
-                    objSub = undefined;
-                }
-                if (timeout !== undefined) {
-                    clearTimeout(timeout);
-                    timeout = undefined;
-                }
-                reject(new Error('Failed to gather ' + count + ' prims - only gathered ' + gatheredPrims.length));
-            }, 30000);
-            objSub = this.currentRegion.clientEvents.onNewObjectEvent.subscribe((evt) => __awaiter(this, void 0, void 0, function* () {
-                if (!evt.object.resolvedAt) {
-                    yield this.resolveObject(evt.object, {});
-                }
-                if (evt.createSelected && !evt.object.claimedForBuild) {
-                    if (evt.object.itemID === undefined || evt.object.itemID.isZero()) {
-                        if (evt.object.PCode === PCode_1.PCode.Prim &&
-                            evt.object.Material === 3 &&
-                            evt.object.PathCurve === 16 &&
-                            evt.object.ProfileCurve === 1 &&
-                            evt.object.PathBegin === 0 &&
-                            evt.object.PathEnd === 1 &&
-                            evt.object.PathScaleX === 1 &&
-                            evt.object.PathScaleY === 1 &&
-                            evt.object.PathShearX === 0 &&
-                            evt.object.PathShearY === 0 &&
-                            evt.object.PathTwist === 0 &&
-                            evt.object.PathTwistBegin === 0 &&
-                            evt.object.PathRadiusOffset === 0 &&
-                            evt.object.PathTaperX === 0 &&
-                            evt.object.PathTaperY === 0 &&
-                            evt.object.PathRevolutions === 1 &&
-                            evt.object.PathSkew === 0 &&
-                            evt.object.ProfileBegin === 0 &&
-                            evt.object.ProfileHollow === 0) {
-                            evt.object.claimedForBuild = true;
-                            gatheredPrims.push(evt.object);
-                            if (gatheredPrims.length === count) {
-                                if (objSub !== undefined) {
-                                    objSub.unsubscribe();
-                                    objSub = undefined;
-                                }
-                                if (timeout !== undefined) {
-                                    clearTimeout(timeout);
-                                    timeout = undefined;
-                                }
-                                resolve(gatheredPrims);
-                            }
+        }
+        if (obj.inventory !== undefined) {
+            const invList = [...obj.inventory];
+            for (const j of invList) {
+                const { assetID } = j;
+                switch (j.inventoryType) {
+                    case InventoryType_1.InventoryType.Animation:
+                        {
+                            buildMap.assetMap.animations.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
                         }
-                    }
-                }
-            }));
-            for (let x = 0; x < count; x++) {
-                const msg = new ObjectAdd_1.ObjectAddMessage();
-                msg.AgentData = {
-                    AgentID: this.agent.agentID,
-                    SessionID: this.circuit.sessionID,
-                    GroupID: UUID_1.UUID.zero()
-                };
-                msg.ObjectData = {
-                    PCode: PCode_1.PCode.Prim,
-                    Material: 3,
-                    AddFlags: PrimFlags_1.PrimFlags.CreateSelected,
-                    PathCurve: 16,
-                    ProfileCurve: 1,
-                    PathBegin: 0,
-                    PathEnd: 0,
-                    PathScaleX: 100,
-                    PathScaleY: 100,
-                    PathShearX: 0,
-                    PathShearY: 0,
-                    PathTwist: 0,
-                    PathTwistBegin: 0,
-                    PathRadiusOffset: 0,
-                    PathTaperX: 0,
-                    PathTaperY: 0,
-                    PathRevolutions: 0,
-                    PathSkew: 0,
-                    ProfileBegin: 0,
-                    ProfileEnd: 0,
-                    ProfileHollow: 0,
-                    BypassRaycast: 1,
-                    RayStart: position,
-                    RayEnd: position,
-                    RayTargetID: UUID_1.UUID.zero(),
-                    RayEndIsIntersection: 0,
-                    Scale: new Vector3_1.Vector3([0.5, 0.5, 0.5]),
-                    Rotation: Quaternion_1.Quaternion.getIdentity(),
-                    State: 0
-                };
-                this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
-            }
-        });
-    }
-    getObjectByLocalID(id_1, resolve_1) {
-        return __awaiter(this, arguments, void 0, function* (id, resolve, waitFor = 0) {
-            let obj = null;
-            try {
-                obj = this.currentRegion.objects.getObjectByLocalID(id);
-            }
-            catch (error) {
-                if (waitFor > 0) {
-                    obj = yield this.waitForObjectByLocalID(id, waitFor);
-                }
-                else {
-                    throw (error);
-                }
-            }
-            if (resolve) {
-                yield this.currentRegion.resolver.resolveObjects([obj], {});
-            }
-            return obj;
-        });
-    }
-    getObjectByUUID(id_1, resolve_1) {
-        return __awaiter(this, arguments, void 0, function* (id, resolve, waitFor = 0) {
-            let obj = null;
-            try {
-                obj = this.currentRegion.objects.getObjectByUUID(id);
-            }
-            catch (error) {
-                if (waitFor > 0) {
-                    obj = yield this.waitForObjectByUUID(id, waitFor);
-                }
-                else {
-                    throw (error);
-                }
-            }
-            if (resolve) {
-                yield this.currentRegion.resolver.resolveObjects([obj], {});
-            }
-            return obj;
-        });
-    }
-    findObjectsByName(pattern, minX, maxX, minY, maxY, minZ, maxZ) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let objects = [];
-            if (minX !== undefined && maxX !== undefined && minY !== undefined && maxY !== undefined && minZ !== undefined && maxZ !== undefined) {
-                objects = yield this.getObjectsInArea(minX, maxX, minY, maxY, minZ, maxZ, true);
-            }
-            else {
-                objects = yield this.getAllObjects({ resolve: true });
-            }
-            const idCheck = {};
-            const matches = [];
-            const it = function (go) {
-                if (go.name !== undefined) {
-                    let match = false;
-                    if (pattern instanceof RegExp) {
-                        if (pattern.test(go.name)) {
-                            match = true;
+                    case InventoryType_1.InventoryType.Wearable:
+                        {
+                            buildMap.assetMap.wearables.request(assetID, {
+                                name: j.name,
+                                description: j.description,
+                                assetType: j.type
+                            });
+                            break;
                         }
-                    }
-                    else {
-                        match = micromatch.isMatch(go.name, pattern, { nocase: true });
-                    }
-                    if (match) {
-                        const fullID = go.FullID.toString();
-                        if (!idCheck[fullID]) {
-                            matches.push(go);
-                            idCheck[fullID] = true;
+                    case InventoryType_1.InventoryType.CallingCard:
+                        {
+                            buildMap.assetMap.callingcards.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
                         }
-                    }
-                }
-                if (go.children && go.children.length > 0) {
-                    for (const child of go.children) {
-                        it(child);
-                    }
-                }
-            };
-            for (const go of objects) {
-                it(go);
-            }
-            return matches;
-        });
-    }
-    getParcelAt(x, y) {
-        return this.currentRegion.getParcelProperties(x, y);
-    }
-    getParcels() {
-        return this.currentRegion.getParcels();
-    }
-    getAllObjects(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const objs = yield this.currentRegion.objects.getAllObjects();
-            if (options.resolve) {
-                yield this.currentRegion.resolver.resolveObjects(objs, options);
-            }
-            return objs;
-        });
-    }
-    getObjectsInArea(minX_1, maxX_1, minY_1, maxY_1, minZ_1, maxZ_1) {
-        return __awaiter(this, arguments, void 0, function* (minX, maxX, minY, maxY, minZ, maxZ, resolve = false) {
-            const objs = yield this.currentRegion.objects.getObjectsInArea(minX, maxX, minY, maxY, minZ, maxZ);
-            if (resolve) {
-                yield this.currentRegion.resolver.resolveObjects(objs, {});
-            }
-            return objs;
-        });
-    }
-    pruneObjects(checkList) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let uuids = [];
-            let objects = [];
-            const stillAlive = {};
-            const checkObjects = (uuidList, objectList) => __awaiter(this, void 0, void 0, function* () {
-                const objRef = {};
-                for (const obj of objectList) {
-                    objRef[obj.FullID.toString()] = obj;
-                }
-                const result = yield this.currentRegion.caps.capsPostXML('GetObjectCost', {
-                    'object_ids': uuidList
-                });
-                for (const u of Object.keys(result)) {
-                    stillAlive[u] = objRef[u];
-                }
-            });
-            for (const o of checkList) {
-                if (o.FullID) {
-                    uuids.push(new LLSD.UUID(o.FullID));
-                    objects.push(o);
-                    if (uuids.length > 256) {
-                        yield checkObjects(uuids, objects);
-                        uuids = [];
-                        objects = [];
-                    }
+                    case InventoryType_1.InventoryType.Gesture:
+                        {
+                            buildMap.assetMap.gestures.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.LSL:
+                        {
+                            buildMap.assetMap.scripts.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Texture:
+                    case InventoryType_1.InventoryType.Snapshot:
+                        {
+                            buildMap.assetMap.textures.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Notecard:
+                        {
+                            buildMap.assetMap.notecards.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Sound:
+                        {
+                            buildMap.assetMap.sounds.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Object:
+                        {
+                            buildMap.assetMap.objects.request(assetID);
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Settings:
+                        {
+                            buildMap.assetMap.settings.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
+                        }
+                    case InventoryType_1.InventoryType.Material:
+                        {
+                            buildMap.assetMap.gltfMaterials.request(assetID, {
+                                name: j.name,
+                                description: j.description
+                            });
+                            break;
+                        }
+                    default:
+                        console.error('Unsupported inventory type: ' + j.inventoryType);
+                        break;
                 }
             }
-            if (uuids.length > 0) {
-                yield checkObjects(uuids, objects);
-            }
-            const deadObjects = [];
-            for (const o of checkList) {
-                let found = false;
-                if (o.FullID) {
-                    const fullID = o.FullID.toString();
-                    if (stillAlive[fullID]) {
-                        found = true;
-                    }
-                }
-                if (!found) {
-                    deadObjects.push(o);
-                }
+        }
+        if (obj.children) {
+            for (const child of obj.children) {
+                this.gatherAssets(child, buildMap);
             }
-            return deadObjects;
-        });
-    }
-    setPersist(persist) {
-        this.currentRegion.objects.setPersist(persist);
-    }
-    grabObject(localID_1) {
-        return __awaiter(this, arguments, void 0, function* (localID, grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
-            if (localID instanceof UUID_1.UUID) {
-                const obj = this.currentRegion.objects.getObjectByUUID(localID);
-                localID = obj.ID;
-            }
-            const msg = new ObjectGrab_1.ObjectGrabMessage();
-            msg.AgentData = {
-                AgentID: this.agent.agentID,
-                SessionID: this.circuit.sessionID
-            };
-            msg.ObjectData = {
-                LocalID: localID,
-                GrabOffset: grabOffset
-            };
-            msg.SurfaceInfo = [
-                {
-                    UVCoord: uvCoordinate,
-                    STCoord: stCoordinate,
-                    FaceIndex: faceIndex,
-                    Position: position,
-                    Normal: normal,
-                    Binormal: binormal
-                }
-            ];
-            const seqID = this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
-            return this.circuit.waitForAck(seqID, 10000);
-        });
-    }
-    deGrabObject(localID_1) {
-        return __awaiter(this, arguments, void 0, function* (localID, _grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
-            if (localID instanceof UUID_1.UUID) {
-                const obj = this.currentRegion.objects.getObjectByUUID(localID);
-                localID = obj.ID;
-            }
-            const msg = new ObjectDeGrab_1.ObjectDeGrabMessage();
-            msg.AgentData = {
-                AgentID: this.agent.agentID,
-                SessionID: this.circuit.sessionID
-            };
-            msg.ObjectData = {
-                LocalID: localID
-            };
-            msg.SurfaceInfo = [
-                {
-                    UVCoord: uvCoordinate,
-                    STCoord: stCoordinate,
-                    FaceIndex: faceIndex,
-                    Position: position,
-                    Normal: normal,
-                    Binormal: binormal
-                }
-            ];
-            const seqID = this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
-            return this.circuit.waitForAck(seqID, 10000);
-        });
-    }
-    dragGrabbedObject(localID_1, grabPosition_1) {
-        return __awaiter(this, arguments, void 0, function* (localID, grabPosition, grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
-            if (!(localID instanceof UUID_1.UUID)) {
-                const obj = this.currentRegion.objects.getObjectByLocalID(localID);
-                localID = obj.FullID;
-            }
-            const msg = new ObjectGrabUpdate_1.ObjectGrabUpdateMessage();
-            msg.AgentData = {
-                AgentID: this.agent.agentID,
-                SessionID: this.circuit.sessionID
-            };
-            msg.ObjectData = {
-                ObjectID: localID,
-                GrabOffsetInitial: grabOffset,
-                GrabPosition: grabPosition,
-                TimeSinceLast: 0
-            };
-            msg.SurfaceInfo = [
-                {
-                    UVCoord: uvCoordinate,
-                    STCoord: stCoordinate,
-                    FaceIndex: faceIndex,
-                    Position: position,
-                    Normal: normal,
-                    Binormal: binormal
-                }
-            ];
-            const seqID = this.circuit.sendMessage(msg, PacketFlags_1.PacketFlags.Reliable);
-            return this.circuit.waitForAck(seqID, 10000);
-        });
-    }
-    touchObject(localID_1) {
-        return __awaiter(this, arguments, void 0, function* (localID, grabOffset = Vector3_1.Vector3.getZero(), uvCoordinate = Vector3_1.Vector3.getZero(), stCoordinate = Vector3_1.Vector3.getZero(), faceIndex = 0, position = Vector3_1.Vector3.getZero(), normal = Vector3_1.Vector3.getZero(), binormal = Vector3_1.Vector3.getZero()) {
-            if (localID instanceof UUID_1.UUID) {
-                const obj = this.currentRegion.objects.getObjectByUUID(localID);
-                localID = obj.ID;
-            }
-            yield this.grabObject(localID, grabOffset, uvCoordinate, stCoordinate, faceIndex, position, normal, binormal);
-            return this.deGrabObject(localID, grabOffset, uvCoordinate, stCoordinate, faceIndex, position, normal, binormal);
-        });
+        }
     }
 }
 exports.RegionCommands = RegionCommands;