@casual-simulation/aux-records 3.4.6-alpha.14668890889 → 3.5.0-alpha.15119114602

package/RecordsServer.js

@@ -1,42 +1,3 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 /* 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.
@@ -54,12 +15,19 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { tryDecodeUriComponent, tryParseJson } from './Utils';
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { tryDecodeUriComponent } from './Utils';
 import { INVALID_REQUEST_ERROR_MESSAGE, MAX_EMAIL_ADDRESS_LENGTH, MAX_SMS_ADDRESS_LENGTH, PRIVO_OPEN_ID_PROVIDER, validateSessionKey, } from './AuthController';
-import { isSuperUserRole, parseSessionKey } from './AuthUtils';
+import { isSuperUserRole, parseSessionKey, } from '@casual-simulation/aux-common';
 import { z } from 'zod';
 import { HUME_CONFIG, LOOM_CONFIG } from './RecordsStore';
-import { AVAILABLE_PERMISSIONS_VALIDATION, PRIVATE_MARKER, RESOURCE_KIND_VALIDATION, getProcedureMetadata, procedure, } from '@casual-simulation/aux-common';
+import { tryParseJson } from '@casual-simulation/aux-common';
+import { AVAILABLE_PERMISSIONS_VALIDATION, ENTITLEMENT_FEATURE_VALIDATION, ENTITLEMENT_VALIDATION, PRIVATE_MARKER, RESOURCE_KIND_VALIDATION, getProcedureMetadata, procedure, } from '@casual-simulation/aux-common';
 import { AI_CHAT_MESSAGE_SCHEMA } from './AIChatInterface';
 import { WebsocketEventTypes, websocketEventSchema, websocketRequestMessageSchema, } from '@casual-simulation/aux-common/websockets/WebsocketEvents';
 import { DEFAULT_BRANCH_NAME } from '@casual-simulation/aux-common';
@@ -72,6 +40,7 @@ import { ADDRESS_VALIDATION, COM_ID_VALIDATION, DISPLAY_NAME_VALIDATION, ERASE_D
 import { eraseItemProcedure, getItemProcedure, listItemsProcedure, recordItemProcedure, } from './crud/CrudHelpers';
 import { merge, omit } from 'lodash';
 import { PUSH_NOTIFICATION_PAYLOAD, PUSH_SUBSCRIPTION_SCHEMA, } from './notifications';
+import { getPackageVersionSpecifier } from './packages/version/PackageVersionRecordsStore';
 export const NOT_LOGGED_IN_RESULT = {
     success: false,
     errorCode: 'not_logged_in',
@@ -150,7 +119,7 @@ export class RecordsServer {
     get procedures() {
         return this._procedures;
     }
-    constructor({ allowedAccountOrigins, allowedApiOrigins, authController, livekitController, recordsController, eventsController, dataController, manualDataController, filesController, subscriptionController, websocketController, websocketRateLimitController, rateLimitController, policyController, aiController, moderationController, loomController, webhooksController, notificationsController, }) {
+    constructor({ allowedAccountOrigins, allowedApiOrigins, authController, livekitController, recordsController, eventsController, dataController, manualDataController, filesController, subscriptionController, websocketController, websocketRateLimitController, rateLimitController, policyController, aiController, moderationController, loomController, webhooksController, notificationsController, packagesController, packageVersionController, }) {
         /**
          * The map of paths to routes that they match.
          */
@@ -175,6 +144,8 @@ export class RecordsServer {
         this._loomController = loomController;
         this._webhooksController = webhooksController;
         this._notificationsController = notificationsController;
+        this._packagesController = packagesController;
+        this._packageVersionController = packageVersionController;
         this._tracer = trace.getTracer('RecordsServer', typeof GIT_TAG === 'undefined' ? undefined : GIT_TAG);
         this._procedures = this._createProcedures();
         this._setupRoutes();
@@ -186,12 +157,12 @@ export class RecordsServer {
                 .inputs(z.object({
                 userId: z.string(),
             }))
-                .handler(({ userId }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ userId }, context) => {
                 const authorization = context.sessionKey;
                 if (!authorization) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const result = yield this._auth.getUserInfo({
+                const result = await this._auth.getUserInfo({
                     userId,
                     sessionKey: authorization,
                 });
@@ -211,14 +182,14 @@ export class RecordsServer {
                     displayName: result.displayName,
                     role: result.role,
                 };
-            })),
+            }),
             isEmailValid: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/email/valid')
                 .inputs(z.object({ email: z.string() }))
-                .handler(({ email }) => __awaiter(this, void 0, void 0, function* () {
-                return yield this._auth.isValidEmailAddress(email);
-            })),
+                .handler(async ({ email }) => {
+                return await this._auth.isValidEmailAddress(email);
+            }),
             isDisplayNameValid: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/displayName/valid')
@@ -226,27 +197,27 @@ export class RecordsServer {
                 displayName: z.string(),
                 name: NAME_VALIDATION.optional(),
             }))
-                .handler(({ displayName, name }) => __awaiter(this, void 0, void 0, function* () {
-                return yield this._auth.isValidDisplayName(displayName, name);
-            })),
+                .handler(async ({ displayName, name }) => {
+                return await this._auth.isValidDisplayName(displayName, name);
+            }),
             createAccount: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/createAccount')
                 .inputs(z.object({}))
-                .handler((_, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async (_, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._auth.createAccount({
+                const result = await this._auth.createAccount({
                     userRole: validation.role,
                     ipAddress: context.ipAddress,
                 });
                 return result;
-            })),
+            }),
             listSessions: procedure()
                 .origins('account')
                 .http('GET', '/api/v2/sessions')
@@ -256,7 +227,7 @@ export class RecordsServer {
                 userId: z.string().optional(),
             })
                 .default({}))
-                .handler(({ expireTimeMs, userId }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ expireTimeMs, userId }, context) => {
                 const sessionKey = context.sessionKey;
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
@@ -266,44 +237,44 @@ export class RecordsServer {
                     return UNACCEPTABLE_SESSION_KEY;
                 }
                 const [sessionKeyUserId] = parsed;
-                const result = yield this._auth.listSessions({
+                const result = await this._auth.listSessions({
                     userId: userId !== null && userId !== void 0 ? userId : sessionKeyUserId,
                     sessionKey,
                     expireTimeMs,
                 });
                 return result;
-            })),
+            }),
             replaceSession: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/replaceSession')
-                .handler((_, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async (_, context) => {
                 const sessionKey = context.sessionKey;
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const result = yield this._auth.replaceSession({
+                const result = await this._auth.replaceSession({
                     sessionKey: sessionKey,
                     ipAddress: context.ipAddress,
                 });
                 return result;
-            })),
+            }),
             revokeAllSessions: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/revokeAllSessions')
                 .inputs(z.object({
                 userId: z.string(),
             }))
-                .handler(({ userId }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ userId }, context) => {
                 const authorization = context.sessionKey;
                 if (!authorization) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const result = yield this._auth.revokeAllSessions({
+                const result = await this._auth.revokeAllSessions({
                     userId: userId,
                     sessionKey: authorization,
                 });
                 return result;
-            })),
+            }),
             revokeSession: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/revokeSession')
@@ -312,7 +283,7 @@ export class RecordsServer {
                 sessionId: z.string().optional(),
                 sessionKey: z.string().optional(),
             }))
-                .handler(({ userId, sessionId, sessionKey: sessionKeyToRevoke }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ userId, sessionId, sessionKey: sessionKeyToRevoke }, context) => {
                 // Parse the User ID and Session ID from the sessionKey that is provided in
                 // session key that should be revoked
                 if (!!sessionKeyToRevoke) {
@@ -326,13 +297,13 @@ export class RecordsServer {
                 if (!authorization) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const result = yield this._auth.revokeSession({
+                const result = await this._auth.revokeSession({
                     userId,
                     sessionId,
                     sessionKey: authorization,
                 });
                 return result;
-            })),
+            }),
             completeLogin: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/completeLogin')
@@ -341,15 +312,15 @@ export class RecordsServer {
                 requestId: z.string(),
                 code: z.string(),
             }))
-                .handler(({ userId, requestId, code }, context) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._auth.completeLogin({
+                .handler(async ({ userId, requestId, code }, context) => {
+                const result = await this._auth.completeLogin({
                     userId,
                     requestId,
                     code,
                     ipAddress: context.ipAddress,
                 });
                 return result;
-            })),
+            }),
             requestLogin: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/login')
@@ -357,25 +328,25 @@ export class RecordsServer {
                 address: z.string(),
                 addressType: z.enum(['email', 'phone']),
             }))
-                .handler(({ address, addressType }, context) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._auth.requestLogin({
+                .handler(async ({ address, addressType }, context) => {
+                const result = await this._auth.requestLogin({
                     address,
                     addressType,
                     ipAddress: context.ipAddress,
                 });
                 return result;
-            })),
+            }),
             requestPrivoLogin: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/login/privo')
                 .inputs(z.object({}))
-                .handler((_, context) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._auth.requestOpenIDLogin({
+                .handler(async (_, context) => {
+                const result = await this._auth.requestOpenIDLogin({
                     provider: PRIVO_OPEN_ID_PROVIDER,
                     ipAddress: context.ipAddress,
                 });
                 return result;
-            })),
+            }),
             processOAuthCode: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/oauth/code')
@@ -383,27 +354,27 @@ export class RecordsServer {
                 code: z.string().nonempty(),
                 state: z.string().nonempty(),
             }))
-                .handler(({ code, state }, context) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._auth.processOpenIDAuthorizationCode({
+                .handler(async ({ code, state }, context) => {
+                const result = await this._auth.processOpenIDAuthorizationCode({
                     ipAddress: context.ipAddress,
                     authorizationCode: code,
                     state,
                 });
                 return result;
-            })),
+            }),
             completeOAuthLogin: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/oauth/complete')
                 .inputs(z.object({
                 requestId: z.string().nonempty(),
             }))
-                .handler(({ requestId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._auth.completeOpenIDLogin({
+                .handler(async ({ requestId }, context) => {
+                const result = await this._auth.completeOpenIDLogin({
                     ipAddress: context.ipAddress,
                     requestId,
                 });
                 return result;
-            })),
+            }),
             requestPrivoSignUp: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/register/privo')
@@ -414,8 +385,8 @@ export class RecordsServer {
                 dateOfBirth: z.coerce.date(),
                 displayName: DISPLAY_NAME_VALIDATION,
             }))
-                .handler(({ email, parentEmail, name, dateOfBirth, displayName }, context) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._auth.requestPrivoSignUp({
+                .handler(async ({ email, parentEmail, name, dateOfBirth, displayName }, context) => {
+                const result = await this._auth.requestPrivoSignUp({
                     email,
                     parentEmail,
                     name,
@@ -424,44 +395,44 @@ export class RecordsServer {
                     ipAddress: context.ipAddress,
                 });
                 return result;
-            })),
+            }),
             requestPrivacyFeaturesChange: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/privacyFeatures/change')
                 .inputs(z.object({
                 userId: z.string(),
             }))
-                .handler(({ userId }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ userId }, context) => {
                 const sessionKey = context.sessionKey;
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const result = yield this._auth.requestPrivacyFeaturesChange({
+                const result = await this._auth.requestPrivacyFeaturesChange({
                     userId,
                     sessionKey,
                 });
                 return result;
-            })),
+            }),
             getWebAuthnRegistrationOptions: procedure()
                 .origins(true)
                 .http('GET', '/api/v2/webauthn/register/options')
-                .handler((_, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async (_, context) => {
                 var _a, _b, _c, _d, _e, _f;
                 // We don't validate origin because the AuthController will validate it based on the allowed
                 // relying parties.
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._auth.requestWebAuthnRegistration({
+                const result = await this._auth.requestWebAuthnRegistration({
                     userId: validation.userId,
                     originOrHost: (_e = (_c = (_a = context.origin) !== null && _a !== void 0 ? _a : (_b = context.httpRequest) === null || _b === void 0 ? void 0 : _b.headers.origin) !== null && _c !== void 0 ? _c : (_d = context.httpRequest) === null || _d === void 0 ? void 0 : _d.headers['x-dev-proxy-host']) !== null && _e !== void 0 ? _e : (_f = context.httpRequest) === null || _f === void 0 ? void 0 : _f.headers.host,
                 });
                 return result;
-            })),
+            }),
             registerWebAuthn: procedure()
                 .origins(true)
                 .http('POST', '/api/v2/webauthn/register')
@@ -497,38 +468,38 @@ export class RecordsServer {
                     type: z.literal('public-key'),
                 }),
             }))
-                .handler(({ response }, context) => __awaiter(this, void 0, void 0, function* () {
-                var _g, _h, _j, _k, _l, _m, _o;
+                .handler(async ({ response }, context) => {
+                var _a, _b, _c, _d, _e, _f, _g;
                 // We don't validate origin because the AuthController will validate it based on the allowed
                 // relying parties.
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._auth.completeWebAuthnRegistration({
+                const result = await this._auth.completeWebAuthnRegistration({
                     userId: validation.userId,
                     response: response,
-                    originOrHost: (_l = (_j = (_g = context.origin) !== null && _g !== void 0 ? _g : (_h = context.httpRequest) === null || _h === void 0 ? void 0 : _h.headers.origin) !== null && _j !== void 0 ? _j : (_k = context.httpRequest) === null || _k === void 0 ? void 0 : _k.headers['x-dev-proxy-host']) !== null && _l !== void 0 ? _l : (_m = context.httpRequest) === null || _m === void 0 ? void 0 : _m.headers.host,
-                    userAgent: (_o = context.httpRequest) === null || _o === void 0 ? void 0 : _o.headers['user-agent'],
+                    originOrHost: (_e = (_c = (_a = context.origin) !== null && _a !== void 0 ? _a : (_b = context.httpRequest) === null || _b === void 0 ? void 0 : _b.headers.origin) !== null && _c !== void 0 ? _c : (_d = context.httpRequest) === null || _d === void 0 ? void 0 : _d.headers['x-dev-proxy-host']) !== null && _e !== void 0 ? _e : (_f = context.httpRequest) === null || _f === void 0 ? void 0 : _f.headers.host,
+                    userAgent: (_g = context.httpRequest) === null || _g === void 0 ? void 0 : _g.headers['user-agent'],
                 });
                 return result;
-            })),
+            }),
             getWebAuthnLoginOptions: procedure()
                 .origins(true)
                 .http('GET', '/api/v2/webauthn/login/options')
-                .handler((_, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async (_, context) => {
                 // We don't validate origin because the AuthController will validate it based on the allowed
                 // relying parties.
-                var _p, _q, _r, _s, _t, _u;
-                const result = yield this._auth.requestWebAuthnLogin({
+                var _a, _b, _c, _d, _e, _f;
+                const result = await this._auth.requestWebAuthnLogin({
                     ipAddress: context.ipAddress,
-                    originOrHost: (_t = (_r = (_p = context.origin) !== null && _p !== void 0 ? _p : (_q = context.httpRequest) === null || _q === void 0 ? void 0 : _q.headers.origin) !== null && _r !== void 0 ? _r : (_s = context.httpRequest) === null || _s === void 0 ? void 0 : _s.headers['x-dev-proxy-host']) !== null && _t !== void 0 ? _t : (_u = context.httpRequest) === null || _u === void 0 ? void 0 : _u.headers.host,
+                    originOrHost: (_e = (_c = (_a = context.origin) !== null && _a !== void 0 ? _a : (_b = context.httpRequest) === null || _b === void 0 ? void 0 : _b.headers.origin) !== null && _c !== void 0 ? _c : (_d = context.httpRequest) === null || _d === void 0 ? void 0 : _d.headers['x-dev-proxy-host']) !== null && _e !== void 0 ? _e : (_f = context.httpRequest) === null || _f === void 0 ? void 0 : _f.headers.host,
                 });
                 return result;
-            })),
+            }),
             completeWebAuthnLogin: procedure()
                 .origins(true)
                 .http('POST', '/api/v2/webauthn/login')
@@ -558,49 +529,49 @@ export class RecordsServer {
                     type: z.literal('public-key'),
                 }),
             }))
-                .handler(({ response, requestId }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ response, requestId }, context) => {
                 // We don't validate origin because the AuthController will validate it based on the allowed
                 // relying parties.
-                var _v, _w, _x, _y, _z, _0;
-                const result = yield this._auth.completeWebAuthnLogin({
+                var _a, _b, _c, _d, _e, _f;
+                const result = await this._auth.completeWebAuthnLogin({
                     requestId: requestId,
                     ipAddress: context.ipAddress,
                     response: response,
-                    originOrHost: (_z = (_x = (_v = context.origin) !== null && _v !== void 0 ? _v : (_w = context.httpRequest) === null || _w === void 0 ? void 0 : _w.headers.origin) !== null && _x !== void 0 ? _x : (_y = context.httpRequest) === null || _y === void 0 ? void 0 : _y.headers['x-dev-proxy-host']) !== null && _z !== void 0 ? _z : (_0 = context.httpRequest) === null || _0 === void 0 ? void 0 : _0.headers.host,
+                    originOrHost: (_e = (_c = (_a = context.origin) !== null && _a !== void 0 ? _a : (_b = context.httpRequest) === null || _b === void 0 ? void 0 : _b.headers.origin) !== null && _c !== void 0 ? _c : (_d = context.httpRequest) === null || _d === void 0 ? void 0 : _d.headers['x-dev-proxy-host']) !== null && _e !== void 0 ? _e : (_f = context.httpRequest) === null || _f === void 0 ? void 0 : _f.headers.host,
                 });
                 return result;
-            })),
+            }),
             listUserAuthenticators: procedure()
                 .origins('account')
                 .http('GET', '/api/v2/webauthn/authenticators')
