@casual-simulation/aux-vm 3.4.6-alpha.14668890889 → 3.5.0-alpha.15117651144

package/managers/RecordsManager.js

@@ -1,39 +1,12 @@
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-import { hasValue, asyncResult, asyncError, APPROVED_SYMBOL, iterableNext, iterableThrow, iterableComplete, } from '@casual-simulation/aux-common';
+import { hasValue, asyncResult, asyncError, APPROVED_SYMBOL, iterableNext, iterableThrow, iterableComplete, formatVersionNumber, remote, installAuxFile, formatInstId, isRecordKey, parseRecordKey, } from '@casual-simulation/aux-common';
 import axios from 'axios';
-import { isRecordKey, formatInstId, parseRecordKey, } from '@casual-simulation/aux-records';
 import { sha256 } from 'hash.js';
 import stringify from '@casual-simulation/fast-json-stable-stringify';
 import '@casual-simulation/aux-common/BlobPolyfill';
 import { ReplaySubject, Subject, filter, firstValueFrom, map, share, takeWhile, } from 'rxjs';
 import { DateTime } from 'luxon';
-import { createRecordsClient, } from '@casual-simulation/aux-records/RecordsClient';
+/* eslint-disable casualos/no-non-type-imports */
+import { createRecordsClient } from '@casual-simulation/aux-records/RecordsClient';
 /**
  * The list of headers that JavaScript applications are not allowed to set by themselves.
  */
@@ -123,6 +96,13 @@ export class RecordsManager {
             'listNotificationSubscriptions',
             'listUserNotificationSubscriptions',
             'createOpenAIRealtimeSession',
+            'erasePackageVersion',
+            'listPackageVersions',
+            'getPackageVersion',
+            'recordPackage',
+            'erasePackage',
+            'listPackages',
+            'getPackage',
         ]);
         this._config = config;
         this._helper = helper;
@@ -222,1198 +202,1539 @@ export class RecordsManager {
             else if (event.type === 'records_call_procedure') {
                 this._recordsCallProcedure(event);
             }
+            else if (event.type === 'record_package_version') {
+                this._recordPackageVersion(event);
+            }
+            else if (event.type === 'install_package') {
+                this._installPackage(event);
+            }
+            else if (event.type === 'list_installed_packages') {
+                this._listInstalledPackages(event);
+            }
         }
     }
-    _getRecordsEndpoint(event) {
-        if (hasValue(event.taskId)) {
-            this._helper.transaction(asyncResult(event.taskId, this._config.recordsOrigin));
+    async grantEntitlements(event) {
+        const info = await this._resolveInfoForEvent(event);
+        if (info.error) {
+            return;
         }
-    }
-    _recordsCallProcedure(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let name;
-            let input;
-            let query;
-            for (let key in event.procedure) {
-                if (Object.hasOwn(event.procedure, key)) {
-                    const val = event.procedure[key];
-                    if (val) {
-                        name = key;
-                        input = val.input;
-                        query = val.query;
-                        break;
-                    }
-                }
-            }
-            if (!name || !this._allowedProcedures.has(name)) {
-                console.warn('[RecordsManager] No procedure found in the call procedure event.');
+        let grantIds = [];
+        for (let feature of event.request.features) {
+            const result = await this._client.grantEntitlement({
+                packageId: event.request.packageId,
+                feature: feature,
+                scope: event.request.scope,
+                recordName: event.request.recordName,
+                expireTimeMs: event.request.expireTimeMs,
+            }, {
+                sessionKey: info.token,
+                endpoint: info.recordsOrigin,
+            });
+            if (result.success === false) {
+                console.error('[RecordsManager] Unable to grant entitlement:', result);
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'not_found',
-                        errorMessage: `The procedure was either not found or not allowed. (name: ${name !== null && name !== void 0 ? name : 'undefined'})`,
-                    }));
+                    await this._helper.transaction(asyncResult(event.taskId, result));
                 }
                 return;
             }
-            const info = yield this._resolveInfoForEvent(event);
-            if (info.error) {
-                return;
+            else {
+                grantIds.push(result.grantId);
             }
-            if (hasValue(this._helper.origin)) {
-                const instances = [
-                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                ];
-                if (query) {
-                    query.instances = instances;
-                }
-                else {
-                    input.instances = instances;
+        }
+        if (hasValue(event.taskId)) {
+            await this._helper.transaction(asyncResult(event.taskId, {
+                success: true,
+                grantIds,
+            }));
+        }
+    }
+    _getRecordsEndpoint(event) {
+        if (hasValue(event.taskId)) {
+            this._helper.transaction(asyncResult(event.taskId, this._config.recordsOrigin));
+        }
+    }
+    async _recordsCallProcedure(event) {
+        let name;
+        let input;
+        let query;
+        for (let key in event.procedure) {
+            if (Object.hasOwn(event.procedure, key)) {
+                const val = event.procedure[key];
+                if (val) {
+                    name = key;
+                    input = val.input;
+                    query = val.query;
+                    break;
                 }
             }
-            const result = yield this._client.callProcedure(name, input, {
-                sessionKey: info.token,
-                endpoint: info.recordsOrigin,
-            }, query);
+        }
+        if (!name || !this._allowedProcedures.has(name)) {
+            console.warn('[RecordsManager] No procedure found in the call procedure event.');
             if (hasValue(event.taskId)) {
-                this._helper.transaction(asyncResult(event.taskId, result));
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'not_found',
+                    errorMessage: `The procedure was either not found or not allowed. (name: ${name !== null && name !== void 0 ? name : 'undefined'})`,
+                }));
             }
-        });
+            return;
+        }
+        const info = await this._resolveInfoForEvent(event);
+        if (info.error) {
+            return;
+        }
+        if (hasValue(this._helper.origin)) {
+            const instances = [
+                formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+            ];
+            if (query) {
+                query.instances = instances;
+            }
+            else {
+                input.instances = instances;
+            }
+        }
+        const result = await this._client.callProcedure(name, input, {
+            sessionKey: info.token,
+            endpoint: info.recordsOrigin,
+        }, query);
+        if (hasValue(event.taskId)) {
+            this._helper.transaction(asyncResult(event.taskId, result));
+        }
     }
     /**
      * Reports the given inst to the server.
      * @param request The request to send to the server.
      */
-    reportInst(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getEndpointInfo(null, false);
-            if (info.error) {
-                return;
-            }
-            const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/insts/report'), Object.assign({}, request), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-            return result.data;
+    async reportInst(request) {
+        const info = await this._resolveInfoForEvent({ options: {} }, false);
+        if (info.error) {
+            return;
+        }
+        const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/insts/report'), {
+            ...request,
+        }, {
+            ...this._axiosOptions,
+            headers: info.headers,
         });
+        return result.data;
     }
     /**
      * Gets a token that can be used to access loom for the given record.
      * @param recordName The name of the record.
      */
