@casual-simulation/aux-records 3.4.6-alpha.14601027727 → 3.5.0-alpha.15117651144

package/MemoryStore.js

@@ -1,23 +1,3 @@
-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;
-};
 /* CasualOS is a set of web-based tools designed to facilitate the creation of real-time, multi-user, context-aware interactive experiences.
  *
  * Copyright (c) 2019-2025 Casual Simulation, Inc.
@@ -115,6 +95,9 @@ export class MemoryStore {
     get comIdRequests() {
         return this._comIdRequests;
     }
+    get grantedPackageEntitlements() {
+        return this._grantedPackageEntitlements;
+    }
     constructor(config) {
         var _a, _b;
         this._users = [];
@@ -149,8 +132,10 @@ export class MemoryStore {
         this._comIdRequests = [];
         this._resourcePermissionAssignments = [];
         this._markerPermissionAssignments = [];
+        this._grantedPackageEntitlements = [];
         this._studioLoomConfigs = new Map();
         this._studioHumeConfigs = new Map();
+        this._loadedPackages = new Map();
         // TODO: Support global permissions
         // private _globalPermissionAssignments: GlobalPermissionAssignment[] = [];
         this.maxAllowedInstSize = Infinity;
@@ -207,407 +192,331 @@ export class MemoryStore {
         newStore.roleAssignments = cloneDeep(this.roleAssignments);
         return newStore;
     }
-    listUserAuthenticators(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._userAuthenticators.filter((a) => a.userId === userId);
-        });
-    }
-    saveUserAuthenticator(authenticator) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._userAuthenticators.findIndex((a) => a.id === authenticator.id);
-            if (index >= 0) {
-                this._userAuthenticators[index] = authenticator;
-            }
-            else {
-                this._userAuthenticators.push(authenticator);
-            }
-        });
-    }
-    saveComIdRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._comIdRequests.push(request);
-        });
-    }
-    getStudioByComId(comId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._studios.find((s) => s.comId === comId);
-        });
+    async listUserAuthenticators(userId) {
+        return this._userAuthenticators.filter((a) => a.userId === userId);
     }
-    listStudiosForUserAndComId(userId, comId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assignments = yield this.listUserAssignments(userId);
-            const studios = yield Promise.all(assignments.map((a) => __awaiter(this, void 0, void 0, function* () {
-                const s = yield this.getStudioById(a.studioId);
-                return Object.assign(Object.assign({}, s), a);
-            })));
-            return studios
-                .filter((s) => s.ownerStudioComId === comId)
-                .map((s) => ({
-                studioId: s.id,
-                displayName: s.displayName,
-                role: s.role,
-                isPrimaryContact: s.isPrimaryContact,
-                subscriptionId: s.subscriptionId,
-                subscriptionStatus: s.subscriptionStatus,
-                comId: s.comId,
-                logoUrl: s.logoUrl,
-                ownerStudioComId: s.ownerStudioComId,
-            }));
-        });
+    async saveUserAuthenticator(authenticator) {
+        const index = this._userAuthenticators.findIndex((a) => a.id === authenticator.id);
+        if (index >= 0) {
+            this._userAuthenticators[index] = authenticator;
+        }
+        else {
+            this._userAuthenticators.push(authenticator);
+        }
     }
-    sendRecordNotification(notification) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._recordNotifications.push(notification);
-        });
+    async saveComIdRequest(request) {
+        this._comIdRequests.push(request);
     }
-    saveUserInstReport(report) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingReportIndex = this._userInstReports.findIndex((r) => r.id === report.id);
-            if (existingReportIndex >= 0) {
-                this._userInstReports[existingReportIndex] = report;
-            }
-            else {
-                this._userInstReports.push(report);
-            }
-        });
+    async getStudioByComId(comId) {
+        return this._studios.find((s) => s.comId === comId);
     }
-    addModerationJob(job) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._moderationJobs.push(job);
-        });
+    async listStudiosForUserAndComId(userId, comId) {
+        const assignments = await this.listUserAssignments(userId);
+        const studios = await Promise.all(assignments.map(async (a) => {
+            const s = await this.getStudioById(a.studioId);
+            return {
+                ...s,
+                ...a,
+            };
+        }));
+        return studios
+            .filter((s) => s.ownerStudioComId === comId)
+            .map((s) => ({
+            studioId: s.id,
+            displayName: s.displayName,
+            role: s.role,
+            isPrimaryContact: s.isPrimaryContact,
+            subscriptionId: s.subscriptionId,
+            subscriptionStatus: s.subscriptionStatus,
+            comId: s.comId,
+            logoUrl: s.logoUrl,
+            ownerStudioComId: s.ownerStudioComId,
+        }));
+    }
+    async sendRecordNotification(notification) {
+        this._recordNotifications.push(notification);
+    }
+    async saveUserInstReport(report) {
+        const existingReportIndex = this._userInstReports.findIndex((r) => r.id === report.id);
+        if (existingReportIndex >= 0) {
+            this._userInstReports[existingReportIndex] = report;
+        }
+        else {
+            this._userInstReports.push(report);
+        }
     }
-    findMostRecentJobOfType(type) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const jobs = this._moderationJobs.filter((j) => j.type === type);
-            const mostRecent = orderBy(jobs, (j) => j.createdAtMs, 'desc');
-            if (mostRecent.length > 0) {
-                return mostRecent[0];
-            }
-            else {
-                return null;
-            }
-        });
+    async addModerationJob(job) {
+        this._moderationJobs.push(job);
     }
-    addFileModerationResult(result) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._moderationFileResults.push(result);
-        });
+    async findMostRecentJobOfType(type) {
+        const jobs = this._moderationJobs.filter((j) => j.type === type);
+        const mostRecent = orderBy(jobs, (j) => j.createdAtMs, 'desc');
+        if (mostRecent.length > 0) {
+            return mostRecent[0];
+        }
+        else {
+            return null;
+        }
     }
-    getSubscriptionConfiguration() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._subscriptionConfiguration;
-        });
+    async addFileModerationResult(result) {
+        this._moderationFileResults.push(result);
     }
-    getPrivoConfiguration() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._privoConfiguration;
-        });
+    async getSubscriptionConfiguration() {
+        return this._subscriptionConfiguration;
     }
-    getModerationConfig() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._moderationConfiguration;
-        });
+    async getPrivoConfiguration() {
+        return this._privoConfiguration;
     }
-    getRecordByName(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = this._records.find((r) => r.name === name);
-            return record;
-        });
+    async getModerationConfig() {
+        return this._moderationConfiguration;
     }
-    updateRecord(record) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingRecordIndex = this._records.findIndex((r) => r.name === record.name);
-            if (existingRecordIndex >= 0) {
-                this._records[existingRecordIndex] = record;
-            }
-        });
+    async getRecordByName(name) {
+        const record = this._records.find((r) => r.name === name);
+        return record;
     }
-    addRecord(record) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingRecordIndex = this._records.findIndex((r) => r.name === record.name);
-            if (existingRecordIndex < 0) {
-                this._records.push(record);
-            }
-        });
+    async updateRecord(record) {
+        const existingRecordIndex = this._records.findIndex((r) => r.name === record.name);
+        if (existingRecordIndex >= 0) {
+            this._records[existingRecordIndex] = record;
+        }
     }
-    addRecordKey(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingKeyIndex = this._recordKeys.findIndex((k) => k.recordName === key.recordName &&
-                k.secretHash === key.secretHash);
-            if (existingKeyIndex < 0) {
-                this._recordKeys.push(key);
-            }
-        });
+    async addRecord(record) {
+        const existingRecordIndex = this._records.findIndex((r) => r.name === record.name);
+        if (existingRecordIndex < 0) {
+            this._records.push(record);
+        }
     }
-    getRecordKeyByRecordAndHash(recordName, hash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = this._recordKeys.find((k) => k.recordName === recordName && k.secretHash == hash);
-            return key;
-        });
+    async addRecordKey(key) {
+        const existingKeyIndex = this._recordKeys.findIndex((k) => k.recordName === key.recordName &&
+            k.secretHash === key.secretHash);
+        if (existingKeyIndex < 0) {
+            this._recordKeys.push(key);
+        }
     }
-    listRecordsByOwnerId(ownerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return sortBy(this._records
-                .filter((r) => r.ownerId === ownerId)
-                .map((r) => ({
-                name: r.name,
-                ownerId: r.ownerId,
-                studioId: r.studioId,
-            })), (r) => r.name);
-        });
+    async getRecordKeyByRecordAndHash(recordName, hash) {
+        const key = this._recordKeys.find((k) => k.recordName === recordName && k.secretHash == hash);
+        return key;
+    }
+    async listRecordsByOwnerId(ownerId) {
+        return sortBy(this._records
+            .filter((r) => r.ownerId === ownerId)
+            .map((r) => ({
+            name: r.name,
+            ownerId: r.ownerId,
+            studioId: r.studioId,
+        })), (r) => r.name);
+    }
+    async listRecordsByStudioId(studioId) {
+        return sortBy(this._records
+            .filter((r) => r.studioId === studioId)
+            .map((r) => ({
+            name: r.name,
+            ownerId: r.ownerId,
+            studioId: r.studioId,
+        })), (r) => r.name);
+    }
+    async listRecordsByStudioIdAndUserId(studioId, userId) {
+        return sortBy(this._records
+            .filter((s) => {
+            if (s.studioId !== studioId) {
+                return false;
+            }
+            const isAssigned = this._studioAssignments.some((a) => a.studioId === studioId && a.userId === userId);
+            return isAssigned;
+        })
+            .map((r) => ({
+            name: r.name,
+            ownerId: r.ownerId,
+            studioId: r.studioId,
+        })), (r) => r.name);
+    }
+    async addStudio(studio) {
+        const existingStudioIndex = this._studios.findIndex((r) => r.id === studio.id);
+        if (existingStudioIndex < 0) {
+            this._studios.push(studio);
+        }
     }
-    listRecordsByStudioId(studioId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return sortBy(this._records
-                .filter((r) => r.studioId === studioId)
-                .map((r) => ({
-                name: r.name,
-                ownerId: r.ownerId,
-                studioId: r.studioId,
-            })), (r) => r.name);
-        });
+    async createStudioForUser(studio, adminId) {
+        await this.addStudio(studio);
+        const assignment = {
+            studioId: studio.id,
+            userId: adminId,
+            isPrimaryContact: true,
+            role: 'admin',
+        };
+        await this.addStudioAssignment(assignment);
+        return {
+            studio,
+            assignment,
+        };
+    }
+    async updateStudio(studio) {
+        const existingStudioIndex = this._studios.findIndex((r) => r.id === studio.id);
+        if (existingStudioIndex >= 0) {
+            this._studios[existingStudioIndex] = studio;
+        }
     }
-    listRecordsByStudioIdAndUserId(studioId, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return sortBy(this._records
-                .filter((s) => {
-                if (s.studioId !== studioId) {
-                    return false;
-                }
-                const isAssigned = this._studioAssignments.some((a) => a.studioId === studioId && a.userId === userId);
-                return isAssigned;
-            })
-                .map((r) => ({
-                name: r.name,
-                ownerId: r.ownerId,
-                studioId: r.studioId,
-            })), (r) => r.name);
-        });
+    async getStudioById(id) {
+        return this._studios.find((s) => s.id === id);
     }
-    addStudio(studio) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingStudioIndex = this._studios.findIndex((r) => r.id === studio.id);
-            if (existingStudioIndex < 0) {
-                this._studios.push(studio);
-            }
-        });
+    async getStudioByStripeCustomerId(customerId) {
+        return this._studios.find((s) => s.stripeCustomerId === customerId);
     }
-    createStudioForUser(studio, adminId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.addStudio(studio);
-            const assignment = {
-                studioId: studio.id,
-                userId: adminId,
-                isPrimaryContact: true,
-                role: 'admin',
-            };
-            yield this.addStudioAssignment(assignment);
+    async listStudiosForUser(userId) {
+        const assignments = await this.listUserAssignments(userId);
+        const studios = await Promise.all(assignments.map(async (a) => {
+            const s = await this.getStudioById(a.studioId);
             return {
-                studio,
-                assignment,
+                ...s,
+                ...a,
             };
-        });
-    }
-    updateStudio(studio) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingStudioIndex = this._studios.findIndex((r) => r.id === studio.id);
-            if (existingStudioIndex >= 0) {
-                this._studios[existingStudioIndex] = studio;
-            }
-        });
+        }));
+        return studios
+            .filter((s) => !s.ownerStudioComId)
+            .map((s) => ({
+            studioId: s.id,
+            displayName: s.displayName,
+            role: s.role,
+            isPrimaryContact: s.isPrimaryContact,
+            subscriptionId: s.subscriptionId,
+            subscriptionStatus: s.subscriptionStatus,
+            comId: s.comId,
+            logoUrl: s.logoUrl,
+            ownerStudioComId: s.ownerStudioComId,
+        }));
+    }
+    async countStudiosInComId(comId) {
+        const studios = this._studios.filter((s) => s.ownerStudioComId === comId);
+        return studios.length;
+    }
+    async addStudioAssignment(assignment) {
+        const existingAssignmentIndex = this._studioAssignments.findIndex((r) => r.studioId === assignment.studioId &&
+            r.userId === assignment.userId);
+        if (existingAssignmentIndex < 0) {
+            this._studioAssignments.push(assignment);
+        }
     }
-    getStudioById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._studios.find((s) => s.id === id);
-        });
+    async removeStudioAssignment(studioId, userId) {
+        this._studioAssignments = this._studioAssignments.filter((s) => s.studioId !== studioId || s.userId !== userId);
     }
-    getStudioByStripeCustomerId(customerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._studios.find((s) => s.stripeCustomerId === customerId);
-        });
+    async updateStudioAssignment(assignment) {
+        const existingAssignmentIndex = this._studioAssignments.findIndex((r) => r.studioId === assignment.studioId &&
+            r.userId === assignment.userId);
+        if (existingAssignmentIndex >= 0) {
+            this._studioAssignments[existingAssignmentIndex] = assignment;
+        }
     }
-    listStudiosForUser(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assignments = yield this.listUserAssignments(userId);
-            const studios = yield Promise.all(assignments.map((a) => __awaiter(this, void 0, void 0, function* () {
-                const s = yield this.getStudioById(a.studioId);
-                return Object.assign(Object.assign({}, s), a);
-            })));
-            return studios
-                .filter((s) => !s.ownerStudioComId)
-                .map((s) => ({
-                studioId: s.id,
-                displayName: s.displayName,
-                role: s.role,
+    async listStudioAssignments(studioId, filters) {
+        const assignments = this._studioAssignments.filter((s) => {
+            const matchesRole = !(filters === null || filters === void 0 ? void 0 : filters.role) || s.role === filters.role;
+            const matchesPrimaryContact = !(filters === null || filters === void 0 ? void 0 : filters.isPrimaryContact) ||
+                s.isPrimaryContact === filters.isPrimaryContact;
+            const matchesUserId = !(filters === null || filters === void 0 ? void 0 : filters.userId) || s.userId === filters.userId;
+            return (s.studioId === studioId &&
+                matchesRole &&
+                matchesPrimaryContact &&
+                matchesUserId);
+        });
+        let results = [];
+        for (let s of assignments) {
+            const user = await this.findUser(s.userId);
+            if (!user) {
+                continue;
+            }
+            results.push({
+                studioId: s.studioId,
+                userId: s.userId,
                 isPrimaryContact: s.isPrimaryContact,
-                subscriptionId: s.subscriptionId,
-                subscriptionStatus: s.subscriptionStatus,
-                comId: s.comId,
-                logoUrl: s.logoUrl,
-                ownerStudioComId: s.ownerStudioComId,
-            }));
-        });
-    }
-    countStudiosInComId(comId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const studios = this._studios.filter((s) => s.ownerStudioComId === comId);
-            return studios.length;
-        });
-    }
-    addStudioAssignment(assignment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingAssignmentIndex = this._studioAssignments.findIndex((r) => r.studioId === assignment.studioId &&
-                r.userId === assignment.userId);
-            if (existingAssignmentIndex < 0) {
-                this._studioAssignments.push(assignment);
-            }
-        });
-    }
-    removeStudioAssignment(studioId, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._studioAssignments = this._studioAssignments.filter((s) => s.studioId !== studioId || s.userId !== userId);
-        });
-    }
-    updateStudioAssignment(assignment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingAssignmentIndex = this._studioAssignments.findIndex((r) => r.studioId === assignment.studioId &&
-                r.userId === assignment.userId);
-            if (existingAssignmentIndex >= 0) {
-                this._studioAssignments[existingAssignmentIndex] = assignment;
-            }
-        });
-    }
-    listStudioAssignments(studioId, filters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assignments = this._studioAssignments.filter((s) => {
-                const matchesRole = !(filters === null || filters === void 0 ? void 0 : filters.role) || s.role === filters.role;
-                const matchesPrimaryContact = !(filters === null || filters === void 0 ? void 0 : filters.isPrimaryContact) ||
-                    s.isPrimaryContact === filters.isPrimaryContact;
-                const matchesUserId = !(filters === null || filters === void 0 ? void 0 : filters.userId) || s.userId === filters.userId;
-                return (s.studioId === studioId &&
-                    matchesRole &&
-                    matchesPrimaryContact &&
-                    matchesUserId);
+                role: s.role,
+                user: {
+                    id: user.id,
+                    name: user.name,
+                    email: user.email,
+                    phoneNumber: user.phoneNumber,
+                    privoServiceId: user.privoServiceId,
+                },
             });
-            let results = [];
-            for (let s of assignments) {
-                const user = yield this.findUser(s.userId);
-                if (!user) {
-                    continue;
-                }
-                results.push({
-                    studioId: s.studioId,
-                    userId: s.userId,
-                    isPrimaryContact: s.isPrimaryContact,
-                    role: s.role,
-                    user: {
-                        id: user.id,
-                        name: user.name,
-                        email: user.email,
-                        phoneNumber: user.phoneNumber,
-                        privoServiceId: user.privoServiceId,
-                    },
-                });
-            }
-            return results;
-        });
+        }
+        return results;
     }
-    listUserAssignments(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assignments = this._studioAssignments.filter((s) => s.userId === userId);
-            return assignments.map((s) => {
-                const studio = this._studios.find((studio) => studio.id === s.studioId);
-                return {
-                    displayName: studio.displayName,
-                    studioId: s.studioId,
-                    userId: s.userId,
-                    isPrimaryContact: s.isPrimaryContact,
-                    role: s.role,
-                };
-            });
+    async listUserAssignments(userId) {
+        const assignments = this._studioAssignments.filter((s) => s.userId === userId);
+        return assignments.map((s) => {
+            const studio = this._studios.find((studio) => studio.id === s.studioId);
+            return {
+                displayName: studio.displayName,
+                studioId: s.studioId,
+                userId: s.userId,
+                isPrimaryContact: s.isPrimaryContact,
+                role: s.role,
+            };
         });
     }
-    getStudioLoomConfig(studioId) {
+    async getStudioLoomConfig(studioId) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return (_a = this._studioLoomConfigs.get(studioId)) !== null && _a !== void 0 ? _a : null;
-        });
+        return (_a = this._studioLoomConfigs.get(studioId)) !== null && _a !== void 0 ? _a : null;
     }
-    updateStudioLoomConfig(studioId, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._studioLoomConfigs.set(studioId, config);
-        });
+    async updateStudioLoomConfig(studioId, config) {
+        this._studioLoomConfigs.set(studioId, config);
     }
-    getStudioHumeConfig(studioId) {
+    async getStudioHumeConfig(studioId) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return (_a = this._studioHumeConfigs.get(studioId)) !== null && _a !== void 0 ? _a : null;
-        });
-    }
-    updateStudioHumeConfig(studioId, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._studioHumeConfigs.set(studioId, config);
-        });
-    }
-    getUserPrivacyFeatures(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._getUserPrivacyFeatures(userId);
-        });
+        return (_a = this._studioHumeConfigs.get(studioId)) !== null && _a !== void 0 ? _a : null;
     }
-    getRecordOwnerPrivacyFeatures(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = yield this.getRecordByName(recordName);
-            if (!record || !record.ownerId) {
-                return null;
-            }
-            return yield this._getUserPrivacyFeatures(record.ownerId);
-        });
+    async updateStudioHumeConfig(studioId, config) {
+        this._studioHumeConfigs.set(studioId, config);
     }
-    getPermissionForSubjectAndResource(subjectType, subjectId, recordName, resourceKind, resourceId, action, currentTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingRoles = subjectType === 'user'
-                ? yield this.listRolesForUser(recordName, subjectId)
-                : subjectType === 'inst'
-                    ? yield this.listRolesForInst(recordName, subjectId)
-                    : [];
-            const roles = existingRoles.map((r) => r.role);
-            const assignment = this._resourcePermissionAssignments.find((p) => p.recordName === recordName &&
-                ((p.subjectType === 'role' &&
-                    roles.indexOf(p.subjectId) >= 0) ||
-                    (p.subjectType === subjectType &&
-                        p.subjectId === subjectId)) &&
-                p.resourceKind === resourceKind &&
-                p.resourceId === resourceId &&
-                (p.action === null || p.action === action) &&
-                (!p.expireTimeMs || p.expireTimeMs > currentTimeMs));
-            return {
-                success: true,
-                permissionAssignment: assignment,
-            };
-        });
+    async getUserPrivacyFeatures(userId) {
+        return await this._getUserPrivacyFeatures(userId);
     }
-    getPermissionForSubjectAndMarkers(subjectType, subjectId, recordName, resourceKind, markers, action, currentTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingRoles = subjectType === 'user'
-                ? yield this.listRolesForUser(recordName, subjectId)
-                : subjectType === 'inst'
-                    ? yield this.listRolesForInst(recordName, subjectId)
-                    : [];
-            const roles = existingRoles.map((r) => r.role);
-            const assignment = this._markerPermissionAssignments.find((p) => p.recordName === recordName &&
-                markers.indexOf(p.marker) >= 0 &&
-                ((p.subjectType === 'role' &&
-                    roles.indexOf(p.subjectId) >= 0) ||
-                    (p.subjectType === subjectType &&
-                        p.subjectId === subjectId)) &&
-                p.resourceKind === resourceKind &&
-                (p.action === null || p.action === action) &&
-                (!p.expireTimeMs || p.expireTimeMs > currentTimeMs));
-            return {
-                success: true,
-                permissionAssignment: assignment,
-            };
-        });
+    async getRecordOwnerPrivacyFeatures(recordName) {
+        const record = await this.getRecordByName(recordName);
+        if (!record || !record.ownerId) {
+            return null;
+        }
+        return await this._getUserPrivacyFeatures(record.ownerId);
+    }
+    async getPermissionForSubjectAndResource(subjectType, subjectId, recordName, resourceKind, resourceId, action, currentTimeMs) {
+        const existingRoles = subjectType === 'user'
+            ? await this.listRolesForUser(recordName, subjectId)
+            : subjectType === 'inst'
+                ? await this.listRolesForInst(recordName, subjectId)
+                : [];
+        const roles = existingRoles.map((r) => r.role);
+        const assignment = this._resourcePermissionAssignments.find((p) => p.recordName === recordName &&
+            ((p.subjectType === 'role' &&
+                roles.indexOf(p.subjectId) >= 0) ||
+                (p.subjectType === subjectType &&
+                    p.subjectId === subjectId)) &&
+            p.resourceKind === resourceKind &&
+            p.resourceId === resourceId &&
+            (p.action === null || p.action === action) &&
+            (!p.expireTimeMs || p.expireTimeMs > currentTimeMs));
+        return {
+            success: true,
+            permissionAssignment: assignment,
+        };
+    }
+    async getPermissionForSubjectAndMarkers(subjectType, subjectId, recordName, resourceKind, markers, action, currentTimeMs) {
+        const existingRoles = subjectType === 'user'
+            ? await this.listRolesForUser(recordName, subjectId)
+            : subjectType === 'inst'
+                ? await this.listRolesForInst(recordName, subjectId)
+                : [];
+        const roles = existingRoles.map((r) => r.role);
+        const assignment = this._markerPermissionAssignments.find((p) => p.recordName === recordName &&
+            markers.indexOf(p.marker) >= 0 &&
+            ((p.subjectType === 'role' &&
+                roles.indexOf(p.subjectId) >= 0) ||
+                (p.subjectType === subjectType &&
+                    p.subjectId === subjectId)) &&
+            p.resourceKind === resourceKind &&
+            (p.action === null || p.action === action) &&
+            (!p.expireTimeMs || p.expireTimeMs > currentTimeMs));
+        return {
+            success: true,
+            permissionAssignment: assignment,
+        };
     }
     // TODO: Support global permissions
     // async assignGlobalPermissionToSubject(
@@ -635,706 +544,738 @@ export class MemoryStore {
     //         permissionAssignment: assignment,
     //     };
     // }
-    assignPermissionToSubjectAndResource(recordName, subjectType, subjectId, resourceKind, resourceId, action, options, expireTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assignmentIndex = this._resourcePermissionAssignments.findIndex((a) => a.recordName === recordName &&
-                a.subjectType === subjectType &&
-                a.subjectId === subjectId &&
-                a.resourceKind === resourceKind &&
-                a.resourceId === resourceId &&
-                a.action === action);
-            if (assignmentIndex >= 0) {
-                const assignment = this._resourcePermissionAssignments[assignmentIndex];
-                this._resourcePermissionAssignments[assignmentIndex] = Object.assign(Object.assign({}, assignment), { options,
-                    expireTimeMs });
-                return {
-                    success: true,
-                    permissionAssignment: assignment,
-                };
-            }
-            const userId = getSubjectUserId(subjectType, subjectId);
-            const assignment = {
-                id: uuid(),
-                recordName,
-                userId,
-                subjectType,
-                subjectId,
-                resourceKind,
-                resourceId,
-                action,
+    async assignPermissionToSubjectAndResource(recordName, subjectType, subjectId, resourceKind, resourceId, action, options, expireTimeMs) {
+        const assignmentIndex = this._resourcePermissionAssignments.findIndex((a) => a.recordName === recordName &&
+            a.subjectType === subjectType &&
+            a.subjectId === subjectId &&
+            a.resourceKind === resourceKind &&
+            a.resourceId === resourceId &&
+            a.action === action);
+        if (assignmentIndex >= 0) {
+            const assignment = this._resourcePermissionAssignments[assignmentIndex];
+            this._resourcePermissionAssignments[assignmentIndex] = {
+                ...assignment,
                 options,
                 expireTimeMs,
             };
-            this._resourcePermissionAssignments.push(assignment);
             return {
                 success: true,
                 permissionAssignment: assignment,
             };
-        });
-    }
-    assignPermissionToSubjectAndMarker(recordName, subjectType, subjectId, resourceKind, marker, action, options, expireTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assignmentIndex = this._markerPermissionAssignments.findIndex((a) => a.recordName === recordName &&
-                a.subjectType === subjectType &&
-                a.subjectId === subjectId &&
-                a.marker === marker &&
-                a.resourceKind === resourceKind &&
-                a.action === action);
-            if (assignmentIndex >= 0) {
-                const assignment = this._markerPermissionAssignments[assignmentIndex];
-                this._markerPermissionAssignments[assignmentIndex] = Object.assign(Object.assign({}, assignment), { options,
-                    expireTimeMs });
-                return {
-                    success: true,
-                    permissionAssignment: assignment,
-                };
-            }
-            const userId = getSubjectUserId(subjectType, subjectId);
-            const assignment = {
-                id: uuid(),
-                recordName,
-                userId,
-                subjectType,
-                subjectId,
-                resourceKind,
-                marker,
-                action,
+        }
+        const userId = getSubjectUserId(subjectType, subjectId);
+        const assignment = {
+            id: uuid(),
+            recordName,
+            userId,
+            subjectType,
+            subjectId,
+            resourceKind,
+            resourceId,
+            action,
+            options,
+            expireTimeMs,
+        };
+        this._resourcePermissionAssignments.push(assignment);
+        return {
+            success: true,
+            permissionAssignment: assignment,
+        };
+    }
+    async assignPermissionToSubjectAndMarker(recordName, subjectType, subjectId, resourceKind, marker, action, options, expireTimeMs) {
+        const assignmentIndex = this._markerPermissionAssignments.findIndex((a) => a.recordName === recordName &&
+            a.subjectType === subjectType &&
+            a.subjectId === subjectId &&
+            a.marker === marker &&
+            a.resourceKind === resourceKind &&
+            a.action === action);
+        if (assignmentIndex >= 0) {
+            const assignment = this._markerPermissionAssignments[assignmentIndex];
+            this._markerPermissionAssignments[assignmentIndex] = {
+                ...assignment,
                 options,
                 expireTimeMs,
             };
-            this._markerPermissionAssignments.push(assignment);
             return {
                 success: true,
                 permissionAssignment: assignment,
             };
-        });
-    }
-    getMarkerPermissionAssignmentById(id) {
+        }
+        const userId = getSubjectUserId(subjectType, subjectId);
+        const assignment = {
+            id: uuid(),
+            recordName,
+            userId,
+            subjectType,
+            subjectId,
+            resourceKind,
+            marker,
+            action,
+            options,
+            expireTimeMs,
+        };
+        this._markerPermissionAssignments.push(assignment);
+        return {
+            success: true,
+            permissionAssignment: assignment,
+        };
+    }
+    async getMarkerPermissionAssignmentById(id) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return ((_a = this._markerPermissionAssignments.find((a) => a.id === id)) !== null && _a !== void 0 ? _a : null);
-        });
+        return ((_a = this._markerPermissionAssignments.find((a) => a.id === id)) !== null && _a !== void 0 ? _a : null);
     }
-    getResourcePermissionAssignmentById(id) {
+    async getResourcePermissionAssignmentById(id) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return ((_a = this._resourcePermissionAssignments.find((a) => a.id === id)) !== null && _a !== void 0 ? _a : null);
-        });
-    }
-    deleteResourcePermissionAssignment(assigment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._resourcePermissionAssignments =
-                this._resourcePermissionAssignments.filter((p) => p.id !== assigment.id);
-            return {
-                success: true,
+        return ((_a = this._resourcePermissionAssignments.find((a) => a.id === id)) !== null && _a !== void 0 ? _a : null);
+    }
+    async deleteResourcePermissionAssignment(assigment) {
+        this._resourcePermissionAssignments =
+            this._resourcePermissionAssignments.filter((p) => p.id !== assigment.id);
+        return {
+            success: true,
+        };
+    }
+    async deleteResourcePermissionAssignmentById(id) {
+        this._resourcePermissionAssignments =
+            this._resourcePermissionAssignments.filter((p) => p.id !== id);
+        return {
+            success: true,
+        };
+    }
+    async deleteMarkerPermissionAssignment(assigment) {
+        this._markerPermissionAssignments =
+            this._markerPermissionAssignments.filter((p) => p.id !== assigment.id);
+        return {
+            success: true,
+        };
+    }
+    async deleteMarkerPermissionAssignmentById(id) {
+        this._markerPermissionAssignments =
+            this._markerPermissionAssignments.filter((p) => p.id !== id);
+        return {
+            success: true,
+        };
+    }
+    async listPermissionsInRecord(recordName) {
+        const resourceAssignments = this._resourcePermissionAssignments.filter((p) => p.recordName === recordName);
+        const markerAssignments = this._markerPermissionAssignments.filter((p) => p.recordName === recordName);
+        return {
+            success: true,
+            resourceAssignments,
+            markerAssignments,
+        };
+    }
+    async listPermissionsForResource(recordName, resourceKind, resourceId) {
+        return this._resourcePermissionAssignments.filter((p) => p.recordName === recordName &&
+            p.resourceKind === resourceKind &&
+            p.resourceId === resourceId);
+    }
+    async listPermissionsForMarker(recordName, marker) {
+        return this._markerPermissionAssignments.filter((p) => p.recordName === recordName && p.marker === marker);
+    }
+    async listPermissionsForSubject(recordName, subjectType, subjectId) {
+        const resourceAssignments = this._resourcePermissionAssignments.filter((p) => p.recordName === recordName &&
+            p.subjectType === subjectType &&
+            p.subjectId === subjectId);
+        const markerAssignments = this._markerPermissionAssignments.filter((p) => p.recordName === recordName &&
+            p.subjectType === subjectType &&
+            p.subjectId === subjectId);
+        return {
+            success: true,
+            resourceAssignments,
+            markerAssignments,
+        };
+    }
+    async saveGrantedPackageEntitlement(grantedEntitlement) {
+        const existingIndex = this._grantedPackageEntitlements.findIndex((e) => e.id === grantedEntitlement.id);
+        if (existingIndex >= 0) {
+            this._grantedPackageEntitlements[existingIndex] = {
+                ...grantedEntitlement,
             };
-        });
+        }
+        else {
+            this._grantedPackageEntitlements.push({
+                ...grantedEntitlement,
+            });
+        }
     }
-    deleteResourcePermissionAssignmentById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._resourcePermissionAssignments =
-                this._resourcePermissionAssignments.filter((p) => p.id !== id);
-            return {
-                success: true,
-            };
-        });
+    async listGrantedEntitlementsByFeatureAndUserId(packageIds, feature, userId, recordName, nowMs) {
+        return this._grantedPackageEntitlements.filter((e) => e.userId === userId &&
+            e.feature === feature &&
+            e.recordName === recordName &&
+            e.expireTimeMs > nowMs &&
+            e.revokeTimeMs === null &&
+            packageIds.includes(e.packageId));
     }
-    deleteMarkerPermissionAssignment(assigment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._markerPermissionAssignments =
-                this._markerPermissionAssignments.filter((p) => p.id !== assigment.id);
-            return {
-                success: true,
-            };
-        });
+    async findGrantedPackageEntitlementByUserIdPackageIdFeatureAndScope(userId, packageId, feature, scope, recordName) {
+        var _a;
+        return ((_a = this._grantedPackageEntitlements.find((e) => e.userId === userId &&
+            e.packageId === packageId &&
+            e.feature === feature &&
+            e.scope === scope &&
+            e.revokeTimeMs === null &&
+            e.recordName === recordName)) !== null && _a !== void 0 ? _a : null);
+    }
+    async findGrantedPackageEntitlementById(id) {
+        return this._grantedPackageEntitlements.find((e) => e.id === id);
+    }
+    async listGrantedEntitlementsForUser(userId, nowMs) {
+        return this._grantedPackageEntitlements.filter((e) => e.userId === userId &&
+            e.expireTimeMs > nowMs &&
+            e.revokeTimeMs === null);
+    }
+    async listGrantedEntitlementsForUserAndPackage(userId, packageId, nowMs) {
+        return this._grantedPackageEntitlements.filter((e) => e.userId === userId &&
+            e.packageId === packageId &&
+            e.expireTimeMs > nowMs &&
+            e.revokeTimeMs === null);
+    }
+    async countRecords(filter) {
+        let count = 0;
+        for (let record of this._records) {
+            if (filter.studioId && record.studioId === filter.studioId) {
+                count++;
+            }
+            else if (filter.ownerId && record.ownerId === filter.ownerId) {
+                count++;
+            }
+            else {
+                count++;
+            }
+        }
+        return count;
     }
-    deleteMarkerPermissionAssignmentById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._markerPermissionAssignments =
-                this._markerPermissionAssignments.filter((p) => p.id !== id);
-            return {
-                success: true,
-            };
-        });
+    async saveUser(user) {
+        let index = this._findUserIndex(user.id);
+        if (index >= 0) {
+            this._users[index] = user;
+        }
+        else {
+            this._users.push(user);
+        }
     }
-    listPermissionsInRecord(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const resourceAssignments = this._resourcePermissionAssignments.filter((p) => p.recordName === recordName);
-            const markerAssignments = this._markerPermissionAssignments.filter((p) => p.recordName === recordName);
+    async saveNewUser(user) {
+        let index = this._users.findIndex((u) => (!!user.email && u.email === user.email) ||
+            (!!user.phoneNumber && u.phoneNumber === user.phoneNumber));
+        if (index >= 0) {
             return {
-                success: true,
-                resourceAssignments,
-                markerAssignments,
+                success: false,
+                errorCode: 'user_already_exists',
+                errorMessage: 'The user already exists.',
             };
-        });
+        }
+        else {
+            this._users.push(user);
+        }
+        return {
+            success: true,
+        };
+    }
+    async findUser(userId) {
+        const user = this._users.find((u) => u.id === userId);
+        return user;
+    }
+    async setRevokeAllSessionsTimeForUser(userId, allSessionRevokeTimeMs) {
+        const user = await this.findUser(userId);
+        if (user) {
+            await this.saveUser({
+                ...user,
+                allSessionRevokeTimeMs: allSessionRevokeTimeMs,
+            });
+        }
     }
-    listPermissionsForResource(recordName, resourceKind, resourceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._resourcePermissionAssignments.filter((p) => p.recordName === recordName &&
-                p.resourceKind === resourceKind &&
-                p.resourceId === resourceId);
-        });
+    async findUserByAddress(address, addressType) {
+        const user = this._users.find((u) => addressType === 'email'
+            ? u.email === address
+            : u.phoneNumber === address);
+        return user;
     }
-    listPermissionsForMarker(recordName, marker) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._markerPermissionAssignments.filter((p) => p.recordName === recordName && p.marker === marker);
-        });
+    async findUserByStripeCustomerId(customerId) {
+        const user = this._users.find((u) => u.stripeCustomerId === customerId);
+        return user;
     }
-    listPermissionsForSubject(recordName, subjectType, subjectId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const resourceAssignments = this._resourcePermissionAssignments.filter((p) => p.recordName === recordName &&
-                p.subjectType === subjectType &&
-                p.subjectId === subjectId);
-            const markerAssignments = this._markerPermissionAssignments.filter((p) => p.recordName === recordName &&
-                p.subjectType === subjectType &&
-                p.subjectId === subjectId);
-            return {
-                success: true,
-                resourceAssignments,
-                markerAssignments,
-            };
-        });
+    async findUserByPrivoServiceId(serviceId) {
+        const user = this._users.find((u) => u.privoServiceId === serviceId);
+        return user;
     }
-    countRecords(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let count = 0;
-            for (let record of this._records) {
-                if (filter.studioId && record.studioId === filter.studioId) {
-                    count++;
-                }
-                else if (filter.ownerId && record.ownerId === filter.ownerId) {
-                    count++;
-                }
-                else {
-                    count++;
-                }
-            }
-            return count;
-        });
+    async findLoginRequest(userId, requestId) {
+        return this._loginRequests.find((lr) => lr.userId === userId && lr.requestId === requestId);
     }
-    saveUser(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let index = this._findUserIndex(user.id);
-            if (index >= 0) {
-                this._users[index] = user;
-            }
-            else {
-                this._users.push(user);
-            }
-        });
+    async findOpenIDLoginRequest(requestId) {
+        return this._oidLoginRequests.find((lr) => lr.requestId === requestId);
     }
-    saveNewUser(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let index = this._users.findIndex((u) => (!!user.email && u.email === user.email) ||
-                (!!user.phoneNumber && u.phoneNumber === user.phoneNumber));
-            if (index >= 0) {
-                return {
-                    success: false,
-                    errorCode: 'user_already_exists',
-                    errorMessage: 'The user already exists.',
-                };
-            }
-            else {
-                this._users.push(user);
-            }
-            return {
-                success: true,
-            };
-        });
+    async findOpenIDLoginRequestByState(state) {
+        return this._oidLoginRequests.find((lr) => lr.state === state);
     }
-    findUser(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = this._users.find((u) => u.id === userId);
-            return user;
-        });
+    async findSession(userId, sessionId) {
+        return this._sessions.find((s) => s.userId === userId && s.sessionId === sessionId);
     }
-    setRevokeAllSessionsTimeForUser(userId, allSessionRevokeTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = yield this.findUser(userId);
-            if (user) {
-                yield this.saveUser(Object.assign(Object.assign({}, user), { allSessionRevokeTimeMs: allSessionRevokeTimeMs }));
-            }
-        });
+    async saveLoginRequest(request) {
+        const index = this._loginRequests.findIndex((lr) => lr.userId === request.userId &&
+            lr.requestId === request.requestId);
+        if (index >= 0) {
+            this._loginRequests[index] = request;
+        }
+        else {
+            this._loginRequests.push(request);
+        }
+        return request;
     }
-    findUserByAddress(address, addressType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = this._users.find((u) => addressType === 'email'
-                ? u.email === address
-                : u.phoneNumber === address);
-            return user;
-        });
+    async saveOpenIDLoginRequest(request) {
+        const index = this._oidLoginRequests.findIndex((lr) => lr.requestId === request.requestId);
+        if (index >= 0) {
+            this._oidLoginRequests[index] = request;
+        }
+        else {
+            this._oidLoginRequests.push(request);
+        }
+        return request;
     }
-    findUserByStripeCustomerId(customerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = this._users.find((u) => u.stripeCustomerId === customerId);
-            return user;
-        });
+    async findWebAuthnLoginRequest(requestId) {
+        return this._webauthnLoginRequests.find((r) => r.requestId === requestId);
     }
-    findUserByPrivoServiceId(serviceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = this._users.find((u) => u.privoServiceId === serviceId);
-            return user;
-        });
+    async saveWebAuthnLoginRequest(request) {
+        const index = this._webauthnLoginRequests.findIndex((r) => r.requestId === request.requestId);
+        if (index >= 0) {
+            this._webauthnLoginRequests[index] = { ...request };
+        }
+        else {
+            this._webauthnLoginRequests.push({ ...request });
+        }
+        return request;
+    }
+    async markWebAuthnLoginRequestComplete(requestId, userId, completedTimeMs) {
+        const index = this._webauthnLoginRequests.findIndex((r) => r.requestId === requestId);
+        if (index >= 0) {
+            const request = this._webauthnLoginRequests[index];
+            request.userId = userId;
+            request.completedTimeMs = completedTimeMs;
+            this._webauthnLoginRequests[index] = { ...request };
+        }
     }
-    findLoginRequest(userId, requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._loginRequests.find((lr) => lr.userId === userId && lr.requestId === requestId);
-        });
+    async findUserAuthenticatorByCredentialId(credentialId) {
+        const authenticator = this._userAuthenticators.find((a) => a.credentialId === credentialId);
+        if (!authenticator) {
+            return { authenticator: null, user: null };
+        }
+        const user = await this.findUser(authenticator.userId);
+        return { authenticator, user };
+    }
+    async findUserLoginMetadata(userId) {
+        let authenticatorIds = this._userAuthenticators
+            .filter((a) => a.userId === userId)
+            .map((a) => a.id);
+        return {
+            hasUserAuthenticator: authenticatorIds.length > 0,
+            userAuthenticatorCredentialIds: authenticatorIds,
+            hasPushSubscription: false,
+            pushSubscriptionIds: [],
+        };
+    }
+    async saveUserAuthenticatorCounter(id, newCounter) {
+        const index = this._userAuthenticators.findIndex((a) => a.id === id);
+        if (index >= 0) {
+            this._userAuthenticators[index] = {
+                ...this._userAuthenticators[index],
+                counter: newCounter,
+            };
+        }
     }
-    findOpenIDLoginRequest(requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._oidLoginRequests.find((lr) => lr.requestId === requestId);
-        });
+    async deleteUserAuthenticator(userId, authenticatorId) {
+        const index = this._userAuthenticators.findIndex((a) => a.userId === userId && a.id === authenticatorId);
+        if (index >= 0) {
+            this._userAuthenticators.splice(index, 1);
+            return 1;
+        }
+        return 0;
+    }
+    async setCurrentLoginRequest(userId, requestId) {
+        const userIndex = this._users.findIndex((u) => u.id === userId);
+        if (userIndex >= 0) {
+            const user = this._users[userIndex];
+            this._users[userIndex] = {
+                ...user,
+                currentLoginRequestId: requestId,
+            };
+        }
     }
-    findOpenIDLoginRequestByState(state) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._oidLoginRequests.find((lr) => lr.state === state);
-        });
+    async setCurrentWebAuthnChallenge(userId, challenge) {
+        const userIndex = this._users.findIndex((u) => u.id === userId);
+        if (userIndex >= 0) {
+            const user = this._users[userIndex];
+            this._users[userIndex] = {
+                ...user,
+                currentWebAuthnChallenge: challenge,
+            };
+        }
     }
-    findSession(userId, sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._sessions.find((s) => s.userId === userId && s.sessionId === sessionId);
-        });
+    async markLoginRequestComplete(userId, requestId, completedTimeMs) {
+        const index = this._loginRequests.findIndex((lr) => lr.userId === userId && lr.requestId === requestId);
+        if (index >= 0) {
+            this._loginRequests[index].completedTimeMs = completedTimeMs;
+        }
+        else {
+            throw new Error('Request not found.');
+        }
     }
-    saveLoginRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._loginRequests.findIndex((lr) => lr.userId === request.userId &&
-                lr.requestId === request.requestId);
-            if (index >= 0) {
-                this._loginRequests[index] = request;
-            }
-            else {
-                this._loginRequests.push(request);
-            }
-            return request;
-        });
+    async markOpenIDLoginRequestComplete(requestId, completedTimeMs) {
+        const index = this._oidLoginRequests.findIndex((lr) => lr.requestId === requestId);
+        if (index >= 0) {
+            this._oidLoginRequests[index].completedTimeMs = completedTimeMs;
+        }
+        else {
+            throw new Error('Request not found.');
+        }
     }
-    saveOpenIDLoginRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._oidLoginRequests.findIndex((lr) => lr.requestId === request.requestId);
-            if (index >= 0) {
-                this._oidLoginRequests[index] = request;
-            }
-            else {
-                this._oidLoginRequests.push(request);
-            }
-            return request;
-        });
+    async saveOpenIDLoginRequestAuthorizationCode(requestId, authorizationCode, authorizationTimeMs) {
+        const index = this._oidLoginRequests.findIndex((lr) => lr.requestId === requestId);
+        if (index >= 0) {
+            const lr = this._oidLoginRequests[index];
+            lr.authorizationCode = authorizationCode;
+            lr.authorizationTimeMs = authorizationTimeMs;
+        }
+        else {
+            throw new Error('Request not found.');
+        }
     }
-    findWebAuthnLoginRequest(requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._webauthnLoginRequests.find((r) => r.requestId === requestId);
-        });
+    async incrementLoginRequestAttemptCount(userId, requestId) {
+        const request = this._loginRequests.find((lr) => lr.userId === userId && lr.requestId === requestId);
+        if (request) {
+            request.attemptCount += 1;
+        }
     }
-    saveWebAuthnLoginRequest(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._webauthnLoginRequests.findIndex((r) => r.requestId === request.requestId);
-            if (index >= 0) {
-                this._webauthnLoginRequests[index] = Object.assign({}, request);
-            }
-            else {
-                this._webauthnLoginRequests.push(Object.assign({}, request));
-            }
-            return request;
-        });
+    async saveSession(session) {
+        const index = this._sessions.findIndex((s) => s.userId === session.userId && s.sessionId === session.sessionId);
+        if (index >= 0) {
+            this._sessions[index] = session;
+        }
+        else {
+            this._sessions.push(session);
+        }
     }
-    markWebAuthnLoginRequestComplete(requestId, userId, completedTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._webauthnLoginRequests.findIndex((r) => r.requestId === requestId);
-            if (index >= 0) {
-                const request = this._webauthnLoginRequests[index];
-                request.userId = userId;
-                request.completedTimeMs = completedTimeMs;
-                this._webauthnLoginRequests[index] = Object.assign({}, request);
-            }
+    async replaceSession(session, newSession, revokeTimeMs) {
+        this.saveSession({
+            ...session,
+            revokeTimeMs: revokeTimeMs,
+            nextSessionId: newSession.sessionId,
         });
-    }
-    findUserAuthenticatorByCredentialId(credentialId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const authenticator = this._userAuthenticators.find((a) => a.credentialId === credentialId);
-            if (!authenticator) {
-                return { authenticator: null, user: null };
-            }
-            const user = yield this.findUser(authenticator.userId);
-            return { authenticator, user };
+        this.saveSession({
+            ...newSession,
+            previousSessionId: session.sessionId,
         });
     }
-    findUserLoginMetadata(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let authenticatorIds = this._userAuthenticators
-                .filter((a) => a.userId === userId)
-                .map((a) => a.id);
-            return {
-                hasUserAuthenticator: authenticatorIds.length > 0,
-                userAuthenticatorCredentialIds: authenticatorIds,
-                hasPushSubscription: false,
-                pushSubscriptionIds: [],
-            };
-        });
+    async listSessions(userId, expireTimeMs) {
+        let orderedSessions = sortBy(this._sessions.filter((s) => s.userId === userId), (s) => -s.expireTimeMs);
+        if (expireTimeMs) {
+            orderedSessions = orderedSessions.filter((s) => s.expireTimeMs < expireTimeMs);
+        }
+        return {
+            success: true,
+            sessions: orderedSessions.slice(0, 10),
+        };
     }
-    saveUserAuthenticatorCounter(id, newCounter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._userAuthenticators.findIndex((a) => a.id === id);
-            if (index >= 0) {
-                this._userAuthenticators[index] = Object.assign(Object.assign({}, this._userAuthenticators[index]), { counter: newCounter });
-            }
-        });
+    async listEmailRules() {
+        return this._emailRules.slice();
     }
-    deleteUserAuthenticator(userId, authenticatorId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._userAuthenticators.findIndex((a) => a.userId === userId && a.id === authenticatorId);
-            if (index >= 0) {
-                this._userAuthenticators.splice(index, 1);
-                return 1;
-            }
-            return 0;
-        });
+    async listSmsRules() {
+        return this._smsRules.slice();
     }
-    setCurrentLoginRequest(userId, requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userIndex = this._users.findIndex((u) => u.id === userId);
-            if (userIndex >= 0) {
-                const user = this._users[userIndex];
-                this._users[userIndex] = Object.assign(Object.assign({}, user), { currentLoginRequestId: requestId });
-            }
-        });
+    async saveSubscription(subscription) {
+        const index = this._subscriptions.findIndex((s) => s.id === subscription.id);
+        if (index >= 0) {
+            this._subscriptions[index] = subscription;
+        }
+        else {
+            this._subscriptions.push(subscription);
+        }
     }
-    setCurrentWebAuthnChallenge(userId, challenge) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const userIndex = this._users.findIndex((u) => u.id === userId);
-            if (userIndex >= 0) {
-                const user = this._users[userIndex];
-                this._users[userIndex] = Object.assign(Object.assign({}, user), { currentWebAuthnChallenge: challenge });
-            }
-        });
+    async getSubscriptionById(id) {
+        return this._subscriptions.find((s) => s.id === id);
     }
-    markLoginRequestComplete(userId, requestId, completedTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._loginRequests.findIndex((lr) => lr.userId === userId && lr.requestId === requestId);
-            if (index >= 0) {
-                this._loginRequests[index].completedTimeMs = completedTimeMs;
-            }
-            else {
-                throw new Error('Request not found.');
-            }
-        });
-    }
-    markOpenIDLoginRequestComplete(requestId, completedTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._oidLoginRequests.findIndex((lr) => lr.requestId === requestId);
-            if (index >= 0) {
-                this._oidLoginRequests[index].completedTimeMs = completedTimeMs;
-            }
-            else {
-                throw new Error('Request not found.');
-            }
-        });
-    }
-    saveOpenIDLoginRequestAuthorizationCode(requestId, authorizationCode, authorizationTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._oidLoginRequests.findIndex((lr) => lr.requestId === requestId);
-            if (index >= 0) {
-                const lr = this._oidLoginRequests[index];
-                lr.authorizationCode = authorizationCode;
-                lr.authorizationTimeMs = authorizationTimeMs;
-            }
-            else {
-                throw new Error('Request not found.');
-            }
-        });
-    }
-    incrementLoginRequestAttemptCount(userId, requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const request = this._loginRequests.find((lr) => lr.userId === userId && lr.requestId === requestId);
-            if (request) {
-                request.attemptCount += 1;
-            }
-        });
-    }
-    saveSession(session) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._sessions.findIndex((s) => s.userId === session.userId && s.sessionId === session.sessionId);
-            if (index >= 0) {
-                this._sessions[index] = session;
-            }
-            else {
-                this._sessions.push(session);
-            }
-        });
-    }
-    replaceSession(session, newSession, revokeTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.saveSession(Object.assign(Object.assign({}, session), { revokeTimeMs: revokeTimeMs, nextSessionId: newSession.sessionId }));
-            this.saveSession(Object.assign(Object.assign({}, newSession), { previousSessionId: session.sessionId }));
-        });
-    }
-    listSessions(userId, expireTimeMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let orderedSessions = sortBy(this._sessions.filter((s) => s.userId === userId), (s) => -s.expireTimeMs);
-            if (expireTimeMs) {
-                orderedSessions = orderedSessions.filter((s) => s.expireTimeMs < expireTimeMs);
-            }
-            return {
-                success: true,
-                sessions: orderedSessions.slice(0, 10),
-            };
-        });
-    }
-    listEmailRules() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._emailRules.slice();
-        });
+    async getSubscriptionByStripeSubscriptionId(id) {
+        return this._subscriptions.find((s) => s.stripeSubscriptionId === id);
     }
-    listSmsRules() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._smsRules.slice();
-        });
-    }
-    saveSubscription(subscription) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._subscriptions.findIndex((s) => s.id === subscription.id);
-            if (index >= 0) {
-                this._subscriptions[index] = subscription;
-            }
-            else {
-                this._subscriptions.push(subscription);
-            }
-        });
-    }
-    getSubscriptionById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._subscriptions.find((s) => s.id === id);
-        });
-    }
-    getSubscriptionByStripeSubscriptionId(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._subscriptions.find((s) => s.stripeSubscriptionId === id);
-        });
-    }
-    saveSubscriptionPeriod(period) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._periods.findIndex((p) => p.id === period.id);
-            if (index >= 0) {
-                this._periods[index] = period;
-            }
-            else {
-                this._periods.push(period);
-            }
-        });
+    async saveSubscriptionPeriod(period) {
+        const index = this._periods.findIndex((p) => p.id === period.id);
+        if (index >= 0) {
+            this._periods[index] = period;
+        }
+        else {
+            this._periods.push(period);
+        }
     }
-    getSubscriptionPeriodById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._periods.find((p) => p.id === id);
-        });
+    async getSubscriptionPeriodById(id) {
+        return this._periods.find((p) => p.id === id);
     }
-    listSubscriptionPeriodsBySubscriptionId(subscriptionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._periods.filter((p) => p.subscriptionId === subscriptionId);
-        });
+    async listSubscriptionPeriodsBySubscriptionId(subscriptionId) {
+        return this._periods.filter((p) => p.subscriptionId === subscriptionId);
     }
-    saveInvoice(invoice) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this._invoices.findIndex((i) => i.id === invoice.id);
-            if (index >= 0) {
-                this._invoices[index] = invoice;
-            }
-            else {
-                this._invoices.push(invoice);
-            }
-        });
+    async saveInvoice(invoice) {
+        const index = this._invoices.findIndex((i) => i.id === invoice.id);
+        if (index >= 0) {
+            this._invoices[index] = invoice;
+        }
+        else {
+            this._invoices.push(invoice);
+        }
     }
-    getInvoiceById(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._invoices.find((i) => i.id === id);
-        });
+    async getInvoiceById(id) {
+        return this._invoices.find((i) => i.id === id);
     }
-    updateSubscriptionInfo(request) {
+    async updateSubscriptionInfo(request) {
         var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (request.userId) {
-                const user = yield this.findUser(request.userId);
-                let subscription = request.stripeSubscriptionId
-                    ? yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId)
-                    : null;
-                if (subscription) {
-                    yield this.saveSubscription(Object.assign(Object.assign({}, subscription), { stripeCustomerId: request.stripeCustomerId, stripeSubscriptionId: request.stripeSubscriptionId, subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, currentPeriodEndMs: request.currentPeriodEndMs, currentPeriodStartMs: request.currentPeriodStartMs }));
-                }
-                else if (request.stripeSubscriptionId) {
-                    subscription = {
-                        id: uuid(),
-                        userId: user.id,
-                        studioId: null,
-                        stripeCustomerId: request.stripeCustomerId,
-                        stripeSubscriptionId: request.stripeSubscriptionId,
-                        subscriptionId: request.subscriptionId,
-                        subscriptionStatus: request.subscriptionStatus,
-                        currentPeriodEndMs: request.currentPeriodEndMs,
-                        currentPeriodStartMs: request.currentPeriodStartMs,
-                    };
-                    yield this.saveSubscription(subscription);
-                }
-                yield this.saveUser(Object.assign(Object.assign({}, user), { subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, stripeCustomerId: (_a = request.stripeCustomerId) !== null && _a !== void 0 ? _a : user.stripeCustomerId, subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs, subscriptionInfoId: (_b = subscription === null || subscription === void 0 ? void 0 : subscription.id) !== null && _b !== void 0 ? _b : null }));
-            }
-            else if (request.studioId) {
-                const studio = yield this.getStudioById(request.studioId);
-                let subscription = request.stripeSubscriptionId
-                    ? yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId)
-                    : null;
-                if (subscription) {
-                    yield this.saveSubscription(Object.assign(Object.assign({}, subscription), { stripeCustomerId: request.stripeCustomerId, stripeSubscriptionId: request.stripeSubscriptionId, subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, currentPeriodEndMs: request.currentPeriodEndMs, currentPeriodStartMs: request.currentPeriodStartMs }));
-                }
-                else if (request.stripeSubscriptionId) {
-                    subscription = {
-                        id: uuid(),
-                        userId: null,
-                        studioId: studio.id,
-                        stripeCustomerId: request.stripeCustomerId,
-                        stripeSubscriptionId: request.stripeSubscriptionId,
-                        subscriptionId: request.subscriptionId,
-                        subscriptionStatus: request.subscriptionStatus,
-                        currentPeriodEndMs: request.currentPeriodEndMs,
-                        currentPeriodStartMs: request.currentPeriodStartMs,
-                    };
-                    yield this.saveSubscription(subscription);
-                }
-                yield this.updateStudio(Object.assign(Object.assign({}, studio), { subscriptionId: request.subscriptionId, subscriptionStatus: request.subscriptionStatus, stripeCustomerId: (_c = request.stripeCustomerId) !== null && _c !== void 0 ? _c : studio.stripeCustomerId, subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs, subscriptionInfoId: (_d = subscription === null || subscription === void 0 ? void 0 : subscription.id) !== null && _d !== void 0 ? _d : null }));
-            }
-        });
-    }
-    updateSubscriptionPeriod(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (request.userId) {
-                let user = yield this.findUser(request.userId);
-                let subscription = yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
-                if (!subscription) {
-                    subscription = {
-                        id: uuid(),
-                        userId: user.id,
-                        studioId: null,
-                        stripeCustomerId: request.stripeCustomerId,
-                        stripeSubscriptionId: request.stripeSubscriptionId,
-                        subscriptionId: request.subscriptionId,
-                        subscriptionStatus: request.subscriptionStatus,
-                        currentPeriodEndMs: request.currentPeriodEndMs,
-                        currentPeriodStartMs: request.currentPeriodStartMs,
-                    };
-                    user.stripeCustomerId = request.stripeCustomerId;
-                    user.subscriptionStatus = request.subscriptionStatus;
-                    user.subscriptionId = request.subscriptionId;
-                    user.subscriptionInfoId = subscription.id;
-                    yield this.saveSubscription(subscription);
-                }
-                yield this.saveUser(Object.assign(Object.assign({}, user), { subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs }));
-                const periodId = uuid();
-                const invoiceId = uuid();
-                yield this.saveInvoice(Object.assign({ id: invoiceId, periodId: periodId, subscriptionId: subscription.id }, request.invoice));
-                yield this.saveSubscriptionPeriod({
-                    id: periodId,
-                    invoiceId: invoiceId,
-                    subscriptionId: subscription.id,
-                    periodEndMs: request.currentPeriodEndMs,
-                    periodStartMs: request.currentPeriodStartMs,
+        if (request.userId) {
+            const user = await this.findUser(request.userId);
+            let subscription = request.stripeSubscriptionId
+                ? await this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId)
+                : null;
+            if (subscription) {
+                await this.saveSubscription({
+                    ...subscription,
+                    stripeCustomerId: request.stripeCustomerId,
+                    stripeSubscriptionId: request.stripeSubscriptionId,
+                    subscriptionId: request.subscriptionId,
+                    subscriptionStatus: request.subscriptionStatus,
+                    currentPeriodEndMs: request.currentPeriodEndMs,
+                    currentPeriodStartMs: request.currentPeriodStartMs,
                 });
             }
-            else if (request.studioId) {
-                let studio = yield this.getStudioById(request.studioId);
-                let subscription = yield this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
-                if (!subscription) {
-                    subscription = {
-                        id: uuid(),
-                        userId: null,
-                        studioId: studio.id,
-                        stripeCustomerId: request.stripeCustomerId,
-                        stripeSubscriptionId: request.stripeSubscriptionId,
-                        subscriptionId: request.subscriptionId,
-                        subscriptionStatus: request.subscriptionStatus,
-                        currentPeriodEndMs: request.currentPeriodEndMs,
-                        currentPeriodStartMs: request.currentPeriodStartMs,
-                    };
-                    studio.stripeCustomerId = request.stripeCustomerId;
-                    studio.subscriptionStatus = request.subscriptionStatus;
-                    studio.subscriptionId = request.subscriptionId;
-                    studio.subscriptionInfoId = subscription.id;
-                    yield this.saveSubscription(subscription);
-                }
-                yield this.updateStudio(Object.assign(Object.assign({}, studio), { subscriptionPeriodStartMs: request.currentPeriodStartMs, subscriptionPeriodEndMs: request.currentPeriodEndMs }));
-                const periodId = uuid();
-                const invoiceId = uuid();
-                yield this.saveInvoice(Object.assign({ id: invoiceId, periodId: periodId, subscriptionId: subscription.id }, request.invoice));
-                yield this.saveSubscriptionPeriod({
-                    id: periodId,
-                    invoiceId: invoiceId,
-                    subscriptionId: subscription.id,
-                    periodEndMs: request.currentPeriodEndMs,
-                    periodStartMs: request.currentPeriodStartMs,
+            else if (request.stripeSubscriptionId) {
+                subscription = {
+                    id: uuid(),
+                    userId: user.id,
+                    studioId: null,
+                    stripeCustomerId: request.stripeCustomerId,
+                    stripeSubscriptionId: request.stripeSubscriptionId,
+                    subscriptionId: request.subscriptionId,
+                    subscriptionStatus: request.subscriptionStatus,
+                    currentPeriodEndMs: request.currentPeriodEndMs,
+                    currentPeriodStartMs: request.currentPeriodStartMs,
+                };
+                await this.saveSubscription(subscription);
+            }
+            await this.saveUser({
+                ...user,
+                subscriptionId: request.subscriptionId,
+                subscriptionStatus: request.subscriptionStatus,
+                stripeCustomerId: (_a = request.stripeCustomerId) !== null && _a !== void 0 ? _a : user.stripeCustomerId,
+                subscriptionPeriodStartMs: request.currentPeriodStartMs,
+                subscriptionPeriodEndMs: request.currentPeriodEndMs,
+                subscriptionInfoId: (_b = subscription === null || subscription === void 0 ? void 0 : subscription.id) !== null && _b !== void 0 ? _b : null,
+            });
+        }
+        else if (request.studioId) {
+            const studio = await this.getStudioById(request.studioId);
+            let subscription = request.stripeSubscriptionId
+                ? await this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId)
+                : null;
+            if (subscription) {
+                await this.saveSubscription({
+                    ...subscription,
+                    stripeCustomerId: request.stripeCustomerId,
+                    stripeSubscriptionId: request.stripeSubscriptionId,
+                    subscriptionId: request.subscriptionId,
+                    subscriptionStatus: request.subscriptionStatus,
+                    currentPeriodEndMs: request.currentPeriodEndMs,
+                    currentPeriodStartMs: request.currentPeriodStartMs,
                 });
             }
-        });
+            else if (request.stripeSubscriptionId) {
+                subscription = {
+                    id: uuid(),
+                    userId: null,
+                    studioId: studio.id,
+                    stripeCustomerId: request.stripeCustomerId,
+                    stripeSubscriptionId: request.stripeSubscriptionId,
+                    subscriptionId: request.subscriptionId,
+                    subscriptionStatus: request.subscriptionStatus,
+                    currentPeriodEndMs: request.currentPeriodEndMs,
+                    currentPeriodStartMs: request.currentPeriodStartMs,
+                };
+                await this.saveSubscription(subscription);
+            }
+            await this.updateStudio({
+                ...studio,
+                subscriptionId: request.subscriptionId,
+                subscriptionStatus: request.subscriptionStatus,
+                stripeCustomerId: (_c = request.stripeCustomerId) !== null && _c !== void 0 ? _c : studio.stripeCustomerId,
+                subscriptionPeriodStartMs: request.currentPeriodStartMs,
+                subscriptionPeriodEndMs: request.currentPeriodEndMs,
+                subscriptionInfoId: (_d = subscription === null || subscription === void 0 ? void 0 : subscription.id) !== null && _d !== void 0 ? _d : null,
+            });
+        }
+    }
+    async updateSubscriptionPeriod(request) {
+        if (request.userId) {
+            let user = await this.findUser(request.userId);
+            let subscription = await this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
+            if (!subscription) {
+                subscription = {
+                    id: uuid(),
+                    userId: user.id,
+                    studioId: null,
+                    stripeCustomerId: request.stripeCustomerId,
+                    stripeSubscriptionId: request.stripeSubscriptionId,
+                    subscriptionId: request.subscriptionId,
+                    subscriptionStatus: request.subscriptionStatus,
+                    currentPeriodEndMs: request.currentPeriodEndMs,
+                    currentPeriodStartMs: request.currentPeriodStartMs,
+                };
+                user.stripeCustomerId = request.stripeCustomerId;
+                user.subscriptionStatus = request.subscriptionStatus;
+                user.subscriptionId = request.subscriptionId;
+                user.subscriptionInfoId = subscription.id;
+                await this.saveSubscription(subscription);
+            }
+            await this.saveUser({
+                ...user,
+                subscriptionPeriodStartMs: request.currentPeriodStartMs,
+                subscriptionPeriodEndMs: request.currentPeriodEndMs,
+            });
+            const periodId = uuid();
+            const invoiceId = uuid();
+            await this.saveInvoice({
+                id: invoiceId,
+                periodId: periodId,
+                subscriptionId: subscription.id,
+                ...request.invoice,
+            });
+            await this.saveSubscriptionPeriod({
+                id: periodId,
+                invoiceId: invoiceId,
+                subscriptionId: subscription.id,
+                periodEndMs: request.currentPeriodEndMs,
+                periodStartMs: request.currentPeriodStartMs,
+            });
+        }
+        else if (request.studioId) {
+            let studio = await this.getStudioById(request.studioId);
+            let subscription = await this.getSubscriptionByStripeSubscriptionId(request.stripeSubscriptionId);
+            if (!subscription) {
+                subscription = {
+                    id: uuid(),
+                    userId: null,
+                    studioId: studio.id,
+                    stripeCustomerId: request.stripeCustomerId,
+                    stripeSubscriptionId: request.stripeSubscriptionId,
+                    subscriptionId: request.subscriptionId,
+                    subscriptionStatus: request.subscriptionStatus,
+                    currentPeriodEndMs: request.currentPeriodEndMs,
+                    currentPeriodStartMs: request.currentPeriodStartMs,
+                };
+                studio.stripeCustomerId = request.stripeCustomerId;
+                studio.subscriptionStatus = request.subscriptionStatus;
+                studio.subscriptionId = request.subscriptionId;
+                studio.subscriptionInfoId = subscription.id;
+                await this.saveSubscription(subscription);
+            }
+            await this.updateStudio({
+                ...studio,
+                subscriptionPeriodStartMs: request.currentPeriodStartMs,
+                subscriptionPeriodEndMs: request.currentPeriodEndMs,
+            });
+            const periodId = uuid();
+            const invoiceId = uuid();
+            await this.saveInvoice({
+                id: invoiceId,
+                periodId: periodId,
+                subscriptionId: subscription.id,
+                ...request.invoice,
+            });
+            await this.saveSubscriptionPeriod({
+                id: periodId,
+                invoiceId: invoiceId,
+                subscriptionId: subscription.id,
+                periodEndMs: request.currentPeriodEndMs,
+                periodStartMs: request.currentPeriodStartMs,
+            });
+        }
     }
     _findUserIndex(id) {
         return this._users.findIndex((u) => u.id === id);
     }
-    setData(recordName, address, data, publisherId, subjectId, updatePolicy, deletePolicy, markers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = this._getDataRecord(recordName);
-            record.set(address, {
-                data: data,
-                publisherId: publisherId,
-                subjectId: subjectId,
-                updatePolicy,
-                deletePolicy,
-                markers,
-            });
+    async setData(recordName, address, data, publisherId, subjectId, updatePolicy, deletePolicy, markers) {
+        let record = this._getDataRecord(recordName);
+        record.set(address, {
+            data: data,
+            publisherId: publisherId,
+            subjectId: subjectId,
+            updatePolicy,
+            deletePolicy,
+            markers,
+        });
+        return {
+            success: true,
+        };
+    }
+    async getData(recordName, address) {
+        let record = this._getDataRecord(recordName);
+        let data = record.get(address);
+        if (!data) {
             return {
-                success: true,
+                success: false,
+                errorCode: 'data_not_found',
+                errorMessage: 'The data was not found.',
             };
-        });
-    }
-    getData(recordName, address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = this._getDataRecord(recordName);
-            let data = record.get(address);
-            if (!data) {
-                return {
-                    success: false,
-                    errorCode: 'data_not_found',
-                    errorMessage: 'The data was not found.',
-                };
-            }
+        }
+        return {
+            success: true,
+            data: data.data,
+            publisherId: data.publisherId,
+            subjectId: data.subjectId,
+            updatePolicy: data.updatePolicy,
+            deletePolicy: data.deletePolicy,
+            markers: data.markers,
+        };
+    }
+    async eraseData(recordName, address) {
+        let record = this._getDataRecord(recordName);
+        let deleted = record.delete(address);
+        if (!deleted) {
             return {
-                success: true,
-                data: data.data,
-                publisherId: data.publisherId,
-                subjectId: data.subjectId,
-                updatePolicy: data.updatePolicy,
-                deletePolicy: data.deletePolicy,
-                markers: data.markers,
+                success: false,
+                errorCode: 'data_not_found',
+                errorMessage: 'The data was not found.',
             };
-        });
-    }
-    eraseData(recordName, address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = this._getDataRecord(recordName);
-            let deleted = record.delete(address);
-            if (!deleted) {
-                return {
-                    success: false,
-                    errorCode: 'data_not_found',
-                    errorMessage: 'The data was not found.',
-                };
+        }
+        return {
+            success: true,
+        };
+    }
+    async listData(recordName, address) {
+        let record = this._getDataRecord(recordName);
+        let items = [];
+        const count = record.size;
+        for (let [key, item] of record.entries()) {
+            if (!address || key > address) {
+                items.push({
+                    address: key,
+                    data: item.data,
+                    markers: item.markers,
+                });
             }
-            return {
-                success: true,
-            };
-        });
-    }
-    listData(recordName, address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = this._getDataRecord(recordName);
-            let items = [];
-            const count = record.size;
-            for (let [key, item] of record.entries()) {
-                if (!address || key > address) {
+        }
+        return {
+            success: true,
+            items,
+            totalCount: count,
+            marker: null,
+        };
+    }
+    async listDataByMarker(request) {
+        var _a;
+        const marker = request.marker;
+        let record = this._getDataRecord(request.recordName);
+        let items = [];
+        const address = request.startingAddress;
+        const sortAscending = ((_a = request.sort) !== null && _a !== void 0 ? _a : 'ascending') === 'ascending';
+        let count = 0;
+        for (let [key, item] of record.entries()) {
+            if (item.markers.includes(marker)) {
+                count += 1;
+                if (!address ||
+                    (sortAscending && key > address) ||
+                    (!sortAscending && key < address)) {
                     items.push({
                         address: key,
                         data: item.data,
@@ -1342,52 +1283,21 @@ export class MemoryStore {
                     });
                 }
             }
-            return {
-                success: true,
-                items,
-                totalCount: count,
-                marker: null,
-            };
-        });
-    }
-    listDataByMarker(request) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const marker = request.marker;
-            let record = this._getDataRecord(request.recordName);
-            let items = [];
-            const address = request.startingAddress;
-            const sortAscending = ((_a = request.sort) !== null && _a !== void 0 ? _a : 'ascending') === 'ascending';
-            let count = 0;
-            for (let [key, item] of record.entries()) {
-                if (item.markers.includes(marker)) {
-                    count += 1;
-                    if (!address ||
-                        (sortAscending && key > address) ||
-                        (!sortAscending && key < address)) {
-                        items.push({
-                            address: key,
-                            data: item.data,
-                            markers: item.markers,
-                        });
-                    }
-                }
+        }
+        if (request.sort) {
+            if (request.sort === 'ascending') {
+                items = sortBy(items, (i) => i.address);
             }
-            if (request.sort) {
-                if (request.sort === 'ascending') {
-                    items = sortBy(items, (i) => i.address);
-                }
-                else if (request.sort === 'descending') {
-                    items = orderBy(items, (i) => i.address, 'desc');
-                }
+            else if (request.sort === 'descending') {
+                items = orderBy(items, (i) => i.address, 'desc');
             }
-            return {
-                success: true,
-                items,
-                totalCount: count,
-                marker: marker,
-            };
-        });
+        }
+        return {
+            success: true,
+            items,
+            totalCount: count,
+            marker: marker,
+        };
     }
     _getDataRecord(recordName) {
         let record = this._dataBuckets.get(recordName);
@@ -1397,246 +1307,233 @@ export class MemoryStore {
         }
         return record;
     }
-    presignFileUpload(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                success: true,
-                uploadHeaders: Object.assign(Object.assign({}, request.headers), { 'record-name': request.recordName, 'content-type': request.fileMimeType }),
-                uploadMethod: 'POST',
-                uploadUrl: `${this._fileUploadUrl}/${request.recordName}/${request.fileName}`,
-            };
-        });
-    }
-    presignFileRead(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                success: true,
-                requestHeaders: Object.assign(Object.assign({}, request.headers), { 'record-name': request.recordName }),
-                requestMethod: 'GET',
-                requestUrl: `${this._fileUploadUrl}/${request.recordName}/${request.fileName}`,
-            };
-        });
-    }
-    getFileNameFromUrl(fileUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (fileUrl.startsWith(this._fileUploadUrl)) {
-                let recordNameAndFileName = fileUrl.slice(this._fileUploadUrl.length + 1);
-                let nextSlash = recordNameAndFileName.indexOf('/');
-                if (nextSlash < 0) {
-                    return {
-                        success: false,
-                        errorCode: 'unacceptable_url',
-                        errorMessage: 'The URL does not match an expected format.',
-                    };
-                }
-                let recordName = recordNameAndFileName.slice(0, nextSlash);
-                let fileName = recordNameAndFileName.slice(nextSlash + 1);
-                if (recordName && fileName) {
-                    return {
-                        success: true,
-                        recordName,
-                        fileName,
-                    };
-                }
+    async presignFileUpload(request) {
+        return {
+            success: true,
+            uploadHeaders: {
+                ...request.headers,
+                'record-name': request.recordName,
+                'content-type': request.fileMimeType,
+            },
+            uploadMethod: 'POST',
+            uploadUrl: `${this._fileUploadUrl}/${request.recordName}/${request.fileName}`,
+        };
+    }
+    async presignFileRead(request) {
+        return {
+            success: true,
+            requestHeaders: {
+                ...request.headers,
+                'record-name': request.recordName,
+            },
+            requestMethod: 'GET',
+            requestUrl: `${this._fileUploadUrl}/${request.recordName}/${request.fileName}`,
+        };
+    }
+    async getFileNameFromUrl(fileUrl) {
+        if (fileUrl.startsWith(this._fileUploadUrl)) {
+            let recordNameAndFileName = fileUrl.slice(this._fileUploadUrl.length + 1);
+            let nextSlash = recordNameAndFileName.indexOf('/');
+            if (nextSlash < 0) {
                 return {
                     success: false,
                     errorCode: 'unacceptable_url',
                     errorMessage: 'The URL does not match an expected format.',
                 };
             }
-            return {
-                success: false,
-                errorCode: 'unacceptable_url',
-                errorMessage: 'The URL does not match an expected format.',
-            };
-        });
-    }
-    getFileRecord(recordName, fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let file = this._files.get(fileName);
-            if (file) {
+            let recordName = recordNameAndFileName.slice(0, nextSlash);
+            let fileName = recordNameAndFileName.slice(nextSlash + 1);
+            if (recordName && fileName) {
                 return {
                     success: true,
-                    fileName: file.fileName,
-                    recordName: file.recordName,
-                    publisherId: file.publisherId,
-                    subjectId: file.subjectId,
-                    sizeInBytes: file.sizeInBytes,
-                    uploaded: file.uploaded,
-                    description: file.description,
-                    url: `${this._fileUploadUrl}/${file.recordName}/${file.fileName}`,
-                    markers: file.markers,
-                };
-            }
-            else {
-                return {
-                    success: false,
-                    errorCode: 'file_not_found',
-                    errorMessage: 'The file was not found in the store.',
+                    recordName,
+                    fileName,
                 };
             }
-        });
-    }
-    listUploadedFiles(recordName, fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let files = sortBy([...this._files.values()].filter((f) => f.recordName === recordName && f.uploaded), (f) => f.fileName);
-            const count = files.length;
-            if (fileName) {
-                files = files.filter((f) => f.fileName > fileName);
-            }
             return {
-                success: true,
-                files: files.slice(0, 10).map((f) => ({
-                    fileName: f.fileName,
-                    uploaded: f.uploaded,
-                    markers: f.markers,
-                    description: f.description,
-                    sizeInBytes: f.sizeInBytes,
-                    url: `${this._fileUploadUrl}/${f.recordName}/${f.fileName}`,
-                })),
-                totalCount: count,
-            };
-        });
-    }
-    addFileRecord(recordName, fileName, publisherId, subjectId, sizeInBytes, description, markers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._files.has(fileName)) {
-                return {
-                    success: false,
-                    errorCode: 'file_already_exists',
-                    errorMessage: 'The file already exists in the store.',
-                };
-            }
-            let file = {
-                fileName: fileName,
-                recordName: recordName,
-                publisherId,
-                subjectId,
-                sizeInBytes,
-                description,
-                markers,
-                uploaded: false,
+                success: false,
+                errorCode: 'unacceptable_url',
+                errorMessage: 'The URL does not match an expected format.',
             };
-            this._files.set(fileName, file);
+        }
+        return {
+            success: false,
+            errorCode: 'unacceptable_url',
+            errorMessage: 'The URL does not match an expected format.',
+        };
+    }
+    async getFileRecord(recordName, fileName) {
+        let file = this._files.get(fileName);
+        if (file) {
             return {
                 success: true,
+                fileName: file.fileName,
+                recordName: file.recordName,
+                publisherId: file.publisherId,
+                subjectId: file.subjectId,
+                sizeInBytes: file.sizeInBytes,
+                uploaded: file.uploaded,
+                description: file.description,
+                url: `${this._fileUploadUrl}/${file.recordName}/${file.fileName}`,
+                markers: file.markers,
             };
-        });
-    }
-    updateFileRecord(recordName, fileName, markers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._files.has(fileName)) {
-                return {
-                    success: false,
-                    errorCode: 'file_not_found',
-                    errorMessage: 'The file was not found in the store.',
-                };
-            }
-            let file = this._files.get(fileName);
-            this._files.set(fileName, Object.assign(Object.assign({}, file), { markers: markers.slice() }));
+        }
+        else {
             return {
-                success: true,
+                success: false,
+                errorCode: 'file_not_found',
+                errorMessage: 'The file was not found in the store.',
             };
-        });
+        }
     }
-    setFileRecordAsUploaded(recordName, fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let file = this._files.get(fileName);
-            if (!file) {
-                return {
-                    success: false,
-                    errorCode: 'file_not_found',
-                    errorMessage: 'The file was not found in the store.',
-                };
-            }
-            file.uploaded = true;
-            return {
-                success: true,
-            };
-        });
+    async listUploadedFiles(recordName, fileName) {
+        let files = sortBy([...this._files.values()].filter((f) => f.recordName === recordName && f.uploaded), (f) => f.fileName);
+        const count = files.length;
+        if (fileName) {
+            files = files.filter((f) => f.fileName > fileName);
+        }
+        return {
+            success: true,
+            files: files.slice(0, 10).map((f) => ({
+                fileName: f.fileName,
+                uploaded: f.uploaded,
+                markers: f.markers,
+                description: f.description,
+                sizeInBytes: f.sizeInBytes,
+                url: `${this._fileUploadUrl}/${f.recordName}/${f.fileName}`,
+            })),
+            totalCount: count,
+        };
     }
-    eraseFileRecord(recordName, fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deleted = this._files.delete(fileName);
-            if (!deleted) {
-                return {
-                    success: false,
-                    errorCode: 'file_not_found',
-                    errorMessage: 'The file was not found in the store.',
-                };
-            }
+    async addFileRecord(recordName, fileName, publisherId, subjectId, sizeInBytes, description, markers) {
+        if (this._files.has(fileName)) {
             return {
-                success: true,
+                success: false,
+                errorCode: 'file_already_exists',
+                errorMessage: 'The file already exists in the store.',
             };
-        });
-    }
-    getAllowedUploadHeaders() {
-        return ['record-name', 'content-type'];
-    }
-    addEventCount(recordName, eventName, count) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = this._getEventRecord(recordName);
-            if (record.has(eventName)) {
-                let data = record.get(eventName);
-                data.count += count;
-            }
-            else {
-                record.set(eventName, {
-                    count: count,
-                });
-            }
+        }
+        let file = {
+            fileName: fileName,
+            recordName: recordName,
+            publisherId,
+            subjectId,
+            sizeInBytes,
+            description,
+            markers,
+            uploaded: false,
+        };
+        this._files.set(fileName, file);
+        return {
+            success: true,
+        };
+    }
+    async updateFileRecord(recordName, fileName, markers) {
+        if (!this._files.has(fileName)) {
             return {
-                success: true,
+                success: false,
+                errorCode: 'file_not_found',
+                errorMessage: 'The file was not found in the store.',
             };
-        });
-    }
-    getEventCount(recordName, eventName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = this._getEventRecord(recordName);
-            const e = record.has(eventName)
-                ? record.get(eventName)
-                : {
-                    count: 0,
-                };
+        }
+        let file = this._files.get(fileName);
+        this._files.set(fileName, {
+            ...file,
+            markers: markers.slice(),
+        });
+        return {
+            success: true,
+        };
+    }
+    async setFileRecordAsUploaded(recordName, fileName) {
+        let file = this._files.get(fileName);
+        if (!file) {
             return {
-                success: true,
-                count: e.count,
-                markers: e.markers,
+                success: false,
+                errorCode: 'file_not_found',
+                errorMessage: 'The file was not found in the store.',
             };
-        });
-    }
-    updateEvent(recordName, eventName, updates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = this._getEventRecord(recordName);
-            const e = record.has(eventName)
-                ? record.get(eventName)
-                : {
-                    count: 0,
-                };
-            record.set(eventName, Object.assign(Object.assign({}, e), updates));
+        }
+        file.uploaded = true;
+        return {
+            success: true,
+        };
+    }
+    async eraseFileRecord(recordName, fileName) {
+        const deleted = this._files.delete(fileName);
+        if (!deleted) {
             return {
-                success: true,
+                success: false,
+                errorCode: 'file_not_found',
+                errorMessage: 'The file was not found in the store.',
             };
-        });
+        }
+        return {
+            success: true,
+        };
     }
-    listEvents(recordName, eventName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = this._getEventRecord(recordName);
-            const totalCount = record.size;
-            let events = sortBy([...record.entries()], ([name, data]) => name);
-            if (eventName) {
-                events = events.filter(([name, data]) => name > eventName);
-            }
-            return {
-                success: true,
-                events: events.slice(0, 10).map(([name, data]) => ({
-                    eventName: name,
-                    count: data.count,
-                    markers: data.markers,
-                })),
-                totalCount,
+    getAllowedUploadHeaders() {
+        return ['record-name', 'content-type'];
+    }
+    async addEventCount(recordName, eventName, count) {
+        const record = this._getEventRecord(recordName);
+        if (record.has(eventName)) {
+            let data = record.get(eventName);
+            data.count += count;
+        }
+        else {
+            record.set(eventName, {
+                count: count,
+            });
+        }
+        return {
+            success: true,
+        };
+    }
+    async getEventCount(recordName, eventName) {
+        const record = this._getEventRecord(recordName);
+        const e = record.has(eventName)
+            ? record.get(eventName)
+            : {
+                count: 0,
             };
-        });
+        return {
+            success: true,
+            count: e.count,
+            markers: e.markers,
+        };
+    }
+    async updateEvent(recordName, eventName, updates) {
+        const record = this._getEventRecord(recordName);
+        const e = record.has(eventName)
+            ? record.get(eventName)
+            : {
+                count: 0,
+            };
+        record.set(eventName, {
+            ...e,
+            ...updates,
+        });
+        return {
+            success: true,
+        };
+    }
+    async listEvents(recordName, eventName) {
+        const record = this._getEventRecord(recordName);
+        const totalCount = record.size;
+        let events = sortBy([...record.entries()], ([name, data]) => name);
+        if (eventName) {
+            events = events.filter(([name, data]) => name > eventName);
+        }
+        return {
+            success: true,
+            events: events.slice(0, 10).map(([name, data]) => ({
+                eventName: name,
+                count: data.count,
+                markers: data.markers,
+            })),
+            totalCount,
+        };
     }
     _getEventRecord(recordName) {
         let record = this._eventBuckets.get(recordName);
@@ -1646,140 +1543,129 @@ export class MemoryStore {
         }
         return record;
     }
-    _getUserPrivacyFeatures(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const user = yield this.findUser(userId);
-            if (user === null || user === void 0 ? void 0 : user.privacyFeatures) {
-                return Object.assign(Object.assign({}, user.privacyFeatures), { userRole: user === null || user === void 0 ? void 0 : user.role });
-            }
+    async _getUserPrivacyFeatures(userId) {
+        const user = await this.findUser(userId);
+        if (user === null || user === void 0 ? void 0 : user.privacyFeatures) {
             return {
-                publishData: true,
-                allowPublicData: true,
-                allowAI: true,
-                allowPublicInsts: true,
+                ...user.privacyFeatures,
                 userRole: user === null || user === void 0 ? void 0 : user.role,
             };
-        });
-    }
-    listRolesForUser(recordName, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._getRolesForEntity(recordName, userId);
-        });
-    }
-    listRolesForInst(recordName, inst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._getRolesForEntity(recordName, inst);
-        });
-    }
-    listAssignmentsForRole(recordName, role) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = this.roles[recordName];
-            let assignedRoles = this.roleAssignments[recordName];
-            let assignments = [];
-            for (let id in record) {
-                if (record[id].has(role)) {
-                    assignments.push({
-                        type: 'user',
-                        userId: id,
-                        role: {
-                            role,
-                            expireTimeMs: null,
-                        },
-                    });
-                }
+        }
+        return {
+            publishData: true,
+            allowPublicData: true,
+            allowAI: true,
+            allowPublicInsts: true,
+            userRole: user === null || user === void 0 ? void 0 : user.role,
+        };
+    }
+    async listRolesForUser(recordName, userId) {
+        return this._getRolesForEntity(recordName, userId);
+    }
+    async listRolesForInst(recordName, inst) {
+        return this._getRolesForEntity(recordName, inst);
+    }
+    async listAssignmentsForRole(recordName, role) {
+        let record = this.roles[recordName];
+        let assignedRoles = this.roleAssignments[recordName];
+        let assignments = [];
+        for (let id in record) {
+            if (record[id].has(role)) {
+                assignments.push({
+                    type: 'user',
+                    userId: id,
+                    role: {
+                        role,
+                        expireTimeMs: null,
+                    },
+                });
             }
-            for (let id in assignedRoles) {
-                let roles = assignedRoles[id];
-                let assignment = roles.find((r) => r.role === role);
-                if (assignment) {
-                    assignments.push({
-                        type: 'user',
-                        userId: id,
-                        role: assignment,
-                    });
-                }
+        }
+        for (let id in assignedRoles) {
+            let roles = assignedRoles[id];
+            let assignment = roles.find((r) => r.role === role);
+            if (assignment) {
+                assignments.push({
+                    type: 'user',
+                    userId: id,
+                    role: assignment,
+                });
             }
-            return {
-                assignments,
-                totalCount: assignments.length,
-            };
-        });
-    }
-    listAssignments(recordName, startingRole) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = this.roles[recordName];
-            let assignedRoles = this.roleAssignments[recordName];
-            let totalCount = 0;
-            let assignments = [];
-            for (let id in record) {
-                const roles = record[id];
-                for (let role of roles) {
-                    assignments.push({
-                        type: 'user',
-                        userId: id,
-                        role: {
-                            role,
-                            expireTimeMs: null,
-                        },
-                    });
-                    totalCount += 1;
-                }
-            }
-            for (let id in assignedRoles) {
-                let roles = assignedRoles[id];
-                for (let role of roles) {
-                    assignments.push({
-                        type: 'user',
-                        userId: id,
+        }
+        return {
+            assignments,
+            totalCount: assignments.length,
+        };
+    }
+    async listAssignments(recordName, startingRole) {
+        let record = this.roles[recordName];
+        let assignedRoles = this.roleAssignments[recordName];
+        let totalCount = 0;
+        let assignments = [];
+        for (let id in record) {
+            const roles = record[id];
+            for (let role of roles) {
+                assignments.push({
+                    type: 'user',
+                    userId: id,
+                    role: {
                         role,
-                    });
-                    totalCount += 1;
-                }
+                        expireTimeMs: null,
+                    },
+                });
+                totalCount += 1;
             }
-            assignments = sortBy(assignments, (a) => a.role.role, (a) => { var _a; return (_a = a.userId) !== null && _a !== void 0 ? _a : a.inst; });
-            if (startingRole) {
-                assignments = assignments.filter((a) => a.role.role > startingRole);
+        }
+        for (let id in assignedRoles) {
+            let roles = assignedRoles[id];
+            for (let role of roles) {
+                assignments.push({
+                    type: 'user',
+                    userId: id,
+                    role,
+                });
+                totalCount += 1;
             }
-            return {
-                assignments: assignments.slice(0, 10),
-                totalCount: totalCount,
-            };
-        });
+        }
+        assignments = sortBy(assignments, (a) => a.role.role, (a) => { var _a; return (_a = a.userId) !== null && _a !== void 0 ? _a : a.inst; });
+        if (startingRole) {
+            assignments = assignments.filter((a) => a.role.role > startingRole);
+        }
+        return {
+            assignments: assignments.slice(0, 10),
+            totalCount: totalCount,
+        };
     }
-    assignSubjectRole(recordName, subjectId, type, role) {
+    async assignSubjectRole(recordName, subjectId, type, role) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.roleAssignments[recordName]) {
-                this.roleAssignments[recordName] = {};
-            }
-            const roles = (_a = this.roleAssignments[recordName][subjectId]) !== null && _a !== void 0 ? _a : [];
-            const filtered = roles.filter((r) => r.role !== role.role ||
-                getExpireTime(r.expireTimeMs) <= role.expireTimeMs);
-            this.roleAssignments[recordName][subjectId] = [
-                ...filtered,
-                {
-                    role: role.role,
-                    expireTimeMs: role.expireTimeMs === Infinity ? null : role.expireTimeMs,
-                },
-            ];
-            return {
-                success: true,
-            };
-        });
+        if (!this.roleAssignments[recordName]) {
+            this.roleAssignments[recordName] = {};
+        }
+        const roles = (_a = this.roleAssignments[recordName][subjectId]) !== null && _a !== void 0 ? _a : [];
+        const filtered = roles.filter((r) => r.role !== role.role ||
+            getExpireTime(r.expireTimeMs) <= role.expireTimeMs);
+        this.roleAssignments[recordName][subjectId] = [
+            ...filtered,
+            {
+                role: role.role,
+                expireTimeMs: role.expireTimeMs === Infinity ? null : role.expireTimeMs,
+            },
+        ];
+        return {
+            success: true,
+        };
     }
-    revokeSubjectRole(recordName, subjectId, type, role) {
+    async revokeSubjectRole(recordName, subjectId, type, role) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.roleAssignments[recordName]) {
-                this.roleAssignments[recordName] = {};
-            }
-            const roles = (_a = this.roleAssignments[recordName][subjectId]) !== null && _a !== void 0 ? _a : [];
-            const filtered = roles.filter((r) => r.role !== role);
-            this.roleAssignments[recordName][subjectId] = filtered;
-            return {
-                success: true,
-            };
-        });
+        if (!this.roleAssignments[recordName]) {
+            this.roleAssignments[recordName] = {};
+        }
+        const roles = (_a = this.roleAssignments[recordName][subjectId]) !== null && _a !== void 0 ? _a : [];
+        const filtered = roles.filter((r) => r.role !== role);
+        this.roleAssignments[recordName][subjectId] = filtered;
+        return {
+            success: true,
+        };
     }
     _getRolesForEntity(recordName, id) {
         var _a, _b, _c, _d;
@@ -1793,309 +1679,370 @@ export class MemoryStore {
             ...assignments.filter((a) => getExpireTime(a.expireTimeMs) > Date.now()),
         ];
     }
-    getSubscriptionDataMetricsByRecordName(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionInfo(recordName);
-            const records = yield this._listRecordsForSubscription(recordName);
-            let totalItems = 0;
-            for (let record of records) {
-                let bucket = this._dataBuckets.get(record.name);
-                if (!bucket) {
-                    continue;
-                }
-                totalItems += bucket.size;
+    async getSubscriptionDataMetricsByRecordName(recordName) {
+        const info = await this._getSubscriptionInfo(recordName);
+        const records = await this._listRecordsForSubscription(recordName);
+        let totalItems = 0;
+        for (let record of records) {
+            let bucket = this._dataBuckets.get(record.name);
+            if (!bucket) {
+                continue;
             }
-            return Object.assign(Object.assign({}, info), { totalItems });
-        });
-    }
-    getSubscriptionFileMetricsByRecordName(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionInfo(recordName);
-            const records = yield this._listRecordsForSubscription(recordName);
-            let totalFiles = 0;
-            let totalBytesStored = 0;
-            let totalBytesReserved = 0;
-            for (let record of records) {
-                let files = [...this.files.values()].filter((f) => f.recordName === record.name);
-                for (let file of files) {
-                    totalFiles++;
-                    totalBytesReserved += file.sizeInBytes;
-                    if (file.uploaded) {
-                        totalBytesStored += file.sizeInBytes;
-                    }
-                }
-            }
-            return Object.assign(Object.assign({}, info), { totalFiles, totalFileBytesReserved: totalBytesReserved });
-        });
-    }
-    getSubscriptionEventMetricsByRecordName(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionInfo(recordName);
-            const records = yield this._listRecordsForSubscription(recordName);
-            let totalEventNames = 0;
-            for (let record of records) {
-                let bucket = this._eventBuckets.get(record.name);
-                if (!bucket) {
-                    continue;
-                }
-                totalEventNames += bucket.size;
-            }
-            return Object.assign(Object.assign({}, info), { totalEventNames });
-        });
-    }
-    getSubscriptionRecordMetrics(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const metrics = yield this._getSubscriptionMetrics(filter);
-            const totalRecords = yield this.countRecords(filter);
-            return Object.assign(Object.assign({}, metrics), { totalRecords });
-        });
-    }
-    getSubscriptionAiChatMetrics(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionMetrics(filter);
-            const metrics = filter.ownerId
-                ? this._aiChatMetrics.filter((m) => m.userId === filter.ownerId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)))
-                : this._aiChatMetrics.filter((m) => m.studioId === filter.studioId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)));
-            let totalTokens = 0;
-            for (let m of metrics) {
-                totalTokens += m.tokens;
-            }
-            return Object.assign(Object.assign({}, info), { totalTokensInCurrentPeriod: totalTokens });
-        });
-    }
-    getSubscriptionInstMetrics(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionMetrics(filter);
-            let totalInsts = 0;
-            for (let [recordName, insts] of this._instRecords) {
-                let r = this._records.find((r) => r.name === recordName);
-                if (!r) {
-                    continue;
-                }
-                else if (r.ownerId === filter.ownerId ||
-                    r.studioId === filter.studioId) {
-                    totalInsts += insts.size;
+            totalItems += bucket.size;
+        }
+        return {
+            ...info,
+            totalItems,
+        };
+    }
+    async getSubscriptionFileMetricsByRecordName(recordName) {
+        const info = await this._getSubscriptionInfo(recordName);
+        const records = await this._listRecordsForSubscription(recordName);
+        let totalFiles = 0;
+        let totalBytesStored = 0;
+        let totalBytesReserved = 0;
+        for (let record of records) {
+            let files = [...this.files.values()].filter((f) => f.recordName === record.name);
+            for (let file of files) {
+                totalFiles++;
+                totalBytesReserved += file.sizeInBytes;
+                if (file.uploaded) {
+                    totalBytesStored += file.sizeInBytes;
                 }
             }
-            return Object.assign(Object.assign({}, info), { totalInsts });
-        });
-    }
-    getSubscriptionInstMetricsByRecordName(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionInfo(recordName);
-            let totalInsts = 0;
-            for (let [recordName, insts] of this._instRecords) {
-                let r = this._records.find((r) => r.name === recordName);
-                if (!r) {
-                    continue;
-                }
-                else if (r.ownerId === info.ownerId ||
-                    r.studioId === info.studioId) {
-                    totalInsts += insts.size;
-                }
+        }
+        return {
+            ...info,
+            totalFiles,
+            totalFileBytesReserved: totalBytesReserved,
+        };
+    }
+    async getSubscriptionEventMetricsByRecordName(recordName) {
+        const info = await this._getSubscriptionInfo(recordName);
+        const records = await this._listRecordsForSubscription(recordName);
+        let totalEventNames = 0;
+        for (let record of records) {
+            let bucket = this._eventBuckets.get(record.name);
+            if (!bucket) {
+                continue;
+            }
+            totalEventNames += bucket.size;
+        }
+        return {
+            ...info,
+            totalEventNames,
+        };
+    }
+    async getSubscriptionRecordMetrics(filter) {
+        const metrics = await this._getSubscriptionMetrics(filter);
+        const totalRecords = await this.countRecords(filter);
+        return {
+            ...metrics,
+            totalRecords,
+        };
+    }
+    async getSubscriptionAiChatMetrics(filter) {
+        const info = await this._getSubscriptionMetrics(filter);
+        const metrics = filter.ownerId
+            ? this._aiChatMetrics.filter((m) => m.userId === filter.ownerId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)))
+            : this._aiChatMetrics.filter((m) => m.studioId === filter.studioId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)));
+        let totalTokens = 0;
+        for (let m of metrics) {
+            totalTokens += m.tokens;
+        }
+        return {
+            ...info,
+            totalTokensInCurrentPeriod: totalTokens,
+        };
+    }
+    async getSubscriptionInstMetrics(filter) {
+        const info = await this._getSubscriptionMetrics(filter);
+        let totalInsts = 0;
+        for (let [recordName, insts] of this._instRecords) {
+            let r = this._records.find((r) => r.name === recordName);
+            if (!r) {
+                continue;
             }
-            return Object.assign(Object.assign({}, info), { totalInsts });
-        });
-    }
-    getSubscriptionInfoForRecord(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._getSubscriptionInfo(recordName);
-        });
-    }
-    listRecordsForSubscriptionByRecordName(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this._listRecordsForSubscription(recordName);
-        });
-    }
-    getSubscriptionAiSloydMetrics(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionMetrics(filter);
-            const metrics = filter.ownerId
-                ? this._aiSloydMetrics.filter((m) => m.userId === filter.ownerId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)))
-                : this._aiSloydMetrics.filter((m) => m.studioId === filter.studioId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)));
-            let totalModels = 0;
-            for (let m of metrics) {
-                totalModels += m.modelsCreated;
+            else if (r.ownerId === filter.ownerId ||
+                r.studioId === filter.studioId) {
+                totalInsts += insts.size;
             }
-            return Object.assign(Object.assign({}, info), { totalModelsInCurrentPeriod: totalModels });
-        });
-    }
-    getSubscriptionAiSloydMetricsByRecordName(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionInfo(recordName);
-            let totalModels = 0;
-            for (let metric of this._aiSloydMetrics) {
-                if (metric.userId === info.ownerId ||
-                    metric.studioId === info.studioId) {
-                    totalModels += metric.modelsCreated;
-                }
+        }
+        return {
+            ...info,
+            totalInsts,
+        };
+    }
+    async getSubscriptionInstMetricsByRecordName(recordName) {
+        const info = await this._getSubscriptionInfo(recordName);
+        let totalInsts = 0;
+        for (let [recordName, insts] of this._instRecords) {
+            let r = this._records.find((r) => r.name === recordName);
+            if (!r) {
+                continue;
             }
-            return Object.assign(Object.assign({}, info), { totalModelsInCurrentPeriod: totalModels });
-        });
-    }
-    recordSloydMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._aiSloydMetrics.push(metrics);
-        });
-    }
-    getSubscriptionAiOpenAIRealtimeMetrics(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionMetrics(filter);
-            const metrics = filter.ownerId
-                ? this._aiRealtimeMetrics.filter((m) => m.userId === filter.ownerId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)))
-                : this._aiRealtimeMetrics.filter((m) => m.studioId === filter.studioId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)));
-            let totalModels = metrics.length;
-            return Object.assign(Object.assign({}, info), { totalSessionsInCurrentPeriod: totalModels });
-        });
-    }
-    recordOpenAIRealtimeMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._aiRealtimeMetrics.push(metrics);
-        });
-    }
-    recordChatMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._aiChatMetrics.push(metrics);
-        });
-    }
-    getSubscriptionAiImageMetrics(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionMetrics(filter);
-            const metrics = filter.ownerId
-                ? this._aiImageMetrics.filter((m) => m.userId === filter.ownerId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)))
-                : this._aiImageMetrics.filter((m) => m.studioId === filter.studioId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)));
-            let totalPixels = 0;
-            for (let m of metrics) {
-                totalPixels += m.squarePixels;
+            else if (r.ownerId === info.ownerId ||
+                r.studioId === info.studioId) {
+                totalInsts += insts.size;
             }
-            return Object.assign(Object.assign({}, info), { totalSquarePixelsInCurrentPeriod: totalPixels });
-        });
-    }
-    recordImageMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._aiImageMetrics.push(metrics);
-        });
-    }
-    getSubscriptionAiSkyboxMetrics(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const info = yield this._getSubscriptionMetrics(filter);
-            const metrics = filter.ownerId
-                ? this._aiSkyboxMetrics.filter((m) => m.userId === filter.ownerId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)))
-                : this._aiSkyboxMetrics.filter((m) => m.studioId === filter.studioId &&
-                    (!info.currentPeriodStartMs ||
-                        (m.createdAtMs >= info.currentPeriodStartMs &&
-                            m.createdAtMs < info.currentPeriodEndMs)));
-            let totalSkyboxes = 0;
-            for (let m of metrics) {
-                totalSkyboxes += m.skyboxes;
+        }
+        return {
+            ...info,
+            totalInsts,
+        };
+    }
+    async getSubscriptionInfoForRecord(recordName) {
+        return await this._getSubscriptionInfo(recordName);
+    }
+    async listRecordsForSubscriptionByRecordName(recordName) {
+        return await this._listRecordsForSubscription(recordName);
+    }
+    async getSubscriptionAiSloydMetrics(filter) {
+        const info = await this._getSubscriptionMetrics(filter);
+        const metrics = filter.ownerId
+            ? this._aiSloydMetrics.filter((m) => m.userId === filter.ownerId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)))
+            : this._aiSloydMetrics.filter((m) => m.studioId === filter.studioId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)));
+        let totalModels = 0;
+        for (let m of metrics) {
+            totalModels += m.modelsCreated;
+        }
+        return {
+            ...info,
+            totalModelsInCurrentPeriod: totalModels,
+        };
+    }
+    async getSubscriptionAiSloydMetricsByRecordName(recordName) {
+        const info = await this._getSubscriptionInfo(recordName);
+        let totalModels = 0;
+        for (let metric of this._aiSloydMetrics) {
+            if (metric.userId === info.ownerId ||
+                metric.studioId === info.studioId) {
+                totalModels += metric.modelsCreated;
             }
-            return Object.assign(Object.assign({}, info), { totalSkyboxesInCurrentPeriod: totalSkyboxes });
-        });
-    }
-    recordSkyboxMetrics(metrics) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._aiSkyboxMetrics.push(metrics);
-        });
-    }
-    _getSubscriptionInfo(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = yield this.getRecordByName(recordName);
-            const metrics = yield this._getSubscriptionMetrics(record);
-            return Object.assign(Object.assign({}, metrics), { recordName: record.name });
-        });
-    }
-    _getSubscriptionMetrics(filter) {
+        }
+        return {
+            ...info,
+            totalModelsInCurrentPeriod: totalModels,
+        };
+    }
+    async recordSloydMetrics(metrics) {
+        this._aiSloydMetrics.push(metrics);
+    }
+    async getSubscriptionAiOpenAIRealtimeMetrics(filter) {
+        const info = await this._getSubscriptionMetrics(filter);
+        const metrics = filter.ownerId
+            ? this._aiRealtimeMetrics.filter((m) => m.userId === filter.ownerId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)))
+            : this._aiRealtimeMetrics.filter((m) => m.studioId === filter.studioId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)));
+        let totalModels = metrics.length;
+        return {
+            ...info,
+            totalSessionsInCurrentPeriod: totalModels,
+        };
+    }
+    async recordOpenAIRealtimeMetrics(metrics) {
+        this._aiRealtimeMetrics.push(metrics);
+    }
+    async recordChatMetrics(metrics) {
+        this._aiChatMetrics.push(metrics);
+    }
+    async getSubscriptionAiImageMetrics(filter) {
+        const info = await this._getSubscriptionMetrics(filter);
+        const metrics = filter.ownerId
+            ? this._aiImageMetrics.filter((m) => m.userId === filter.ownerId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)))
+            : this._aiImageMetrics.filter((m) => m.studioId === filter.studioId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)));
+        let totalPixels = 0;
+        for (let m of metrics) {
+            totalPixels += m.squarePixels;
+        }
+        return {
+            ...info,
+            totalSquarePixelsInCurrentPeriod: totalPixels,
+        };
+    }
+    async recordImageMetrics(metrics) {
+        this._aiImageMetrics.push(metrics);
+    }
+    async getSubscriptionAiSkyboxMetrics(filter) {
+        const info = await this._getSubscriptionMetrics(filter);
+        const metrics = filter.ownerId
+            ? this._aiSkyboxMetrics.filter((m) => m.userId === filter.ownerId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)))
+            : this._aiSkyboxMetrics.filter((m) => m.studioId === filter.studioId &&
+                (!info.currentPeriodStartMs ||
+                    (m.createdAtMs >= info.currentPeriodStartMs &&
+                        m.createdAtMs < info.currentPeriodEndMs)));
+        let totalSkyboxes = 0;
+        for (let m of metrics) {
+            totalSkyboxes += m.skyboxes;
+        }
+        return {
+            ...info,
+            totalSkyboxesInCurrentPeriod: totalSkyboxes,
+        };
+    }
+    async recordSkyboxMetrics(metrics) {
+        this._aiSkyboxMetrics.push(metrics);
+    }
+    async _getSubscriptionInfo(recordName) {
+        const record = await this.getRecordByName(recordName);
+        const metrics = await this._getSubscriptionMetrics(record);
+        return {
+            ...metrics,
+            recordName: record.name,
+        };
+    }
+    async _getSubscriptionMetrics(filter) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this.getSubscriptionConfiguration();
-            let currentPeriodStart = null;
-            let currentPeriodEnd = null;
-            if ((_a = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _a === void 0 ? void 0 : _a.defaultPeriodLength) {
-                const now = DateTime.utc();
-                const periodStart = now.minus(config.defaultFeatures.defaultPeriodLength);
-                currentPeriodStart = periodStart.toMillis();
-                currentPeriodEnd = now.toMillis();
-            }
-            let metrics = {
-                ownerId: filter.ownerId,
-                studioId: filter.studioId,
-                subscriptionId: null,
-                subscriptionStatus: null,
-                currentPeriodStartMs: currentPeriodStart,
-                currentPeriodEndMs: currentPeriodEnd,
-                subscriptionType: filter.ownerId ? 'user' : 'studio',
-            };
-            if (filter.ownerId) {
-                const user = yield this.findUser(filter.ownerId);
-                if (user) {
-                    metrics.subscriptionStatus = user.subscriptionStatus;
-                    metrics.subscriptionId = user.subscriptionId;
-                    metrics.currentPeriodEndMs = user.subscriptionPeriodEndMs;
-                    metrics.currentPeriodStartMs = user.subscriptionPeriodStartMs;
-                }
+        const config = await this.getSubscriptionConfiguration();
+        let currentPeriodStart = null;
+        let currentPeriodEnd = null;
+        if ((_a = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _a === void 0 ? void 0 : _a.defaultPeriodLength) {
+            const now = DateTime.utc();
+            const periodStart = now.minus(config.defaultFeatures.defaultPeriodLength);
+            currentPeriodStart = periodStart.toMillis();
+            currentPeriodEnd = now.toMillis();
+        }
+        let metrics = {
+            ownerId: filter.ownerId,
+            studioId: filter.studioId,
+            subscriptionId: null,
+            subscriptionStatus: null,
+            currentPeriodStartMs: currentPeriodStart,
+            currentPeriodEndMs: currentPeriodEnd,
+            subscriptionType: filter.ownerId ? 'user' : 'studio',
+        };
+        if (filter.ownerId) {
+            const user = await this.findUser(filter.ownerId);
+            if (user) {
+                metrics.subscriptionStatus = user.subscriptionStatus;
+                metrics.subscriptionId = user.subscriptionId;
+                metrics.currentPeriodEndMs = user.subscriptionPeriodEndMs;
+                metrics.currentPeriodStartMs = user.subscriptionPeriodStartMs;
             }
-            else if (filter.studioId) {
-                const studio = yield this.getStudioById(filter.studioId);
-                if (studio) {
-                    metrics.subscriptionId = studio.subscriptionId;
-                    metrics.subscriptionStatus = studio.subscriptionStatus;
-                    metrics.currentPeriodEndMs = studio.subscriptionPeriodEndMs;
-                    metrics.currentPeriodStartMs = studio.subscriptionPeriodStartMs;
-                }
+        }
+        else if (filter.studioId) {
+            const studio = await this.getStudioById(filter.studioId);
+            if (studio) {
+                metrics.subscriptionId = studio.subscriptionId;
+                metrics.subscriptionStatus = studio.subscriptionStatus;
+                metrics.currentPeriodEndMs = studio.subscriptionPeriodEndMs;
+                metrics.currentPeriodStartMs = studio.subscriptionPeriodStartMs;
             }
-            return metrics;
-        });
+        }
+        return metrics;
     }
-    _listRecordsForSubscription(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = yield this.getRecordByName(recordName);
-            if (record.ownerId) {
-                return this.listRecordsByOwnerId(record.ownerId);
-            }
-            else {
-                return this.listRecordsByStudioId(record.studioId);
-            }
-        });
+    async _listRecordsForSubscription(recordName) {
+        const record = await this.getRecordByName(recordName);
+        if (record.ownerId) {
+            return this.listRecordsByOwnerId(record.ownerId);
+        }
+        else {
+            return this.listRecordsByStudioId(record.studioId);
+        }
     }
-    getInstByName(recordName, inst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return null;
-            }
-            const r = this._records.find((r) => r.name === recordName);
-            if (!r) {
-                return null;
-            }
-            const metrics = yield this.getSubscriptionInstMetrics(Object.assign({}, r));
+    async getInstByName(recordName, inst) {
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return null;
+        }
+        const r = this._records.find((r) => r.name === recordName);
+        if (!r) {
+            return null;
+        }
+        const metrics = await this.getSubscriptionInstMetrics({
+            ...r,
+        });
+        return {
+            recordName: i.recordName,
+            inst: i.inst,
+            markers: i.markers,
+            subscriptionId: metrics.subscriptionId,
+            subscriptionStatus: metrics.subscriptionStatus,
+            subscriptionType: !metrics.subscriptionId
+                ? undefined
+                : metrics.ownerId
+                    ? 'user'
+                    : 'studio',
+        };
+    }
+    async listInstsByRecord(recordName, startingInst) {
+        if (!recordName) {
             return {
+                success: true,
+                insts: [],
+                totalCount: 0,
+            };
+        }
+        const record = await this._getInstRecord(recordName);
+        if (!record) {
+            return {
+                success: false,
+                errorCode: 'record_not_found',
+                errorMessage: 'The record was not found.',
+            };
+        }
+        let insts = [...record.values()];
+        if (startingInst) {
+            insts = insts.filter((i) => i.inst > startingInst);
+        }
+        return {
+            success: true,
+            insts: insts.slice(0, 10).map((i) => ({
+                recordName: i.recordName,
+                inst: i.inst,
+                markers: i.markers,
+            })),
+            totalCount: insts.length,
+        };
+    }
+    async getBranchByName(recordName, inst, branch) {
+        let i = await this._getInst(recordName, inst);
+        if (!i) {
+            return null;
+        }
+        const b = i.branches.find((b) => b.branch === branch);
+        if (!b) {
+            return null;
+        }
+        const r = this._records.find((r) => r.name === recordName);
+        if (!r) {
+            return null;
+        }
+        const metrics = await this.getSubscriptionInstMetrics({
+            ...r,
+        });
+        return {
+            recordName: b.recordName,
+            inst: b.inst,
+            branch: b.branch,
+            temporary: b.temporary,
+            linkedInst: {
                 recordName: i.recordName,
                 inst: i.inst,
                 markers: i.markers,
@@ -2106,237 +2053,52 @@ export class MemoryStore {
                     : metrics.ownerId
                         ? 'user'
                         : 'studio',
-            };
-        });
+            },
+        };
     }
-    listInstsByRecord(recordName, startingInst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!recordName) {
-                return {
-                    success: true,
-                    insts: [],
-                    totalCount: 0,
-                };
-            }
-            const record = yield this._getInstRecord(recordName);
-            if (!record) {
-                return {
-                    success: false,
-                    errorCode: 'record_not_found',
-                    errorMessage: 'The record was not found.',
-                };
-            }
-            let insts = [...record.values()];
-            if (startingInst) {
-                insts = insts.filter((i) => i.inst > startingInst);
-            }
-            return {
-                success: true,
-                insts: insts.slice(0, 10).map((i) => ({
-                    recordName: i.recordName,
-                    inst: i.inst,
-                    markers: i.markers,
-                })),
-                totalCount: insts.length,
-            };
-        });
+    async saveLoadedPackage(loadedPackage) {
+        this._loadedPackages.set(loadedPackage.id, { ...loadedPackage });
     }
-    getBranchByName(recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return null;
-            }
-            const b = i.branches.find((b) => b.branch === branch);
-            if (!b) {
-                return null;
-            }
-            const r = this._records.find((r) => r.name === recordName);
-            if (!r) {
-                return null;
+    async listLoadedPackages(recordName, inst) {
+        let loadedPackages = [];
+        for (let [id, loadedPackage] of this._loadedPackages) {
+            if (loadedPackage.recordName === recordName &&
+                loadedPackage.inst === inst) {
+                loadedPackages.push(loadedPackage);
             }
-            const metrics = yield this.getSubscriptionInstMetrics(Object.assign({}, r));
-            return {
-                recordName: b.recordName,
-                inst: b.inst,
-                branch: b.branch,
-                temporary: b.temporary,
-                linkedInst: {
-                    recordName: i.recordName,
-                    inst: i.inst,
-                    markers: i.markers,
-                    subscriptionId: metrics.subscriptionId,
-                    subscriptionStatus: metrics.subscriptionStatus,
-                    subscriptionType: !metrics.subscriptionId
-                        ? undefined
-                        : metrics.ownerId
-                            ? 'user'
-                            : 'studio',
-                },
-            };
-        });
-    }
-    saveInst(inst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const r = yield this._getInstRecord(inst.recordName);
-            if (!r) {
-                return {
-                    success: false,
-                    errorCode: 'record_not_found',
-                    errorMessage: 'The record was not found',
-                };
-            }
-            let i = yield this._getInst(inst.recordName, inst.inst);
-            const { branches } = inst, rest = __rest(inst, ["branches"]);
-            let update = Object.assign(Object.assign({ branches: null }, (i !== null && i !== void 0 ? i : {
-                instSizeInBytes: 0,
-            })), rest);
-            if (branches) {
-                update.branches = branches.map((b) => {
-                    return {
-                        recordName: inst.recordName,
-                        inst: inst.inst,
-                        branch: b.branch,
-                        temporary: b.temporary,
-                        updates: {
-                            updates: [],
-                            timestamps: [],
-                        },
-                        archived: {
-                            updates: [],
-                            timestamps: [],
-                        },
-                    };
-                });
-            }
-            else if (!update.branches) {
-                update.branches = [];
-            }
-            r.set(inst.inst, update);
-            return {
-                success: true,
-            };
-        });
-    }
-    deleteInst(recordName, inst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const r = yield this._getInstRecord(recordName);
-            if (!r) {
-                return;
-            }
-            r.delete(inst);
-        });
-    }
-    saveBranch(branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let i = yield this._getInst(branch.recordName, branch.inst);
-            if (!i) {
-                return {
-                    success: false,
-                    errorCode: 'inst_not_found',
-                    errorMessage: 'The inst was not found.',
-                };
-            }
-            const b = i.branches.find((b) => b.branch === branch.branch);
-            if (!b) {
-                i.branches.push(Object.assign(Object.assign({}, branch), { updates: {
-                        updates: [],
-                        timestamps: [],
-                    }, archived: {
-                        updates: [],
-                        timestamps: [],
-                    } }));
-                return {
-                    success: true,
-                };
-            }
-            b.temporary = branch.temporary;
-            return {
-                success: true,
-            };
-        });
+        }
+        return loadedPackages;
     }
-    getAllUpdates(recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return null;
-            }
-            const b = i.branches.find((b) => b.branch === branch);
-            if (!b) {
-                return null;
-            }
-            return {
-                updates: b.archived.updates.slice(),
-                timestamps: b.archived.timestamps.slice(),
-                instSizeInBytes: i.instSizeInBytes,
-            };
-        });
+    async isPackageLoaded(recordName, inst, packageId) {
+        var _a;
+        const loaded = await this.listLoadedPackages(recordName, inst);
+        return (_a = loaded.find((p) => p.packageId === packageId)) !== null && _a !== void 0 ? _a : null;
     }
-    getCurrentUpdates(recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return null;
-            }
-            const b = i.branches.find((b) => b.branch === branch);
-            if (!b) {
-                return null;
-            }
+    async saveInst(inst) {
+        const r = await this._getInstRecord(inst.recordName);
+        if (!r) {
             return {
-                updates: b.updates.updates.slice(),
-                timestamps: b.updates.timestamps.slice(),
-                instSizeInBytes: i.instSizeInBytes,
+                success: false,
+                errorCode: 'record_not_found',
+                errorMessage: 'The record was not found',
             };
-        });
-    }
-    getInstSize(recordName, inst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return null;
-            }
-            return i.instSizeInBytes;
-        });
-    }
-    countUpdates(recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return 0;
-            }
-            const b = i.branches.find((b) => b.branch === branch);
-            if (!b) {
-                return 0;
-            }
-            return b.updates.updates.length;
-        });
-    }
-    addUpdates(recordName, inst, branch, updates, sizeInBytes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const r = this._instRecords.get(recordName);
-            if (!r) {
-                return {
-                    success: false,
-                    errorCode: 'record_not_found',
-                    branch,
-                };
-            }
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
+        }
+        let i = await this._getInst(inst.recordName, inst.inst);
+        const { branches, ...rest } = inst;
+        let update = {
+            branches: null,
+            ...(i !== null && i !== void 0 ? i : {
+                instSizeInBytes: 0,
+            }),
+            ...rest,
+        };
+        if (branches) {
+            update.branches = branches.map((b) => {
                 return {
-                    success: false,
-                    errorCode: 'inst_not_found',
-                    branch,
-                };
-            }
-            let b = i.branches.find((b) => b.branch === branch);
-            if (!b) {
-                b = {
-                    branch,
-                    inst: i.inst,
-                    recordName: i.recordName,
-                    temporary: false,
+                    recordName: inst.recordName,
+                    inst: inst.inst,
+                    branch: b.branch,
+                    temporary: b.temporary,
                     updates: {
                         updates: [],
                         timestamps: [],
@@ -2346,114 +2108,234 @@ export class MemoryStore {
                         timestamps: [],
                     },
                 };
-                i.branches.push(b);
-            }
-            let storedUpdates = b.updates;
-            const newSize = i.instSizeInBytes + sizeInBytes;
-            if (newSize > this.maxAllowedInstSize) {
-                return {
-                    success: false,
-                    errorCode: 'max_size_reached',
-                    branch,
-                    maxInstSizeInBytes: this.maxAllowedInstSize,
-                    neededInstSizeInBytes: newSize,
-                };
-            }
-            i.instSizeInBytes = newSize;
-            storedUpdates.updates.push(...updates);
-            storedUpdates.timestamps.push(Date.now());
-            const archivedUpdates = b.archived;
-            archivedUpdates.updates.push(...updates);
-            archivedUpdates.timestamps.push(Date.now());
+            });
+        }
+        else if (!update.branches) {
+            update.branches = [];
+        }
+        r.set(inst.inst, update);
+        return {
+            success: true,
+        };
+    }
+    async deleteInst(recordName, inst) {
+        const r = await this._getInstRecord(recordName);
+        if (!r) {
+            return;
+        }
+        r.delete(inst);
+    }
+    async saveBranch(branch) {
+        let i = await this._getInst(branch.recordName, branch.inst);
+        if (!i) {
+            return {
+                success: false,
+                errorCode: 'inst_not_found',
+                errorMessage: 'The inst was not found.',
+            };
+        }
+        const b = i.branches.find((b) => b.branch === branch.branch);
+        if (!b) {
+            i.branches.push({
+                ...branch,
+                updates: {
+                    updates: [],
+                    timestamps: [],
+                },
+                archived: {
+                    updates: [],
+                    timestamps: [],
+                },
+            });
             return {
                 success: true,
             };
-        });
+        }
+        b.temporary = branch.temporary;
+        return {
+            success: true,
+        };
+    }
+    async getAllUpdates(recordName, inst, branch) {
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return null;
+        }
+        const b = i.branches.find((b) => b.branch === branch);
+        if (!b) {
+            return null;
+        }
+        return {
+            updates: b.archived.updates.slice(),
+            timestamps: b.archived.timestamps.slice(),
+            instSizeInBytes: i.instSizeInBytes,
+        };
+    }
+    async getCurrentUpdates(recordName, inst, branch) {
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return null;
+        }
+        const b = i.branches.find((b) => b.branch === branch);
+        if (!b) {
+            return null;
+        }
+        return {
+            updates: b.updates.updates.slice(),
+            timestamps: b.updates.timestamps.slice(),
+            instSizeInBytes: i.instSizeInBytes,
+        };
+    }
+    async getInstSize(recordName, inst) {
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return null;
+        }
+        return i.instSizeInBytes;
     }
-    replaceCurrentUpdates(recordName, inst, branch, updateToAdd, sizeInBytes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const r = this._instRecords.get(recordName);
-            if (!r) {
-                return {
-                    success: false,
-                    errorCode: 'record_not_found',
-                    branch,
-                };
-            }
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return {
-                    success: false,
-                    errorCode: 'inst_not_found',
-                    branch,
-                };
-            }
-            let b = i.branches.find((b) => b.branch === branch);
-            if (!b) {
-                b = {
-                    branch,
-                    inst: i.inst,
-                    recordName: i.recordName,
-                    temporary: false,
-                    updates: {
-                        updates: [],
-                        timestamps: [],
-                    },
-                    archived: {
-                        updates: [],
-                        timestamps: [],
-                    },
-                };
-                i.branches.push(b);
-            }
-            const storedUpdates = b.updates;
-            storedUpdates.updates = [];
-            storedUpdates.timestamps = [];
-            return this.addUpdates(recordName, inst, branch, [updateToAdd], sizeInBytes);
-        });
+    async countUpdates(recordName, inst, branch) {
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return 0;
+        }
+        const b = i.branches.find((b) => b.branch === branch);
+        if (!b) {
+            return 0;
+        }
+        return b.updates.updates.length;
     }
-    deleteBranch(recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const r = this._instRecords.get(recordName);
-            if (!r) {
-                return;
-            }
-            const i = yield this._getInst(recordName, inst);
-            if (!i) {
-                return;
-            }
-            const index = i.branches.findIndex((b) => b.branch === branch);
-            if (index >= 0) {
-                const b = i.branches[index];
-                for (let update of b.updates.updates) {
-                    i.instSizeInBytes -= update.length;
-                }
-                i.branches.splice(index, 1);
+    async addUpdates(recordName, inst, branch, updates, sizeInBytes) {
+        const r = this._instRecords.get(recordName);
+        if (!r) {
+            return {
+                success: false,
+                errorCode: 'record_not_found',
+                branch,
+            };
+        }
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return {
+                success: false,
+                errorCode: 'inst_not_found',
+                branch,
+            };
+        }
+        let b = i.branches.find((b) => b.branch === branch);
+        if (!b) {
+            b = {
+                branch,
+                inst: i.inst,
+                recordName: i.recordName,
+                temporary: false,
+                updates: {
+                    updates: [],
+                    timestamps: [],
+                },
+                archived: {
+                    updates: [],
+                    timestamps: [],
+                },
+            };
+            i.branches.push(b);
+        }
+        let storedUpdates = b.updates;
+        const newSize = i.instSizeInBytes + sizeInBytes;
+        if (newSize > this.maxAllowedInstSize) {
+            return {
+                success: false,
+                errorCode: 'max_size_reached',
+                branch,
+                maxInstSizeInBytes: this.maxAllowedInstSize,
+                neededInstSizeInBytes: newSize,
+            };
+        }
+        i.instSizeInBytes = newSize;
+        storedUpdates.updates.push(...updates);
+        storedUpdates.timestamps.push(Date.now());
+        const archivedUpdates = b.archived;
+        archivedUpdates.updates.push(...updates);
+        archivedUpdates.timestamps.push(Date.now());
+        return {
+            success: true,
+        };
+    }
+    async replaceCurrentUpdates(recordName, inst, branch, updateToAdd, sizeInBytes) {
+        const r = this._instRecords.get(recordName);
+        if (!r) {
+            return {
+                success: false,
+                errorCode: 'record_not_found',
+                branch,
+            };
+        }
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return {
+                success: false,
+                errorCode: 'inst_not_found',
+                branch,
+            };
+        }
+        let b = i.branches.find((b) => b.branch === branch);
+        if (!b) {
+            b = {
+                branch,
+                inst: i.inst,
+                recordName: i.recordName,
+                temporary: false,
+                updates: {
+                    updates: [],
+                    timestamps: [],
+                },
+                archived: {
+                    updates: [],
+                    timestamps: [],
+                },
+            };
+            i.branches.push(b);
+        }
+        const storedUpdates = b.updates;
+        storedUpdates.updates = [];
+        storedUpdates.timestamps = [];
+        return this.addUpdates(recordName, inst, branch, [updateToAdd], sizeInBytes);
+    }
+    async deleteBranch(recordName, inst, branch) {
+        const r = this._instRecords.get(recordName);
+        if (!r) {
+            return;
+        }
+        const i = await this._getInst(recordName, inst);
+        if (!i) {
+            return;
+        }
+        const index = i.branches.findIndex((b) => b.branch === branch);
+        if (index >= 0) {
+            const b = i.branches[index];
+            for (let update of b.updates.updates) {
+                i.instSizeInBytes -= update.length;
             }
-        });
+            i.branches.splice(index, 1);
+        }
     }
     // reset() {
     //     this._instRecords = new Map();
     //     this.maxAllowedInstSize = Infinity;
     // }
-    _getInst(recordName, inst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = yield this._getInstRecord(recordName);
-            return record === null || record === void 0 ? void 0 : record.get(inst);
-        });
+    async _getInst(recordName, inst) {
+        let record = await this._getInstRecord(recordName);
+        return record === null || record === void 0 ? void 0 : record.get(inst);
     }
-    _getInstRecord(recordName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let record = this._instRecords.get(recordName);
-            if (!record) {
-                const r = yield this.getRecordByName(recordName);
-                if (r) {
-                    record = new Map();
-                    this._instRecords.set(recordName, record);
-                }
+    async _getInstRecord(recordName) {
+        let record = this._instRecords.get(recordName);
+        if (!record) {
+            const r = await this.getRecordByName(recordName);
+            if (r) {
+                record = new Map();
+                this._instRecords.set(recordName, record);
             }
-            return record;
-        });
+        }
+        return record;
     }
 }
 //# sourceMappingURL=MemoryStore.js.map