-                .handler((_, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async (_, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._auth.listUserAuthenticators(validation.userId);
+                const result = await this._auth.listUserAuthenticators(validation.userId);
                 return result;
-            })),
+            }),
             deleteUserAuthenticator: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/webauthn/authenticators/delete')
                 .inputs(z.object({
                 authenticatorId: z.string().nonempty(),
             }))
-                .handler(({ authenticatorId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ authenticatorId }, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._auth.deleteUserAuthenticator(validation.userId, authenticatorId);
+                const result = await this._auth.deleteUserAuthenticator(validation.userId, authenticatorId);
                 return result;
-            })),
+            }),
             createMeetToken: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/meet/token')
@@ -608,10 +579,10 @@ export class RecordsServer {
                 roomName: z.string(),
                 userName: z.string(),
             }))
-                .handler(({ roomName, userName }) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._livekit.issueToken(roomName, userName);
+                .handler(async ({ roomName, userName }) => {
+                const result = await this._livekit.issueToken(roomName, userName);
                 return result;
-            })),
+            }),
             createRecord: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/records')
@@ -632,7 +603,7 @@ export class RecordsServer {
                     .nonempty('studioId must not be empty.')
                     .optional(),
             }))
-                .handler(({ recordName, ownerId, studioId }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, ownerId, studioId }, context) => {
                 if (!recordName || typeof recordName !== 'string') {
                     return {
                         success: false,
@@ -640,21 +611,21 @@ export class RecordsServer {
                         errorMessage: 'recordName is required and must be a string.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._records.createRecord({
+                const result = await this._records.createRecord({
                     recordName,
                     ownerId,
                     studioId,
                     userId: validation.userId,
                 });
                 return result;
-            })),
+            }),
             addEventCount: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/events/count')
@@ -667,16 +638,16 @@ export class RecordsServer {
                 }),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordKey, eventName, count, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordKey, eventName, count, instances }, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false &&
                     validation.errorCode !== 'no_session_key') {
                     return validation;
                 }
                 const userId = validation.userId;
-                const result = yield this._events.addCount(recordKey, eventName, count, userId, instances);
+                const result = await this._events.addCount(recordKey, eventName, count, userId, instances);
                 return result;
-            })),
+            }),
             getEventCount: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/events/count')
@@ -690,16 +661,16 @@ export class RecordsServer {
                     .nonempty('eventName must not be empty'),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, eventName, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, eventName, instances }, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false &&
                     validation.errorCode !== 'no_session_key') {
                     return validation;
                 }
                 const userId = validation.userId;
-                const result = yield this._events.getCount(recordName, eventName, userId, instances);
+                const result = await this._events.getCount(recordName, eventName, userId, instances);
                 return result;
-            })),
+            }),
             listEvents: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/events/list')
@@ -714,16 +685,16 @@ export class RecordsServer {
                     .optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, eventName, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, eventName, instances }, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false &&
                     validation.errorCode !== 'no_session_key') {
                     return validation;
                 }
                 const userId = validation.userId;
-                const result = yield this._events.listEvents(recordName, eventName, userId, instances);
+                const result = await this._events.listEvents(recordName, eventName, userId, instances);
                 return result;
-            })),
+            }),
             updateEvent: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/events')
@@ -734,14 +705,14 @@ export class RecordsServer {
                 markers: MARKERS_VALIDATION.optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordKey, eventName, count, markers, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordKey, eventName, count, markers, instances }, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false &&
                     validation.errorCode !== 'no_session_key') {
                     return validation;
                 }
                 const userId = validation.userId;
-                const result = yield this._events.updateEvent({
+                const result = await this._events.updateEvent({
                     recordKeyOrRecordName: recordKey,
                     userId,
                     eventName,
@@ -750,7 +721,7 @@ export class RecordsServer {
                     instances,
                 });
                 return result;
-            })),
+            }),
             deleteManualData: procedure()
                 .origins('api')
                 .http('DELETE', '/api/v2/records/manual/data')
@@ -759,42 +730,42 @@ export class RecordsServer {
                 address: ADDRESS_VALIDATION,
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._baseEraseRecordData(this._manualData, data, context); })),
+                .handler(async (data, context) => this._baseEraseRecordData(this._manualData, data, context)),
             getManualData: procedure()
                 .origins(true)
                 .http('GET', '/api/v2/records/manual/data')
                 .inputs(GET_DATA_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._baseGetRecordData(this._manualData, data, context); })),
+                .handler(async (data, context) => this._baseGetRecordData(this._manualData, data, context)),
             recordManualData: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/manual/data')
                 .inputs(RECORD_DATA_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._baseRecordData(this._manualData, data, context); })),
+                .handler(async (data, context) => this._baseRecordData(this._manualData, data, context)),
             getFile: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/file')
                 .inputs(READ_FILE_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._readFile(data, context); })),
+                .handler(async (data, context) => this._readFile(data, context)),
             listFiles: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/file/list')
                 .inputs(LIST_FILES_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._listFiles(data, context); })),
+                .handler(async (data, context) => this._listFiles(data, context)),
             eraseFile: procedure()
                 .origins('api')
                 .http('DELETE', '/api/v2/records/file')
                 .inputs(ERASE_FILE_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._eraseFile(data, context); })),
+                .handler(async (data, context) => this._eraseFile(data, context)),
             recordFile: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/file')
                 .inputs(RECORD_FILE_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._recordFile(data, context); })),
+                .handler(async (data, context) => this._recordFile(data, context)),
             updateFile: procedure()
                 .origins('api')
                 .http('PUT', '/api/v2/records/file')
                 .inputs(UPDATE_FILE_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._updateFile(data, context); })),
+                .handler(async (data, context) => this._updateFile(data, context)),
             scanFileForModeration: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/records/file/scan')
@@ -802,8 +773,8 @@ export class RecordsServer {
                 recordName: RECORD_NAME_VALIDATION,
                 fileName: z.string().min(1),
             }))
-                .handler(({ recordName, fileName }, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, fileName }, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
@@ -817,18 +788,18 @@ export class RecordsServer {
                         errorMessage: 'You are not authorized to perform this action.',
                     };
                 }
-                const result = yield this._moderationController.scanFile({
+                const result = await this._moderationController.scanFile({
                     recordName,
                     fileName,
                 });
                 return result;
-            })),
+            }),
             scheduleModerationScans: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/moderation/schedule/scan')
                 .inputs(z.object({}))
-                .handler((input, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async (input, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
@@ -842,19 +813,19 @@ export class RecordsServer {
                         errorMessage: 'You are not authorized to perform this action.',
                     };
                 }
-                const result = yield this._moderationController.scheduleModerationScans();
+                const result = await this._moderationController.scheduleModerationScans();
                 return result;
-            })),
+            }),
             eraseData: procedure()
                 .origins('api')
                 .http('DELETE', '/api/v2/records/data')
                 .inputs(ERASE_DATA_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._baseEraseRecordData(this._data, data, context); })),
+                .handler(async (data, context) => this._baseEraseRecordData(this._data, data, context)),
             getData: procedure()
                 .origins(true)
                 .http('GET', '/api/v2/records/data')
                 .inputs(GET_DATA_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._baseGetRecordData(this._data, data, context); })),
+                .handler(async (data, context) => this._baseGetRecordData(this._data, data, context)),
             listData: procedure()
                 .origins(true)
                 .http('GET', '/api/v2/records/data/list')
@@ -865,7 +836,7 @@ export class RecordsServer {
                 sort: z.enum(['ascending', 'descending']).optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, address, instances, marker, sort }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, address, instances, marker, sort }, context) => {
                 if (!recordName || typeof recordName !== 'string') {
                     return {
                         success: false,
@@ -882,17 +853,17 @@ export class RecordsServer {
                         errorMessage: 'address must be null or a string.',
                     };
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false &&
                     sessionKeyValidation.errorCode !== 'no_session_key') {
                     return sessionKeyValidation;
                 }
                 if (!marker) {
-                    const result = yield this._data.listData(recordName, address || null, sessionKeyValidation.userId, instances);
+                    const result = await this._data.listData(recordName, address || null, sessionKeyValidation.userId, instances);
                     return result;
                 }
                 else {
-                    const result = yield this._data.listDataByMarker({
+                    const result = await this._data.listDataByMarker({
                         recordKeyOrName: recordName,
                         marker: marker,
                         startingAddress: address,
@@ -902,12 +873,12 @@ export class RecordsServer {
                     });
                     return result;
                 }
-            })),
+            }),
             recordData: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/data')
                 .inputs(RECORD_DATA_SCHEMA)
-                .handler((data, context) => __awaiter(this, void 0, void 0, function* () { return this._baseRecordData(this._data, data, context); })),
+                .handler(async (data, context) => this._baseRecordData(this._data, data, context)),
             recordWebhook: recordItemProcedure(this._auth, this._webhooksController, z.discriminatedUnion('targetResourceKind', [
                 z.object({
                     address: ADDRESS_VALIDATION,
@@ -946,8 +917,7 @@ export class RecordsServer {
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             })
                 .catchall(z.string()))
-                .handler((data, context, _1) => __awaiter(this, void 0, void 0, function* () {
-                var { recordName, address, instances } = _1, rest = __rest(_1, ["recordName", "address", "instances"]);
+                .handler(async (data, context, { recordName, address, instances, ...rest }) => {
                 if (!this._webhooksController) {
                     return {
                         success: false,
@@ -962,7 +932,7 @@ export class RecordsServer {
                         errorMessage: 'webhooks have to be called from an http request',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false &&
                     validation.errorCode !== 'no_session_key') {
                     return validation;
@@ -981,7 +951,7 @@ export class RecordsServer {
                     'connection',
                     'transfer-encoding',
                 ];
-                const result = yield this._webhooksController.handleWebhook({
+                const result = await this._webhooksController.handleWebhook({
                     recordName,
                     address,
                     instances,
@@ -1018,7 +988,7 @@ export class RecordsServer {
                         body: result.response.body,
                     },
                 };
-            }), (output, context) => __awaiter(this, void 0, void 0, function* () {
+            }, async (output, context) => {
                 if (output.success === false) {
                     // Use defaults
                     return {};
@@ -1026,7 +996,7 @@ export class RecordsServer {
                 else if (output.success === true) {
                     return output.response;
                 }
-            })),
+            }),
             eraseWebhook: eraseItemProcedure(this._auth, this._webhooksController, procedure()
                 .origins('api')
                 .http('DELETE', '/api/v2/records/webhook')),
@@ -1039,7 +1009,7 @@ export class RecordsServer {
                 requestTimeMs: z.number().int().optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, address, requestTimeMs, instances }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, address, requestTimeMs, instances }, context) => {
                 if (!this._webhooksController) {
                     return {
                         success: false,
@@ -1047,14 +1017,14 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._webhooksController.listWebhookRuns({
+                const result = await this._webhooksController.listWebhookRuns({
                     recordName,
                     address,
                     userId: validation.userId,
@@ -1062,7 +1032,7 @@ export class RecordsServer {
                     instances,
                 });
                 return result;
-            })),
+            }),
             getWebhookRun: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/webhook/runs/info')
@@ -1070,7 +1040,7 @@ export class RecordsServer {
                 runId: z.string().min(1),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ runId, instances }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ runId, instances }, context) => {
                 if (!this._webhooksController) {
                     return {
                         success: false,
@@ -1078,20 +1048,20 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._webhooksController.getWebhookRun({
+                const result = await this._webhooksController.getWebhookRun({
                     runId,
                     userId: validation.userId,
                     instances,
                 });
                 return result;
-            })),
+            }),
             recordNotification: recordItemProcedure(this._auth, this._notificationsController, z.object({
                 address: ADDRESS_VALIDATION,
                 description: z.string().min(1),
@@ -1115,7 +1085,7 @@ export class RecordsServer {
                 address: ADDRESS_VALIDATION,
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, address, instances }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, address, instances }, context) => {
                 if (!this._notificationsController) {
                     return {
                         success: false,
@@ -1123,28 +1093,28 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._notificationsController.listSubscriptions({
+                const result = await this._notificationsController.listSubscriptions({
                     recordName,
                     address,
                     userId: validation.userId,
                     instances,
                 });
                 return result;
-            })),
+            }),
             listUserNotificationSubscriptions: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/notification/list/user/subscriptions')
                 .inputs(z.object({
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ instances }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ instances }, context) => {
                 if (!this._notificationsController) {
                     return {
                         success: false,
@@ -1152,19 +1122,19 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._notificationsController.listSubscriptionsForUser({
+                const result = await this._notificationsController.listSubscriptionsForUser({
                     userId: validation.userId,
                     instances,
                 });
                 return result;
-            })),
+            }),
             eraseNotification: eraseItemProcedure(this._auth, this._notificationsController, procedure()
                 .origins('api')
                 .http('DELETE', '/api/v2/records/notification')),
@@ -1175,7 +1145,7 @@ export class RecordsServer {
                 pushSubscription: PUSH_SUBSCRIPTION_SCHEMA,
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ pushSubscription, instances }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ pushSubscription, instances }, context) => {
                 if (!this._notificationsController) {
                     return {
                         success: false,
@@ -1183,18 +1153,18 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false &&
                     validation.errorCode !== 'no_session_key') {
                     return validation;
                 }
-                const result = yield this._notificationsController.registerPushSubscription({
+                const result = await this._notificationsController.registerPushSubscription({
                     userId: validation.userId,
                     pushSubscription,
                     instances,
                 });
                 return result;
-            })),
+            }),
             subscribeToNotification: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/notification/subscribe')
@@ -1204,7 +1174,7 @@ export class RecordsServer {
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
                 pushSubscription: PUSH_SUBSCRIPTION_SCHEMA,
             }))
-                .handler(({ recordName, address, instances, pushSubscription }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, address, instances, pushSubscription }, context) => {
                 if (!this._notificationsController) {
                     return {
                         success: false,
@@ -1212,12 +1182,12 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false &&
                     validation.errorCode !== 'no_session_key') {
                     return validation;
                 }
-                const result = yield this._notificationsController.subscribeToNotification({
+                const result = await this._notificationsController.subscribeToNotification({
                     recordName,
                     address,
                     userId: validation.userId,
@@ -1225,7 +1195,7 @@ export class RecordsServer {
                     instances,
                 });
                 return result;
-            })),
+            }),
             unsubscribeFromNotification: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/notification/unsubscribe')
@@ -1233,7 +1203,7 @@ export class RecordsServer {
                 subscriptionId: z.string(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ subscriptionId, instances }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ subscriptionId, instances }, context) => {
                 if (!this._notificationsController) {
                     return {
                         success: false,
@@ -1241,20 +1211,20 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._notificationsController.unsubscribeFromNotification({
+                const result = await this._notificationsController.unsubscribeFromNotification({
                     subscriptionId,
                     userId: validation.userId,
                     instances,
                 });
                 return result;
-            })),
+            }),
             sendNotification: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/notification/send')
@@ -1265,7 +1235,7 @@ export class RecordsServer {
                 payload: PUSH_NOTIFICATION_PAYLOAD,
                 topic: z.string().optional(),
             }))
-                .handler(({ recordName, address, instances, payload, topic }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, address, instances, payload, topic }, context) => {
                 if (!this._notificationsController) {
                     return {
                         success: false,
@@ -1273,14 +1243,14 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._notificationsController.sendNotification({
+                const result = await this._notificationsController.sendNotification({
                     recordName,
                     address,
                     userId: validation.userId,
@@ -1289,11 +1259,11 @@ export class RecordsServer {
                     instances,
                 });
                 return result;
-            })),
+            }),
             getNotificationsApplicationServerKey: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/notification/applicationServerKey')
-                .handler(() => __awaiter(this, void 0, void 0, function* () {
+                .handler(async () => {
                 if (!this._notificationsController) {
                     return {
                         success: false,
@@ -1301,158 +1271,487 @@ export class RecordsServer {
                         errorMessage: 'This feature is not supported.',
                     };
                 }
-                const result = yield this._notificationsController.getApplicationServerKey();
+                const result = await this._notificationsController.getApplicationServerKey();
                 return result;
-            })),
-            listRecords: procedure()
+            }),
+            getPackage: getItemProcedure(this._auth, this._packagesController, procedure()
                 .origins('api')
-                .http('GET', '/api/v2/records/list')
+                .http('GET', '/api/v2/records/package')),
+            recordPackage: recordItemProcedure(this._auth, this._packagesController, z.object({
+                address: ADDRESS_VALIDATION,
+                markers: MARKERS_VALIDATION,
+            }), procedure()
+                .origins('api')
+                .http('POST', '/api/v2/records/package')),
+            erasePackage: eraseItemProcedure(this._auth, this._packagesController, procedure()
+                .origins('api')
+                .http('DELETE', '/api/v2/records/package')),
+            listPackages: listItemsProcedure(this._auth, this._packagesController, procedure()
+                .origins('api')
+                .http('GET', '/api/v2/records/package/list')),
+            getPackageVersion: procedure()
+                .origins('api')
+                .http('GET', '/api/v2/records/package/version')
                 .inputs(z.object({
-                studioId: z.string().nonempty().optional(),
-                userId: z.string().optional(),
+                recordName: RECORD_NAME_VALIDATION,
+                address: ADDRESS_VALIDATION,
+                major: z.coerce.number().int().optional().nullable(),
+                minor: z.coerce.number().int().optional().nullable(),
+                patch: z.coerce.number().int().optional().nullable(),
+                tag: z.string().optional().nullable(),
+                sha256: z.string().optional(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
+                key: z.string().min(1).optional(),
             }))
-                .handler(({ studioId, userId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, address, major, minor, patch, tag, sha256, key, instances, }, context) => {
+                if (!this._packageVersionController) {
+                    return {
+                        success: false,
+                        errorCode: 'not_supported',
+                        errorMessage: 'This feature is not supported.',
+                    };
+                }
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                if (studioId) {
-                    const result = yield this._records.listStudioRecords(studioId, validation.userId);
-                    return result;
-                }
-                else if (userId && userId !== validation.userId) {
-                    if (!isSuperUserRole(validation.role)) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'You are not authorized to perform this action.',
-                        };
-                    }
-                    const result = yield this._records.listRecords(userId);
-                    return result;
-                }
-                else {
-                    const result = yield this._records.listRecords(validation.userId);
-                    return result;
+                const keyResult = getPackageVersionSpecifier(key, major, minor, patch, tag, sha256);
+                if (keyResult.success === false) {
+                    return keyResult;
                 }
-            })),
-            createRecordKey: procedure()
+                const result = await this._packageVersionController.getItem({
+                    recordName,
+                    address,
+                    userId: validation.userId,
+                    key: keyResult.key,
+                    instances,
+                });
+                return result;
+            }),
+            recordPackageVersion: procedure()
                 .origins('api')