-    getLoomToken(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._resolveInfoForEvent({ options: {} });
-            const result = yield this._client.getLoomAccessToken({
-                recordName,
-            }, {
-                sessionKey: info.token,
-                endpoint: info.recordsOrigin,
+    async getLoomToken(recordName) {
+        const info = await this._resolveInfoForEvent({ options: {} });
+        if (info.error) {
+            return;
+        }
+        const result = await this._client.getLoomAccessToken({
+            recordName,
+        }, {
+            sessionKey: info.token,
+            endpoint: info.recordsOrigin,
+        });
+        if (result.success === false) {
+            console.error('[RecordsManager] Unable to get loom token:', result);
+            return null;
+        }
+        return result.token;
+    }
+    async _recordData(event) {
+        if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+            return;
+        }
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            console.log('[RecordsManager] Recording data...', event);
+            let requestData = {
+                recordKey: event.recordKey,
+                address: event.address,
+                data: event.data,
+            };
+            if (hasValue(this._helper.origin)) {
+                requestData.instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            if (hasValue(event.options.markers)) {
+                requestData.markers = event.options.markers;
+            }
+            if (hasValue(event.options.updatePolicy)) {
+                requestData.updatePolicy = event.options.updatePolicy;
+            }
+            if (hasValue(event.options.deletePolicy)) {
+                requestData.deletePolicy = event.options.deletePolicy;
+            }
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, !event.requiresApproval
+                ? '/api/v2/records/data'
+                : '/api/v2/records/manual/data'), requestData, {
+                ...this._axiosOptions,
+                headers: info.headers,
             });
-            if (result.success === false) {
-                console.error('[RecordsManager] Unable to get loom token:', result);
-                return null;
+            if (result.data.success) {
+                console.log('[RecordsManager] Data recorded!');
             }
-            return result.token;
-        });
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error publishing record:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _recordData(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+    async _getRecordData(event) {
+        if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+            return;
+        }
+        try {
+            const info = await this._resolveInfoForEvent(event, false);
+            if (info.error) {
                 return;
             }
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Recording data...', event);
-                let requestData = {
-                    recordKey: event.recordKey,
-                    address: event.address,
-                    data: event.data,
-                };
-                if (hasValue(this._helper.origin)) {
-                    requestData.instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                if (hasValue(event.options.markers)) {
-                    requestData.markers = event.options.markers;
-                }
-                if (hasValue(event.options.updatePolicy)) {
-                    requestData.updatePolicy = event.options.updatePolicy;
-                }
-                if (hasValue(event.options.deletePolicy)) {
-                    requestData.deletePolicy = event.options.deletePolicy;
-                }
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, !event.requiresApproval
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            if (hasValue(event.taskId)) {
+                const result = await axios.get(await this._publishUrl(info.recordsOrigin, !event.requiresApproval
                     ? '/api/v2/records/data'
-                    : '/api/v2/records/manual/data'), requestData, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Data recorded!');
-                }
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
-                }
+                    : '/api/v2/records/manual/data', {
+                    recordName: event.recordName,
+                    address: event.address,
+                    instances,
+                }), {
+                    ...this._axiosOptions,
+                    headers: info.headers,
+                });
+                this._helper.transaction(asyncResult(event.taskId, result.data));
             }
-            catch (e) {
-                console.error('[RecordsManager] Error publishing record:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error getting record:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
-        });
+        }
     }
-    _getRecordData(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+    async _listRecordData(event) {
+        if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+            return;
+        }
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
                 return;
             }
-            try {
-                const info = yield this._resolveInfoForEvent(event, false);
-                if (info.error) {
-                    return;
-                }
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
+            if (event.requiresApproval) {
                 if (hasValue(event.taskId)) {
-                    const result = yield axios.get(yield this._publishUrl(info.recordsOrigin, !event.requiresApproval
-                        ? '/api/v2/records/data'
-                        : '/api/v2/records/manual/data', {
-                        recordName: event.recordName,
-                        address: event.address,
-                        instances,
-                    }), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_supported',
+                        errorMessage: 'It is not possible to list manual approval records.',
+                    }));
                 }
+                return;
             }
-            catch (e) {
-                console.error('[RecordsManager] Error getting record:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
             }
-        });
+            if (hasValue(event.taskId)) {
+                let query = {
+                    recordName: event.recordName,
+                };
+                if (event.type === 'list_record_data_by_marker') {
+                    query.marker = event.marker;
+                }
+                query.address = event.startingAddress || null;
+                query.instances = instances;
+                const result = await axios.get(await this._publishUrl(info.recordsOrigin, '/api/v2/records/data/list', query), {
+                    ...this._axiosOptions,
+                    headers: info.headers,
+                });
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error listing record:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _listRecordData(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+    async _eraseRecordData(event) {
+        if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+            return;
+        }
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
                 return;
             }
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (event.requiresApproval) {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_supported',
-                            errorMessage: 'It is not possible to list manual approval records.',
-                        }));
-                    }
-                    return;
-                }
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                if (hasValue(event.taskId)) {
-                    let query = {
-                        recordName: event.recordName,
-                    };
-                    if (event.type === 'list_record_data_by_marker') {
-                        query.marker = event.marker;
-                    }
-                    query.address = event.startingAddress || null;
-                    query.instances = instances;
-                    const result = yield axios.get(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/data/list', query), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
-                }
+            console.log('[RecordsManager] Deleting data...', event);
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
             }
-            catch (e) {
-                console.error('[RecordsManager] Error listing record:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+            const result = await axios.request({
+                ...this._axiosOptions,
+                method: 'DELETE',
+                url: await this._publishUrl(info.recordsOrigin, !event.requiresApproval
+                    ? '/api/v2/records/data'
+                    : '/api/v2/records/manual/data'),
+                data: {
+                    recordKey: event.recordKey,
+                    address: event.address,
+                    instances,
+                },
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] Data deleted!');
             }
-        });
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error deleting record:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _eraseRecordData(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.requiresApproval && !event[APPROVED_SYMBOL]) {
+    async _recordFile(event) {
+        var _a;
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
                 return;
             }
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Deleting data...', event);
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                const result = yield axios.request(Object.assign(Object.assign({}, this._axiosOptions), { method: 'DELETE', url: yield this._publishUrl(info.recordsOrigin, !event.requiresApproval
-                        ? '/api/v2/records/data'
-                        : '/api/v2/records/manual/data'), data: {
-                        recordKey: event.recordKey,
-                        address: event.address,
-                        instances,
-                    }, headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Data deleted!');
-                }
+            console.log('[RecordsManager] Recording file...', event);
+            const fileInfo = await this._resolveRecordFileInfo(event.data, event.mimeType);
+            if (fileInfo.success === false) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
+                    this._helper.transaction(asyncResult(event.taskId, fileInfo));
                 }
+                return;
             }
-            catch (e) {
-                console.error('[RecordsManager] Error deleting record:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+            const { byteLength, hash, mimeType, data } = fileInfo;
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/file'), {
+                recordKey: event.recordKey,
+                fileSha256Hex: hash,
+                fileMimeType: mimeType,
+                fileByteLength: byteLength,
+                fileDescription: event.description,
+                markers: (_a = event.options) === null || _a === void 0 ? void 0 : _a.markers,
+                instances,
+            }, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            const uploadResult = await this._uploadFile(result.data, data, hash);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, uploadResult));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error recording file:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
+        }
+    }
+    async _uploadFile(result, data, hash) {
+        if (result.success === false) {
+            return result;
+        }
+        const method = result.uploadMethod;
+        const url = result.uploadUrl;
+        const headers = { ...result.uploadHeaders };
+        for (let name of UNSAFE_HEADERS) {
+            delete headers[name];
+        }
+        const uploadResult = await axios.request({
+            ...this._axiosOptions,
+            method: method.toLowerCase(),
+            url: url,
+            headers: headers,
+            data: data,
         });
+        if (uploadResult.status >= 200 && uploadResult.status < 300) {
+            console.log('[RecordsManager] File recorded!');
+            return {
+                success: true,
+                url: url,
+                sha256Hash: hash,
+            };
+            // if (hasValue(event.taskId)) {
+            //     this._helper.transaction(
+            //         asyncResult(event.taskId, {
+            //             success: true,
+            //             url: url,
+            //             sha256Hash: hash,
+            //         } as FileRecordedResult)
+            //     );
+            // }
+        }
+        else {
+            console.error('[RecordsManager] File upload failed!', uploadResult);
+            return {
+                success: false,
+                errorCode: 'upload_failed',
+                errorMessage: 'The file upload failed.',
+            };
+            // if (hasValue(event.taskId)) {
+            //     this._helper.transaction(
+            //         asyncResult(event.taskId, {
+            //             success: false,
+            //             errorCode: 'upload_failed',
+            //             errorMessage: 'The file upload failed.',
+            //         } as FileRecordedResult)
+            //     );
+            // }
+        }
     }