-                .http('POST', '/api/v2/records/key')
+                .http('POST', '/api/v2/records/package/version')
                 .inputs(z.object({
                 recordName: RECORD_NAME_VALIDATION,
-                policy: z.string({
-                    invalid_type_error: 'policy must be a string.',
-                    required_error: 'policy is required.',
+                item: z.object({
+                    address: ADDRESS_VALIDATION,
+                    key: z.object({
+                        major: z.number().int(),
+                        minor: z.number().int(),
+                        patch: z.number().int(),
+                        tag: z
+                            .string()
+                            .max(16)
+                            .nullable()
+                            .optional()
+                            .default(''),
+                    }),
+                    auxFileRequest: z.object({
+                        fileSha256Hex: z.string().min(1).max(123),
+                        fileByteLength: z.number().positive().int(),
+                        fileMimeType: z.string().min(1).max(128),
+                        fileDescription: z
+                            .string()
+                            .min(1)
+                            .max(128)
+                            .optional(),
+                    }),
+                    entitlements: z.array(ENTITLEMENT_VALIDATION),
+                    description: z.string(),
+                    markers: MARKERS_VALIDATION.optional(),
                 }),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, policy }, context) => __awaiter(this, void 0, void 0, function* () {
-                if (!recordName || typeof recordName !== 'string') {
+                .handler(async ({ recordName, item, instances }, context) => {
+                var _a;
+                if (!this._packageVersionController) {
                     return {
                         success: false,
-                        errorCode: 'unacceptable_request',
-                        errorMessage: 'recordName is required and must be a string.',
+                        errorCode: 'not_supported',
+                        errorMessage: 'This feature is not supported.',
                     };
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return validation;
                 }
-                const result = yield this._records.createPublicRecordKey(recordName, policy, validation.userId);
+                const result = await this._packageVersionController.recordItem({
+                    recordKeyOrRecordName: recordName,
+                    userId: validation.userId,
+                    item: {
+                        address: item.address,
+                        key: {
+                            major: item.key.major,
+                            minor: item.key.minor,
+                            patch: item.key.patch,
+                            tag: (_a = item.key.tag) !== null && _a !== void 0 ? _a : '',
+                        },
+                        auxFileRequest: item.auxFileRequest,
+                        entitlements: item.entitlements,
+                        description: item.description,
+                        markers: item.markers,
+                    },
+                    instances,
+                });
                 return result;
-            })),
-            grantPermission: procedure()
+            }),
+            listPackageVersions: procedure()
                 .origins('api')
-                .http('POST', '/api/v2/records/permissions')
+                .http('GET', '/api/v2/records/package/version/list')
                 .inputs(z.object({
                 recordName: RECORD_NAME_VALIDATION,
-                permission: AVAILABLE_PERMISSIONS_VALIDATION,
+                address: ADDRESS_VALIDATION,
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, permission, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
-                if (sessionKeyValidation.success === false) {
-                    if (sessionKeyValidation.errorCode ===
-                        'no_session_key') {
-                        return NOT_LOGGED_IN_RESULT;
-                    }
-                    return sessionKeyValidation;
-                }
-                if (permission.marker) {
-                    const result = yield this._policyController.grantMarkerPermission({
-                        recordKeyOrRecordName: recordName,
-                        marker: permission.marker,
-                        userId: sessionKeyValidation.userId,
-                        permission: permission,
-                        instances,
-                    });
-                    return result;
+                .handler(async ({ recordName, address, instances }, context) => {
+                if (!this._packageVersionController) {
+                    return {
+                        success: false,
+                        errorCode: 'not_supported',
+                        errorMessage: 'This feature is not supported.',
+                    };
                 }
-                else if (permission.resourceKind &&
-                    permission.resourceId) {
-                    const result = yield this._policyController.grantResourcePermission({
-                        recordKeyOrRecordName: recordName,
-                        permission: permission,
-                        userId: sessionKeyValidation.userId,
-                        instances,
-                    });
-                    return result;
+                const validation = await this._validateSessionKey(context.sessionKey);
+                if (validation.success === false &&
+                    validation.errorCode !== 'no_session_key') {
+                    return validation;
                 }
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'The given permission must have either a marker or a resourceId.',
-                };
-            })),
-            revokePermission: procedure()
+                const result = await this._packageVersionController.listItems({
+                    userId: validation.userId,
+                    recordName: recordName,
+                    address: address,
+                    instances: instances !== null && instances !== void 0 ? instances : [],
+                });
+                return result;
+            }),
+            erasePackageVersion: procedure()
                 .origins('api')
-                .http('POST', '/api/v2/records/permissions/revoke')
+                .http('DELETE', '/api/v2/records/package/version')
                 .inputs(z.object({
-                permissionId: z
-                    .string({
-                    invalid_type_error: 'permissionId must be a string.',
-                    required_error: 'permissionId is required.',
-                })
-                    .nonempty('permissionId must not be empty'),
+                recordName: RECORD_NAME_VALIDATION,
+                address: ADDRESS_VALIDATION,
+                key: z.object({
+                    major: z.number().int(),
+                    minor: z.number().int(),
+                    patch: z.number().int(),
+                    tag: z.string().max(16).default(''),
+                }),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ permissionId, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
-                if (sessionKeyValidation.success === false) {
-                    if (sessionKeyValidation.errorCode === 'no_session_key') {
+                .handler(async ({ recordName, address, key, instances }, context) => {
+                if (!this._packageVersionController) {
+                    return {
+                        success: false,
+                        errorCode: 'not_supported',
+                        errorMessage: 'This feature is not supported.',
+                    };
+                }
+                const validation = await this._validateSessionKey(context.sessionKey);
+                if (validation.success === false) {
+                    if (validation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
-                    return sessionKeyValidation;
+                    return validation;
                 }
-                const result = yield this._policyController.revokePermission({
-                    permissionId,
-                    userId: sessionKeyValidation.userId,
-                    instances,
+                const result = await this._packageVersionController.eraseItem({
+                    recordName,
+                    address,
+                    key: key,
+                    userId: validation.userId,
+                    instances: instances !== null && instances !== void 0 ? instances : [],
                 });
                 return result;
-            })),
-            listPermissions: procedure()
+            }),
+            reviewPackageVersion: procedure()
                 .origins('api')
-                .http('GET', '/api/v2/records/permissions/list')
+                .http('POST', '/api/v2/records/package/version/review')
                 .inputs(z.object({
-                recordName: RECORD_NAME_VALIDATION,
-                marker: MARKER_VALIDATION.optional(),
-                resourceKind: RESOURCE_KIND_VALIDATION.optional(),
-                resourceId: z
-                    .string({
-                    invalid_type_error: 'resourceId must be a string.',
-                    required_error: 'resourceId is required.',
-                })
-                    .optional(),
+                packageVersionId: z.string().min(1).max(36),
+                review: z.object({
+                    id: z.string().min(1).max(36).optional(),
+                    approved: z.boolean(),
+                    approvalType: z
+                        .enum(['normal', 'super'])
+                        .nullable(),
+                    reviewStatus: z.enum([
+                        'pending',
+                        'approved',
+                        'rejected',
+                    ]),
+                    reviewComments: z.string().min(1).max(4096),
+                }),
+            }))
+                .handler(async ({ packageVersionId, review }, context) => {
+                if (!this._packageVersionController) {
+                    return {
+                        success: false,
+                        errorCode: 'not_supported',
+                        errorMessage: 'This feature is not supported.',
+                    };
+                }
+                const validation = await this._validateSessionKey(context.sessionKey);
+                if (validation.success === false) {
+                    if (validation.errorCode === 'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return validation;
+                }
+                const result = await this._packageVersionController.reviewItem({
+                    packageVersionId,
+                    userId: validation.userId,
+                    review: review,
+                });
+                return result;
+            }),
+            installPackage: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/records/package/install')
+                .inputs(z.object({
+                recordName: RECORD_NAME_VALIDATION.optional().nullable(),
+                inst: z.string().min(1),
+                branch: z.string().optional().nullable(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
+                package: z.object({
+                    recordName: RECORD_NAME_VALIDATION,
+                    address: ADDRESS_VALIDATION,
+                    key: z
+                        .union([
+                        z
+                            .string()
+                            .describe('The package version to install as a string'),
+                        z
+                            .object({
+                            major: z
+                                .number()
+                                .int()
+                                .optional()
+                                .nullable(),
+                            minor: z
+                                .number()
+                                .int()
+                                .optional()
+                                .nullable(),
+                            patch: z
+                                .number()
+                                .int()
+                                .optional()
+                                .nullable(),
+                            tag: z
+                                .string()
+                                .optional()
+                                .nullable(),
+                            sha256: z
+                                .string()
+                                .optional()
+                                .nullable(),
+                        })
+                            .describe('The package version specifier to install'),
+                    ])
+                        .optional()
+                        .nullable(),
+                }),
+            }))
+                .handler(async ({ recordName, inst, branch, package: pkg, instances }, context) => {
+                if (!this._websocketController) {
+                    return INSTS_NOT_SUPPORTED_RESULT;
+                }
+                const validation = await this._validateSessionKey(context.sessionKey);
+                if (validation.success === false &&
+                    validation.errorCode !== 'no_session_key') {
+                    return validation;
+                }
+                const result = await this._websocketController.installPackage({
+                    userId: validation.userId,
+                    userRole: validation.role,
+                    recordName: recordName !== null && recordName !== void 0 ? recordName : null,
+                    inst,
+                    branch,
+                    package: pkg,
+                    instances,
+                });
+                return result;
+            }),
+            listInstalledPackages: procedure()
+                .origins('api')
+                .http('GET', '/api/v2/records/package/install/list')
+                .inputs(z.object({
+                recordName: RECORD_NAME_VALIDATION.optional().nullable(),
+                inst: z.string().min(1),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
+            }))
+                .handler(async ({ recordName, inst, instances }, context) => {
+                if (!this._websocketController) {
+                    return INSTS_NOT_SUPPORTED_RESULT;
+                }
+                const validation = await this._validateSessionKey(context.sessionKey);
+                if (validation.success === false &&
+                    validation.errorCode !== 'no_session_key') {
+                    return validation;
+                }
+                const result = await this._websocketController.listInstalledPackages({
+                    userId: validation.userId,
+                    userRole: validation.role,
+                    recordName: recordName !== null && recordName !== void 0 ? recordName : null,
+                    inst,
+                    instances,
+                });
+                return result;
+            }),
+            listRecords: procedure()
+                .origins('api')
+                .http('GET', '/api/v2/records/list')
+                .inputs(z.object({
+                studioId: z.string().nonempty().optional(),
+                userId: z.string().optional(),
+            }))
+                .handler(async ({ studioId, userId }, context) => {
+                const validation = await this._validateSessionKey(context.sessionKey);
+                if (validation.success === false) {
+                    if (validation.errorCode === 'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return validation;
+                }
+                if (studioId) {
+                    const result = await this._records.listStudioRecords(studioId, validation.userId);
+                    return result;
+                }
+                else if (userId && userId !== validation.userId) {
+                    if (!isSuperUserRole(validation.role)) {
+                        return {
+                            success: false,
+                            errorCode: 'not_authorized',
+                            errorMessage: 'You are not authorized to perform this action.',
+                        };
+                    }
+                    const result = await this._records.listRecords(userId);
+                    return result;
+                }
+                else {
+                    const result = await this._records.listRecords(validation.userId);
+                    return result;
+                }
+            }),
+            createRecordKey: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/records/key')
+                .inputs(z.object({
+                recordName: RECORD_NAME_VALIDATION,
+                policy: z.string({
+                    invalid_type_error: 'policy must be a string.',
+                    required_error: 'policy is required.',
+                }),
+            }))
+                .handler(async ({ recordName, policy }, context) => {
+                if (!recordName || typeof recordName !== 'string') {
+                    return {
+                        success: false,
+                        errorCode: 'unacceptable_request',
+                        errorMessage: 'recordName is required and must be a string.',
+                    };
+                }
+                const validation = await this._validateSessionKey(context.sessionKey);
+                if (validation.success === false) {
+                    if (validation.errorCode === 'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return validation;
+                }
+                const result = await this._records.createPublicRecordKey(recordName, policy, validation.userId);
+                return result;
+            }),
+            grantPermission: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/records/permissions')
+                .inputs(z.object({
+                recordName: RECORD_NAME_VALIDATION,
+                permission: AVAILABLE_PERMISSIONS_VALIDATION,
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
+            }))
+                .handler(async ({ recordName, permission, instances }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
+                if (sessionKeyValidation.success === false) {
+                    if (sessionKeyValidation.errorCode ===
+                        'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return sessionKeyValidation;
+                }
+                if (permission.marker) {
+                    const result = await this._policyController.grantMarkerPermission({
+                        recordKeyOrRecordName: recordName,
+                        marker: permission.marker,
+                        userId: sessionKeyValidation.userId,
+                        permission: permission,
+                        instances,
+                    });
+                    return result;
+                }
+                else if (permission.resourceKind &&
+                    permission.resourceId) {
+                    const result = await this._policyController.grantResourcePermission({
+                        recordKeyOrRecordName: recordName,
+                        permission: permission,
+                        userId: sessionKeyValidation.userId,
+                        instances,
+                    });
+                    return result;
+                }
+                return {
+                    success: false,
+                    errorCode: 'unacceptable_request',
+                    errorMessage: 'The given permission must have either a marker or a resourceId.',
+                };
+            }),
+            revokePermission: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/records/permissions/revoke')
+                .inputs(z.object({
+                permissionId: z
+                    .string({
+                    invalid_type_error: 'permissionId must be a string.',
+                    required_error: 'permissionId is required.',
+                })
+                    .nonempty('permissionId must not be empty'),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
+            }))
+                .handler(async ({ permissionId, instances }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
+                if (sessionKeyValidation.success === false) {
+                    if (sessionKeyValidation.errorCode === 'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return sessionKeyValidation;
+                }
+                const result = await this._policyController.revokePermission({
+                    permissionId,
+                    userId: sessionKeyValidation.userId,
+                    instances,
+                });
+                return result;
+            }),
+            listPermissions: procedure()
+                .origins('api')
+                .http('GET', '/api/v2/records/permissions/list')
+                .inputs(z.object({
+                recordName: RECORD_NAME_VALIDATION,
+                marker: MARKER_VALIDATION.optional(),
+                resourceKind: RESOURCE_KIND_VALIDATION.optional(),
+                resourceId: z
+                    .string({
+                    invalid_type_error: 'resourceId must be a string.',
+                    required_error: 'resourceId is required.',
+                })
+                    .optional(),
             }))
-                .handler(({ recordName, marker, resourceKind, resourceId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, marker, resourceKind, resourceId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1461,18 +1760,18 @@ export class RecordsServer {
                     return sessionKeyValidation;
                 }
                 if (resourceKind && resourceId) {
-                    const result = yield this._policyController.listPermissionsForResource(recordName, resourceKind, resourceId, sessionKeyValidation.userId);
+                    const result = await this._policyController.listPermissionsForResource(recordName, resourceKind, resourceId, sessionKeyValidation.userId);
                     return result;
                 }
                 else if (marker) {
-                    const result = yield this._policyController.listPermissionsForMarker(recordName, marker, sessionKeyValidation.userId);
+                    const result = await this._policyController.listPermissionsForMarker(recordName, marker, sessionKeyValidation.userId);
                     return result;
                 }
                 else {
-                    const result = yield this._policyController.listPermissions(recordName, sessionKeyValidation.userId);
+                    const result = await this._policyController.listPermissions(recordName, sessionKeyValidation.userId);
                     return result;
                 }
-            })),
+            }),
             listUserRoles: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/role/user/list')
@@ -1486,17 +1785,17 @@ export class RecordsServer {
                     .nonempty('userId must not be empty'),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, userId, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, userId, instances }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._policyController.listUserRoles(recordName, sessionKeyValidation.userId, userId, instances);
+                const result = await this._policyController.listUserRoles(recordName, sessionKeyValidation.userId, userId, instances);
                 return result;
-            })),
+            }),
             listInstRoles: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/role/inst/list')
@@ -1510,17 +1809,17 @@ export class RecordsServer {
                     .nonempty('inst must not be empty'),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, inst, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, inst, instances }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._policyController.listInstRoles(recordName, sessionKeyValidation.userId, inst, instances);
+                const result = await this._policyController.listInstRoles(recordName, sessionKeyValidation.userId, inst, instances);
                 return result;
-            })),
+            }),
             listRoleAssignments: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/role/assignments/list')
@@ -1542,8 +1841,8 @@ export class RecordsServer {
                     .optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, role, startingRole, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, role, startingRole, instances }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1552,14 +1851,14 @@ export class RecordsServer {
                     return sessionKeyValidation;
                 }
                 if (role) {
-                    const result = yield this._policyController.listAssignedRoles(recordName, sessionKeyValidation.userId, role, instances);
+                    const result = await this._policyController.listAssignedRoles(recordName, sessionKeyValidation.userId, role, instances);
                     return result;
                 }
                 else {
-                    const result = yield this._policyController.listRoleAssignments(recordName, sessionKeyValidation.userId, startingRole, instances);
+                    const result = await this._policyController.listRoleAssignments(recordName, sessionKeyValidation.userId, startingRole, instances);
                     return result;
                 }
-            })),
+            }),
             grantRole: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/role/grant')
@@ -1594,8 +1893,8 @@ export class RecordsServer {
                     .optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, userId, inst, expireTimeMs, role, instances, }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, userId, inst, expireTimeMs, role, instances, }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1603,14 +1902,14 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._policyController.grantRole(recordName, sessionKeyValidation.userId, {
+                const result = await this._policyController.grantRole(recordName, sessionKeyValidation.userId, {
                     instance: inst,
                     userId: userId,
                     role,
                     expireTimeMs,
                 }, instances);
                 return result;
-            })),
+            }),
             revokeRole: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/role/revoke')
@@ -1638,8 +1937,8 @@ export class RecordsServer {
                     .nonempty('role must not be empty'),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ recordName, userId, inst, role, instances }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ recordName, userId, inst, role, instances }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1647,32 +1946,26 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._policyController.revokeRole(recordName, sessionKeyValidation.userId, {
+                const result = await this._policyController.revokeRole(recordName, sessionKeyValidation.userId, {
                     instance: inst,
                     userId: userId,
                     role,
                 }, instances);
                 return result;
-            })),
-            aiChat: procedure()
+            }),
+            grantEntitlement: procedure()
                 .origins('api')
-                .http('POST', '/api/v2/ai/chat')
+                .http('POST', '/api/v2/records/entitlement/grants')
                 .inputs(z.object({
-                model: z.string().nonempty().optional(),
-                messages: z.array(AI_CHAT_MESSAGE_SCHEMA).nonempty(),
-                instances: INSTANCES_ARRAY_VALIDATION.optional(),
-                temperature: z.number().min(0).max(2).optional(),
-                topP: z.number().optional(),
-                presencePenalty: z.number().min(-2).max(2).optional(),
-                frequencyPenalty: z.number().min(-2).max(2).optional(),
-                stopWords: z.array(z.string()).max(4).optional(),
+                packageId: z.string().min(1).max(36),
+                userId: z.string().optional().nullable(),
+                recordName: RECORD_NAME_VALIDATION,
+                feature: ENTITLEMENT_FEATURE_VALIDATION,
+                scope: z.literal('designated'),
+                expireTimeMs: z.number().min(1),
             }))
-                .handler((_2, context) => __awaiter(this, void 0, void 0, function* () {
-                var { model, messages, instances } = _2, options = __rest(_2, ["model", "messages", "instances"]);
-                if (!this._aiController) {
-                    return AI_NOT_SUPPORTED_RESULT;
-                }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ packageId, userId, recordName, feature, scope, expireTimeMs, }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1680,61 +1973,155 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._aiController.chat(Object.assign(Object.assign({}, options), { model, messages: messages, userId: sessionKeyValidation.userId, userSubscriptionTier: sessionKeyValidation.subscriptionTier }));
+                const result = await this._policyController.grantEntitlement({
+                    packageId,
+                    userId: sessionKeyValidation.userId,
+                    userRole: sessionKeyValidation.role,
+                    grantingUserId: userId !== null && userId !== void 0 ? userId : sessionKeyValidation.userId,
+                    recordName,
+                    feature,
+                    scope,
+                    expireTimeMs,
+                });
                 return result;
-            })),
-            aiChatStream: procedure()
+            }),
+            revokeEntitlement: procedure()
                 .origins('api')
-                .http('POST', '/api/v2/ai/chat/stream')
+                .http('POST', '/api/v2/records/entitlement/revoke')
                 .inputs(z.object({
-                model: z.string().nonempty().optional(),
-                messages: z.array(AI_CHAT_MESSAGE_SCHEMA).nonempty(),
-                instances: INSTANCES_ARRAY_VALIDATION.optional(),
-                temperature: z.number().min(0).max(2).optional(),
-                topP: z.number().optional(),
-                presencePenalty: z.number().min(-2).max(2).optional(),
-                frequencyPenalty: z.number().min(-2).max(2).optional(),
-                stopWords: z.array(z.string()).max(4).optional(),
+                grantId: z.string(),
             }))
-                .handler((_3, context) => __awaiter(this, void 0, void 0, function* () {
-                var { model, messages } = _3, options = __rest(_3, ["model", "messages"]);
-                if (!this._aiController) {
-                    return AI_NOT_SUPPORTED_RESULT;
-                }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ grantId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = this._aiController.chatStream(Object.assign(Object.assign({}, options), { model, messages: messages, userId: sessionKeyValidation.userId, userSubscriptionTier: sessionKeyValidation.subscriptionTier }));
+                const result = await this._policyController.revokeEntitlement({
+                    userId: sessionKeyValidation.userId,
+                    userRole: sessionKeyValidation.role,
+                    grantId,
+                });
                 return result;
-            })),
-            createAiSkybox: procedure()
+            }),
+            listGrantedEntitlements: procedure()
                 .origins('api')
-                .http('POST', '/api/v2/ai/skybox')
+                .http('GET', '/api/v2/records/entitlement/grants/list')
                 .inputs(z.object({
-                prompt: z.string().nonempty().max(600),
-                negativePrompt: z
+                packageId: z
                     .string()
-                    .nonempty()
-                    .max(600)
-                    .optional(),
-                blockadeLabs: z
-                    .object({
-                    skyboxStyleId: z.number().optional(),
-                    remixImagineId: z.number().optional(),
-                    seed: z.number().optional(),
-                })
+                    .min(1)
+                    .max(36)
+                    .optional()
+                    .nullable(),
+            }))
+                .handler(async ({ packageId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
+                if (sessionKeyValidation.success === false) {
+                    if (sessionKeyValidation.errorCode === 'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return sessionKeyValidation;
+                }
+                const result = await this._policyController.listGrantedEntitlements({
+                    userId: sessionKeyValidation.userId,
+                    packageId: packageId,
+                });
+                return result;
+            }),
+            aiChat: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/ai/chat')
+                .inputs(z.object({
+                model: z.string().nonempty().optional(),
+                messages: z.array(AI_CHAT_MESSAGE_SCHEMA).nonempty(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
+                temperature: z.number().min(0).max(2).optional(),
+                topP: z.number().optional(),
+                presencePenalty: z.number().min(-2).max(2).optional(),
+                frequencyPenalty: z.number().min(-2).max(2).optional(),
+                stopWords: z.array(z.string()).max(4).optional(),
+            }))
+                .handler(async ({ model, messages, instances, ...options }, context) => {
+                if (!this._aiController) {
+                    return AI_NOT_SUPPORTED_RESULT;
+                }
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
+                if (sessionKeyValidation.success === false) {
+                    if (sessionKeyValidation.errorCode ===
+                        'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return sessionKeyValidation;
+                }
+                const result = await this._aiController.chat({
+                    ...options,
+                    model,
+                    messages: messages,
+                    userId: sessionKeyValidation.userId,
+                    userSubscriptionTier: sessionKeyValidation.subscriptionTier,
+                });
+                return result;
+            }),
+            aiChatStream: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/ai/chat/stream')
+                .inputs(z.object({
+                model: z.string().nonempty().optional(),
+                messages: z.array(AI_CHAT_MESSAGE_SCHEMA).nonempty(),
+                instances: INSTANCES_ARRAY_VALIDATION.optional(),
+                temperature: z.number().min(0).max(2).optional(),
+                topP: z.number().optional(),
+                presencePenalty: z.number().min(-2).max(2).optional(),
+                frequencyPenalty: z.number().min(-2).max(2).optional(),
+                stopWords: z.array(z.string()).max(4).optional(),
+            }))
+                .handler(async ({ model, messages, ...options }, context) => {
+                if (!this._aiController) {
+                    return AI_NOT_SUPPORTED_RESULT;
+                }
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
+                if (sessionKeyValidation.success === false) {
+                    if (sessionKeyValidation.errorCode === 'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return sessionKeyValidation;
+                }
+                const result = this._aiController.chatStream({
+                    ...options,
+                    model,
+                    messages: messages,
+                    userId: sessionKeyValidation.userId,
+                    userSubscriptionTier: sessionKeyValidation.subscriptionTier,
+                });
+                return result;
+            }),
+            createAiSkybox: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/ai/skybox')
+                .inputs(z.object({
+                prompt: z.string().nonempty().max(600),
+                negativePrompt: z
+                    .string()
+                    .nonempty()
+                    .max(600)
+                    .optional(),
+                blockadeLabs: z
+                    .object({
+                    skyboxStyleId: z.number().optional(),
+                    remixImagineId: z.number().optional(),
+                    seed: z.number().optional(),
+                })
                     .optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ prompt, negativePrompt, instances, blockadeLabs }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ prompt, negativePrompt, instances, blockadeLabs }, context) => {
                 if (!this._aiController) {
                     return AI_NOT_SUPPORTED_RESULT;
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1742,7 +2129,7 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._aiController.generateSkybox({
+                const result = await this._aiController.generateSkybox({
                     prompt,
                     negativePrompt,
                     blockadeLabs,
@@ -1750,7 +2137,7 @@ export class RecordsServer {
                     userSubscriptionTier: sessionKeyValidation.subscriptionTier,
                 });
                 return result;
-            })),
+            }),
             getAiSkybox: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/ai/skybox')
@@ -1763,24 +2150,24 @@ export class RecordsServer {
                     .nonempty('skyboxId must not be empty'),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ skyboxId, instances }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ skyboxId, instances }, context) => {
                 if (!this._aiController) {
                     return AI_NOT_SUPPORTED_RESULT;
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._aiController.getSkybox({
+                const result = await this._aiController.getSkybox({
                     skyboxId,
                     userId: sessionKeyValidation.userId,
                     userSubscriptionTier: sessionKeyValidation.subscriptionTier,
                 });
                 return result;
-            })),
+            }),
             createAiImage: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/ai/image')
@@ -1810,11 +2197,11 @@ export class RecordsServer {
                 stylePreset: z.string().nonempty().optional(),
                 instances: INSTANCES_ARRAY_VALIDATION.optional(),
             }))
-                .handler(({ prompt, model, negativePrompt, width, height, seed, numberOfImages, steps, sampler, cfgScale, clipGuidancePreset, stylePreset, instances, }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ prompt, model, negativePrompt, width, height, seed, numberOfImages, steps, sampler, cfgScale, clipGuidancePreset, stylePreset, instances, }, context) => {
                 if (!this._aiController) {
                     return AI_NOT_SUPPORTED_RESULT;
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1822,7 +2209,7 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._aiController.generateImage({
+                const result = await this._aiController.generateImage({
                     model,
                     prompt,
                     negativePrompt,
@@ -1839,30 +2226,30 @@ export class RecordsServer {
                     userSubscriptionTier: sessionKeyValidation.subscriptionTier,
                 });
                 return result;
-            })),
+            }),
             getHumeAccessToken: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/ai/hume/token')
                 .inputs(z.object({
                 recordName: RECORD_NAME_VALIDATION.optional(),
             }))
-                .handler(({ recordName }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName }, context) => {
                 if (!this._aiController) {
                     return AI_NOT_SUPPORTED_RESULT;
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._aiController.getHumeAccessToken({
+                const result = await this._aiController.getHumeAccessToken({
                     userId: sessionKeyValidation.userId,
                     recordName,
                 });
                 return result;
-            })),
+            }),
             createSloydModel: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/ai/sloyd/model')
@@ -1882,11 +2269,11 @@ export class RecordsServer {
                 })
                     .optional(),
             }))
-                .handler(({ recordName, outputMimeType, prompt, levelOfDetail, baseModelId, thumbnail, }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, outputMimeType, prompt, levelOfDetail, baseModelId, thumbnail, }, context) => {
                 if (!this._aiController) {
                     return AI_NOT_SUPPORTED_RESULT;
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -1894,7 +2281,7 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._aiController.sloydGenerateModel({
+                const result = await this._aiController.sloydGenerateModel({
                     userId: sessionKeyValidation.userId,
                     recordName: recordName !== null && recordName !== void 0 ? recordName : sessionKeyValidation.userId,
                     outputMimeType,
@@ -1904,30 +2291,30 @@ export class RecordsServer {
                     thumbnail: thumbnail,
                 });
                 return result;
-            })),
+            }),
             getLoomAccessToken: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/loom/token')
                 .inputs(z.object({
                 recordName: RECORD_NAME_VALIDATION,
             }))
-                .handler(({ recordName }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName }, context) => {
                 if (!this._loomController) {
                     return LOOM_NOT_SUPPORTED_RESULT;
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._loomController.getToken({
+                const result = await this._loomController.getToken({
                     userId: sessionKeyValidation.userId,
                     recordName: recordName,
                 });
                 return result;
-            })),
+            }),
             createOpenAIRealtimeSession: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/ai/openai/realtime/session')
@@ -2002,41 +2389,44 @@ export class RecordsServer {
                     voice: z.string().min(1).optional(),
                 }),
             }))
-                .handler(({ recordName, request }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, request }, context) => {
                 if (!this._aiController) {
                     return AI_NOT_SUPPORTED_RESULT;
                 }
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._aiController.createOpenAIRealtimeSessionToken({
+                const result = await this._aiController.createOpenAIRealtimeSessionToken({
                     userId: sessionKeyValidation.userId,
                     recordName: recordName,
-                    request: Object.assign({ model: request.model }, request),
+                    request: {
+                        model: request.model,
+                        ...request,
+                    },
                 });
                 return result;
-            })),
+            }),
             getStudio: procedure()
                 .origins('account')
                 .http('GET', '/api/v2/studios')
                 .inputs(z.object({
                 studioId: STUDIO_ID_VALIDATION,
             }))
-                .handler(({ studioId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ studioId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._records.getStudio(studioId, sessionKeyValidation.userId);
+                const result = await this._records.getStudio(studioId, sessionKeyValidation.userId);
                 return result;
-            })),
+            }),
             createStudio: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/studios')
@@ -2051,8 +2441,8 @@ export class RecordsServer {
                     .nullable()
                     .optional(),
             }))
-                .handler(({ displayName, ownerStudioComId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ displayName, ownerStudioComId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
@@ -2060,14 +2450,14 @@ export class RecordsServer {
                     return sessionKeyValidation;
                 }
                 if (!ownerStudioComId) {
-                    const result = yield this._records.createStudio(displayName, sessionKeyValidation.userId);
+                    const result = await this._records.createStudio(displayName, sessionKeyValidation.userId);
                     return result;
                 }
                 else {
-                    const result = yield this._records.createStudioInComId(displayName, sessionKeyValidation.userId, ownerStudioComId);
+                    const result = await this._records.createStudioInComId(displayName, sessionKeyValidation.userId, ownerStudioComId);
                     return result;
                 }
-            })),
+            }),
             updateStudio: procedure()
                 .origins('account')
                 .http('PUT', '/api/v2/studios')
@@ -2089,8 +2479,8 @@ export class RecordsServer {
                 loomConfig: LOOM_CONFIG.optional(),
                 humeConfig: HUME_CONFIG.optional(),
             }))
-                .handler(({ id, displayName, logoUrl, comIdConfig, playerConfig, loomConfig, humeConfig, }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ id, displayName, logoUrl, comIdConfig, playerConfig, loomConfig, humeConfig, }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -2098,7 +2488,7 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._records.updateStudio({
+                const result = await this._records.updateStudio({
                     userId: sessionKeyValidation.userId,
                     studio: {
                         id,
@@ -2111,7 +2501,7 @@ export class RecordsServer {
                     },
                 });
                 return result;
-            })),
+            }),
             requestStudioComId: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/studios/requestComId')
@@ -2119,22 +2509,22 @@ export class RecordsServer {
                 studioId: STUDIO_ID_VALIDATION,
                 comId: COM_ID_VALIDATION,
             }))