-    _recordFile(event) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Recording file...', event);
-                let byteLength;
-                let hash;
-                let mimeType;
-                let data;
-                if (typeof event.data === 'function') {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'invalid_file_data',
-                            errorMessage: 'Function instances cannot be stored in files.',
-                        }));
+    async _resolveRecordFileInfo(eventData, eventMimeType) {
+        let byteLength;
+        let hash;
+        let mimeType;
+        let data;
+        if (typeof eventData === 'function') {
+            // if (hasValue(event.taskId)) {
+            //     this._helper.transaction(
+            //         asyncResult(event.taskId, {
+            //             success: false,
+            //             errorCode: 'invalid_file_data',
+            //             errorMessage:
+            //                 'Function instances cannot be stored in files.',
+            //         } as RecordFileResult)
+            //     );
+            // }
+            return {
+                success: false,
+                errorCode: 'invalid_file_data',
+                errorMessage: 'Function instances cannot be stored in files.',
+            };
+        }
+        else if (typeof eventData === 'undefined' || eventData === null) {
+            return {
+                success: false,
+                errorCode: 'invalid_file_data',
+                errorMessage: 'Null or undefined values cannot be stored in files.',
+            };
+        }
+        else if (typeof eventData === 'string' ||
+            typeof eventData === 'number' ||
+            typeof eventData === 'boolean') {
+            const encoder = new TextEncoder();
+            data = encoder.encode(eventData.toString());
+            byteLength = data.byteLength;
+            mimeType = eventMimeType || 'text/plain';
+            hash = getHash(data);
+        }
+        else if (typeof eventData === 'object') {
+            if (eventData instanceof Blob) {
+                const buffer = await eventData.arrayBuffer();
+                data = new Uint8Array(buffer);
+                byteLength = data.byteLength;
+                mimeType =
+                    eventMimeType ||
+                        eventData.type ||
+                        'application/octet-stream';
+                hash = getHash(data);
+            }
+            else if (eventData instanceof ArrayBuffer) {
+                data = new Uint8Array(eventData);
+                byteLength = data.byteLength;
+                mimeType = eventMimeType || 'application/octet-stream';
+                hash = getHash(data);
+            }
+            else if (ArrayBuffer.isView(eventData)) {
+                data = new Uint8Array(eventData.buffer);
+                byteLength = data.byteLength;
+                mimeType = eventMimeType || 'application/octet-stream';
+                hash = getHash(data);
+            }
+            else {
+                const obj = eventData;
+                if ('data' in obj &&
+                    'mimeType' in obj &&
+                    (obj.data instanceof ArrayBuffer ||
+                        typeof obj.data === 'string') &&
+                    typeof obj.mimeType === 'string') {
+                    if (typeof obj.data === 'string') {
+                        data = new TextEncoder().encode(obj.data);
                     }
-                    return;
-                }
-                else if (typeof event.data === 'undefined' ||
-                    event.data === null) {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'invalid_file_data',
-                            errorMessage: 'Null or undefined values cannot be stored in files.',
-                        }));
+                    else {
+                        data = new Uint8Array(obj.data);
                     }
-                    return;
-                }
-                else if (typeof event.data === 'string' ||
-                    typeof event.data === 'number' ||
-                    typeof event.data === 'boolean') {
-                    const encoder = new TextEncoder();
-                    data = encoder.encode(event.data.toString());
                     byteLength = data.byteLength;
-                    mimeType = event.mimeType || 'text/plain';
+                    mimeType =
+                        eventMimeType ||
+                            obj.mimeType ||
+                            (typeof obj.data === 'string'
+                                ? 'text/plain'
+                                : 'application/octet-stream');
                     hash = getHash(data);
                 }
-                else if (typeof event.data === 'object') {
-                    if (event.data instanceof Blob) {
-                        const buffer = yield event.data.arrayBuffer();
-                        data = new Uint8Array(buffer);
-                        byteLength = data.byteLength;
-                        mimeType =
-                            event.mimeType ||
-                                event.data.type ||
-                                'application/octet-stream';
-                        hash = getHash(data);
-                    }
-                    else if (event.data instanceof ArrayBuffer) {
-                        data = new Uint8Array(event.data);
-                        byteLength = data.byteLength;
-                        mimeType = event.mimeType || 'application/octet-stream';
-                        hash = getHash(data);
-                    }
-                    else if (ArrayBuffer.isView(event.data)) {
-                        data = new Uint8Array(event.data.buffer);
-                        byteLength = data.byteLength;
-                        mimeType = event.mimeType || 'application/octet-stream';
-                        hash = getHash(data);
-                    }
-                    else {
-                        const obj = event.data;
-                        if ('data' in obj &&
-                            'mimeType' in obj &&
-                            (obj.data instanceof ArrayBuffer ||
-                                typeof obj.data === 'string') &&
-                            typeof obj.mimeType === 'string') {
-                            if (typeof obj.data === 'string') {
-                                data = new TextEncoder().encode(obj.data);
-                            }
-                            else {
-                                data = new Uint8Array(obj.data);
-                            }
-                            byteLength = data.byteLength;
-                            mimeType =
-                                event.mimeType ||
-                                    obj.mimeType ||
-                                    (typeof obj.data === 'string'
-                                        ? 'text/plain'
-                                        : 'application/octet-stream');
-                            hash = getHash(data);
-                        }
-                        else {
-                            let json = stringify(event.data);
-                            data = new TextEncoder().encode(json);
-                            byteLength = data.byteLength;
-                            mimeType = event.mimeType || 'application/json';
-                            hash = getHash(data);
-                        }
-                    }
+                else {
+                    let json = stringify(eventData);
+                    data = new TextEncoder().encode(json);
+                    byteLength = data.byteLength;
+                    mimeType = eventMimeType || 'application/json';
+                    hash = getHash(data);
                 }
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/file'), {
-                    recordKey: event.recordKey,
-                    fileSha256Hex: hash,
-                    fileMimeType: mimeType,
-                    fileByteLength: byteLength,
-                    fileDescription: event.description,
-                    markers: (_a = event.options) === null || _a === void 0 ? void 0 : _a.markers,
-                    instances,
-                }, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success === true) {
-                    const method = result.data.uploadMethod;
-                    const url = result.data.uploadUrl;
-                    const headers = Object.assign({}, result.data.uploadHeaders);
-                    for (let name of UNSAFE_HEADERS) {
-                        delete headers[name];
-                    }
-                    const uploadResult = yield axios.request(Object.assign(Object.assign({}, this._axiosOptions), { method: method.toLowerCase(), url: url, headers: headers, data: data }));
-                    if (uploadResult.status >= 200 && uploadResult.status < 300) {
-                        console.log('[RecordsManager] File recorded!');
-                        if (hasValue(event.taskId)) {
-                            this._helper.transaction(asyncResult(event.taskId, {
-                                success: true,
-                                url: url,
-                                sha256Hash: hash,
-                            }));
-                        }
+            }
+        }
+        return {
+            success: true,
+            byteLength,
+            hash,
+            mimeType,
+            data,
+        };
+    }
+    async _getFile(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event, false);
+            if (info.error) {
+                return;
+            }
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            const result = await axios.get(await this._publishUrl(info.recordsOrigin, '/api/v2/records/file', {
+                fileUrl: event.fileUrl,
+                instances,
+            }), {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (hasValue(event.taskId)) {
+                if (result.data.success) {
+                    const getResult = await axios.request({
+                        ...this._axiosOptions,
+                        method: result.data.requestMethod,
+                        url: result.data.requestUrl,
+                        headers: result.data.requestHeaders,
+                    });
+                    if (getResult.status >= 200 && getResult.status < 300) {
+                        this._helper.transaction(asyncResult(event.taskId, getResult.data));
                     }
                     else {
-                        console.error('[RecordsManager] File upload failed!', uploadResult);
-                        if (hasValue(event.taskId)) {
-                            this._helper.transaction(asyncResult(event.taskId, {
-                                success: false,
-                                errorCode: 'upload_failed',
-                                errorMessage: 'The file upload failed.',
-                            }));
-                        }
+                        this._helper.transaction(asyncError(event.taskId, {
+                            success: false,
+                            errorCode: getResult.status === 404
+                                ? 'file_not_found'
+                                : getResult.status >= 500
+                                    ? 'server_error'
+                                    : 'not_authorized',
+                            errorMessage: 'The file upload failed.',
+                        }));
                     }
                 }
                 else {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, result.data));
-                    }
+                    this._helper.transaction(asyncError(event.taskId, result.data));
                 }
             }
-            catch (e) {
-                console.error('[RecordsManager] Error recording file:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error getting file:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
+        }
+    }
+    async _readFile(result) {
+        const getResult = await axios.request({
+            ...this._axiosOptions,
+            method: result.requestMethod,
+            url: result.requestUrl,
+            headers: result.requestHeaders,
         });
+        if (getResult.status >= 200 && getResult.status < 300) {
+            return {
+                success: true,
+                data: getResult.data,
+            };
+        }
+        else {
+            return {
+                success: false,
+                errorCode: getResult.status === 404
+                    ? 'file_not_found'
+                    : getResult.status >= 500
+                        ? 'server_error'
+                        : 'not_authorized',
+                errorMessage: getResult.status === 404
+                    ? 'The file was not found.'
+                    : 'The file download failed.',
+            };
+        }
     }