-                .handler(({ studioId, comId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ studioId, comId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._records.requestComId({
+                const result = await this._records.requestComId({
                     studioId,
                     userId: sessionKeyValidation.userId,
                     requestedComId: comId,
                     ipAddress: context.ipAddress,
                 });
                 return result;
-            })),
+            }),
             listStudios: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/studios/list')
@@ -2142,8 +2532,8 @@ export class RecordsServer {
                 comId: z.string().nonempty().nullable().optional(),
                 userId: z.string().optional(),
             }))
-                .handler(({ comId, userId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ comId, userId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
@@ -2163,31 +2553,31 @@ export class RecordsServer {
                     userId = sessionKeyValidation.userId;
                 }
                 if (comId) {
-                    const result = yield this._records.listStudiosByComId(userId, comId);
+                    const result = await this._records.listStudiosByComId(userId, comId);
                     return result;
                 }
                 else {
-                    const result = yield this._records.listStudios(userId);
+                    const result = await this._records.listStudios(userId);
                     return result;
                 }
-            })),
+            }),
             listStudioMembers: procedure()
                 .origins('account')
                 .http('GET', '/api/v2/studios/members/list')
                 .inputs(z.object({
                 studioId: STUDIO_ID_VALIDATION,
             }))
-                .handler(({ studioId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ studioId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._records.listStudioMembers(studioId, sessionKeyValidation.userId);
+                const result = await this._records.listStudioMembers(studioId, sessionKeyValidation.userId);
                 return result;
-            })),
+            }),
             addStudioMember: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/studios/members')
@@ -2226,8 +2616,8 @@ export class RecordsServer {
                     z.literal('member'),
                 ]),
             }))
-                .handler(({ studioId, addedUserId, addedEmail, addedPhoneNumber, addedDisplayName, role, }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ studioId, addedUserId, addedEmail, addedPhoneNumber, addedDisplayName, role, }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode ===
                         'no_session_key') {
@@ -2235,7 +2625,7 @@ export class RecordsServer {
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._records.addStudioMember({
+                const result = await this._records.addStudioMember({
                     studioId,
                     userId: sessionKeyValidation.userId,
                     role,
@@ -2245,7 +2635,7 @@ export class RecordsServer {
                     addedDisplayName,
                 });
                 return result;
-            })),
+            }),
             removeStudioMember: procedure()
                 .origins('account')
                 .http('DELETE', '/api/v2/studios/members')
@@ -2259,31 +2649,31 @@ export class RecordsServer {
                     .nonempty('removedUserId must not be empty')
                     .optional(),
             }))
-                .handler(({ studioId, removedUserId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                .handler(async ({ studioId, removedUserId }, context) => {
+                const sessionKeyValidation = await this._validateSessionKey(context.sessionKey);
                 if (sessionKeyValidation.success === false) {
                     if (sessionKeyValidation.errorCode === 'no_session_key') {
                         return NOT_LOGGED_IN_RESULT;
                     }
                     return sessionKeyValidation;
                 }
-                const result = yield this._records.removeStudioMember({
+                const result = await this._records.removeStudioMember({
                     studioId,
                     userId: sessionKeyValidation.userId,
                     removedUserId,
                 });
                 return result;
-            })),
+            }),
             getPlayerConfig: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/player/config')
                 .inputs(z.object({
                 comId: z.string().nonempty(),
             }))
-                .handler(({ comId }, context) => __awaiter(this, void 0, void 0, function* () {
-                const result = yield this._records.getPlayerConfig(comId);
+                .handler(async ({ comId }, context) => {
+                const result = await this._records.getPlayerConfig(comId);
                 return result;
-            })),
+            }),
             getSubscriptions: procedure()
                 .origins('account')
                 .http('GET', '/api/v2/subscriptions')
@@ -2303,7 +2693,7 @@ export class RecordsServer {
                     .nonempty('userId must be non-empty.')
                     .optional(),
             }))
-                .handler(({ studioId, userId }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ studioId, userId }, context) => {
                 if (!this._subscriptions) {
                     return SUBSCRIPTIONS_NOT_SUPPORTED_RESULT;
                 }
@@ -2311,7 +2701,7 @@ export class RecordsServer {
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const result = yield this._subscriptions.getSubscriptionStatus({
+                const result = await this._subscriptions.getSubscriptionStatus({
                     sessionKey,
                     userId,
                     studioId,
@@ -2347,7 +2737,7 @@ export class RecordsServer {
                         defaultSubscription: s.defaultSubscription,
                     })),
                 };
-            })),
+            }),
             getManageSubscriptionLink: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/subscriptions/manage')
@@ -2381,7 +2771,7 @@ export class RecordsServer {
                 })
                     .optional(),
             }))
-                .handler(({ userId, studioId, subscriptionId, expectedPrice }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ userId, studioId, subscriptionId, expectedPrice }, context) => {
                 if (!this._subscriptions) {
                     return SUBSCRIPTIONS_NOT_SUPPORTED_RESULT;
                 }
@@ -2389,7 +2779,7 @@ export class RecordsServer {
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const result = yield this._subscriptions.createManageSubscriptionLink({
+                const result = await this._subscriptions.createManageSubscriptionLink({
                     sessionKey,
                     userId,
                     studioId,
@@ -2403,7 +2793,7 @@ export class RecordsServer {
                     success: true,
                     url: result.url,
                 };
-            })),
+            }),
             updateSubscription: procedure()
                 .origins('account')
                 .http('POST', '/api/v2/subscriptions/update')
@@ -2435,7 +2825,7 @@ export class RecordsServer {
                     .int()
                     .nullable(),
             }))
-                .handler(({ userId, studioId, subscriptionId, subscriptionStatus, subscriptionPeriodStartMs, subscriptionPeriodEndMs, }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ userId, studioId, subscriptionId, subscriptionStatus, subscriptionPeriodStartMs, subscriptionPeriodEndMs, }, context) => {
                 if (!this._subscriptions) {
                     return SUBSCRIPTIONS_NOT_SUPPORTED_RESULT;
                 }
@@ -2443,11 +2833,11 @@ export class RecordsServer {
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const validation = yield this._validateSessionKey(sessionKey);
+                const validation = await this._validateSessionKey(sessionKey);
                 if (validation.success === false) {
                     return validation;
                 }
-                const result = yield this._subscriptions.updateSubscription({
+                const result = await this._subscriptions.updateSubscription({
                     currentUserId: validation.userId,
                     currentUserRole: validation.role,
                     userId,
@@ -2458,7 +2848,7 @@ export class RecordsServer {
                     subscriptionPeriodEndMs,
                 });
                 return result;
-            })),
+            }),
             listInsts: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/records/insts/list')
@@ -2466,7 +2856,7 @@ export class RecordsServer {
                 recordName: RECORD_NAME_VALIDATION.optional(),
                 inst: z.string().optional(),
             }))
-                .handler(({ recordName, inst }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, inst }, context) => {
                 if (!this._websocketController) {
                     return INSTS_NOT_SUPPORTED_RESULT;
                 }
@@ -2474,14 +2864,14 @@ export class RecordsServer {
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const validation = yield this._validateSessionKey(sessionKey);
+                const validation = await this._validateSessionKey(sessionKey);
                 if (validation.success === false) {
                     return validation;
                 }
                 const userId = validation.userId;
-                const result = yield this._websocketController.listInsts(recordName, userId, inst);
+                const result = await this._websocketController.listInsts(recordName, userId, inst);
                 return result;
-            })),
+            }),
             deleteInst: procedure()
                 .origins('account')
                 .http('DELETE', '/api/v2/records/insts')
@@ -2490,7 +2880,7 @@ export class RecordsServer {
                 recordName: RECORD_NAME_VALIDATION.optional(),
                 inst: z.string().optional(),
             }))
-                .handler(({ recordKey, recordName, inst }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordKey, recordName, inst }, context) => {
                 if (!this._websocketController) {
                     return INSTS_NOT_SUPPORTED_RESULT;
                 }
@@ -2498,13 +2888,13 @@ export class RecordsServer {
                 if (!sessionKey) {
                     return NOT_LOGGED_IN_RESULT;
                 }
-                const validation = yield this._validateSessionKey(sessionKey);
+                const validation = await this._validateSessionKey(sessionKey);
                 if (validation.success === false) {
                     return validation;
                 }
-                const result = yield this._websocketController.eraseInst(recordKey !== null && recordKey !== void 0 ? recordKey : recordName, inst, validation.userId);
+                const result = await this._websocketController.eraseInst(recordKey !== null && recordKey !== void 0 ? recordKey : recordName, inst, validation.userId);
                 return result;
-            })),
+            }),
             reportInst: procedure()
                 .origins('api')
                 .http('POST', '/api/v2/records/insts/report')
@@ -2525,17 +2915,17 @@ export class RecordsServer {
                 reportedUrl: z.string().url(),
                 reportedPermalink: z.string().url(),
             }))
-                .handler(({ recordName, inst, automaticReport, reportReason, reportReasonText, reportedUrl, reportedPermalink, }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, inst, automaticReport, reportReason, reportReasonText, reportedUrl, reportedPermalink, }, context) => {
                 if (!this._moderationController) {
                     return MODERATION_NOT_SUPPORTED_RESULT;
                 }
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode !== 'no_session_key') {
                         return validation;
                     }
                 }
-                const result = yield this._moderationController.reportInst({
+                const result = await this._moderationController.reportInst({
                     recordName,
                     inst,
                     automaticReport,
@@ -2547,7 +2937,7 @@ export class RecordsServer {
                     reportingUserId: validation.userId,
                 });
                 return result;
-            })),
+            }),
             getInstData: procedure()
                 .origins(true)
                 .http('GET', '/instData')
@@ -2559,9 +2949,9 @@ export class RecordsServer {
                     .nonempty()
                     .default(DEFAULT_BRANCH_NAME),
             }))
-                .handler(({ recordName, inst, branch }, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async ({ recordName, inst, branch }, context) => {
                 let userId = null;
-                const validation = yield this._validateSessionKey(context.sessionKey);
+                const validation = await this._validateSessionKey(context.sessionKey);
                 if (validation.success === false) {
                     if (validation.errorCode === 'no_session_key') {
                         userId = null;
@@ -2573,18 +2963,26 @@ export class RecordsServer {
                 else {
                     userId = validation.userId;
                 }
-                const data = yield this._websocketController.getBranchData(userId, recordName !== null && recordName !== void 0 ? recordName : null, inst, branch);
-                return Object.assign({ success: true }, data);
-            })),
+                const data = await this._websocketController.getBranchData(userId, recordName !== null && recordName !== void 0 ? recordName : null, inst, branch);
+                return {
+                    success: true,
+                    ...data,
+                };
+            }),
             listProcedures: procedure()
                 .origins(true)
                 .http('GET', '/api/v2/procedures')
                 .inputs(z.object({}))
-                .handler((_, context) => __awaiter(this, void 0, void 0, function* () {
+                .handler(async (_, context) => {
                 const procedures = this._procedures;
                 const metadata = getProcedureMetadata(procedures);
-                return Object.assign(Object.assign({ success: true }, metadata), { version: typeof GIT_TAG === 'string' ? GIT_TAG : undefined, versionHash: typeof GIT_HASH === 'string' ? GIT_HASH : undefined });
-            })),
+                return {
+                    success: true,
+                    ...metadata,
+                    version: typeof GIT_TAG === 'string' ? GIT_TAG : undefined,
+                    versionHash: typeof GIT_HASH === 'string' ? GIT_HASH : undefined,
+                };
+            }),
         };
     }
     _setupRoutes() {
@@ -2605,7 +3003,7 @@ export class RecordsServer {
                 input: z.any().optional(),
                 query: z.any().optional(),
             }),