-    _getFile(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event, false);
-                if (info.error) {
-                    return;
-                }
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                const result = yield axios.get(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/file', {
+    async _eraseFile(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            console.log('[RecordsManager] Deleting file...', event);
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            const result = await axios.request({
+                ...this._axiosOptions,
+                method: 'DELETE',
+                url: await this._publishUrl(info.recordsOrigin, '/api/v2/records/file'),
+                data: {
+                    recordKey: event.recordKey,
                     fileUrl: event.fileUrl,
                     instances,
-                }), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (hasValue(event.taskId)) {
-                    if (result.data.success) {
-                        const getResult = yield axios.request(Object.assign(Object.assign({}, this._axiosOptions), { method: result.data.requestMethod, url: result.data.requestUrl, headers: result.data.requestHeaders }));
-                        if (getResult.status >= 200 && getResult.status < 300) {
-                            this._helper.transaction(asyncResult(event.taskId, getResult.data));
-                        }
-                        else {
-                            this._helper.transaction(asyncError(event.taskId, {
-                                success: false,
-                                errorCode: getResult.status === 404
-                                    ? 'file_not_found'
-                                    : getResult.status >= 500
-                                        ? 'server_error'
-                                        : 'not_authorized',
-                                errorMessage: 'The file upload failed.',
-                            }));
-                        }
-                    }
-                    else {
-                        this._helper.transaction(asyncError(event.taskId, result.data));
-                    }
-                }
+                },
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] File deleted!');
             }
-            catch (e) {
-                console.error('[RecordsManager] Error getting file:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
             }
-        });
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error deleting file:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _eraseFile(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Deleting file...', event);
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                const result = yield axios.request(Object.assign(Object.assign({}, this._axiosOptions), { method: 'DELETE', url: yield this._publishUrl(info.recordsOrigin, '/api/v2/records/file'), data: {
-                        recordKey: event.recordKey,
-                        fileUrl: event.fileUrl,
-                        instances,
-                    }, headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] File deleted!');
-                }
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
-                }
+    async _recordEvent(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
             }
-            catch (e) {
-                console.error('[RecordsManager] Error deleting file:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+            console.log('[RecordsManager] Recording event...', event);
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
             }
-        });
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/events/count'), {
+                recordKey: event.recordKey,
+                eventName: event.eventName,
+                count: event.count,
+                instances,
+            }, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] Event recorded!');
+            }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error recording event:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _recordEvent(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Recording event...', event);
+    async _getEventCount(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            if (hasValue(event.taskId)) {
                 let instances = undefined;
                 if (hasValue(this._helper.origin)) {
                     instances = [
                         formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
                     ];
                 }
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/events/count'), {
-                    recordKey: event.recordKey,
+                const result = await axios.get(await this._publishUrl(info.recordsOrigin, '/api/v2/records/events/count', {
+                    recordName: event.recordName,
                     eventName: event.eventName,
-                    count: event.count,
                     instances,
-                }, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Event recorded!');
-                }
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error recording event:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+                }), { ...this._axiosOptions, headers: info.headers });
+                this._helper.transaction(asyncResult(event.taskId, result.data));
             }
-        });
-    }
-    _getEventCount(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (hasValue(event.taskId)) {
-                    let instances = undefined;
-                    if (hasValue(this._helper.origin)) {
-                        instances = [
-                            formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                        ];
-                    }
-                    const result = yield axios.get(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/events/count', {
-                        recordName: event.recordName,
-                        eventName: event.eventName,
-                        instances,
-                    }), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error getting event count:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
-            }
-        });
-    }
-    _joinRoom(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event, false);
-                if (info.error) {
-                    // if (hasValue(event.taskId)) {
-                    //     this._helper.transaction(
-                    //         asyncResult(event.taskId, {
-                    //             success: false,
-                    //             errorCode: 'not_supported',
-                    //             errorMessage:
-                    //                 'Records are not supported on this inst.',
-                    //         } as IssueMeetTokenResult)
-                    //     );
-                    // }
-                    return;
-                }
-                if (hasValue(event.taskId)) {
-                    const userId = this._helper.userId;
-                    const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/meet/token'), {
-                        roomName: event.roomName,
-                        userName: userId,
-                    }, Object.assign({}, this._axiosOptions));
-                    const data = result.data;
-                    if (data.success) {
-                        const join = {
-                            roomName: data.roomName,
-                            token: data.token,
-                            url: data.url,
-                            options: event.options,
-                            resolve: (options) => {
-                                this._helper.transaction(asyncResult(event.taskId, {
-                                    success: true,
-                                    roomName: data.roomName,
-                                    options,
-                                }));
-                            },
-                            reject: (code, message) => {
-                                this._helper.transaction(asyncResult(event.taskId, {
-                                    success: false,
-                                    roomName: data.roomName,
-                                    errorCode: code,
-                                    errorMessage: message,
-                                }));
-                            },
-                        };
-                        this._roomJoin.next(join);
-                    }
-                    else {
-                        this._helper.transaction(asyncResult(event.taskId, data));
-                    }
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error joining room:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error getting event count:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
-        });
+        }
     }
-    _leaveRoom(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (hasValue(event.taskId)) {
-                    const leave = {
-                        roomName: event.roomName,
-                        resolve: () => {
-                            this._helper.transaction(asyncResult(event.taskId, {
-                                success: true,
-                                roomName: event.roomName,
-                            }));
-                        },
-                        reject: (code, message) => {
-                            this._helper.transaction(asyncResult(event.taskId, {
-                                success: false,
-                                roomName: event.roomName,
-                                errorCode: code,
-                                errorMessage: message,
-                            }));
-                        },
-                    };
-                    this._roomLeave.next(leave);
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error leaving room:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+    async _joinRoom(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event, false);
+            if (info.error) {
+                // if (hasValue(event.taskId)) {
+                //     this._helper.transaction(
+                //         asyncResult(event.taskId, {
+                //             success: false,
+                //             errorCode: 'not_supported',
+                //             errorMessage:
+                //                 'Records are not supported on this inst.',
+                //         } as IssueMeetTokenResult)
+                //     );
+                // }
+                return;
             }
-        });
-    }
-    _setRoomOptions(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (hasValue(event.taskId)) {
-                    const leave = {
-                        roomName: event.roomName,
+            if (hasValue(event.taskId)) {
+                const userId = this._helper.userId;
+                const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/meet/token'), {
+                    roomName: event.roomName,
+                    userName: userId,
+                }, { ...this._axiosOptions });
+                const data = result.data;
+                if (data.success) {
+                    const join = {
+                        roomName: data.roomName,
+                        token: data.token,
+                        url: data.url,
                         options: event.options,
                         resolve: (options) => {
                             this._helper.transaction(asyncResult(event.taskId, {
                                 success: true,
-                                roomName: event.roomName,
+                                roomName: data.roomName,
                                 options,
                             }));
                         },
                         reject: (code, message) => {
                             this._helper.transaction(asyncResult(event.taskId, {
                                 success: false,
-                                roomName: event.roomName,
+                                roomName: data.roomName,
                                 errorCode: code,
                                 errorMessage: message,
                             }));
                         },
                     };
-                    this._onSetRoomOptions.next(leave);
+                    this._roomJoin.next(join);
                 }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error setting room options:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
+                else {
+                    this._helper.transaction(asyncResult(event.taskId, data));
                 }
             }
-        });
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error joining room:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _getRoomOptions(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (hasValue(event.taskId)) {
-                    const getRoomOptions = {
-                        roomName: event.roomName,
-                        resolve: (options) => {
-                            this._helper.transaction(asyncResult(event.taskId, {
-                                success: true,
-                                roomName: event.roomName,
-                                options: options,
-                            }));
-                        },
-                        reject: (code, message) => {
-                            this._helper.transaction(asyncResult(event.taskId, {
-                                success: false,
-                                roomName: event.roomName,
-                                errorCode: code,
-                                errorMessage: message,
-                            }));
-                        },
-                    };
-                    this._onGetRoomOptions.next(getRoomOptions);
-                }
+    async _leaveRoom(event) {
+        try {
+            if (hasValue(event.taskId)) {
+                const leave = {
+                    roomName: event.roomName,
+                    resolve: () => {
+                        this._helper.transaction(asyncResult(event.taskId, {
+                            success: true,
+                            roomName: event.roomName,
+                        }));
+                    },
+                    reject: (code, message) => {
+                        this._helper.transaction(asyncResult(event.taskId, {
+                            success: false,
+                            roomName: event.roomName,
+                            errorCode: code,
+                            errorMessage: message,
+                        }));
+                    },
+                };
+                this._roomLeave.next(leave);
             }
-            catch (e) {
-                console.error('[RecordsManager] Error setting room options:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error leaving room:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
-        });
+        }
     }
-    _grantRecordPermission(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Granting policy permission...', event);
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                let requestData = {
-                    recordName: event.recordName,
-                    permission: event.permission,
-                    instances,
+    async _setRoomOptions(event) {
+        try {
+            if (hasValue(event.taskId)) {
+                const leave = {
+                    roomName: event.roomName,
+                    options: event.options,
+                    resolve: (options) => {
+                        this._helper.transaction(asyncResult(event.taskId, {
+                            success: true,
+                            roomName: event.roomName,
+                            options,
+                        }));
+                    },
+                    reject: (code, message) => {
+                        this._helper.transaction(asyncResult(event.taskId, {
+                            success: false,
+                            roomName: event.roomName,
+                            errorCode: code,
+                            errorMessage: message,
+                        }));
+                    },
                 };
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/permissions'), requestData, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Permission granted!');
-                }
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
-                }
+                this._onSetRoomOptions.next(leave);
             }
-            catch (e) {
-                console.error('[RecordsManager] Error granting record permission:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error setting room options:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
-        });
+        }
     }
-    _revokeRecordPermission(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Revoking policy permission...', event);
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                let requestData = {
-                    recordName: event.recordName,
-                    permissionId: event.permissionId,
-                    instances,
+    async _getRoomOptions(event) {
+        try {
+            if (hasValue(event.taskId)) {
+                const getRoomOptions = {
+                    roomName: event.roomName,
+                    resolve: (options) => {
+                        this._helper.transaction(asyncResult(event.taskId, {
+                            success: true,
+                            roomName: event.roomName,
+                            options: options,
+                        }));
+                    },
+                    reject: (code, message) => {
+                        this._helper.transaction(asyncResult(event.taskId, {
+                            success: false,
+                            roomName: event.roomName,
+                            errorCode: code,
+                            errorMessage: message,
+                        }));
+                    },
                 };
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/permissions/revoke'), requestData, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Permission revoked!');
-                }
+                this._onGetRoomOptions.next(getRoomOptions);
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error setting room options:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _grantRecordPermission(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            console.log('[RecordsManager] Granting policy permission...', event);
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            let requestData = {
+                recordName: event.recordName,
+                permission: event.permission,
+                instances,
+            };
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/permissions'), requestData, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] Permission granted!');
+            }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error granting record permission:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _revokeRecordPermission(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            console.log('[RecordsManager] Revoking policy permission...', event);
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            let requestData = {
+                recordName: event.recordName,
+                permissionId: event.permissionId,
+                instances,
+            };
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/permissions/revoke'), requestData, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] Permission revoked!');
+            }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error revoking policy permission:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _grantInstAdminPermission(event) {
+        if (!event[APPROVED_SYMBOL]) {
+            return;
+        }
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            if (!hasValue(this._helper.origin)) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
+                    this._helper.transaction(asyncError(event.taskId, 'Unable to grant inst admin permission with no simulation origin!'));
                 }
+                return;
+            }
+            const now = DateTime.now();
+            const plusOneDay = now.plus({ day: 1 });
+            const startOfNextDay = plusOneDay.set({
+                hour: 0,
+                minute: 0,
+                second: 0,
+                millisecond: 0,
+            });
+            console.log('[RecordsManager] Granting inst admin role...', event);
+            let requestData = {
+                recordName: event.recordName,
+                inst: formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                role: 'admin',
+                expireTimeMs: startOfNextDay.toMillis(),
+            };
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/role/grant'), requestData, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] Role granted!');
+            }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error granting inst admin role:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _grantRole(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            console.log('[RecordsManager] Granting role...', event);
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            let requestData = {
+                recordName: event.recordName,
+                userId: event.userId,
+                inst: event.inst,
+                role: event.role,
+                expireTimeMs: event.expireTimeMs,
+                instances,
+            };
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/role/grant'), requestData, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] Role granted!');
+            }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error granting role:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
-            catch (e) {
-                console.error('[RecordsManager] Error revoking policy permission:', e);
+        }
+    }
+    async _revokeRole(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            console.log('[RecordsManager] Revoking role...', event);
+            let requestData = {
+                recordName: event.recordName,
+                userId: event.userId,
+                inst: event.inst,
+                role: event.role,
+                instances,
+            };
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/records/role/revoke'), requestData, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (result.data.success) {
+                console.log('[RecordsManager] Role revoked!');
+            }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error revoking role:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _aiChat(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            if (!info.token) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_logged_in',
+                        errorMessage: 'The user is not logged in.',
+                    }));
                 }
+                return;
             }
-        });
+            const { endpoint, preferredModel, ...rest } = event.options;
+            let requestData = {
+                ...rest,
+                model: preferredModel,
+                messages: event.messages,
+            };
+            if (hasValue(this._helper.origin)) {
+                requestData.instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/ai/chat'), requestData, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error sending chat message:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _grantInstAdminPermission(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!event[APPROVED_SYMBOL]) {
+    async _aiChatStream(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
                 return;
             }
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (!hasValue(this._helper.origin)) {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncError(event.taskId, 'Unable to grant inst admin permission with no simulation origin!'));
-                    }
-                    return;
+            if (!info.token) {
+                if (hasValue(event.taskId)) {
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_logged_in',
+                        errorMessage: 'The user is not logged in.',
+                    }));
                 }
-                const now = DateTime.now();
-                const plusOneDay = now.plus({ day: 1 });
-                const startOfNextDay = plusOneDay.set({
-                    hour: 0,
-                    minute: 0,
-                    second: 0,
-                    millisecond: 0,
+                return;
+            }
+            const { endpoint, preferredModel, ...rest } = event.options;
+            let requestData = {
+                ...rest,
+                model: preferredModel,
+                messages: event.messages,
+            };
+            if (hasValue(this._helper.origin)) {
+                requestData.instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            if (USE_HTTP_STREAMING) {
+                const result = await this._client.aiChatStream(requestData, {
+                    sessionKey: info.token,
+                    endpoint: info.recordsOrigin,
                 });
-                console.log('[RecordsManager] Granting inst admin role...', event);
-                let requestData = {
-                    recordName: event.recordName,
-                    inst: formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    role: 'admin',
-                    expireTimeMs: startOfNextDay.toMillis(),
-                };
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/role/grant'), requestData, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Role granted!');
-                }
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
+                    if (Symbol.asyncIterator in result) {
+                        this._helper.transaction(asyncResult(event.taskId, {
+                            success: true,
+                        }));
+                        try {
+                            for await (let data of result) {
+                                this._helper.transaction(iterableNext(event.taskId, data));
+                            }
+                            this._helper.transaction(iterableComplete(event.taskId));
+                        }
+                        catch (err) {
+                            this._helper.transaction(iterableThrow(event.taskId, err));
+                        }
+                    }
+                    else {
+                        this._helper.transaction(asyncResult(event.taskId, result));
+                    }
                 }
+                return;
             }
-            catch (e) {
-                console.error('[RecordsManager] Error granting inst admin role:', e);
+            const client = await this._getWebsocketClient(info.websocketOrigin, info.websocketProtocol);
+            if (!client) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_supported',
+                        errorMessage: 'Streaming AI chat is not supported on this inst.',
+                    }));
                 }
+                return;
             }
-        });
+            const result = await this._sendWebsocketStreamRequest(client, 'POST', '/api/v2/ai/chat/stream', {}, requestData, info.headers);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: true,
+                }));
+                result.subscribe({
+                    next: (data) => {
+                        this._helper.transaction(iterableNext(event.taskId, data));
+                    },
+                    error: (err) => {
+                        this._helper.transaction(iterableThrow(event.taskId, err));
+                    },
+                    complete: () => {
+                        this._helper.transaction(iterableComplete(event.taskId));
+                    },
+                });
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error sending chat message:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _grantRole(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                console.log('[RecordsManager] Granting role...', event);
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                let requestData = {
-                    recordName: event.recordName,
-                    userId: event.userId,
-                    inst: event.inst,
-                    role: event.role,
-                    expireTimeMs: event.expireTimeMs,
-                    instances,
-                };
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/role/grant'), requestData, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Role granted!');
-                }
+    async _aiGenerateSkybox(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            if (!info.token) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_logged_in',
+                        errorMessage: 'The user is not logged in.',
+                    }));
                 }