-            handler: (request, { procedure, input, query }) => __awaiter(this, void 0, void 0, function* () {
+            handler: async (request, { procedure, input, query }) => {
                 var _a, _b;
                 const proc = procs[procedure];
                 if (!proc) {
@@ -2648,13 +3046,13 @@ export class RecordsServer {
                         }
                         queryData = parseResult.data;
                     }
-                    result = yield proc.handler(parseResult.data, context, queryData);
+                    result = await proc.handler(parseResult.data, context, queryData);
                 }
                 else {
-                    result = yield proc.handler(input, context);
+                    result = await proc.handler(input, context);
                 }
                 return returnProcedureOutput(result);
-            }),
+            },
         });
         this.addRoute({
             method: 'POST',
@@ -2702,7 +3100,7 @@ export class RecordsServer {
             schema: procedure.schema,
             querySchema: procedure.querySchema,
             name: name,
-            handler: (request, data, query) => __awaiter(this, void 0, void 0, function* () {
+            handler: async (request, data, query) => {
                 var _a;
                 const context = {
                     ipAddress: request.ipAddress,
@@ -2710,14 +3108,14 @@ export class RecordsServer {
                     httpRequest: request,
                     origin: (_a = request.headers.origin) !== null && _a !== void 0 ? _a : null,
                 };
-                const result = yield procedure.handler(data, context, query);
+                const result = await procedure.handler(data, context, query);
                 const response = returnProcedureOutput(result);
                 if (procedure.mapToResponse) {
-                    const procedureResponse = yield procedure.mapToResponse(result, context);
+                    const procedureResponse = await procedure.mapToResponse(result, context);
                     return merge(response, procedureResponse);
                 }
                 return response;
-            }),
+            },
             allowedOrigins: procedure.allowedOrigins,
         };
         this.addRoute(r);
@@ -2744,360 +3142,351 @@ export class RecordsServer {
      * Handles the given request and returns the specified response.
      * @param request The request that should be handled.
      */
-    handleHttpRequest(request) {
+    async handleHttpRequest(request) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const span = trace.getActiveSpan();
-            if (span) {
-                const url = new URL(request.path, `http://${request.headers.host}`);
-                span.setAttributes({
-                    [SEMATTRS_HTTP_METHOD]: request.method,
-                    [SEMATTRS_HTTP_URL]: url.href,
-                    [SEMATTRS_HTTP_TARGET]: request.path,
-                    [SEMATTRS_HTTP_CLIENT_IP]: request.ipAddress,
-                    [SEMATTRS_HTTP_HOST]: request.headers.host,
-                    [SEMATTRS_HTTP_USER_AGENT]: request.headers['user-agent'],
-                    ['http.origin']: request.headers.origin,
-                });
-            }
-            let skipRateLimitCheck = false;
-            if (!this._rateLimit) {
-                skipRateLimitCheck = true;
+        const span = trace.getActiveSpan();
+        if (span) {
+            const url = new URL(request.path, `http://${request.headers.host}`);
+            span.setAttributes({
+                [SEMATTRS_HTTP_METHOD]: request.method,
+                [SEMATTRS_HTTP_URL]: url.href,
+                [SEMATTRS_HTTP_TARGET]: request.path,
+                [SEMATTRS_HTTP_CLIENT_IP]: request.ipAddress,
+                [SEMATTRS_HTTP_HOST]: request.headers.host,
+                [SEMATTRS_HTTP_USER_AGENT]: request.headers['user-agent'],
+                ['http.origin']: request.headers.origin,
+            });
+        }
+        let skipRateLimitCheck = false;
+        if (!this._rateLimit) {
+            skipRateLimitCheck = true;
+        }
+        else if (request.method == 'POST' &&
+            request.path === '/api/stripeWebhook') {
+            skipRateLimitCheck = true;
+        }
+        if (skipRateLimitCheck && span) {
+            span.setAttribute('request.rateLimitCheck', 'skipped');
+        }
+        if (!skipRateLimitCheck) {
+            const response = await this._rateLimit.checkRateLimit({
+                ipAddress: request.ipAddress,
+            });
+            if (response.success === false) {
+                if (response.errorCode === 'rate_limit_exceeded') {
+                    return formatResponse(request, returnResult(response), true);
+                }
+                else {
+                    console.log('[RecordsServer] Rate limit check failed. Allowing request to continue.');
+                }
             }
-            else if (request.method == 'POST' &&
-                request.path === '/api/stripeWebhook') {
-                skipRateLimitCheck = true;
+        }
+        if (request.method === 'GET' &&
+            request.path.startsWith('/api/') &&
+            request.path.endsWith('/metadata') &&
+            !!request.pathParams.userId) {
+            return formatResponse(request, await this._getUserInfo(request), this._allowedAccountOrigins);
+        }
+        else if (request.method === 'PUT' &&
+            request.path.startsWith('/api/') &&
+            request.path.endsWith('/metadata') &&
+            !!request.pathParams.userId) {
+            return formatResponse(request, await this._putUserInfo(request), this._allowedAccountOrigins);
+        }
+        else if (request.method === 'GET' &&
+            request.path.startsWith('/api/') &&
+            request.path.endsWith('/subscription') &&
+            !!request.pathParams.userId) {
+            return formatResponse(request, await this._getSubscriptionInfo(request), this._allowedAccountOrigins);
+        }
+        else if (request.method === 'POST' &&
+            request.path.startsWith('/api/') &&
+            request.path.endsWith('/subscription/manage') &&
+            !!request.pathParams.userId) {
+            return formatResponse(request, await this._manageSubscription(request), this._allowedAccountOrigins);
+        }
+        else if (request.method === 'OPTIONS' &&
+            request.path.startsWith('/api/v2/records/file/')) {
+            return formatResponse(request, await this._handleRecordFileOptions(request), this._allowedApiOrigins);
+        }
+        else if (request.method === 'OPTIONS') {
+            return formatResponse(request, await this._handleOptions(request), true);
+        }
+        const route = this._routes.get(`${request.method}:${request.path}`);
+        if (route) {
+            if (span && route.name) {
+                span.updateName(`http:${route.name}`);
             }
-            if (skipRateLimitCheck && span) {
-                span.setAttribute('request.rateLimitCheck', 'skipped');
+            const origins = route.allowedOrigins === 'account'
+                ? this._allowedAccountOrigins
+                : route.allowedOrigins === 'api'
+                    ? this._allowedApiOrigins
+                    : (_a = route.allowedOrigins) !== null && _a !== void 0 ? _a : true;
+            if (origins !== true && !validateOrigin(request, origins)) {
+                return formatResponse(request, returnResult(INVALID_ORIGIN_RESULT), origins);
             }
-            if (!skipRateLimitCheck) {
-                const response = yield this._rateLimit.checkRateLimit({
-                    ipAddress: request.ipAddress,
-                });
-                if (response.success === false) {
-                    if (response.errorCode === 'rate_limit_exceeded') {
-                        return formatResponse(request, returnResult(response), true);
+            try {
+                let response;
+                if (route.schema) {
+                    let data;
+                    if (request.method === 'GET' || request.method === 'HEAD') {
+                        const parseResult = route.schema.safeParse(request.query);
+                        if (parseResult.success === false) {
+                            return formatResponse(request, returnZodError(parseResult.error), origins);
+                        }
+                        data = parseResult.data;
                     }
                     else {
-                        console.log('[RecordsServer] Rate limit check failed. Allowing request to continue.');
-                    }
-                }
-            }
-            if (request.method === 'GET' &&
-                request.path.startsWith('/api/') &&
-                request.path.endsWith('/metadata') &&
-                !!request.pathParams.userId) {
-                return formatResponse(request, yield this._getUserInfo(request), this._allowedAccountOrigins);
-            }
-            else if (request.method === 'PUT' &&
-                request.path.startsWith('/api/') &&
-                request.path.endsWith('/metadata') &&
-                !!request.pathParams.userId) {
-                return formatResponse(request, yield this._putUserInfo(request), this._allowedAccountOrigins);
-            }
-            else if (request.method === 'GET' &&
-                request.path.startsWith('/api/') &&
-                request.path.endsWith('/subscription') &&
-                !!request.pathParams.userId) {
-                return formatResponse(request, yield this._getSubscriptionInfo(request), this._allowedAccountOrigins);
-            }
-            else if (request.method === 'POST' &&
-                request.path.startsWith('/api/') &&
-                request.path.endsWith('/subscription/manage') &&
-                !!request.pathParams.userId) {
-                return formatResponse(request, yield this._manageSubscription(request), this._allowedAccountOrigins);
-            }
-            else if (request.method === 'OPTIONS' &&
-                request.path.startsWith('/api/v2/records/file/')) {
-                return formatResponse(request, yield this._handleRecordFileOptions(request), this._allowedApiOrigins);
-            }
-            else if (request.method === 'OPTIONS') {
-                return formatResponse(request, yield this._handleOptions(request), true);
-            }
-            const route = this._routes.get(`${request.method}:${request.path}`);
-            if (route) {
-                if (span && route.name) {
-                    span.updateName(`http:${route.name}`);
-                }
-                const origins = route.allowedOrigins === 'account'
-                    ? this._allowedAccountOrigins
-                    : route.allowedOrigins === 'api'
-                        ? this._allowedApiOrigins
-                        : (_a = route.allowedOrigins) !== null && _a !== void 0 ? _a : true;
-                if (origins !== true && !validateOrigin(request, origins)) {
-                    return formatResponse(request, returnResult(INVALID_ORIGIN_RESULT), origins);
-                }
-                try {
-                    let response;
-                    if (route.schema) {
-                        let data;
-                        if (request.method === 'GET' || request.method === 'HEAD') {
-                            const parseResult = route.schema.safeParse(request.query);
-                            if (parseResult.success === false) {
-                                return formatResponse(request, returnZodError(parseResult.error), origins);
-                            }
-                            data = parseResult.data;
+                        if (typeof request.body !== 'string') {
+                            return formatResponse(request, returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON), origins);
                         }
-                        else {
-                            if (typeof request.body !== 'string') {
-                                return formatResponse(request, returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON), origins);
-                            }
-                            const jsonResult = tryParseJson(request.body);
-                            if (!jsonResult.success ||
-                                typeof jsonResult.value !== 'object') {
-                                return formatResponse(request, returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON), origins);
-                            }
-                            const parseResult = route.schema.safeParse(jsonResult.value);
-                            if (parseResult.success === false) {
-                                return formatResponse(request, returnZodError(parseResult.error), origins);
-                            }
-                            data = parseResult.data;
+                        const jsonResult = tryParseJson(request.body);
+                        if (!jsonResult.success ||
+                            typeof jsonResult.value !== 'object') {
+                            return formatResponse(request, returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON), origins);
                         }
-                        let query;
-                        if (route.querySchema) {
-                            const parseResult = route.schema.safeParse(request.query);
-                            if (parseResult.success === false) {
-                                return formatResponse(request, returnZodError(parseResult.error), origins);
-                            }
-                            query = parseResult.data;
+                        const parseResult = route.schema.safeParse(jsonResult.value);
+                        if (parseResult.success === false) {
+                            return formatResponse(request, returnZodError(parseResult.error), origins);
                         }
-                        response = yield route.handler(request, data, query);
-                    }
-                    else {
-                        response = yield route.handler(request);
+                        data = parseResult.data;
                     }
-                    if (response) {
-                        return formatResponse(request, response, origins);
-                    }
-                    else {
-                        return formatResponse(request, returnResult({ success: true }), origins);
+                    let query;
+                    if (route.querySchema) {
+                        const parseResult = route.schema.safeParse(request.query);
+                        if (parseResult.success === false) {
+                            return formatResponse(request, returnZodError(parseResult.error), origins);
+                        }
+                        query = parseResult.data;
                     }
+                    response = await route.handler(request, data, query);
                 }
-                catch (err) {
-                    console.error('[RecordsServer] Error while handling request: ', err, request);
-                    return formatResponse(request, returnResult({
-                        success: false,
-                        errorCode: 'server_error',
-                        errorMessage: 'A server error occurred.',
-                    }), origins);
+                else {
+                    response = await route.handler(request);
+                }
+                if (response) {
+                    return formatResponse(request, response, origins);
+                }
+                else {
+                    return formatResponse(request, returnResult({ success: true }), origins);
                 }
             }
-            return formatResponse(request, returnResult(OPERATION_NOT_FOUND_RESULT), true);
-        });
+            catch (err) {
+                console.error('[RecordsServer] Error while handling request: ', err, request);
+                return formatResponse(request, returnResult({
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'A server error occurred.',
+                }), origins);
+            }
+        }
+        return formatResponse(request, returnResult(OPERATION_NOT_FOUND_RESULT), true);
     }
     /**
      * Handles the given request and returns the specified response.
      * @param request The request that should be handled.
      */
-    handleWebsocketRequest(request) {
+    async handleWebsocketRequest(request) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._websocketController) {
-                return;
-            }
-            const span = trace.getActiveSpan();
-            if (span) {
-                span.setAttributes({
-                    [SEMATTRS_HTTP_CLIENT_IP]: request.ipAddress,
-                    ['http.origin']: request.origin,
-                    ['websocket.type']: request.type,
-                    ['request.connectionId']: request.connectionId,
-                });
-            }
-            let skipRateLimitCheck = false;
-            if (!this._websocketRateLimit) {
-                skipRateLimitCheck = true;
-            }
-            else if (request.type !== 'message') {
-                skipRateLimitCheck = true;
-            }
-            if (!skipRateLimitCheck) {
-                const response = yield this._websocketRateLimit.checkRateLimit({
-                    ipAddress: request.ipAddress,
-                });
-                if (response.success === false) {
-                    if (response.errorCode === 'rate_limit_exceeded') {
-                        yield this._websocketController.rateLimitExceeded(request.connectionId, (_a = response.retryAfterSeconds) !== null && _a !== void 0 ? _a : 0, response.totalHits, Date.now());
-                        return;
-                    }
-                    else {
-                        console.log('[RecordsServer] Websocket rate limit check failed. Allowing request to continue.');
-                    }
-                }
-            }
-            if (skipRateLimitCheck && span) {
-                span.setAttribute('request.rateLimitCheck', 'skipped');
-            }
-            if (request.type === 'connect') {
-                console.log(`[RecordsServer] Connection recieved: `, request.connectionId);
-            }
-            else if (request.type === 'disconnect') {
-                console.log(`[RecordsServer] Disconnection recieved: `, request.connectionId);
-                yield this._websocketController.disconnect(request.connectionId);
-            }
-            else if (request.type === 'message') {
-                if (typeof request.body !== 'string') {
-                    // Bad request
-                    return;
-                }
-                const jsonResult = tryParseJson(request.body);
-                if (!jsonResult.success || typeof jsonResult.value !== 'object') {
-                    return;
-                }
-                const parseResult = websocketEventSchema.safeParse(jsonResult.value);
-                if (parseResult.success === false) {
-                    yield this._sendWebsocketZodError(request.connectionId, null, parseResult.error);
+        if (!this._websocketController) {
+            return;
+        }
+        const span = trace.getActiveSpan();
+        if (span) {
+            span.setAttributes({
+                [SEMATTRS_HTTP_CLIENT_IP]: request.ipAddress,
+                ['http.origin']: request.origin,
+                ['websocket.type']: request.type,
+                ['request.connectionId']: request.connectionId,
+            });
+        }
+        let skipRateLimitCheck = false;
+        if (!this._websocketRateLimit) {
+            skipRateLimitCheck = true;
+        }
+        else if (request.type !== 'message') {
+            skipRateLimitCheck = true;
+        }
+        if (!skipRateLimitCheck) {
+            const response = await this._websocketRateLimit.checkRateLimit({
+                ipAddress: request.ipAddress,
+            });
+            if (response.success === false) {
+                if (response.errorCode === 'rate_limit_exceeded') {
+                    await this._websocketController.rateLimitExceeded(request.connectionId, (_a = response.retryAfterSeconds) !== null && _a !== void 0 ? _a : 0, response.totalHits, Date.now());
                     return;
                 }
-                let [type, requestId, ...rest] = parseResult.data;
-                if (type === WebsocketEventTypes.Message) {
-                    const [message] = rest;
-                    return yield this._processWebsocketMessage(request, requestId, message);
-                }
-                else if (type === WebsocketEventTypes.UploadRequest) {
-                    return yield this._processWebsocketUploadRequest(request, requestId);
-                }
-                else if (type === WebsocketEventTypes.DownloadRequest) {
-                    const [url, method, headers] = rest;
-                    return yield this._processWebsocketDownload(request, requestId, url, method, headers);
-                }
                 else {
-                    // not supported
-                    return;
+                    console.log('[RecordsServer] Websocket rate limit check failed. Allowing request to continue.');
                 }
             }
-        });
-    }
-    _sendWebsocketZodError(connectionId, requestId, error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._websocketController.sendError(connectionId, requestId, {
-                success: false,
-                errorCode: 'unacceptable_request',
-                errorMessage: 'The request was invalid. One or more fields were invalid.',
-                issues: error.issues,
-            });
-        });
-    }
-    _processWebsocketMessage(request, requestId, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const span = trace.getActiveSpan();
-            const messageResult = websocketRequestMessageSchema.safeParse(message);
-            if (messageResult.success === false) {
-                span === null || span === void 0 ? void 0 : span.setAttribute('request.messageType', 'invalid');
-                yield this._sendWebsocketZodError(request.connectionId, requestId, messageResult.error);
+        }
+        if (skipRateLimitCheck && span) {
+            span.setAttribute('request.rateLimitCheck', 'skipped');
+        }
+        if (request.type === 'connect') {
+            console.log(`[RecordsServer] Connection recieved: `, request.connectionId);
+        }
+        else if (request.type === 'disconnect') {
+            console.log(`[RecordsServer] Disconnection recieved: `, request.connectionId);
+            await this._websocketController.disconnect(request.connectionId);
+        }
+        else if (request.type === 'message') {
+            if (typeof request.body !== 'string') {
+                // Bad request
                 return;
             }
-            const data = messageResult.data;
-            span === null || span === void 0 ? void 0 : span.setAttribute('request.messageType', data.type);
-            if (data.type === 'login') {
-                yield this._websocketController.login(request.connectionId, requestId, data);
+            const jsonResult = tryParseJson(request.body);
+            if (!jsonResult.success || typeof jsonResult.value !== 'object') {
+                return;
             }
-            else if (data.type === 'repo/watch_branch') {
-                yield this._websocketController.watchBranch(request.connectionId, data);
+            const parseResult = websocketEventSchema.safeParse(jsonResult.value);
+            if (parseResult.success === false) {
+                await this._sendWebsocketZodError(request.connectionId, null, parseResult.error);
+                return;
             }
-            else if (data.type === 'repo/unwatch_branch') {
-                yield this._websocketController.unwatchBranch(request.connectionId, data.recordName, data.inst, data.branch);
+            let [type, requestId, ...rest] = parseResult.data;
+            if (type === WebsocketEventTypes.Message) {
+                const [message] = rest;
+                return await this._processWebsocketMessage(request, requestId, message);
             }
-            else if (data.type === 'repo/add_updates') {
-                yield this._websocketController.addUpdates(request.connectionId, data);
+            else if (type === WebsocketEventTypes.UploadRequest) {
+                return await this._processWebsocketUploadRequest(request, requestId);
             }
-            else if (data.type === 'repo/get_updates') {
-                yield this._websocketController.getUpdates(request.connectionId, data.recordName, data.inst, data.branch);
+            else if (type === WebsocketEventTypes.DownloadRequest) {
+                const [url, method, headers] = rest;
+                return await this._processWebsocketDownload(request, requestId, url, method, headers);
             }
-            else if (data.type === 'repo/send_action') {
-                yield this._websocketController.sendAction(request.connectionId, data);
-            }
-            else if (data.type === 'repo/watch_branch_devices') {
-                yield this._websocketController.watchBranchDevices(request.connectionId, data.recordName, data.inst, data.branch);
-            }
-            else if (data.type === 'repo/unwatch_branch_devices') {
-                yield this._websocketController.unwatchBranchDevices(request.connectionId, data.recordName, data.inst, data.branch);
-            }
-            else if (data.type === 'repo/connection_count') {
-                yield this._websocketController.deviceCount(request.connectionId, data.recordName, data.inst, data.branch);
-            }
-            else if (data.type === 'sync/time') {
-                yield this._websocketController.syncTime(request.connectionId, data, Date.now());
-            }
-            else if (data.type === 'permission/request/missing') {
-                yield this._websocketController.requestMissingPermission(request.connectionId, data);
+            else {
+                // not supported
+                return;
             }
-            else if (data.type === 'permission/request/missing/response') {
-                yield this._websocketController.respondToPermissionRequest(request.connectionId, data);
+        }
+    }
+    async _sendWebsocketZodError(connectionId, requestId, error) {
+        await this._websocketController.sendError(connectionId, requestId, {
+            success: false,
+            errorCode: 'unacceptable_request',
+            errorMessage: 'The request was invalid. One or more fields were invalid.',
+            issues: error.issues,
+        });
+    }
+    async _processWebsocketMessage(request, requestId, message) {
+        const span = trace.getActiveSpan();
+        const messageResult = websocketRequestMessageSchema.safeParse(message);
+        if (messageResult.success === false) {
+            span === null || span === void 0 ? void 0 : span.setAttribute('request.messageType', 'invalid');
+            await this._sendWebsocketZodError(request.connectionId, requestId, messageResult.error);
+            return;
+        }
+        const data = messageResult.data;
+        span === null || span === void 0 ? void 0 : span.setAttribute('request.messageType', data.type);
+        if (data.type === 'login') {
+            await this._websocketController.login(request.connectionId, requestId, data);
+        }
+        else if (data.type === 'repo/watch_branch') {
+            await this._websocketController.watchBranch(request.connectionId, data);
+        }
+        else if (data.type === 'repo/unwatch_branch') {
+            await this._websocketController.unwatchBranch(request.connectionId, data.recordName, data.inst, data.branch);
+        }
+        else if (data.type === 'repo/add_updates') {
+            await this._websocketController.addUpdates(request.connectionId, data);
+        }
+        else if (data.type === 'repo/get_updates') {
+            await this._websocketController.getUpdates(request.connectionId, data.recordName, data.inst, data.branch);
+        }
+        else if (data.type === 'repo/send_action') {
+            await this._websocketController.sendAction(request.connectionId, data);
+        }
+        else if (data.type === 'repo/watch_branch_devices') {
+            await this._websocketController.watchBranchDevices(request.connectionId, data.recordName, data.inst, data.branch);
+        }
+        else if (data.type === 'repo/unwatch_branch_devices') {
+            await this._websocketController.unwatchBranchDevices(request.connectionId, data.recordName, data.inst, data.branch);
+        }
+        else if (data.type === 'repo/connection_count') {
+            await this._websocketController.deviceCount(request.connectionId, data.recordName, data.inst, data.branch);
+        }
+        else if (data.type === 'sync/time') {
+            await this._websocketController.syncTime(request.connectionId, data, Date.now());
+        }
+        else if (data.type === 'permission/request/missing') {
+            await this._websocketController.requestMissingPermission(request.connectionId, data);
+        }
+        else if (data.type === 'permission/request/missing/response') {
+            await this._websocketController.respondToPermissionRequest(request.connectionId, data);
+        }
+        else if (data.type === 'http_request') {
+            let headers = {};
+            for (let key in data.request.headers) {
+                headers[key.toLowerCase()] = data.request.headers[key];
             }
-            else if (data.type === 'http_request') {
-                let headers = {};
-                for (let key in data.request.headers) {
-                    headers[key.toLowerCase()] = data.request.headers[key];
-                }
-                headers.origin = request.origin;
-                const httpRequest = {
-                    path: data.request.path,
-                    method: data.request.method,
-                    pathParams: data.request.pathParams,
-                    body: data.request.body,
-                    query: data.request.query,
-                    headers: headers,
-                    ipAddress: request.ipAddress,
-                };
-                const result = yield this.handleHttpRequest(httpRequest);
-                if (typeof result.body === 'object' &&
-                    Symbol.asyncIterator in result.body) {
-                    let response = result;
-                    let index = 0;
-                    const i = result.body[Symbol.asyncIterator]();
-                    while (true) {
-                        let { value, done } = yield i.next();
-                        yield this._websocketController.messenger.sendMessage([request.connectionId], {
-                            type: 'http_partial_response',
-                            id: data.id,
-                            index: index,
-                            final: done ? true : undefined,
-                            response: Object.assign(Object.assign({}, response), { body: value }),
-                        });
-                        response = {};
-                        index += 1;
-                        if (done) {
-                            break;
-                        }
-                    }
-                }
-                else {
-                    yield this._websocketController.messenger.sendMessage([request.connectionId], {
-                        type: 'http_response',
+            headers.origin = request.origin;
+            const httpRequest = {
+                path: data.request.path,
+                method: data.request.method,
+                pathParams: data.request.pathParams,
+                body: data.request.body,
+                query: data.request.query,
+                headers: headers,
+                ipAddress: request.ipAddress,
+            };
+            const result = await this.handleHttpRequest(httpRequest);
+            if (typeof result.body === 'object' &&
+                Symbol.asyncIterator in result.body) {
+                let response = result;
+                let index = 0;
+                const i = result.body[Symbol.asyncIterator]();
+                while (true) {
+                    let { value, done } = await i.next();
+                    await this._websocketController.messenger.sendMessage([request.connectionId], {
+                        type: 'http_partial_response',
                         id: data.id,
-                        response: result,
+                        index: index,
+                        final: done ? true : undefined,
+                        response: {
+                            ...response,
+                            body: value,
+                        },
                     });
+                    response = {};
+                    index += 1;
+                    if (done) {
+                        break;
+                    }
                 }
             }
-        });
-    }
-    _processWebsocketDownload(request, requestId, url, method, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connectionId = request.connectionId;
-            const result = yield this._websocketController.downloadRequest(connectionId, requestId, url, method, headers);
-            if (result.success === false) {
-                yield this._websocketController.sendError(connectionId, requestId, result);
-                return;
-            }
-            const parseResult = tryParseJson(result.message);
-            if (!parseResult.success) {
-                yield this._websocketController.sendError(connectionId, requestId, {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'The request was invalid. The downloaded file must contain JSON.',
+            else {
+                await this._websocketController.messenger.sendMessage([request.connectionId], {
+                    type: 'http_response',
+                    id: data.id,
+                    response: result,
                 });
-                return;
             }
-            yield this._processWebsocketMessage(request, requestId, parseResult.value);
-        });
+        }
     }
-    _processWebsocketUploadRequest(request, requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connectionId = request.connectionId;
-            yield this._websocketController.uploadRequest(connectionId, requestId);
-        });
+    async _processWebsocketDownload(request, requestId, url, method, headers) {
+        const connectionId = request.connectionId;
+        const result = await this._websocketController.downloadRequest(connectionId, requestId, url, method, headers);
+        if (result.success === false) {
+            await this._websocketController.sendError(connectionId, requestId, result);
+            return;
+        }
+        const parseResult = tryParseJson(result.message);
+        if (!parseResult.success) {
+            await this._websocketController.sendError(connectionId, requestId, {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'The request was invalid. The downloaded file must contain JSON.',
+            });
+            return;
+        }
+        await this._processWebsocketMessage(request, requestId, parseResult.value);
+    }
+    async _processWebsocketUploadRequest(request, requestId) {
+        const connectionId = request.connectionId;
+        await this._websocketController.uploadRequest(connectionId, requestId);
     }
     // private _setupRoutes() {
     //     this.addRoute({
@@ -5026,572 +5415,538 @@ export class RecordsServer {
     //         },
     //     });
     // }
-    _stripeWebhook(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._subscriptions) {
-                return returnResult(SUBSCRIPTIONS_NOT_SUPPORTED_RESULT);
-            }
-            let body = null;
-            if (typeof request.body === 'string') {
-                body = request.body;
+    async _stripeWebhook(request) {
+        if (!this._subscriptions) {
+            return returnResult(SUBSCRIPTIONS_NOT_SUPPORTED_RESULT);
+        }
+        let body = null;
+        if (typeof request.body === 'string') {
+            body = request.body;
+        }
+        else if (ArrayBuffer.isView(request.body)) {
+            try {
+                const decoder = new TextDecoder();
+                body = decoder.decode(request.body);
             }
-            else if (ArrayBuffer.isView(request.body)) {
-                try {
-                    const decoder = new TextDecoder();
-                    body = decoder.decode(request.body);
-                }
-                catch (err) {
-                    console.log('[RecordsServer] Unable to decode request body!', err);
-                    return returnResult({
-                        success: false,
-                        errorCode: 'invalid_request',
-                        errorMessage: INVALID_REQUEST_ERROR_MESSAGE,
-                    });
-                }
+            catch (err) {
+                console.log('[RecordsServer] Unable to decode request body!', err);
+                return returnResult({
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: INVALID_REQUEST_ERROR_MESSAGE,
+                });
             }
-            const signature = request.headers['stripe-signature'];
-            const result = yield this._subscriptions.handleStripeWebhook({
-                requestBody: body,
-                signature,
-            });
-            return returnResult(result);
+        }
+        const signature = request.headers['stripe-signature'];
+        const result = await this._subscriptions.handleStripeWebhook({
+            requestBody: body,
+            signature,
         });
+        return returnResult(result);
     }
-    _handleOptions(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!validateOrigin(request, this._allowedApiOrigins)) {
-                return returnResult(INVALID_ORIGIN_RESULT);
-            }
+    async _handleOptions(request) {
+        if (!validateOrigin(request, this._allowedApiOrigins)) {
+            return returnResult(INVALID_ORIGIN_RESULT);
+        }
+        return {
+            statusCode: 204,
+            headers: {
+                'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+            },
+        };
+    }
+    async _handleRecordFileOptions(request) {
+        if (!validateOrigin(request, this._allowedApiOrigins)) {
+            return returnResult(INVALID_ORIGIN_RESULT);
+        }
+        const headers = this._files.getAllowedUploadHeaders();
+        const allAllowedHeaders = new Set([
+            ...headers.map((h) => h.toLocaleLowerCase()),
+            'content-type',
+            'authorization',
+        ]);
+        return {
+            statusCode: 204,
+            headers: {
+                'Access-Control-Allow-Headers': [...allAllowedHeaders].join(', '),
+                'Access-Control-Allow-Methods': 'POST',
+                'Access-Control-Max-Age': '14400',
+            },
+        };
+    }
+    async _recordFile({ recordKey, fileSha256Hex, fileByteLength, fileMimeType, fileDescription, markers, instances, }, context) {
+        if (!recordKey || typeof recordKey !== 'string') {
             return {
-                statusCode: 204,
-                headers: {
-                    'Access-Control-Allow-Methods': 'POST, OPTIONS',
-                    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-                },
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'recordKey is required and must be a string.',
             };
-        });
-    }
-    _handleRecordFileOptions(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!validateOrigin(request, this._allowedApiOrigins)) {
-                return returnResult(INVALID_ORIGIN_RESULT);
-            }
-            const headers = this._files.getAllowedUploadHeaders();
-            const allAllowedHeaders = new Set([
-                ...headers.map((h) => h.toLocaleLowerCase()),
-                'content-type',
-                'authorization',
-            ]);
+        }
+        if (!fileSha256Hex || typeof fileSha256Hex !== 'string') {
             return {
-                statusCode: 204,
-                headers: {
-                    'Access-Control-Allow-Headers': [...allAllowedHeaders].join(', '),
-                    'Access-Control-Allow-Methods': 'POST',
-                    'Access-Control-Max-Age': '14400',
-                },
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileSha256Hex is required and must be a string.',
             };
+        }
+        if (!fileByteLength || typeof fileByteLength !== 'number') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileByteLength is required and must be a number.',
+            };
+        }
+        if (!fileMimeType || typeof fileMimeType !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileMimeType is required and must be a string.',
+            };
+        }
+        if (!!fileDescription && typeof fileDescription !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileDescription must be a string.',
+            };
+        }
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const userId = validation.userId;
+        const result = await this._files.recordFile(recordKey, userId, {
+            fileSha256Hex,
+            fileByteLength,
+            fileMimeType,
+            fileDescription,
+            headers: {},
+            markers,
+            instances,
         });
+        return result;
     }
-    _recordFile({ recordKey, fileSha256Hex, fileByteLength, fileMimeType, fileDescription, markers, instances, }, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!recordKey || typeof recordKey !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'recordKey is required and must be a string.',
-                };
-            }
-            if (!fileSha256Hex || typeof fileSha256Hex !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileSha256Hex is required and must be a string.',
-                };
-            }
-            if (!fileByteLength || typeof fileByteLength !== 'number') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileByteLength is required and must be a number.',
-                };
-            }
-            if (!fileMimeType || typeof fileMimeType !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileMimeType is required and must be a string.',
-                };
-            }
-            if (!!fileDescription && typeof fileDescription !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileDescription must be a string.',
-                };
+    async _updateFile(data, context) {
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const userId = validation.userId;
+        const fileNameResult = await this._files.getFileNameFromUrl(data.fileUrl);
+        if (!fileNameResult.success) {
+            return fileNameResult;
+        }
+        const result = await this._files.updateFile(data.recordKey, fileNameResult.fileName, userId, data.markers, data.instances);
+        return result;
+    }
+    async _readFile({ fileUrl, recordName, fileName, instances, }, context) {
+        if (!!fileUrl && typeof fileUrl !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileUrl must be a string.',
+            };
+        }
+        if (!!recordName && typeof recordName !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'recordName must be a string.',
+            };
+        }
+        if (!!fileName && typeof fileName !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileName must be a string.',
+            };
+        }
+        if (!fileUrl && (!recordName || !fileName)) {
+            let message;
+            if (!!fileName) {
+                message = 'recordName is required when fileName is provided.';
             }
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
+            else if (!!recordName) {
+                message = 'fileName is required when recordName is provided.';
             }
-            const userId = validation.userId;
-            const result = yield this._files.recordFile(recordKey, userId, {
-                fileSha256Hex,
-                fileByteLength,
-                fileMimeType,
-                fileDescription,
-                headers: {},
-                markers,
-                instances,
-            });
-            return result;
-        });
-    }
-    _updateFile(data, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
+            else {
+                message =
+                    'fileUrl or both recordName and fileName are required.';
             }
-            const userId = validation.userId;
-            const fileNameResult = yield this._files.getFileNameFromUrl(data.fileUrl);
-            if (!fileNameResult.success) {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: message,
+            };
+        }
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const userId = validation.userId;
+        if (!!fileUrl) {
+            const fileNameResult = await this._files.getFileNameFromUrl(fileUrl);
+            if (fileNameResult.success === false) {
                 return fileNameResult;
             }
-            const result = yield this._files.updateFile(data.recordKey, fileNameResult.fileName, userId, data.markers, data.instances);
-            return result;
-        });
+            recordName = fileNameResult.recordName;
+            fileName = fileNameResult.fileName;
+        }
+        const result = await this._files.readFile(recordName, fileName, userId, instances);
+        return result;
     }
-    _readFile({ fileUrl, recordName, fileName, instances, }, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!!fileUrl && typeof fileUrl !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileUrl must be a string.',
-                };
-            }
-            if (!!recordName && typeof recordName !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'recordName must be a string.',
-                };
-            }
-            if (!!fileName && typeof fileName !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileName must be a string.',
-                };
-            }
-            if (!fileUrl && (!recordName || !fileName)) {
-                let message;
-                if (!!fileName) {
-                    message = 'recordName is required when fileName is provided.';
-                }
-                else if (!!recordName) {
-                    message = 'fileName is required when recordName is provided.';
-                }
-                else {
-                    message =
-                        'fileUrl or both recordName and fileName are required.';
-                }
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: message,
-                };
-            }
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
-            }
-            const userId = validation.userId;
-            if (!!fileUrl) {
-                const fileNameResult = yield this._files.getFileNameFromUrl(fileUrl);
-                if (fileNameResult.success === false) {
-                    return fileNameResult;
-                }
-                recordName = fileNameResult.recordName;
-                fileName = fileNameResult.fileName;
-            }
-            const result = yield this._files.readFile(recordName, fileName, userId, instances);
-            return result;
-        });
+    async _listFiles({ recordName, fileName, instances }, context) {
+        if (!!recordName && typeof recordName !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'recordName must be a string.',
+            };
+        }
+        if (!!fileName && typeof fileName !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileName must be a string.',
+            };
+        }
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const userId = validation.userId;
+        const result = await this._files.listFiles(recordName, fileName, userId, instances);
+        return result;
     }