+                return;
             }
-            catch (e) {
-                console.error('[RecordsManager] Error granting role:', e);
+            const { endpoint, blockadeLabs, ...rest } = event.options;
+            let requestData = {
+                prompt: event.prompt,
+                negativePrompt: event.negativePrompt,
+                blockadeLabs: blockadeLabs,
+            };
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            const result = await axios.post(await this._publishUrl(info.recordsOrigin, '/api/v2/ai/skybox'), {
+                ...requestData,
+                instances,
+            }, {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (!result.data.success) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
+                    this._helper.transaction(asyncResult(event.taskId, result.data));
                 }
+                return;
             }
-        });
-    }
-    _revokeRole(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                console.log('[RecordsManager] Revoking role...', event);
-                let requestData = {
-                    recordName: event.recordName,
-                    userId: event.userId,
-                    inst: event.inst,
-                    role: event.role,
+            const skyboxId = result.data.skyboxId;
+            for (let i = 0; i < 10; i++) {
+                if (!this._skipTimers) {
+                    const seconds = i === 0
+                        ? 1
+                        : i === 1
+                            ? 4
+                            : i === 2
+                                ? 4
+                                : i === 3
+                                    ? 8
+                                    : i === 4
+                                        ? 16
+                                        : i === 5
+                                            ? 32
+                                            : 32;
+                    await wait(seconds);
+                }
+                const getResult = await axios.get(await this._publishUrl(info.recordsOrigin, '/api/v2/ai/skybox', {
+                    skyboxId: result.data.skyboxId,
                     instances,
-                };
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/records/role/revoke'), requestData, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (result.data.success) {
-                    console.log('[RecordsManager] Role revoked!');
+                }), {
+                    ...this._axiosOptions,
+                    headers: info.headers,
+                });
+                if (getResult.data.success) {
+                    if (getResult.data.status === 'generated') {
+                        if (hasValue(event.taskId)) {
+                            this._helper.transaction(asyncResult(event.taskId, getResult.data));
+                        }
+                        return;
+                    }
                 }
+            }
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'The request timed out.',
+                }));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error generating skybox:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _aiGenerateImage(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            if (!info.token) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_logged_in',
+                        errorMessage: 'The user is not logged in.',
+                    }));
                 }
+                return;
+            }
+            const { taskId, type, options, ...rest } = event;
+            let requestData = {
+                ...rest,
+            };
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            const result = await this._sendWebsocketSupportedRequest(info.recordsOrigin, info.websocketOrigin, info.websocketProtocol, 'POST', '/api/v2/ai/image', {}, {
+                ...requestData,
+                instances,
+            }, info.headers);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result));
             }
-            catch (e) {
-                console.error('[RecordsManager] Error revoking role:', e);
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error generating image:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _aiHumeGetAccessToken(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            if (!info.token) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_logged_in',
+                        errorMessage: 'The user is not logged in.',
+                    }));
                 }
+                return;
             }
-        });
+            const result = await this._client.getHumeAccessToken({
+                recordName: event.recordName,
+            }, {
+                sessionKey: info.token,
+                endpoint: info.recordsOrigin,
+            });
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error getting Hume access token:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _aiChat(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (!info.token) {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_logged_in',
-                            errorMessage: 'The user is not logged in.',
-                        }));
-                    }
-                    return;
+    async _aiSloydGenerateModel(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            if (!info.token) {
+                if (hasValue(event.taskId)) {
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_logged_in',
+                        errorMessage: 'The user is not logged in.',
+                    }));
                 }
-                const _a = event.options, { endpoint, preferredModel } = _a, rest = __rest(_a, ["endpoint", "preferredModel"]);
-                let requestData = Object.assign(Object.assign({}, rest), { model: preferredModel, messages: event.messages });
-                if (hasValue(this._helper.origin)) {
-                    requestData.instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
+                return;
+            }
+            const result = await this._client.createSloydModel({
+                recordName: event.recordName,
+                prompt: event.prompt,
+                baseModelId: event.baseModelId,
+                levelOfDetail: event.levelOfDetail,
+                outputMimeType: event.outputMimeType,
+                thumbnail: event.thumbnail,
+            }, {
+                endpoint: info.recordsOrigin,
+                sessionKey: info.token,
+            });
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error generating Sloyd model:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _recordPackageVersion(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            const fileInfo = await this._resolveRecordFileInfo(event.request.state, 'application/json');
+            if (fileInfo.success === false) {
+                if (hasValue(event.taskId)) {
+                    this._helper.transaction(asyncResult(event.taskId, fileInfo));
                 }
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/ai/chat'), requestData, Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
+                return;
+            }
+            const { byteLength, hash, mimeType, data } = fileInfo;
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            const result = await this._client.recordPackageVersion({
+                recordName: event.request.recordName,
+                item: {
+                    address: event.request.address,
+                    key: event.request.key,
+                    description: event.request.description,
+                    entitlements: event.request.entitlements,
+                    markers: event.request.markers,
+                    auxFileRequest: {
+                        fileByteLength: byteLength,
+                        fileSha256Hex: hash,
+                        fileMimeType: mimeType,
+                        fileDescription: `${event.request.recordName}/${event.request.address}@${formatVersionNumber(event.request.key.major, event.request.key.minor, event.request.key.patch, event.request.key.tag)}`,
+                    },
+                },
+                instances,
+            }, {
+                endpoint: info.recordsOrigin,
+                sessionKey: info.token,
+            });
+            if (result.success === false) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
+                    this._helper.transaction(asyncResult(event.taskId, result));
                 }
+                return;
             }
-            catch (e) {
-                console.error('[RecordsManager] Error sending chat message:', e);
+            const uploadResult = await this._uploadFile(result.auxFileResult, data, hash);
+            if (uploadResult.success === false) {
                 if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
+                    this._helper.transaction(asyncResult(event.taskId, uploadResult));
                 }
+                return;
             }
-        });
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: true,
+                    recordName: result.recordName,
+                    address: result.address,
+                    auxFileResult: uploadResult,
+                }));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error recording package version:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
     }
-    _aiChatStream(event) {
-        var _a, e_1, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
+    async _installPackage(event) {
+        var _a;
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            if ((_a = this._helper.origin) === null || _a === void 0 ? void 0 : _a.isStatic) {
+                // static origins need to install packages via fetching the package
+                const input = {
+                    recordName: event.recordName,
+                    address: event.address,
+                    instances,
+                };
+                if (typeof event.key === 'string') {
+                    input.key = event.key;
                 }
-                if (!info.token) {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_logged_in',
-                            errorMessage: 'The user is not logged in.',
-                        }));
+                else if (typeof event.key === 'object') {
+                    if (event.key.sha256) {
+                        input.sha256 = event.key.sha256;
                     }
-                    return;
-                }
-                const _d = event.options, { endpoint, preferredModel } = _d, rest = __rest(_d, ["endpoint", "preferredModel"]);
-                let requestData = Object.assign(Object.assign({}, rest), { model: preferredModel, messages: event.messages });
-                if (hasValue(this._helper.origin)) {
-                    requestData.instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                if (USE_HTTP_STREAMING) {
-                    const result = yield this._client.aiChatStream(requestData, {
-                        sessionKey: info.token,
-                        endpoint: info.recordsOrigin,
-                    });
-                    if (hasValue(event.taskId)) {
-                        if (Symbol.asyncIterator in result) {
-                            this._helper.transaction(asyncResult(event.taskId, {
-                                success: true,
-                            }));
-                            try {
-                                try {
-                                    for (var _e = true, result_1 = __asyncValues(result), result_1_1; result_1_1 = yield result_1.next(), _a = result_1_1.done, !_a; _e = true) {
-                                        _c = result_1_1.value;
-                                        _e = false;
-                                        let data = _c;
-                                        this._helper.transaction(iterableNext(event.taskId, data));
-                                    }
-                                }
-                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                                finally {
-                                    try {
-                                        if (!_e && !_a && (_b = result_1.return)) yield _b.call(result_1);
-                                    }
-                                    finally { if (e_1) throw e_1.error; }
-                                }
-                                this._helper.transaction(iterableComplete(event.taskId));
-                            }
-                            catch (err) {
-                                this._helper.transaction(iterableThrow(event.taskId, err));
-                            }
-                        }
-                        else {
-                            this._helper.transaction(asyncResult(event.taskId, result));
-                        }
+                    else {
+                        input.major = event.key.major;
+                        input.minor = event.key.minor;
+                        input.patch = event.key.patch;
+                        input.tag = event.key.tag;
                     }
-                    return;
                 }
-                const client = yield this._getWebsocketClient(info.websocketOrigin, info.websocketProtocol);
-                if (!client) {
+                const result = await this._client.getPackageVersion(input, {
+                    sessionKey: info.token,
+                    endpoint: info.recordsOrigin,
+                });
+                if (result.success === false) {
                     if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_supported',
-                            errorMessage: 'Streaming AI chat is not supported on this inst.',
-                        }));
+                        this._helper.transaction(asyncResult(event.taskId, result));
                     }
                     return;
                 }
-                const result = yield this._sendWebsocketStreamRequest(client, 'POST', '/api/v2/ai/chat/stream', {}, requestData, info.headers);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: true,
-                    }));
-                    result.subscribe({
-                        next: (data) => {
-                            this._helper.transaction(iterableNext(event.taskId, data));
-                        },
-                        error: (err) => {
-                            this._helper.transaction(iterableThrow(event.taskId, err));
-                        },
-                        complete: () => {
-                            this._helper.transaction(iterableComplete(event.taskId));
-                        },
-                    });
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error sending chat message:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
-            }
-        });
-    }
-    _aiGenerateSkybox(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (!info.token) {
+                if (result.auxFile.success === false) {
                     if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_logged_in',
-                            errorMessage: 'The user is not logged in.',
-                        }));
+                        this._helper.transaction(asyncResult(event.taskId, result.auxFile));
                     }
                     return;
                 }
-                const _a = event.options, { endpoint, blockadeLabs } = _a, rest = __rest(_a, ["endpoint", "blockadeLabs"]);
-                let requestData = {
-                    prompt: event.prompt,
-                    negativePrompt: event.negativePrompt,
-                    blockadeLabs: blockadeLabs,
-                };
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                const result = yield axios.post(yield this._publishUrl(info.recordsOrigin, '/api/v2/ai/skybox'), Object.assign(Object.assign({}, requestData), { instances }), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (!result.data.success) {
+                const fileResult = await this._readFile(result.auxFile);
+                if (fileResult.success === false) {
                     if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, result.data));
+                        this._helper.transaction(asyncResult(event.taskId, fileResult));
                     }
                     return;
                 }
-                const skyboxId = result.data.skyboxId;
-                for (let i = 0; i < 10; i++) {
-                    if (!this._skipTimers) {
-                        const seconds = i === 0
-                            ? 1
-                            : i === 1
-                                ? 4
-                                : i === 2
-                                    ? 4
-                                    : i === 3
-                                        ? 8
-                                        : i === 4
-                                            ? 16
-                                            : i === 5
-                                                ? 32
-                                                : 32;
-                        yield wait(seconds);
-                    }
-                    const getResult = yield axios.get(yield this._publishUrl(info.recordsOrigin, '/api/v2/ai/skybox', {
-                        skyboxId: result.data.skyboxId,
-                        instances,
-                    }), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                    if (getResult.data.success) {
-                        if (getResult.data.status === 'generated') {
-                            if (hasValue(event.taskId)) {
-                                this._helper.transaction(asyncResult(event.taskId, getResult.data));
-                            }
-                            return;
-                        }
-                    }
-                }
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'server_error',
-                        errorMessage: 'The request timed out.',
-                    }));
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error generating skybox:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
-            }
-        });
-    }
-    _aiGenerateImage(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (!info.token) {
+                else {
+                    // get json and apply it
+                    const aux = fileResult.data;
+                    await this._helper.transaction(remote(installAuxFile(aux, 'default')));
                     if (hasValue(event.taskId)) {
                         this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_logged_in',
-                            errorMessage: 'The user is not logged in.',
+                            success: true,
+                            packageLoadId: null,
+                            package: result.item,
                         }));
                     }
-                    return;
-                }
-                const { taskId, type, options } = event, rest = __rest(event, ["taskId", "type", "options"]);
-                let requestData = Object.assign({}, rest);
-                let instances = undefined;
-                if (hasValue(this._helper.origin)) {
-                    instances = [
-                        formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
-                    ];
-                }
-                const result = yield this._sendWebsocketSupportedRequest(info.recordsOrigin, info.websocketOrigin, info.websocketProtocol, 'POST', '/api/v2/ai/image', {}, Object.assign(Object.assign({}, requestData), { instances }), info.headers);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result));
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error generating image:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
                 }
             }
-        });
-    }
-    _aiHumeGetAccessToken(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (!info.token) {
+            else {
+                if (!this._helper.origin) {
                     if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_logged_in',
-                            errorMessage: 'The user is not logged in.',
-                        }));
+                        this._helper.transaction(asyncError(event.taskId, 'Unable to install package with no simulation origin!'));
                     }
                     return;
                 }
-                const result = yield this._client.getHumeAccessToken({
-                    recordName: event.recordName,
+                // other origins can install via a HTTP request
+                const result = await this._client.installPackage({
+                    recordName: this._helper.origin.recordName,
+                    inst: this._helper.origin.inst,
+                    package: {
+                        recordName: event.recordName,
+                        address: event.address,
+                        key: event.key,
+                    },
+                    instances,
                 }, {
                     sessionKey: info.token,
                     endpoint: info.recordsOrigin,
@@ -1422,108 +1743,76 @@ export class RecordsManager {
                     this._helper.transaction(asyncResult(event.taskId, result));
                 }
             }
-            catch (e) {
-                console.error('[RecordsManager] Error getting Hume access token:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error installing package:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
-        });
+        }
     }
-    _aiSloydGenerateModel(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (!info.token) {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_logged_in',
-                            errorMessage: 'The user is not logged in.',
-                        }));
-                    }
-                    return;
+    async _listInstalledPackages(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
+            }
+            let instances = undefined;
+            if (hasValue(this._helper.origin)) {
+                instances = [
+                    formatInstId(this._helper.origin.recordName, this._helper.origin.inst),
+                ];
+            }
+            if (!hasValue(this._helper.origin) ||
+                this._helper.origin.isStatic) {
+                console.warn(`[RecordsManager] Unable to list packages for local insts.`);
+                if (hasValue(event.taskId)) {
+                    this._helper.transaction(asyncResult(event.taskId, {
+                        success: false,
+                        errorCode: 'not_supported',
+                        errorMessage: 'Listing packages is not supported for local insts.',
+                    }));
                 }
-                const result = yield this._client.createSloydModel({
-                    recordName: event.recordName,
-                    prompt: event.prompt,
-                    baseModelId: event.baseModelId,
-                    levelOfDetail: event.levelOfDetail,
-                    outputMimeType: event.outputMimeType,
-                    thumbnail: event.thumbnail,
+            }
+            else {
+                const result = await this._client.listInstalledPackages({
+                    recordName: this._helper.origin.recordName,
+                    inst: this._helper.origin.inst,
+                    instances,
                 }, {
-                    endpoint: info.recordsOrigin,
                     sessionKey: info.token,
+                    endpoint: info.recordsOrigin,
                 });
                 if (hasValue(event.taskId)) {
                     this._helper.transaction(asyncResult(event.taskId, result));
                 }
             }
-            catch (e) {
-                console.error('[RecordsManager] Error generating Sloyd model:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
-            }
-        });
-    }
-    _sendWebsocketSupportedRequest(recordsOrigin, websocketOrigin, websocketProtocol, method, path, query, data, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const client = this._getConnectionClient(websocketOrigin, websocketProtocol);
-            if (!client) {
-                const result = yield axios.request(Object.assign(Object.assign({ url: yield this._publishUrl(recordsOrigin, path, query), method }, this._axiosOptions), { data: data, headers }));
-                return result.data;
-            }
-            else {
-                yield firstValueFrom(client.connectionState.pipe(filter((c) => c.connected)));
-                const id = this._httpRequestId++;
-                const promise = firstValueFrom(client
-                    .event('http_response')
-                    .pipe(filter((response) => response.id === id)));
-                client.send({
-                    type: 'http_request',
-                    id,
-                    request: {
-                        path,
-                        method,
-                        headers,
-                        pathParams: {},
-                        query: query,
-                        body: JSON.stringify(data),
-                    },
-                });
-                const response = yield promise;
-                if (response.response.body) {
-                    return JSON.parse(response.response.body);
-                }
-                return null;
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error listing packages:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
             }
-        });
-    }
-    _getWebsocketClient(websocketOrigin, websocketProtocol) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const client = this._getConnectionClient(websocketOrigin, websocketProtocol);
-            return client;
-        });
+        }
     }