-    _listFiles({ recordName, fileName, instances }, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!!recordName && typeof recordName !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'recordName must be a string.',
-                };
-            }
-            if (!!fileName && typeof fileName !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileName must be a string.',
-                };
-            }
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
-            }
-            const userId = validation.userId;
-            const result = yield this._files.listFiles(recordName, fileName, userId, instances);
-            return result;
-        });
+    async _eraseFile({ recordKey, fileUrl, instances }, context) {
+        if (!recordKey || typeof recordKey !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'recordKey is required and must be a string.',
+            };
+        }
+        if (!fileUrl || typeof fileUrl !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'fileUrl is required and must be a string.',
+            };
+        }
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const userId = validation.userId;
+        const fileNameResult = await this._files.getFileNameFromUrl(fileUrl);
+        if (!fileNameResult.success) {
+            return fileNameResult;
+        }
+        const result = await this._files.eraseFile(recordKey, fileNameResult.fileName, userId, instances);
+        return result;
     }
-    _eraseFile({ recordKey, fileUrl, instances }, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!recordKey || typeof recordKey !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'recordKey is required and must be a string.',
-                };
-            }
-            if (!fileUrl || typeof fileUrl !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'fileUrl is required and must be a string.',
-                };
-            }
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
-            }
-            const userId = validation.userId;
-            const fileNameResult = yield this._files.getFileNameFromUrl(fileUrl);
-            if (!fileNameResult.success) {
-                return fileNameResult;
-            }
-            const result = yield this._files.eraseFile(recordKey, fileNameResult.fileName, userId, instances);
-            return result;
-        });
+    async _baseRecordData(controller, { recordKey, address, data, updatePolicy, deletePolicy, markers, instances, }, context) {
+        if (!recordKey || typeof recordKey !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'recordKey is required and must be a string.',
+            };
+        }
+        if (!address || typeof address !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'address is required and must be a string.',
+            };
+        }
+        if (typeof data === 'undefined') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'data is required.',
+            };
+        }
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const userId = validation.userId;
+        const result = await controller.recordData(recordKey, address, data, userId, updatePolicy, deletePolicy, markers, instances);
+        return result;
     }
-    _baseRecordData(controller, { recordKey, address, data, updatePolicy, deletePolicy, markers, instances, }, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!recordKey || typeof recordKey !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'recordKey is required and must be a string.',
-                };
-            }
-            if (!address || typeof address !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'address is required and must be a string.',
-                };
-            }
-            if (typeof data === 'undefined') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'data is required.',
-                };
-            }
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
-            }
-            const userId = validation.userId;
-            const result = yield controller.recordData(recordKey, address, data, userId, updatePolicy, deletePolicy, markers, instances);
-            return result;
-        });
+    async _baseGetRecordData(controller, { recordName, address, instances }, context) {
+        if (!recordName || typeof recordName !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'recordName is required and must be a string.',
+            };
+        }
+        if (!address || typeof address !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'address is required and must be a string.',
+            };
+        }
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const result = await controller.getData(recordName, address, validation.userId, instances);
+        return result;
     }
-    _baseGetRecordData(controller, { recordName, address, instances }, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!recordName || typeof recordName !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'recordName is required and must be a string.',
-                };
-            }
-            if (!address || typeof address !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'address is required and must be a string.',
-                };
-            }
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
-            }
-            const result = yield controller.getData(recordName, address, validation.userId, instances);
-            return result;
-        });
+    async _baseEraseRecordData(controller, { recordKey, address, instances }, context) {
+        if (!recordKey || typeof recordKey !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'recordKey is required and must be a string.',
+            };
+        }
+        if (!address || typeof address !== 'string') {
+            return {
+                success: false,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'address is required and must be a string.',
+            };
+        }
+        const validation = await this._validateSessionKey(context.sessionKey);
+        if (validation.success === false &&
+            validation.errorCode !== 'no_session_key') {
+            return validation;
+        }
+        const userId = validation.userId;
+        const result = await controller.eraseData(recordKey, address, userId, instances);
+        return result;
     }
-    _baseEraseRecordData(controller, { recordKey, address, instances }, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!recordKey || typeof recordKey !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'recordKey is required and must be a string.',
-                };
-            }
-            if (!address || typeof address !== 'string') {
-                return {
-                    success: false,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'address is required and must be a string.',
-                };
-            }
-            const validation = yield this._validateSessionKey(context.sessionKey);
-            if (validation.success === false &&
-                validation.errorCode !== 'no_session_key') {
-                return validation;
-            }
-            const userId = validation.userId;
-            const result = yield controller.eraseData(recordKey, address, userId, instances);
-            return result;
+    async _postReplaceSession(request) {
+        const sessionKey = getSessionKey(request);
+        if (!sessionKey) {
+            return returnResult(NOT_LOGGED_IN_RESULT);
+        }
+        const result = await this._auth.replaceSession({
+            sessionKey: sessionKey,
+            ipAddress: request.ipAddress,
         });
+        return returnResult(result);
     }
-    _postReplaceSession(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sessionKey = getSessionKey(request);
-            if (!sessionKey) {
-                return returnResult(NOT_LOGGED_IN_RESULT);
-            }
-            const result = yield this._auth.replaceSession({
-                sessionKey: sessionKey,
-                ipAddress: request.ipAddress,
-            });
-            return returnResult(result);
+    async _getSubscriptionInfo(request) {
+        if (!this._subscriptions) {
+            return returnResult(SUBSCRIPTIONS_NOT_SUPPORTED_RESULT);
+        }
+        if (!validateOrigin(request, this._allowedAccountOrigins)) {
+            return returnResult(INVALID_ORIGIN_RESULT);
+        }
+        const sessionKey = getSessionKey(request);
+        if (!sessionKey) {
+            return returnResult(NOT_LOGGED_IN_RESULT);
+        }
+        const userId = tryDecodeUriComponent(request.pathParams.userId);
+        if (!userId) {
+            return returnResult(UNACCEPTABLE_USER_ID);
+        }
+        const result = await this._subscriptions.getSubscriptionStatus({
+            sessionKey,
+            userId,
         });
-    }
-    _getSubscriptionInfo(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._subscriptions) {
-                return returnResult(SUBSCRIPTIONS_NOT_SUPPORTED_RESULT);
-            }
-            if (!validateOrigin(request, this._allowedAccountOrigins)) {
-                return returnResult(INVALID_ORIGIN_RESULT);
-            }
-            const sessionKey = getSessionKey(request);
-            if (!sessionKey) {
-                return returnResult(NOT_LOGGED_IN_RESULT);
-            }
-            const userId = tryDecodeUriComponent(request.pathParams.userId);
-            if (!userId) {
-                return returnResult(UNACCEPTABLE_USER_ID);
-            }
-            const result = yield this._subscriptions.getSubscriptionStatus({
-                sessionKey,
-                userId,
-            });
-            if (!result.success) {
-                return returnResult(result);
-            }
-            return returnResult({
-                success: true,
-                publishableKey: result.publishableKey,
-                subscriptions: result.subscriptions.map((s) => ({
-                    active: s.active,
-                    statusCode: s.statusCode,
-                    productName: s.productName,
-                    startDate: s.startDate,
-                    endedDate: s.endedDate,
-                    cancelDate: s.cancelDate,
-                    canceledDate: s.canceledDate,
-                    currentPeriodStart: s.currentPeriodStart,
-                    currentPeriodEnd: s.currentPeriodEnd,
-                    renewalInterval: s.renewalInterval,
-                    intervalLength: s.intervalLength,
-                    intervalCost: s.intervalCost,
-                    currency: s.currency,
-                    featureList: s.featureList,
-                })),
-                purchasableSubscriptions: result.purchasableSubscriptions.map((s) => ({
-                    id: s.id,
-                    name: s.name,
-                    description: s.description,
-                    featureList: s.featureList,
-                    prices: s.prices,
-                    defaultSubscription: s.defaultSubscription,
-                })),
-            });
+        if (!result.success) {
+            return returnResult(result);
+        }
+        return returnResult({
+            success: true,
+            publishableKey: result.publishableKey,
+            subscriptions: result.subscriptions.map((s) => ({
+                active: s.active,
+                statusCode: s.statusCode,
+                productName: s.productName,
+                startDate: s.startDate,
+                endedDate: s.endedDate,
+                cancelDate: s.cancelDate,
+                canceledDate: s.canceledDate,
+                currentPeriodStart: s.currentPeriodStart,
+                currentPeriodEnd: s.currentPeriodEnd,
+                renewalInterval: s.renewalInterval,
+                intervalLength: s.intervalLength,
+                intervalCost: s.intervalCost,
+                currency: s.currency,
+                featureList: s.featureList,
+            })),
+            purchasableSubscriptions: result.purchasableSubscriptions.map((s) => ({
+                id: s.id,
+                name: s.name,
+                description: s.description,
+                featureList: s.featureList,
+                prices: s.prices,
+                defaultSubscription: s.defaultSubscription,
+            })),
         });
     }
-    _manageSubscription(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._subscriptions) {
-                return returnResult(SUBSCRIPTIONS_NOT_SUPPORTED_RESULT);
-            }
-            if (!validateOrigin(request, this._allowedAccountOrigins)) {
-                return returnResult(INVALID_ORIGIN_RESULT);
-            }
-            const sessionKey = getSessionKey(request);
-            if (!sessionKey) {
-                return returnResult(NOT_LOGGED_IN_RESULT);
-            }
-            const userId = tryDecodeUriComponent(request.pathParams.userId);
-            if (!userId) {
-                return returnResult(UNACCEPTABLE_USER_ID);
-            }
-            let subscriptionId;
-            let expectedPrice;
-            if (typeof request.body === 'string' && request.body) {
-                let body = tryParseJson(request.body);
-                if (body.success) {
-                    const schema = z.object({
-                        subscriptionId: z.string().optional(),
-                        expectedPrice: z
-                            .object({
-                            currency: z.string(),
-                            cost: z.number(),
-                            interval: z.enum(['month', 'year', 'week', 'day']),
-                            intervalLength: z.number(),
-                        })
-                            .optional(),
-                    });
-                    const parseResult = schema.safeParse(body.value);
-                    if (parseResult.success === false) {
-                        return returnZodError(parseResult.error);
-                    }
-                    if (typeof parseResult.data.subscriptionId === 'string') {
-                        subscriptionId = parseResult.data.subscriptionId;
-                    }
-                    if (typeof parseResult.data.expectedPrice === 'object') {
-                        expectedPrice = parseResult.data
-                            .expectedPrice;
-                    }
+    async _manageSubscription(request) {
+        if (!this._subscriptions) {
+            return returnResult(SUBSCRIPTIONS_NOT_SUPPORTED_RESULT);
+        }
+        if (!validateOrigin(request, this._allowedAccountOrigins)) {
+            return returnResult(INVALID_ORIGIN_RESULT);
+        }
+        const sessionKey = getSessionKey(request);
+        if (!sessionKey) {
+            return returnResult(NOT_LOGGED_IN_RESULT);
+        }
+        const userId = tryDecodeUriComponent(request.pathParams.userId);
+        if (!userId) {
+            return returnResult(UNACCEPTABLE_USER_ID);
+        }
+        let subscriptionId;
+        let expectedPrice;
+        if (typeof request.body === 'string' && request.body) {
+            let body = tryParseJson(request.body);
+            if (body.success) {
+                const schema = z.object({
+                    subscriptionId: z.string().optional(),
+                    expectedPrice: z
+                        .object({
+                        currency: z.string(),
+                        cost: z.number(),
+                        interval: z.enum(['month', 'year', 'week', 'day']),
+                        intervalLength: z.number(),
+                    })
+                        .optional(),
+                });
+                const parseResult = schema.safeParse(body.value);
+                if (parseResult.success === false) {
+                    return returnZodError(parseResult.error);
+                }
+                if (typeof parseResult.data.subscriptionId === 'string') {
+                    subscriptionId = parseResult.data.subscriptionId;
+                }
+                if (typeof parseResult.data.expectedPrice === 'object') {
+                    expectedPrice = parseResult.data
+                        .expectedPrice;
                 }
             }
-            const result = yield this._subscriptions.createManageSubscriptionLink({
-                sessionKey,
-                userId,
-                subscriptionId,
-                expectedPrice,
-            });
-            if (!result.success) {
-                return returnResult(result);
-            }
-            return returnResult({
-                success: true,
-                url: result.url,
-            });
+        }
+        const result = await this._subscriptions.createManageSubscriptionLink({
+            sessionKey,
+            userId,
+            subscriptionId,
+            expectedPrice,
+        });
+        if (!result.success) {
+            return returnResult(result);
+        }
+        return returnResult({
+            success: true,
+            url: result.url,
         });
     }
     /**
      * Endpoint to retrieve info about a user.
      * @param request The request.
      */
-    _getUserInfo(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (request.method !== 'GET') {
-                throw new Error(`getUserInfo only accept GET method, you tried: ${request.method}`);
-            }
-            if (!validateOrigin(request, this._allowedAccountOrigins)) {
-                return returnResult(INVALID_ORIGIN_RESULT);
-            }
-            const sessionKey = getSessionKey(request);
-            if (!sessionKey) {
-                return returnResult(NOT_LOGGED_IN_RESULT);
-            }
-            const userId = tryDecodeUriComponent(request.pathParams.userId);
-            if (!userId) {
-                return returnResult(UNACCEPTABLE_USER_ID);
-            }
-            const result = yield this._auth.getUserInfo({
-                sessionKey,
-                userId,
-            });
-            if (!result.success) {
-                return returnResult(result);
-            }
-            return returnResult({
-                success: true,
-                name: result.name,
-                avatarUrl: result.avatarUrl,
-                avatarPortraitUrl: result.avatarPortraitUrl,
-                email: result.email,
-                phoneNumber: result.phoneNumber,
-                hasActiveSubscription: result.hasActiveSubscription,
-                subscriptionTier: result.subscriptionTier,
-                privacyFeatures: result.privacyFeatures,
-                displayName: result.displayName,
-                role: result.role,
-            });
+    async _getUserInfo(request) {
+        if (request.method !== 'GET') {
+            throw new Error(`getUserInfo only accept GET method, you tried: ${request.method}`);
+        }
+        if (!validateOrigin(request, this._allowedAccountOrigins)) {
+            return returnResult(INVALID_ORIGIN_RESULT);
+        }
+        const sessionKey = getSessionKey(request);
+        if (!sessionKey) {
+            return returnResult(NOT_LOGGED_IN_RESULT);
+        }
+        const userId = tryDecodeUriComponent(request.pathParams.userId);
+        if (!userId) {
+            return returnResult(UNACCEPTABLE_USER_ID);
+        }
+        const result = await this._auth.getUserInfo({
+            sessionKey,
+            userId,
         });
-    }
-    _putUserInfo(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (request.method !== 'PUT') {
-                throw new Error(`putUserInfo only accept PUT method, you tried: ${request.method}`);
-            }
-            if (!validateOrigin(request, this._allowedAccountOrigins)) {
-                return returnResult(INVALID_ORIGIN_RESULT);
-            }
-            const sessionKey = getSessionKey(request);
-            if (!sessionKey) {
-                return returnResult(NOT_LOGGED_IN_RESULT);
-            }
-            if (typeof request.body !== 'string') {
-                return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
-            }
-            const jsonResult = tryParseJson(request.body);
-            if (!jsonResult.success || typeof jsonResult.value !== 'object') {
-                return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
-            }
-            const userId = tryDecodeUriComponent(request.pathParams.userId);
-            if (!userId) {
-                return returnResult(UNACCEPTABLE_USER_ID);
-            }
-            const schema = z.object({
-                name: z.string().min(1).optional().nullable(),
-                email: z
-                    .string()
-                    .email()
-                    .max(MAX_EMAIL_ADDRESS_LENGTH)
-                    .optional()
-                    .nullable(),
-                phoneNumber: z
-                    .string()
-                    .max(MAX_SMS_ADDRESS_LENGTH)
-                    .optional()
-                    .nullable(),
-                avatarUrl: z.string().url().optional().nullable(),
-                avatarPortraitUrl: z.string().url().optional().nullable(),
-            });
-            const parseResult = schema.safeParse(jsonResult.value);
-            if (parseResult.success === false) {
-                return returnZodError(parseResult.error);
-            }
-            const update = parseResult.data;
-            const result = yield this._auth.updateUserInfo({
-                sessionKey: sessionKey,
-                userId: userId,
-                update,
-            });
-            if (!result.success) {
-                return returnResult(result);
-            }
-            return returnResult({
-                success: true,
-                userId: result.userId,
-            });
+        if (!result.success) {
+            return returnResult(result);
+        }
+        return returnResult({
+            success: true,
+            name: result.name,
+            avatarUrl: result.avatarUrl,
+            avatarPortraitUrl: result.avatarPortraitUrl,
+            email: result.email,
+            phoneNumber: result.phoneNumber,
+            hasActiveSubscription: result.hasActiveSubscription,
+            subscriptionTier: result.subscriptionTier,
+            privacyFeatures: result.privacyFeatures,
+            displayName: result.displayName,
+            role: result.role,
         });
     }
-    _validateSessionKey(sessionKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return validateSessionKey(this._auth, sessionKey);
+    async _putUserInfo(request) {
+        if (request.method !== 'PUT') {
+            throw new Error(`putUserInfo only accept PUT method, you tried: ${request.method}`);
+        }
+        if (!validateOrigin(request, this._allowedAccountOrigins)) {
+            return returnResult(INVALID_ORIGIN_RESULT);
+        }
+        const sessionKey = getSessionKey(request);
+        if (!sessionKey) {
+            return returnResult(NOT_LOGGED_IN_RESULT);
+        }
+        if (typeof request.body !== 'string') {
+            return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
+        }
+        const jsonResult = tryParseJson(request.body);
+        if (!jsonResult.success || typeof jsonResult.value !== 'object') {
+            return returnResult(UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON);
+        }
+        const userId = tryDecodeUriComponent(request.pathParams.userId);
+        if (!userId) {
+            return returnResult(UNACCEPTABLE_USER_ID);
+        }
+        const schema = z.object({
+            name: z.string().min(1).optional().nullable(),
+            email: z
+                .string()
+                .email()
+                .max(MAX_EMAIL_ADDRESS_LENGTH)
+                .optional()
+                .nullable(),
+            phoneNumber: z
+                .string()
+                .max(MAX_SMS_ADDRESS_LENGTH)
+                .optional()
+                .nullable(),
+            avatarUrl: z.string().url().optional().nullable(),
+            avatarPortraitUrl: z.string().url().optional().nullable(),
         });
+        const parseResult = schema.safeParse(jsonResult.value);
+        if (parseResult.success === false) {
+            return returnZodError(parseResult.error);
+        }
+        const update = parseResult.data;
+        const result = await this._auth.updateUserInfo({
+            sessionKey: sessionKey,
+            userId: userId,
+            update,
+        });
+        if (!result.success) {
+            return returnResult(result);
+        }
+        return returnResult({
+            success: true,
+            userId: result.userId,
+        });
+    }
+    async _validateSessionKey(sessionKey) {
+        return validateSessionKey(this._auth, sessionKey);
     }
 }
 __decorate([
@@ -5686,16 +6041,14 @@ export function returnProcedureOutputStream(result) {
             ['result.stream']: true,
         });
     }
-    function generateBody() {
-        return __asyncGenerator(this, arguments, function* generateBody_1() {
-            while (true) {
-                const { done, value } = yield __await(result.next());
-                if (done) {
-                    return yield __await(JSON.stringify(value));
-                }
-                yield yield __await(JSON.stringify(value) + '\n');
+    async function* generateBody() {
+        while (true) {
+            const { done, value } = await result.next();
+            if (done) {
+                return JSON.stringify(value);
             }
-        });
+            yield JSON.stringify(value) + '\n';
+        }
     }
     return {
         statusCode: 200,
@@ -5749,7 +6102,9 @@ export function parseAuthorization(authorization) {
 }
 export function formatResponse(request, response, origins) {
     const origin = request.headers['origin'];
-    let headers = Object.assign({}, (response.headers || {}));
+    let headers = {
+        ...(response.headers || {}),
+    };
     if (!!origin &&
         (origins === true ||
             (typeof origins === 'object' && validateOrigin(request, origins)))) {
@@ -5761,13 +6116,16 @@ export function formatResponse(request, response, origins) {
                 'Content-Type, Authorization';
         }
     }
-    return Object.assign(Object.assign({}, response), { headers });
+    return {
+        ...response,
+        headers,
+    };
 }
 export function wrapHandler(func, allowedOrigins) {
-    return (request) => __awaiter(this, void 0, void 0, function* () {
-        const response = yield func(request);
+    return async (request) => {
+        const response = await func(request);
         return formatResponse(request, response, allowedOrigins);
-    });
+    };
 }
 /**
  * Returns the given ZodError as a GenericHttpResponse.