-    _sendWebsocketStreamRequest(client, method, path, query, data, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield firstValueFrom(client.connectionState.pipe(filter((c) => c.connected)));
+    async _sendWebsocketSupportedRequest(recordsOrigin, websocketOrigin, websocketProtocol, method, path, query, data, headers) {
+        const client = this._getConnectionClient(websocketOrigin, websocketProtocol);
+        if (!client) {
+            const result = await axios.request({
+                url: await this._publishUrl(recordsOrigin, path, query),
+                method,
+                ...this._axiosOptions,
+                data: data,
+                headers,
+            });
+            return result.data;
+        }
+        else {
+            await firstValueFrom(client.connectionState.pipe(filter((c) => c.connected)));
             const id = this._httpRequestId++;
-            const responses = client.event('http_partial_response').pipe(filter((response) => response.id === id), takeWhile((response) => !response.final), map((response) => {
-                if (response.response.body) {
-                    return JSON.parse(response.response.body);
-                }
-                return null;
-            }), share({
-                connector: () => new ReplaySubject(),
-                resetOnError: false,
-                resetOnComplete: false,
-                resetOnRefCountZero: false,
-            }));
+            const promise = firstValueFrom(client
+                .event('http_response')
+                .pipe(filter((response) => response.id === id)));
             client.send({
                 type: 'http_request',
                 id,
@@ -1536,8 +1825,44 @@ export class RecordsManager {
                     body: JSON.stringify(data),
                 },
             });
-            return responses;
+            const response = await promise;
+            if (response.response.body) {
+                return JSON.parse(response.response.body);
+            }
+            return null;
+        }
+    }
+    async _getWebsocketClient(websocketOrigin, websocketProtocol) {
+        const client = this._getConnectionClient(websocketOrigin, websocketProtocol);
+        return client;
+    }
+    async _sendWebsocketStreamRequest(client, method, path, query, data, headers) {
+        await firstValueFrom(client.connectionState.pipe(filter((c) => c.connected)));
+        const id = this._httpRequestId++;
+        const responses = client.event('http_partial_response').pipe(filter((response) => response.id === id), takeWhile((response) => !response.final), map((response) => {
+            if (response.response.body) {
+                return JSON.parse(response.response.body);
+            }
+            return null;
+        }), share({
+            connector: () => new ReplaySubject(),
+            resetOnError: false,
+            resetOnComplete: false,
+            resetOnRefCountZero: false,
+        }));
+        client.send({
+            type: 'http_request',
+            id,
+            request: {
+                path,
+                method,
+                headers,
+                pathParams: {},
+                query: query,
+                body: JSON.stringify(data),
+            },
         });
+        return responses;
     }
     _getConnectionClient(origin, protocol) {
         if (!origin || !protocol || !this._connectionClientFactory) {
@@ -1553,70 +1878,13 @@ export class RecordsManager {
         }
         return client;
     }
-    _listUserStudios(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield this._resolveInfoForEvent(event);
-                if (info.error) {
-                    return;
-                }
-                if (!info.token) {
-                    if (hasValue(event.taskId)) {
-                        this._helper.transaction(asyncResult(event.taskId, {
-                            success: false,
-                            errorCode: 'not_logged_in',
-                            errorMessage: 'The user is not logged in.',
-                        }));
-                    }
-                    return;
-                }
-                const query = {};
-                if (this._config.comId) {
-                    query['comId'] = this._config.comId;
-                }
-                const result = yield axios.get(yield this._publishUrl(info.recordsOrigin, '/api/v2/studios/list', query), Object.assign(Object.assign({}, this._axiosOptions), { headers: info.headers }));
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, result.data));
-                }
-            }
-            catch (e) {
-                console.error('[RecordsManager] Error listing studios:', e);
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncError(event.taskId, e.toString()));
-                }
-            }
-        });
-    }
-    _resolveInfoForEvent(event, authenticateIfNotLoggedIn = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let recordKeyPolicy = null;
-            if ('recordKey' in event && isRecordKey(event.recordKey)) {
-                const parsed = parseRecordKey(event.recordKey);
-                if (parsed) {
-                    const [name, password, policy] = parsed;
-                    recordKeyPolicy = policy;
-                    if (recordKeyPolicy === 'subjectless') {
-                        authenticateIfNotLoggedIn = false;
-                    }
-                }
-            }
-            const info = yield this._getInfoFromEvent(event.options, authenticateIfNotLoggedIn);
-            if (!info) {
-                if (hasValue(event.taskId)) {
-                    this._helper.transaction(asyncResult(event.taskId, {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'Records are not supported on this inst.',
-                    }));
-                }
-                return {
-                    error: true,
-                    recordsOrigin: null,
-                    headers: null,
-                    token: null,
-                };
+    async _listUserStudios(event) {
+        try {
+            const info = await this._resolveInfoForEvent(event);
+            if (info.error) {
+                return;
             }
-            if (!hasValue(info.token) && recordKeyPolicy === 'subjectfull') {
+            if (!info.token) {
                 if (hasValue(event.taskId)) {
                     this._helper.transaction(asyncResult(event.taskId, {
                         success: false,
@@ -1624,15 +1892,71 @@ export class RecordsManager {
                         errorMessage: 'The user is not logged in.',
                     }));
                 }
-                return {
-                    error: true,
-                    recordsOrigin: null,
-                    headers: null,
-                    token: null,
-                };
+                return;
             }
-            return info;
-        });
+            const query = {};
+            if (this._config.comId) {
+                query['comId'] = this._config.comId;
+            }
+            const result = await axios.get(await this._publishUrl(info.recordsOrigin, '/api/v2/studios/list', query), {
+                ...this._axiosOptions,
+                headers: info.headers,
+            });
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, result.data));
+            }
+        }
+        catch (e) {
+            console.error('[RecordsManager] Error listing studios:', e);
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncError(event.taskId, e.toString()));
+            }
+        }
+    }
+    async _resolveInfoForEvent(event, authenticateIfNotLoggedIn = true) {
+        let recordKeyPolicy = null;
+        if ('recordKey' in event && isRecordKey(event.recordKey)) {
+            const parsed = parseRecordKey(event.recordKey);
+            if (parsed) {
+                const [name, password, policy] = parsed;
+                recordKeyPolicy = policy;
+                if (recordKeyPolicy === 'subjectless') {
+                    authenticateIfNotLoggedIn = false;
+                }
+            }
+        }
+        const info = await this._getInfoFromEvent(event.options, authenticateIfNotLoggedIn);
+        if (!info) {
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'Records are not supported on this inst.',
+                }));
+            }
+            return {
+                error: true,
+                recordsOrigin: null,
+                headers: null,
+                token: null,
+            };
+        }
+        if (!hasValue(info.token) && recordKeyPolicy === 'subjectfull') {
+            if (hasValue(event.taskId)) {
+                this._helper.transaction(asyncResult(event.taskId, {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'The user is not logged in.',
+                }));
+            }
+            return {
+                error: true,
+                recordsOrigin: null,
+                headers: null,
+                token: null,
+            };
+        }
+        return info;
     }
     /**
      * Gets the information needed to call an API on the given endpoint.
@@ -1653,22 +1977,20 @@ export class RecordsManager {
         let endpoint = event.endpoint;
         return this.getInfoForEndpoint(endpoint, authenticateIfNotLoggedIn);
     }
-    _publishUrl(recordsOrigin, path, queryParams = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let url = new URL(path, recordsOrigin);
-            for (let key in queryParams) {
-                const val = queryParams[key];
-                if (hasValue(val)) {
-                    if (Array.isArray(val)) {
-                        url.searchParams.set(key, val.join(','));
-                    }
-                    else {
-                        url.searchParams.set(key, val);
-                    }
+    async _publishUrl(recordsOrigin, path, queryParams = {}) {
+        let url = new URL(path, recordsOrigin);
+        for (let key in queryParams) {
+            const val = queryParams[key];
+            if (hasValue(val)) {
+                if (Array.isArray(val)) {
+                    url.searchParams.set(key, val.join(','));
+                }
+                else {
+                    url.searchParams.set(key, val);
                 }
             }
-            return url.href;
-        });
+        }
+        return url.href;
     }
 }
 function getHash(buffer) {