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

package/websockets/WebsocketController.js

@@ -4,40 +4,23 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
-};
-import { action, ON_WEBHOOK_ACTION_NAME, } from '@casual-simulation/aux-common/bots';
-import { YjsPartitionImpl } from '@casual-simulation/aux-common/partitions';
+import { action, createInitializationUpdate, ON_WEBHOOK_ACTION_NAME, } from '@casual-simulation/aux-common/bots';
+import { constructInitializationUpdate, YjsPartitionImpl, } from '@casual-simulation/aux-common/partitions';
 import { device, deviceError, deviceResult, } from '@casual-simulation/aux-common/common/RemoteActions';
 import { fromByteArray, toByteArray } from 'base64-js';
 import { applyUpdate, Doc, encodeStateAsUpdate } from 'yjs';
-import { WebsocketEventTypes, } from '@casual-simulation/aux-common/websockets/WebsocketEvents';
+import { WebsocketEventTypes } from '@casual-simulation/aux-common/websockets/WebsocketEvents';
 import { sumBy } from 'lodash';
-import { PRIVATE_MARKER, ACCOUNT_MARKER, DEFAULT_BRANCH_NAME, } from '@casual-simulation/aux-common';
+import { PRIVATE_MARKER, ACCOUNT_MARKER, DEFAULT_BRANCH_NAME, tryParseJson, } from '@casual-simulation/aux-common';
 import { SplitInstRecordsStore } from './SplitInstRecordsStore';
-import { v4 as uuid } from 'uuid';
+import { v4 as uuid, v7 as uuidv7 } from 'uuid';
 import { getSubscriptionFeatures } from '../SubscriptionConfiguration';
 import { traced } from '../tracing/TracingDecorators';
 import { trace } from '@opentelemetry/api';
 import { SEMATTRS_ENDUSER_ID } from '@opentelemetry/semantic-conventions';
+import { formatVersionSpecifier, } from '../packages/version';
+import { STORED_AUX_SCHEMA } from '../webhooks';
+import { formatInstId } from '@casual-simulation/aux-common';
 const TRACE_NAME = 'WebsocketController';
 export const SAVE_PERMANENT_BRANCHES_LOCK = 'savePermanentBranches';
 /**
@@ -47,7 +30,7 @@ export class WebsocketController {
     get messenger() {
         return this._messenger;
     }
-    constructor(connectionStore, messenger, instStore, temporaryInstStore, auth, policies, config, metrics, authStore) {
+    constructor(connectionStore, messenger, instStore, temporaryInstStore, auth, policies, config, metrics, authStore, packageVersions = null) {
         this.mergeUpdatesOnMaxSizeExceeded = false;
         this._connectionStore = connectionStore;
         this._messenger = messenger;
@@ -58,6 +41,7 @@ export class WebsocketController {
         this._policies = policies;
         this._config = config;
         this._metrics = metrics;
+        this._packageVersions = packageVersions;
     }
     /**
      * Attempts to log the given connection in.
@@ -65,987 +49,1171 @@ export class WebsocketController {
      * @param requestId The ID of the request.
      * @param message The login message.
      */
-    login(connectionId, requestId, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let userId = null;
-                let sessionId = null;
-                let clientConnectionId;
-                if (!message.connectionToken) {
-                    if (!message.connectionId) {
-                        yield this._messenger.sendMessage([connectionId], {
-                            type: 'login_result',
-                            success: false,
-                            errorCode: 'unacceptable_connection_id',
-                            errorMessage: 'A connection ID must be specified when logging in without a connection token.',
-                        });
-                        return;
-                    }
-                    yield this._connectionStore.saveConnection({
-                        serverConnectionId: connectionId,
-                        clientConnectionId: message.connectionId,
-                        userId: null,
-                        sessionId: null,
-                        token: null,
-                    });
-                    clientConnectionId = message.connectionId;
-                }
-                else {
-                    const validationResult = yield this._auth.validateConnectionToken(message.connectionToken);
-                    if (validationResult.success === false) {
-                        yield this._messenger.sendMessage([connectionId], {
-                            type: 'login_result',
-                            success: false,
-                            errorCode: validationResult.errorCode,
-                            errorMessage: validationResult.errorMessage,
-                        });
-                        return;
-                    }
-                    yield this._connectionStore.saveConnection({
-                        serverConnectionId: connectionId,
-                        userId: validationResult.userId,
-                        sessionId: validationResult.sessionId,
-                        clientConnectionId: validationResult.connectionId,
-                        token: message.connectionToken,
+    async login(connectionId, requestId, message) {
+        try {
+            let userId = null;
+            let sessionId = null;
+            let clientConnectionId;
+            if (!message.connectionToken) {
+                if (!message.connectionId) {
+                    await this._messenger.sendMessage([connectionId], {
+                        type: 'login_result',
+                        success: false,
+                        errorCode: 'unacceptable_connection_id',
+                        errorMessage: 'A connection ID must be specified when logging in without a connection token.',
                     });
-                    yield this._connectionStore.saveAuthorizedInst(connectionId, validationResult.recordName, validationResult.inst, 'token');
-                    userId = validationResult.userId;
-                    sessionId = validationResult.sessionId;
-                    clientConnectionId = validationResult.connectionId;
-                    const span = trace.getActiveSpan();
-                    if (span) {
-                        span.setAttributes({
-                            [SEMATTRS_ENDUSER_ID]: userId,
-                            ['request.userId']: userId,
-                            ['request.sessionId']: sessionId,
-                            ['request.subscriptionId']: validationResult.subscriptionId,
-                            ['request.subscriptionTier']: validationResult.subscriptionTier,
-                        });
-                    }
+                    return;
                 }
-                yield this._messenger.sendMessage([connectionId], {
-                    type: 'login_result',
-                    success: true,
-                    info: {
-                        userId,
-                        sessionId,
-                        connectionId: clientConnectionId,
-                    },
+                await this._connectionStore.saveConnection({
+                    serverConnectionId: connectionId,
+                    clientConnectionId: message.connectionId,
+                    userId: null,
+                    sessionId: null,
+                    token: null,
                 });
+                clientConnectionId = message.connectionId;
             }
-            catch (err) {
-                console.error('[WebsocketController] [login] Error while logging in.', err);
-                yield this.sendError(connectionId, requestId, {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred while logging in.',
+            else {
+                const validationResult = await this._auth.validateConnectionToken(message.connectionToken);
+                if (validationResult.success === false) {
+                    await this._messenger.sendMessage([connectionId], {
+                        type: 'login_result',
+                        success: false,
+                        errorCode: validationResult.errorCode,
+                        errorMessage: validationResult.errorMessage,
+                    });
+                    return;
+                }
+                await this._connectionStore.saveConnection({
+                    serverConnectionId: connectionId,
+                    userId: validationResult.userId,
+                    sessionId: validationResult.sessionId,
+                    clientConnectionId: validationResult.connectionId,
+                    token: message.connectionToken,
                 });
+                await this._connectionStore.saveAuthorizedInst(connectionId, validationResult.recordName, validationResult.inst, 'token');
+                userId = validationResult.userId;
+                sessionId = validationResult.sessionId;
+                clientConnectionId = validationResult.connectionId;
+                const span = trace.getActiveSpan();
+                if (span) {
+                    span.setAttributes({
+                        [SEMATTRS_ENDUSER_ID]: userId,
+                        ['request.userId']: userId,
+                        ['request.sessionId']: sessionId,
+                        ['request.subscriptionId']: validationResult.subscriptionId,
+                        ['request.subscriptionTier']: validationResult.subscriptionTier,
+                    });
+                }
             }
-        });
+            await this._messenger.sendMessage([connectionId], {
+                type: 'login_result',
+                success: true,
+                info: {
+                    userId,
+                    sessionId,
+                    connectionId: clientConnectionId,
+                },
+            });
+        }
+        catch (err) {
+            console.error('[WebsocketController] [login] Error while logging in.', err);
+            await this.sendError(connectionId, requestId, {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred while logging in.',
+            });
+        }
     }
-    disconnect(connectionId) {
+    async disconnect(connectionId) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const loadedConnections = yield this._connectionStore.getConnections(connectionId);
-            yield this._connectionStore.clearConnection(connectionId);
-            for (let connection of loadedConnections) {
-                if (connection.mode === 'branch') {
-                    if (connection.temporary) {
-                        const count = yield this._connectionStore.countConnectionsByBranch(connection.mode, connection.recordName, connection.inst, connection.branch);
-                        if (count <= 0) {
-                            const branch = (_a = (yield this._instStore.getBranchByName(connection.recordName, connection.inst, connection.branch))) !== null && _a !== void 0 ? _a : (yield this._temporaryStore.getBranchByName(connection.recordName, connection.inst, connection.branch));
-                            if (branch.temporary) {
-                                console.log('[WebsocketController] Deleting temporary branch', connection.recordName, connection.inst, connection.branch);
-                                yield this._temporaryStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
-                                yield this._instStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
-                            }
+        const loadedConnections = await this._connectionStore.getConnections(connectionId);
+        await this._connectionStore.clearConnection(connectionId);
+        for (let connection of loadedConnections) {
+            if (connection.mode === 'branch') {
+                if (connection.temporary) {
+                    const count = await this._connectionStore.countConnectionsByBranch(connection.mode, connection.recordName, connection.inst, connection.branch);
+                    if (count <= 0) {
+                        const branch = (_a = (await this._instStore.getBranchByName(connection.recordName, connection.inst, connection.branch))) !== null && _a !== void 0 ? _a : (await this._temporaryStore.getBranchByName(connection.recordName, connection.inst, connection.branch));
+                        if (branch.temporary) {
+                            console.log('[WebsocketController] Deleting temporary branch', connection.recordName, connection.inst, connection.branch);
+                            await this._temporaryStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
+                            await this._instStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
                         }
                     }
-                    const watchingDevices = yield this._connectionStore.getConnectionsByBranch('watch_branch', connection.recordName, connection.inst, connection.branch);
-                    yield this._messenger.sendMessage(watchingDevices.map((d) => d.serverConnectionId), {
-                        type: 'repo/disconnected_from_branch',
-                        broadcast: false,
-                        recordName: connection.recordName,
-                        inst: connection.inst,
-                        branch: connection.branch,
-                        connection: connectionInfo(connection),
-                    });
                 }
+                const watchingDevices = await this._connectionStore.getConnectionsByBranch('watch_branch', connection.recordName, connection.inst, connection.branch);
+                await this._messenger.sendMessage(watchingDevices.map((d) => d.serverConnectionId), {
+                    type: 'repo/disconnected_from_branch',
+                    broadcast: false,
+                    recordName: connection.recordName,
+                    inst: connection.inst,
+                    branch: connection.branch,
+                    connection: connectionInfo(connection),
+                });
             }
-        });
+        }
     }
-    watchBranch(connectionId, event) {
+    async watchBranch(connectionId, event) {
         var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!event) {
-                console.warn('[CasualRepoServer] Trying to watch branch with a null event!');
-                return;
-            }
-            console.log(`[CausalRepoServer] [namespace: ${event.recordName}/${event.inst}/${event.branch}, ${connectionId}] Watch`);
-            const connection = yield this._connectionStore.getConnection(connectionId);
-            if (!connection) {
-                console.error(`[CausalRepoServer] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}] Unable to watch branch. Connection not found!`);
-                yield this.sendError(connectionId, -1, {
+        if (!event) {
+            console.warn('[CasualRepoServer] Trying to watch branch with a null event!');
+            return;
+        }
+        console.log(`[WebsocketController] [namespace: ${event.recordName}/${event.inst}/${event.branch}, ${connectionId}] Watch`);
+        const connection = await this._connectionStore.getConnection(connectionId);
+        if (!connection) {
+            console.error(`[WebsocketController] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}] Unable to watch branch. Connection not found!`);
+            await this.sendError(connectionId, -1, {
+                success: false,
+                errorCode: 'invalid_connection_state',
+                errorMessage: `A server error occurred. (namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId})`,
+                recordName: event.recordName,
+                inst: event.inst,
+                branch: event.branch,
+            });
+            await this.messenger.disconnect(connectionId);
+            return;
+        }
+        if (connection.token && event.recordName) {
+            const authorized = await this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'token');
+            if (!authorized) {
+                await this.messenger.sendMessage([connectionId], {
+                    type: 'repo/watch_branch_result',
                     success: false,
-                    errorCode: 'invalid_connection_state',
-                    errorMessage: `A server error occurred. (namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId})`,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to access this inst.',
                     recordName: event.recordName,
                     inst: event.inst,
                     branch: event.branch,
+                    reason: {
+                        type: 'invalid_token',
+                    },
                 });
-                yield this.messenger.disconnect(connectionId);
-                return;
-            }
-            if (connection.token && event.recordName) {
-                const authorized = yield this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'token');
-                if (!authorized) {
-                    yield this.messenger.sendMessage([connectionId], {
-                        type: 'repo/watch_branch_result',
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to access this inst.',
-                        recordName: event.recordName,
-                        inst: event.inst,
-                        branch: event.branch,
-                        reason: {
-                            type: 'invalid_token',
-                        },
-                    });
-                    return;
-                }
-            }
-            const config = yield this._config.getSubscriptionConfiguration();
-            if (!event.recordName) {
-                if (((_b = (_a = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _a === void 0 ? void 0 : _a.publicInsts) === null || _b === void 0 ? void 0 : _b.allowed) === false) {
-                    yield this.messenger.sendMessage([connectionId], {
-                        type: 'repo/watch_branch_result',
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'Temporary insts are not allowed.',
-                        recordName: event.recordName,
-                        inst: event.inst,
-                        branch: event.branch,
-                    });
-                    return;
-                }
-            }
-            const instResult = yield this._getOrCreateInst(event.recordName, event.inst, connection.userId, config);
-            if (instResult.success === false) {
-                yield this.messenger.sendMessage([connectionId], Object.assign(Object.assign({}, instResult), { type: 'repo/watch_branch_result', recordName: event.recordName, inst: event.inst, branch: event.branch }));
                 return;
             }
-            const inst = instResult.inst;
-            const features = instResult.features;
-            let maxConnections = null;
-            if (features &&
-                typeof features.insts.maxActiveConnectionsPerInst === 'number') {
-                maxConnections = features.insts.maxActiveConnectionsPerInst;
-            }
-            else if (!event.recordName &&
-                typeof ((_d = (_c = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _c === void 0 ? void 0 : _c.publicInsts) === null || _d === void 0 ? void 0 : _d.maxActiveConnectionsPerInst) === 'number') {
-                maxConnections =
-                    config.defaultFeatures.publicInsts.maxActiveConnectionsPerInst;
-            }
-            if (maxConnections) {
-                const count = yield this._connectionStore.countConnectionsByBranch('branch', event.recordName, event.inst, event.branch);
-                if (count >= maxConnections) {
-                    yield this.messenger.sendMessage([connectionId], {
-                        type: 'repo/watch_branch_result',
-                        success: false,
-                        errorCode: features
-                            ? 'subscription_limit_reached'
-                            : 'not_authorized',
-                        errorMessage: 'The maximum number of active connections to this inst has been reached.',
-                        recordName: event.recordName,
-                        inst: event.inst,
-                        branch: event.branch,
-                    });
-                    return;
-                }
-            }
-            yield this._connectionStore.saveBranchConnection(Object.assign(Object.assign({}, connection), { serverConnectionId: connectionId, mode: 'branch', recordName: event.recordName, inst: event.inst, branch: event.branch, temporary: event.temporary || false }));
-            const branch = yield this._getOrCreateBranch(event.recordName, event.inst, event.branch, event.temporary, inst);
-            let updates;
-            if (branch.temporary) {
-                // Temporary branches use a temporary inst data store.
-                // This is because temporary branches are never persisted to disk.
-                updates = yield this._temporaryStore.getUpdates(event.recordName, event.inst, event.branch);
-            }
-            else {
-                updates = yield this._instStore.getCurrentUpdates(event.recordName, event.inst, event.branch);
-            }
-            if (!updates) {
-                // branch info exists, but no updates for them exist yet.
-                updates = {
-                    updates: [],
-                    timestamps: [],
-                    instSizeInBytes: 0,
-                };
-            }
-            const watchingDevices = yield this._connectionStore.getConnectionsByBranch('watch_branch', event.recordName, event.inst, event.branch);
-            console.log(`[CausalRepoServer] [namespace: ${event.recordName}/${event.inst}/${event.branch}, ${connectionId}] Connected.`);
-            const promises = [
-                this._messenger.sendMessage(watchingDevices.map((d) => d.serverConnectionId), {
-                    type: 'repo/connected_to_branch',
-                    broadcast: false,
-                    branch: event,
-                    connection: connectionInfo(connection),
-                }),
-                this._messenger.sendMessage([connection.serverConnectionId], {
-                    type: 'repo/add_updates',
+        }
+        const config = await this._config.getSubscriptionConfiguration();
+        if (!event.recordName) {
+            if (((_b = (_a = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _a === void 0 ? void 0 : _a.publicInsts) === null || _b === void 0 ? void 0 : _b.allowed) === false) {
+                await this.messenger.sendMessage([connectionId], {
+                    type: 'repo/watch_branch_result',
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'Temporary insts are not allowed.',
                     recordName: event.recordName,
                     inst: event.inst,
                     branch: event.branch,
-                    updates: updates.updates,
-                    initial: true,
-                }),
-                this._messenger.sendMessage([connection.serverConnectionId], {
+                });
+                return;
+            }
+        }
+        const instResult = await this._getOrCreateInst(event.recordName, event.inst, connection.userId, config);
+        if (instResult.success === false) {
+            await this.messenger.sendMessage([connectionId], {
+                ...instResult,
+                type: 'repo/watch_branch_result',
+                recordName: event.recordName,
+                inst: event.inst,
+                branch: event.branch,
+            });
+            return;
+        }
+        const inst = instResult.inst;
+        const features = instResult.features;
+        let maxConnections = null;
+        if (features &&
+            typeof features.insts.maxActiveConnectionsPerInst === 'number') {
+            maxConnections = features.insts.maxActiveConnectionsPerInst;
+        }
+        else if (!event.recordName &&
+            typeof ((_d = (_c = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _c === void 0 ? void 0 : _c.publicInsts) === null || _d === void 0 ? void 0 : _d.maxActiveConnectionsPerInst) === 'number') {
+            maxConnections =
+                config.defaultFeatures.publicInsts.maxActiveConnectionsPerInst;
+        }
+        if (maxConnections) {
+            const count = await this._connectionStore.countConnectionsByBranch('branch', event.recordName, event.inst, event.branch);
+            if (count >= maxConnections) {
+                await this.messenger.sendMessage([connectionId], {
                     type: 'repo/watch_branch_result',
+                    success: false,
+                    errorCode: features
+                        ? 'subscription_limit_reached'
+                        : 'not_authorized',
+                    errorMessage: 'The maximum number of active connections to this inst has been reached.',
                     recordName: event.recordName,
                     inst: event.inst,
                     branch: event.branch,
-                    success: true,
-                }),
-            ];
-            yield Promise.all(promises);
+                });
+                return;
+            }
+        }
+        await this._connectionStore.saveBranchConnection({
+            ...connection,
+            serverConnectionId: connectionId,
+            mode: 'branch',
+            recordName: event.recordName,
+            inst: event.inst,
+            branch: event.branch,
+            temporary: event.temporary || false,
         });
+        const branch = await this._getOrCreateBranch(event.recordName, event.inst, event.branch, event.temporary, inst);
+        let updates;
+        if (branch.temporary) {
+            // Temporary branches use a temporary inst data store.
+            // This is because temporary branches are never persisted to disk.
+            updates = await this._temporaryStore.getUpdates(event.recordName, event.inst, event.branch);
+        }
+        else {
+            updates = await this._instStore.getCurrentUpdates(event.recordName, event.inst, event.branch);
+        }
+        if (!updates) {
+            // branch info exists, but no updates for them exist yet.
+            updates = {
+                updates: [],
+                timestamps: [],
+                instSizeInBytes: 0,
+            };
+        }
+        const watchingDevices = await this._connectionStore.getConnectionsByBranch('watch_branch', event.recordName, event.inst, event.branch);
+        console.log(`[WebsocketController] [namespace: ${event.recordName}/${event.inst}/${event.branch}, ${connectionId}] Connected.`);
+        const promises = [
+            this._messenger.sendMessage(watchingDevices.map((d) => d.serverConnectionId), {
+                type: 'repo/connected_to_branch',
+                broadcast: false,
+                branch: event,
+                connection: connectionInfo(connection),
+            }),
+            this._messenger.sendMessage([connection.serverConnectionId], {
+                type: 'repo/add_updates',
+                recordName: event.recordName,
+                inst: event.inst,
+                branch: event.branch,
+                updates: updates.updates,
+                initial: true,
+            }),
+            this._messenger.sendMessage([connection.serverConnectionId], {
+                type: 'repo/watch_branch_result',
+                recordName: event.recordName,
+                inst: event.inst,
+                branch: event.branch,
+                success: true,
+            }),
+        ];
+        await Promise.all(promises);
     }
-    unwatchBranch(connectionId, recordName, inst, branch) {
+    async unwatchBranch(connectionId, recordName, inst, branch) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!branch) {
-                console.warn('[CasualRepoServer] Trying to unwatch branch with a null event!');
-                return;
-            }
-            console.log(`[CausalRepoServer] [namespace: ${recordName}/${inst}/${branch}, ${connectionId}] Unwatch`);
-            const connection = yield this._connectionStore.getBranchConnection(connectionId, 'branch', recordName, inst, branch);
-            if (connection) {
-                yield this._connectionStore.deleteBranchConnection(connectionId, 'branch', recordName, inst, branch);
-                if (connection.temporary) {
-                    const count = yield this._connectionStore.countConnectionsByBranch('branch', recordName, inst, branch);
-                    if (count <= 0) {
-                        const branch = (_a = (yield this._instStore.getBranchByName(connection.recordName, connection.inst, connection.branch))) !== null && _a !== void 0 ? _a : (yield this._temporaryStore.getBranchByName(connection.recordName, connection.inst, connection.branch));
-                        if (branch === null || branch === void 0 ? void 0 : branch.temporary) {
-                            yield this._temporaryStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
-                            // Delete the branch from the permentent store even if it is temporary
-                            // because it is possible that the branch was created before temporary branches were only stored in the temporary store.
-                            yield this._instStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
-                        }
+        if (!branch) {
+            console.warn('[CasualRepoServer] Trying to unwatch branch with a null event!');
+            return;
+        }
+        console.log(`[WebsocketController] [namespace: ${recordName}/${inst}/${branch}, ${connectionId}] Unwatch`);
+        const connection = await this._connectionStore.getBranchConnection(connectionId, 'branch', recordName, inst, branch);
+        if (connection) {
+            await this._connectionStore.deleteBranchConnection(connectionId, 'branch', recordName, inst, branch);
+            if (connection.temporary) {
+                const count = await this._connectionStore.countConnectionsByBranch('branch', recordName, inst, branch);
+                if (count <= 0) {
+                    const branch = (_a = (await this._instStore.getBranchByName(connection.recordName, connection.inst, connection.branch))) !== null && _a !== void 0 ? _a : (await this._temporaryStore.getBranchByName(connection.recordName, connection.inst, connection.branch));
+                    if (branch === null || branch === void 0 ? void 0 : branch.temporary) {
+                        await this._temporaryStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
+                        // Delete the branch from the permentent store even if it is temporary
+                        // because it is possible that the branch was created before temporary branches were only stored in the temporary store.
+                        await this._instStore.deleteBranch(connection.recordName, connection.inst, connection.branch);
                     }
                 }
-                const watchingDevices = yield this._connectionStore.getConnectionsByBranch('watch_branch', recordName, inst, branch);
-                yield this._messenger.sendMessage(watchingDevices.map((d) => d.serverConnectionId), {
-                    type: 'repo/disconnected_from_branch',
-                    broadcast: false,
-                    recordName,
-                    inst,
-                    branch: branch,
-                    connection: connectionInfo(connection),
-                });
             }
-        });
+            const watchingDevices = await this._connectionStore.getConnectionsByBranch('watch_branch', recordName, inst, branch);
+            await this._messenger.sendMessage(watchingDevices.map((d) => d.serverConnectionId), {
+                type: 'repo/disconnected_from_branch',
+                broadcast: false,
+                recordName,
+                inst,
+                branch: branch,
+                connection: connectionInfo(connection),
+            });
+        }
     }
-    addUpdates(connectionId, event) {
+    async addUpdates(connectionId, event) {
         var _a, _b, _c, _d, _e;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!event) {
-                console.warn('[CasualRepoServer] Trying to add atoms with a null event!');
-                return;
-            }
-            console.log(`[CausalRepoServer] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}] Add Updates`);
-            const connection = yield this._connectionStore.getConnection(connectionId);
-            if (!connection) {
-                console.error(`[CausalRepoServer] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}] Unable to add updates. Connection not found!`);
-                yield this.sendError(connectionId, -1, {
+        if (!event) {
+            console.warn('[CasualRepoServer] Trying to add atoms with a null event!');
+            return;
+        }
+        console.log(`[WebsocketController] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}] Add Updates`);
+        const connection = await this._connectionStore.getConnection(connectionId);
+        if (!connection) {
+            console.error(`[WebsocketController] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}] Unable to add updates. Connection not found!`);
+            await this.sendError(connectionId, -1, {
+                success: false,
+                errorCode: 'invalid_connection_state',
+                errorMessage: `A server error occurred. (namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId})`,
+                recordName: event.recordName,
+                inst: event.inst,
+                branch: event.branch,
+            });
+            await this.messenger.disconnect(connectionId);
+            return;
+        }
+        if (connection.token && event.recordName) {
+            const authorized = await this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'token');
+            if (!authorized) {
+                await this.sendError(connectionId, -1, {
                     success: false,
-                    errorCode: 'invalid_connection_state',
-                    errorMessage: `A server error occurred. (namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId})`,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to access this inst.',
                     recordName: event.recordName,
                     inst: event.inst,
                     branch: event.branch,
+                    reason: {
+                        type: 'invalid_token',
+                    },
                 });
-                yield this.messenger.disconnect(connectionId);
                 return;
             }
-            if (connection.token && event.recordName) {
-                const authorized = yield this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'token');
-                if (!authorized) {
-                    yield this.sendError(connectionId, -1, {
+        }
+        if (event.updates) {
+            let branch = (_a = (await this._instStore.getBranchByName(event.recordName, event.inst, event.branch))) !== null && _a !== void 0 ? _a : (await this._temporaryStore.getBranchByName(event.recordName, event.inst, event.branch));
+            const updateSize = sumBy(event.updates, (u) => Buffer.byteLength(u, 'utf8'));
+            const config = await this._config.getSubscriptionConfiguration();
+            let features = null;
+            if (!event.recordName) {
+                if (((_c = (_b = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _b === void 0 ? void 0 : _b.publicInsts) === null || _c === void 0 ? void 0 : _c.allowed) === false) {
+                    await this.sendError(connectionId, -1, {
                         success: false,
                         errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to access this inst.',
+                        errorMessage: 'Temporary insts are not allowed.',
                         recordName: event.recordName,
                         inst: event.inst,
                         branch: event.branch,
-                        reason: {
-                            type: 'invalid_token',
-                        },
                     });
                     return;
                 }
             }
-            if (event.updates) {
-                let branch = (_a = (yield this._instStore.getBranchByName(event.recordName, event.inst, event.branch))) !== null && _a !== void 0 ? _a : (yield this._temporaryStore.getBranchByName(event.recordName, event.inst, event.branch));
-                const updateSize = sumBy(event.updates, (u) => Buffer.byteLength(u, 'utf8'));
-                const config = yield this._config.getSubscriptionConfiguration();
-                let features = null;
-                if (!event.recordName) {
-                    if (((_c = (_b = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _b === void 0 ? void 0 : _b.publicInsts) === null || _c === void 0 ? void 0 : _c.allowed) === false) {
-                        yield this.sendError(connectionId, -1, {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'Temporary insts are not allowed.',
-                            recordName: event.recordName,
-                            inst: event.inst,
-                            branch: event.branch,
-                        });
-                        return;
-                    }
-                }
-                if (!branch) {
-                    console.log(`[CausalRepoServer] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}]  Branch not found!`);
-                    const instResult = yield this._getOrCreateInst(event.recordName, event.inst, connection.userId, config);
-                    if (instResult.success === false) {
-                        yield this.sendError(connectionId, -1, Object.assign(Object.assign({}, instResult), { recordName: event.recordName, inst: event.inst, branch: event.branch }));
-                        return;
-                    }
-                    else if (event.recordName) {
-                        const authorizeResult = yield this._policies.authorizeUserAndInstances(instResult.context, {
-                            resourceKind: 'inst',
-                            resourceId: event.inst,
-                            action: 'updateData',
-                            userId: connection.userId,
-                            markers: instResult.inst.markers,
-                            instances: [],
-                        });
-                        if (authorizeResult.success === false) {
-                            yield this.sendError(connectionId, -1, Object.assign(Object.assign({}, authorizeResult), { recordName: event.recordName, inst: event.inst, branch: event.branch }));
-                            return;
-                        }
-                    }
-                    features = instResult.features;
-                    const branchResult = yield this._instStore.saveBranch({
-                        branch: event.branch,
-                        inst: event.inst,
+            if (!branch) {
+                console.log(`[WebsocketController] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}]  Branch not found!`);
+                const instResult = await this._getOrCreateInst(event.recordName, event.inst, connection.userId, config);
+                if (instResult.success === false) {
+                    await this.sendError(connectionId, -1, {
+                        ...instResult,
                         recordName: event.recordName,
-                        temporary: false,
+                        inst: event.inst,
+                        branch: event.branch,
                     });
-                    if (branchResult.success === false) {
-                        yield this.sendError(connectionId, -1, Object.assign(Object.assign({}, branchResult), { recordName: event.recordName, inst: event.inst, branch: event.branch }));
-                        return;
-                    }
-                    branch = yield this._instStore.getBranchByName(event.recordName, event.inst, event.branch);
+                    return;
                 }
                 else if (event.recordName) {
-                    const authorized = yield this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'updateData');
-                    if (!authorized) {
-                        if (!branch.linkedInst) {
-                            console.error('[WebsocketController] The inst was not found even though the branch was found and exists in a record!');
-                            yield this.sendError(connectionId, -1, {
-                                success: false,
-                                errorCode: 'inst_not_found',
-                                errorMessage: 'The inst was not found.',
-                                recordName: event.recordName,
-                                inst: event.inst,
-                                branch: event.branch,
-                            });
-                            return;
-                        }
-                        const contextResult = yield this._policies.constructAuthorizationContext({
-                            recordKeyOrRecordName: event.recordName,
-                            userId: connection.userId,
-                        });
-                        if (contextResult.success === false) {
-                            yield this.sendError(connectionId, -1, Object.assign(Object.assign({}, contextResult), { recordName: event.recordName, inst: event.inst, branch: event.branch }));
-                            return;
-                        }
-                        const authorizeResult = yield this._policies.authorizeUserAndInstancesForResources(contextResult.context, {
-                            userId: connection.userId,
-                            instances: [],
-                            resources: [
-                                {
-                                    resourceKind: 'inst',
-                                    resourceId: event.inst,
-                                    action: 'read',
-                                    markers: branch.linkedInst.markers,
-                                },
-                                {
-                                    resourceKind: 'inst',
-                                    resourceId: event.inst,
-                                    action: 'updateData',
-                                    markers: branch.linkedInst.markers,
-                                },
-                            ],
-                        });
-                        // const authorizeReadResult =
-                        //     await this._policies.authorizeRequestUsingContext(
-                        //         contextResult.context,
-                        //         {
-                        //             action: 'inst.read',
-                        //             inst: event.inst,
-                        //             recordKeyOrRecordName: event.recordName,
-                        //             resourceMarkers: branch.linkedInst.markers,
-                        //             userId: connection.userId,
-                        //         }
-                        //     );
-                        if (authorizeResult.success === false) {
-                            yield this.sendError(connectionId, -1, Object.assign(Object.assign({}, authorizeResult), { recordName: event.recordName, inst: event.inst, branch: event.branch }));
-                            return;
-                        }
-                        // const authorizeUpdateResult =
-                        //     await this._policies.authorizeUserAndInstances(
-                        //         contextResult.context,
-                        //         {
-                        //             resourceKind: 'inst',
-                        //             resourceId: event.inst,
-                        //             action: 'updateData',
-                        //             markers: branch.linkedInst.markers,
-                        //             userId: connection.userId,
-                        //             instances: [],
-                        //         }
-                        //     );
-                        // if (authorizeUpdateResult.success === false) {
-                        //     await this.sendError(connectionId, -1, {
-                        //         ...authorizeUpdateResult,
-                        //         recordName: event.recordName,
-                        //         inst: event.inst,
-                        //         branch: event.branch,
-                        //     });
-                        //     return;
-                        // }
-                        yield this._connectionStore.saveAuthorizedInst(connectionId, event.recordName, event.inst, 'updateData');
-                    }
-                }
-                if (!features && branch.linkedInst) {
-                    features = getSubscriptionFeatures(config, branch.linkedInst.subscriptionStatus, branch.linkedInst.subscriptionId, branch.linkedInst.subscriptionType);
-                }
-                let maxInstSize = null;
-                if (features &&
-                    typeof features.insts.maxBytesPerInst === 'number') {
-                    maxInstSize = features.insts.maxBytesPerInst;
-                }
-                else if (!event.recordName &&
-                    typeof ((_e = (_d = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _d === void 0 ? void 0 : _d.publicInsts) === null || _e === void 0 ? void 0 : _e.maxBytesPerInst) ===
-                        'number') {
-                    maxInstSize =
-                        config.defaultFeatures.publicInsts.maxBytesPerInst;
-                }
-                if (maxInstSize) {
-                    const currentSize = branch.temporary
-                        ? yield this._temporaryStore.getInstSize(event.recordName, event.inst)
-                        : yield this._instStore.getInstSize(event.recordName, event.inst);
-                    const neededSizeInBytes = currentSize + updateSize;
-                    if (neededSizeInBytes > maxInstSize) {
-                        yield this._messenger.sendMessage([connectionId], {
-                            type: 'repo/updates_received',
+                    const authorizeResult = await this._policies.authorizeUserAndInstances(instResult.context, {
+                        resourceKind: 'inst',
+                        resourceId: event.inst,
+                        action: 'updateData',
+                        userId: connection.userId,
+                        markers: instResult.inst.markers,
+                        instances: [],
+                    });
+                    if (authorizeResult.success === false) {
+                        await this.sendError(connectionId, -1, {
+                            ...authorizeResult,
                             recordName: event.recordName,
                             inst: event.inst,
                             branch: event.branch,
-                            updateId: event.updateId,
-                            errorCode: 'max_size_reached',
-                            maxBranchSizeInBytes: maxInstSize,
-                            neededBranchSizeInBytes: neededSizeInBytes,
                         });
                         return;
                     }
                 }
-                if (branch.temporary) {
-                    // Temporary branches use a temporary inst data store.
-                    // This is because temporary branches are never persisted to disk.
-                    yield this._temporaryStore.addUpdates(event.recordName, event.inst, event.branch, event.updates, updateSize);
-                }
-                else {
-                    const result = yield this._instStore.addUpdates(event.recordName, event.inst, event.branch, event.updates, updateSize);
-                    if (result.success === false) {
-                        console.log(`[CausalRepoServer] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}]  Failed to add updates`, result);
-                        if (result.errorCode === 'max_size_reached') {
-                            if (result.success === false) {
-                                if ('updateId' in event) {
-                                    let { success, branch } = result, rest = __rest(result, ["success", "branch"]);
-                                    yield this._messenger.sendMessage([connectionId], Object.assign({ type: 'repo/updates_received', recordName: event.recordName, inst: event.inst, branch: event.branch, updateId: event.updateId }, rest));
-                                }
-                                return;
-                            }
-                        }
-                    }
-                    else {
-                        if (event.recordName &&
-                            this._instStore instanceof SplitInstRecordsStore) {
-                            this._instStore.temp.markBranchAsDirty({
-                                recordName: event.recordName,
-                                inst: event.inst,
-                                branch: event.branch,
-                            });
-                        }
-                    }
-                }
-            }
-            const hasUpdates = event.updates && event.updates.length > 0;
-            if (hasUpdates) {
-                const connectedDevices = yield this._connectionStore.getConnectionsByBranch('branch', event.recordName, event.inst, event.branch);
-                let ret = {
-                    type: 'repo/add_updates',
-                    recordName: event.recordName,
-                    inst: event.inst,
+                features = instResult.features;
+                const branchResult = await this._instStore.saveBranch({
                     branch: event.branch,
-                    updates: event.updates,
-                };
-                yield this._messenger.sendMessage(connectedDevices.map((c) => c.serverConnectionId), ret, connectionId);
-            }
-            if ('updateId' in event) {
-                yield this._messenger.sendMessage([connectionId], {
-                    type: 'repo/updates_received',
-                    recordName: event.recordName,
                     inst: event.inst,
-                    branch: event.branch,
-                    updateId: event.updateId,
+                    recordName: event.recordName,
+                    temporary: false,
                 });
-            }
-        });
-    }
-    sendAction(connectionId, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!event) {
-                console.warn('[CasualRepoServer] Trying to send event with a null event!');
-                return;
-            }
-            // const namespace = branchNamespace(event.recordName, event.inst, event.branch);
-            const connectedDevices = yield this._connectionStore.getConnectionsByBranch('branch', event.recordName, event.inst, event.branch);
-            if (event.action.type === 'remote') {
-                const action = event.action.event;
-            }
-            let finalAction;
-            if (event.action.sessionId ||
-                event.action.connectionId ||
-                event.action.userId ||
-                (typeof event.action.broadcast !== 'undefined' &&
-                    event.action.broadcast !== null)) {
-                finalAction = event.action;
-            }
-            else {
-                // TODO: Replace with system that selects target devices with better uniformity
-                // than Math.random().
-                const randomDeviceIndex = Math.min(connectedDevices.length - 1, Math.max(Math.floor(Math.random() * connectedDevices.length), 0));
-                const randomDevice = connectedDevices[randomDeviceIndex];
-                if (randomDevice) {
-                    finalAction = Object.assign(Object.assign({}, event.action), { connectionId: randomDevice.clientConnectionId });
-                }
-            }
-            if (!finalAction) {
-                return;
-            }
-            const currentConnection = yield this._connectionStore.getConnection(connectionId);
-            if (currentConnection.token && event.recordName) {
-                const authorized = yield this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'token');
-                if (!authorized) {
-                    yield this.sendError(connectionId, -1, {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to access this inst.',
+                if (branchResult.success === false) {
+                    await this.sendError(connectionId, -1, {
+                        ...branchResult,
                         recordName: event.recordName,
                         inst: event.inst,
                         branch: event.branch,
-                        reason: {
-                            type: 'invalid_token',
-                        },
                     });
                     return;
                 }
+                branch = await this._instStore.getBranchByName(event.recordName, event.inst, event.branch);
             }
-            if (event.recordName) {
-                const config = yield this._config.getSubscriptionConfiguration();
-                const instResult = yield this._getInst(event.recordName, event.inst, currentConnection.userId, config);
-                if (instResult.success === false) {
-                    yield this.sendError(connectionId, -1, instResult);
-                    return;
-                }
-                else if (!instResult.inst) {
-                    yield this.sendError(connectionId, -1, {
-                        success: false,
-                        errorCode: 'inst_not_found',
-                        errorMessage: 'The inst was not found.',
-                    });
-                    return;
-                }
-                const authorizeResult = yield this._policies.authorizeUserAndInstances(instResult.context, {
-                    resourceKind: 'inst',
-                    resourceId: event.inst,
-                    action: 'sendAction',
-                    markers: instResult.inst.markers,
-                    userId: currentConnection.userId,
-                    instances: [],
-                });
-                if (authorizeResult.success === false) {
-                    yield this.sendError(connectionId, -1, authorizeResult);
-                    return;
-                }
-            }
-            const targetedDevices = connectedDevices.filter((d) => isEventForDevice(finalAction, d));
-            const dEvent = finalAction.type === 'remote'
-                ? device(connectionInfo(currentConnection), finalAction.event, finalAction.taskId)
-                : finalAction.type === 'remote_result'
-                    ? deviceResult(connectionInfo(currentConnection), finalAction.result, finalAction.taskId)
-                    : deviceError(connectionInfo(currentConnection), finalAction.error, finalAction.taskId);
-            yield this._messenger.sendMessage(targetedDevices.map((c) => c.serverConnectionId), {
-                type: 'repo/receive_action',
-                recordName: event.recordName,
-                inst: event.inst,
-                branch: event.branch,
-                action: dEvent,
-            });
-        });
-    }
-    watchBranchDevices(connectionId, recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`[CausalRepoServer] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Watch devices for branch`);
-            const connection = yield this._connectionStore.getConnection(connectionId);
-            if (!connection) {
-                console.error(`[CausalRepoServer] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Unable to watch_branch_devices. Connection not found!`);
-                yield this.sendError(connectionId, -1, {
-                    success: false,
-                    errorCode: 'invalid_connection_state',
-                    errorMessage: `A server error occurred. (namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId})`,
-                    recordName: recordName,
-                    inst: inst,
-                    branch: branch,
-                });
-                yield this.messenger.disconnect(connectionId);
-                return;
-            }
-            if (connection.token && recordName) {
-                const authorized = yield this._connectionStore.isAuthorizedInst(connectionId, recordName, inst, 'token');
+            else if (event.recordName) {
+                const authorized = await this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'updateData');
                 if (!authorized) {
-                    yield this.sendError(connectionId, -1, {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to access this inst.',
-                        recordName,
-                        inst,
-                        branch,
-                        reason: {
-                            type: 'invalid_token',
-                        },
+                    if (!branch.linkedInst) {
+                        console.error('[WebsocketController] The inst was not found even though the branch was found and exists in a record!');
+                        await this.sendError(connectionId, -1, {
+                            success: false,
+                            errorCode: 'inst_not_found',
+                            errorMessage: 'The inst was not found.',
+                            recordName: event.recordName,
+                            inst: event.inst,
+                            branch: event.branch,
+                        });
+                        return;
+                    }
+                    const contextResult = await this._policies.constructAuthorizationContext({
+                        recordKeyOrRecordName: event.recordName,
+                        userId: connection.userId,
                     });
-                    return;
+                    if (contextResult.success === false) {
+                        await this.sendError(connectionId, -1, {
+                            ...contextResult,
+                            recordName: event.recordName,
+                            inst: event.inst,
+                            branch: event.branch,
+                        });
+                        return;
+                    }
+                    const authorizeResult = await this._policies.authorizeUserAndInstancesForResources(contextResult.context, {
+                        userId: connection.userId,
+                        instances: [],
+                        resources: [
+                            {
+                                resourceKind: 'inst',
+                                resourceId: event.inst,
+                                action: 'read',
+                                markers: branch.linkedInst.markers,
+                            },
+                            {
+                                resourceKind: 'inst',
+                                resourceId: event.inst,
+                                action: 'updateData',
+                                markers: branch.linkedInst.markers,
+                            },
+                        ],
+                    });
+                    // const authorizeReadResult =
+                    //     await this._policies.authorizeRequestUsingContext(
+                    //         contextResult.context,
+                    //         {
+                    //             action: 'inst.read',
+                    //             inst: event.inst,
+                    //             recordKeyOrRecordName: event.recordName,
+                    //             resourceMarkers: branch.linkedInst.markers,
+                    //             userId: connection.userId,
+                    //         }
+                    //     );
+                    if (authorizeResult.success === false) {
+                        await this.sendError(connectionId, -1, {
+                            ...authorizeResult,
+                            recordName: event.recordName,
+                            inst: event.inst,
+                            branch: event.branch,
+                        });
+                        return;
+                    }
+                    // const authorizeUpdateResult =
+                    //     await this._policies.authorizeUserAndInstances(
+                    //         contextResult.context,
+                    //         {
+                    //             resourceKind: 'inst',
+                    //             resourceId: event.inst,
+                    //             action: 'updateData',
+                    //             markers: branch.linkedInst.markers,
+                    //             userId: connection.userId,
+                    //             instances: [],
+                    //         }
+                    //     );
+                    // if (authorizeUpdateResult.success === false) {
+                    //     await this.sendError(connectionId, -1, {
+                    //         ...authorizeUpdateResult,
+                    //         recordName: event.recordName,
+                    //         inst: event.inst,
+                    //         branch: event.branch,
+                    //     });
+                    //     return;
+                    // }
+                    await this._connectionStore.saveAuthorizedInst(connectionId, event.recordName, event.inst, 'updateData');
                 }
             }
-            if (recordName) {
-                const config = yield this._config.getSubscriptionConfiguration();
-                const instResult = yield this._getInst(recordName, inst, connection.userId, config);
-                if (instResult.success === false) {
-                    yield this.sendError(connectionId, -1, instResult);
-                    return;
-                }
+            if (!features && branch.linkedInst) {
+                features = getSubscriptionFeatures(config, branch.linkedInst.subscriptionStatus, branch.linkedInst.subscriptionId, branch.linkedInst.subscriptionType);
             }
-            yield this._connectionStore.saveBranchConnection(Object.assign(Object.assign({}, connection), { mode: 'watch_branch', serverConnectionId: connectionId, recordName,
-                inst,
-                branch, temporary: true }));
-            const currentDevices = yield this._connectionStore.getConnectionsByBranch('branch', recordName, inst, branch);
-            const promises = currentDevices.map((device) => this._messenger.sendMessage([connectionId], {
-                type: 'repo/connected_to_branch',
-                broadcast: false,
-                connection: connectionInfo(device),
-                branch: {
-                    type: 'repo/watch_branch',
-                    recordName: recordName,
-                    inst: inst,
-                    branch: branch,
-                    temporary: device.temporary,
-                },
-            }));
-            yield Promise.all(promises);
-        });
-    }
-    unwatchBranchDevices(connectionId, recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._connectionStore.deleteBranchConnection(connectionId, 'watch_branch', recordName, inst, branch);
-        });
-    }
-    deviceCount(connectionId, recordName, inst, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const count = typeof branch !== 'undefined' && branch !== null
-                ? yield this._connectionStore.countConnectionsByBranch('branch', recordName, inst, branch)
-                : yield this._connectionStore.countConnections();
-            const currentConnection = yield this._connectionStore.getConnection(connectionId);
-            if (recordName && (currentConnection === null || currentConnection === void 0 ? void 0 : currentConnection.token)) {
-                const authorized = yield this._connectionStore.isAuthorizedInst(connectionId, recordName, inst, 'token');
-                if (!authorized) {
-                    yield this.sendError(connectionId, -1, {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to access this inst.',
-                        recordName,
-                        inst,
-                        branch,
-                        reason: {
-                            type: 'invalid_token',
-                        },
+            let maxInstSize = null;
+            if (features &&
+                typeof features.insts.maxBytesPerInst === 'number') {
+                maxInstSize = features.insts.maxBytesPerInst;
+            }
+            else if (!event.recordName &&
+                typeof ((_e = (_d = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _d === void 0 ? void 0 : _d.publicInsts) === null || _e === void 0 ? void 0 : _e.maxBytesPerInst) ===
+                    'number') {
+                maxInstSize =
+                    config.defaultFeatures.publicInsts.maxBytesPerInst;
+            }
+            if (maxInstSize) {
+                const currentSize = branch.temporary
+                    ? await this._temporaryStore.getInstSize(event.recordName, event.inst)
+                    : await this._instStore.getInstSize(event.recordName, event.inst);
+                const neededSizeInBytes = currentSize + updateSize;
+                if (neededSizeInBytes > maxInstSize) {
+                    await this._messenger.sendMessage([connectionId], {
+                        type: 'repo/updates_received',
+                        recordName: event.recordName,
+                        inst: event.inst,
+                        branch: event.branch,
+                        updateId: event.updateId,
+                        errorCode: 'max_size_reached',
+                        maxBranchSizeInBytes: maxInstSize,
+                        neededBranchSizeInBytes: neededSizeInBytes,
                     });
                     return;
                 }
             }
-            if (recordName) {
-                const config = yield this._config.getSubscriptionConfiguration();
-                const instResult = yield this._getInst(recordName, inst, currentConnection === null || currentConnection === void 0 ? void 0 : currentConnection.userId, config);
-                if (instResult.success === false) {
-                    yield this.sendError(connectionId, -1, instResult);
-                    return;
+            if (branch.temporary) {
+                // Temporary branches use a temporary inst data store.
+                // This is because temporary branches are never persisted to disk.
+                await this._temporaryStore.addUpdates(event.recordName, event.inst, event.branch, event.updates, updateSize);
+            }
+            else {
+                const result = await this._instStore.addUpdates(event.recordName, event.inst, event.branch, event.updates, updateSize);
+                if (result.success === false) {
+                    console.log(`[WebsocketController] [namespace: ${event.recordName}/${event.inst}/${event.branch}, connectionId: ${connectionId}]  Failed to add updates`, result);
+                    if (result.errorCode === 'max_size_reached') {
+                        if (result.success === false) {
+                            if ('updateId' in event) {
+                                let { success, branch, ...rest } = result;
+                                await this._messenger.sendMessage([connectionId], {
+                                    type: 'repo/updates_received',
+                                    recordName: event.recordName,
+                                    inst: event.inst,
+                                    branch: event.branch,
+                                    updateId: event.updateId,
+                                    ...rest,
+                                });
+                            }
+                            return;
+                        }
+                    }
                 }
-                else if (!instResult.inst) {
-                    yield this.sendError(connectionId, -1, {
-                        success: false,
-                        errorCode: 'inst_not_found',
-                        errorMessage: 'The inst was not found.',
-                    });
-                    return;
+                else {
+                    if (event.recordName &&
+                        this._instStore instanceof SplitInstRecordsStore) {
+                        this._instStore.temp.markBranchAsDirty({
+                            recordName: event.recordName,
+                            inst: event.inst,
+                            branch: event.branch,
+                        });
+                    }
                 }
             }
-            yield this._messenger.sendMessage([connectionId], {
-                type: 'repo/connection_count',
-                recordName,
-                inst,
-                branch,
-                count: count,
+        }
+        const hasUpdates = event.updates && event.updates.length > 0;
+        if (hasUpdates) {
+            const connectedDevices = await this._connectionStore.getConnectionsByBranch('branch', event.recordName, event.inst, event.branch);
+            let ret = {
+                type: 'repo/add_updates',
+                recordName: event.recordName,
+                inst: event.inst,
+                branch: event.branch,
+                updates: event.updates,
+            };
+            await this._messenger.sendMessage(connectedDevices.map((c) => c.serverConnectionId), ret, connectionId);
+        }
+        if ('updateId' in event) {
+            await this._messenger.sendMessage([connectionId], {
+                type: 'repo/updates_received',
+                recordName: event.recordName,
+                inst: event.inst,
+                branch: event.branch,
+                updateId: event.updateId,
             });
-        });
+        }
     }
-    /**
-     * Gets the data from the given branch in the given inst.
-     * @param userId The ID of the user that is currently logged in.
-     * @param recordName The name of the record that the inst is in. Null if accessing a public inst.
-     * @param inst The name of the inst.
-     * @param branch The name of the branch in the inst.
-     * @param auxVersion The AUX version to return.
-     */
-    getBranchData(userId, recordName, inst, branch, auxVersion = 1) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`[CausalRepoServer] [namespace: ${recordName}/${inst}/${branch}] Get Data`);
-            if (recordName) {
-                const config = yield this._config.getSubscriptionConfiguration();
-                const instResult = yield this._getInst(recordName, inst, userId, config);
-                if (instResult.success === false) {
-                    return instResult;
-                }
-                else if (!instResult.inst) {
+    async addUserUpdates(request) {
+        var _a, _b, _c, _d, _e;
+        console.log(`[CausalRepoServer] [namespace: ${request.recordName}/${request.inst}/${request.branch}, userId: ${request.userId}] Add Updates`);
+        if (request.updates) {
+            let branch = (_a = (await this._instStore.getBranchByName(request.recordName, request.inst, request.branch))) !== null && _a !== void 0 ? _a : (await this._temporaryStore.getBranchByName(request.recordName, request.inst, request.branch));
+            const updateSize = sumBy(request.updates, (u) => Buffer.byteLength(u, 'utf8'));
+            const config = await this._config.getSubscriptionConfiguration();
+            let features = null;
+            if (!request.recordName) {
+                if (((_c = (_b = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _b === void 0 ? void 0 : _b.publicInsts) === null || _c === void 0 ? void 0 : _c.allowed) === false) {
                     return {
                         success: false,
-                        errorCode: 'inst_not_found',
-                        errorMessage: 'The inst was not found.',
+                        errorCode: 'not_authorized',
+                        errorMessage: 'Temporary insts are not allowed.',
                     };
                 }
             }
-            const updates = (_a = (yield this._instStore.getCurrentUpdates(recordName, inst, branch))) !== null && _a !== void 0 ? _a : {
-                updates: [],
-                timestamps: [],
-                instSizeInBytes: 0,
-            };
-            if (auxVersion === 1) {
-                const partition = new YjsPartitionImpl({ type: 'yjs' });
-                for (let updateBase64 of updates.updates) {
-                    const update = toByteArray(updateBase64);
-                    applyUpdate(partition.doc, update);
+            if (!branch) {
+                console.log(`[CausalRepoServer] [namespace: ${request.recordName}/${request.inst}/${request.branch}, userId: ${request.userId}]  Branch not found!`);
+                const instResult = await this._getOrCreateInst(request.recordName, request.inst, request.userId, config);
+                if (instResult.success === false) {
+                    return instResult;
                 }
-                return {
-                    success: true,
-                    data: {
-                        version: 1,
-                        state: partition.state,
-                    },
-                };
-            }
-            else {
-                let stored = [];
-                for (let i = 0; i < updates.updates.length; i++) {
-                    stored.push({
-                        id: i,
-                        update: updates.updates[i],
-                        timestamp: updates.timestamps[i],
+                else if (request.recordName) {
+                    const authorizeResult = await this._policies.authorizeUserAndInstances(instResult.context, {
+                        resourceKind: 'inst',
+                        resourceId: request.inst,
+                        action: 'updateData',
+                        userId: request.userId,
+                        markers: instResult.inst.markers,
+                        instances: [],
                     });
+                    if (authorizeResult.success === false) {
+                        return authorizeResult;
+                    }
                 }
-                return {
-                    success: true,
-                    data: {
-                        version: 2,
-                        updates: stored,
-                    },
-                };
-            }
-        });
-    }
-    listInsts(recordName, userId, startingInst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!recordName) {
-                    return {
-                        success: true,
-                        insts: [],
-                        totalCount: 0,
-                    };
+                features = instResult.features;
+                const branchResult = await this._instStore.saveBranch({
+                    branch: request.branch,
+                    inst: request.inst,
+                    recordName: request.recordName,
+                    temporary: false,
+                });
+                if (branchResult.success === false) {
+                    return branchResult;
                 }
-                const contextResult = yield this._policies.constructAuthorizationContext({
-                    recordKeyOrRecordName: recordName,
-                    userId,
+                branch = await this._instStore.getBranchByName(request.recordName, request.inst, request.branch);
+            }
+            else if (request.recordName) {
+                const contextResult = await this._policies.constructAuthorizationContext({
+                    recordKeyOrRecordName: request.recordName,
+                    userId: request.userId,
                 });
                 if (contextResult.success === false) {
                     return contextResult;
                 }
-                const context = contextResult.context;
-                const authorizeResult = yield this._policies.authorizeUserAndInstances(context, {
-                    resourceKind: 'inst',
-                    action: 'list',
-                    userId,
-                    markers: [PRIVATE_MARKER],
+                const authorizeResult = await this._policies.authorizeUserAndInstancesForResources(contextResult.context, {
+                    userId: request.userId,
                     instances: [],
+                    resources: [
+                        {
+                            resourceKind: 'inst',
+                            resourceId: request.inst,
+                            action: 'read',
+                            markers: branch.linkedInst.markers,
+                        },
+                        {
+                            resourceKind: 'inst',
+                            resourceId: request.inst,
+                            action: 'updateData',
+                            markers: branch.linkedInst.markers,
+                        },
+                    ],
                 });
                 if (authorizeResult.success === false) {
                     return authorizeResult;
                 }
-                const metricsResult = yield this._metrics.getSubscriptionInstMetricsByRecordName(recordName);
-                const config = yield this._config.getSubscriptionConfiguration();
-                const features = getSubscriptionFeatures(config, metricsResult.subscriptionStatus, metricsResult.subscriptionId, metricsResult.subscriptionType);
-                if (!features.insts.allowed) {
+            }
+            if (!features && branch.linkedInst) {
+                features = getSubscriptionFeatures(config, branch.linkedInst.subscriptionStatus, branch.linkedInst.subscriptionId, branch.linkedInst.subscriptionType);
+            }
+            let maxInstSize = null;
+            if (features &&
+                typeof features.insts.maxBytesPerInst === 'number') {
+                maxInstSize = features.insts.maxBytesPerInst;
+            }
+            else if (!request.recordName &&
+                typeof ((_e = (_d = config === null || config === void 0 ? void 0 : config.defaultFeatures) === null || _d === void 0 ? void 0 : _d.publicInsts) === null || _e === void 0 ? void 0 : _e.maxBytesPerInst) ===
+                    'number') {
+                maxInstSize =
+                    config.defaultFeatures.publicInsts.maxBytesPerInst;
+            }
+            if (maxInstSize) {
+                const currentSize = branch.temporary
+                    ? await this._temporaryStore.getInstSize(request.recordName, request.inst)
+                    : await this._instStore.getInstSize(request.recordName, request.inst);
+                const neededSizeInBytes = currentSize + updateSize;
+                if (neededSizeInBytes > maxInstSize) {
                     return {
                         success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'Insts are not allowed for this subscription.',
+                        errorCode: 'subscription_limit_reached',
+                        errorMessage: 'The inst has reached its maximum size.',
                     };
                 }
-                const instsResult = yield this._instStore.listInstsByRecord(recordName, startingInst);
-                if (!instsResult.success) {
-                    return instsResult;
+            }
+            if (branch.temporary) {
+                // Temporary branches use a temporary inst data store.
+                // This is because temporary branches are never persisted to disk.
+                await this._temporaryStore.addUpdates(request.recordName, request.inst, request.branch, request.updates, updateSize);
+            }
+            else {
+                const result = await this._instStore.addUpdates(request.recordName, request.inst, request.branch, request.updates, updateSize);
+                if (result.success === false) {
+                    console.log(`[CausalRepoServer] [namespace: ${request.recordName}/${request.inst}/${request.branch}, userId: ${request.userId}]  Failed to add updates`, result);
+                    if (result.errorCode === 'max_size_reached') {
+                        if (result.success === false) {
+                            return {
+                                success: false,
+                                errorCode: 'subscription_limit_reached',
+                                errorMessage: 'The inst has reached its maximum size.',
+                            };
+                        }
+                    }
                 }
-                return {
-                    success: true,
-                    insts: instsResult.insts,
-                    totalCount: instsResult.totalCount,
+                else {
+                    if (request.recordName &&
+                        this._instStore instanceof SplitInstRecordsStore) {
+                        this._instStore.temp.markBranchAsDirty({
+                            recordName: request.recordName,
+                            inst: request.inst,
+                            branch: request.branch,
+                        });
+                    }
+                }
+            }
+        }
+        const hasUpdates = request.updates && request.updates.length > 0;
+        if (hasUpdates) {
+            const connectedDevices = await this._connectionStore.getConnectionsByBranch('branch', request.recordName, request.inst, request.branch);
+            let ret = {
+                type: 'repo/add_updates',
+                recordName: request.recordName,
+                inst: request.inst,
+                branch: request.branch,
+                updates: request.updates,
+            };
+            await this._messenger.sendMessage(connectedDevices.map((c) => c.serverConnectionId), ret);
+        }
+        return {
+            success: true,
+        };
+    }
+    async sendAction(connectionId, event) {
+        if (!event) {
+            console.warn('[CasualRepoServer] Trying to send event with a null event!');
+            return;
+        }
+        // const namespace = branchNamespace(event.recordName, event.inst, event.branch);
+        const connectedDevices = await this._connectionStore.getConnectionsByBranch('branch', event.recordName, event.inst, event.branch);
+        if (event.action.type === 'remote') {
+            const action = event.action.event;
+        }
+        let finalAction;
+        if (event.action.sessionId ||
+            event.action.connectionId ||
+            event.action.userId ||
+            (typeof event.action.broadcast !== 'undefined' &&
+                event.action.broadcast !== null)) {
+            finalAction = event.action;
+        }
+        else {
+            // TODO: Replace with system that selects target devices with better uniformity
+            // than Math.random().
+            const randomDeviceIndex = Math.min(connectedDevices.length - 1, Math.max(Math.floor(Math.random() * connectedDevices.length), 0));
+            const randomDevice = connectedDevices[randomDeviceIndex];
+            if (randomDevice) {
+                finalAction = {
+                    ...event.action,
+                    connectionId: randomDevice.clientConnectionId,
                 };
             }
-            catch (err) {
-                console.error(`[WebsocketController] A server error occurred while listing insts:`, err);
-                return {
+        }
+        if (!finalAction) {
+            return;
+        }
+        const currentConnection = await this._connectionStore.getConnection(connectionId);
+        if (currentConnection.token && event.recordName) {
+            const authorized = await this._connectionStore.isAuthorizedInst(connectionId, event.recordName, event.inst, 'token');
+            if (!authorized) {
+                await this.sendError(connectionId, -1, {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to access this inst.',
+                    recordName: event.recordName,
+                    inst: event.inst,
+                    branch: event.branch,
+                    reason: {
+                        type: 'invalid_token',
+                    },
+                });
+                return;
             }
-        });
-    }
-    getUpdates(connectionId, recordName, inst, branch) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!branch) {
-                console.warn('[CasualRepoServer] Trying to get branch with a null branch!');
+        }
+        if (event.recordName) {
+            const config = await this._config.getSubscriptionConfiguration();
+            const instResult = await this._getInst(event.recordName, event.inst, currentConnection.userId, config);
+            if (instResult.success === false) {
+                await this.sendError(connectionId, -1, instResult);
                 return;
             }
-            const connection = yield this._connectionStore.getConnection(connectionId);
-            if (!connection) {
-                console.error(`[CausalRepoServer] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Unable to get_updates. Connection not found!`);
-                yield this.sendError(connectionId, -1, {
+            else if (!instResult.inst) {
+                await this.sendError(connectionId, -1, {
                     success: false,
-                    errorCode: 'invalid_connection_state',
-                    errorMessage: `A server error occurred. (namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId})`,
-                    recordName: recordName,
-                    inst: inst,
-                    branch: branch,
+                    errorCode: 'inst_not_found',
+                    errorMessage: 'The inst was not found.',
                 });
-                yield this.messenger.disconnect(connectionId);
                 return;
             }
-            if (connection.token && recordName) {
-                const authorized = yield this._connectionStore.isAuthorizedInst(connectionId, recordName, inst, 'token');
-                if (!authorized) {
-                    yield this.sendError(connectionId, -1, {
-                        success: false,
-                        errorCode: 'not_authorized',
-                        errorMessage: 'You are not authorized to access this inst.',
-                        recordName,
-                        inst,
-                        branch,
-                        reason: {
-                            type: 'invalid_token',
-                        },
-                    });
-                    return;
-                }
+            const authorizeResult = await this._policies.authorizeUserAndInstances(instResult.context, {
+                resourceKind: 'inst',
+                resourceId: event.inst,
+                action: 'sendAction',
+                markers: instResult.inst.markers,
+                userId: currentConnection.userId,
+                instances: [],
+            });
+            if (authorizeResult.success === false) {
+                await this.sendError(connectionId, -1, authorizeResult);
+                return;
+            }
+        }
+        const targetedDevices = connectedDevices.filter((d) => isEventForDevice(finalAction, d));
+        const dEvent = finalAction.type === 'remote'
+            ? device(connectionInfo(currentConnection), finalAction.event, finalAction.taskId)
+            : finalAction.type === 'remote_result'
+                ? deviceResult(connectionInfo(currentConnection), finalAction.result, finalAction.taskId)
+                : deviceError(connectionInfo(currentConnection), finalAction.error, finalAction.taskId);
+        await this._messenger.sendMessage(targetedDevices.map((c) => c.serverConnectionId), {
+            type: 'repo/receive_action',
+            recordName: event.recordName,
+            inst: event.inst,
+            branch: event.branch,
+            action: dEvent,
+        });
+    }
+    async watchBranchDevices(connectionId, recordName, inst, branch) {
+        console.log(`[WebsocketController] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Watch devices for branch`);
+        const connection = await this._connectionStore.getConnection(connectionId);
+        if (!connection) {
+            console.error(`[WebsocketController] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Unable to watch_branch_devices. Connection not found!`);
+            await this.sendError(connectionId, -1, {
+                success: false,
+                errorCode: 'invalid_connection_state',
+                errorMessage: `A server error occurred. (namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId})`,
+                recordName: recordName,
+                inst: inst,
+                branch: branch,
+            });
+            await this.messenger.disconnect(connectionId);
+            return;
+        }
+        if (connection.token && recordName) {
+            const authorized = await this._connectionStore.isAuthorizedInst(connectionId, recordName, inst, 'token');
+            if (!authorized) {
+                await this.sendError(connectionId, -1, {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to access this inst.',
+                    recordName,
+                    inst,
+                    branch,
+                    reason: {
+                        type: 'invalid_token',
+                    },
+                });
+                return;
             }
-            // const namespace = branchNamespace(recordName, inst, branch);
-            console.log(`[CausalRepoServer] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Get Updates`);
-            const config = yield this._config.getSubscriptionConfiguration();
-            const instResult = yield this._getInst(recordName, inst, connection.userId, config);
+        }
+        if (recordName) {
+            const config = await this._config.getSubscriptionConfiguration();
+            const instResult = await this._getInst(recordName, inst, connection.userId, config);
             if (instResult.success === false) {
-                yield this.sendError(connectionId, -1, Object.assign(Object.assign({}, instResult), { recordName,
+                await this.sendError(connectionId, -1, instResult);
+                return;
+            }
+        }
+        await this._connectionStore.saveBranchConnection({
+            ...connection,
+            mode: 'watch_branch',
+            serverConnectionId: connectionId,
+            recordName,
+            inst,
+            branch,
+            temporary: true,
+        });
+        const currentDevices = await this._connectionStore.getConnectionsByBranch('branch', recordName, inst, branch);
+        const promises = currentDevices.map((device) => this._messenger.sendMessage([connectionId], {
+            type: 'repo/connected_to_branch',
+            broadcast: false,
+            connection: connectionInfo(device),
+            branch: {
+                type: 'repo/watch_branch',
+                recordName: recordName,
+                inst: inst,
+                branch: branch,
+                temporary: device.temporary,
+            },
+        }));
+        await Promise.all(promises);
+    }
+    async unwatchBranchDevices(connectionId, recordName, inst, branch) {
+        await this._connectionStore.deleteBranchConnection(connectionId, 'watch_branch', recordName, inst, branch);
+    }
+    async deviceCount(connectionId, recordName, inst, branch) {
+        const count = typeof branch !== 'undefined' && branch !== null
+            ? await this._connectionStore.countConnectionsByBranch('branch', recordName, inst, branch)
+            : await this._connectionStore.countConnections();
+        const currentConnection = await this._connectionStore.getConnection(connectionId);
+        if (recordName && (currentConnection === null || currentConnection === void 0 ? void 0 : currentConnection.token)) {
+            const authorized = await this._connectionStore.isAuthorizedInst(connectionId, recordName, inst, 'token');
+            if (!authorized) {
+                await this.sendError(connectionId, -1, {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to access this inst.',
+                    recordName,
                     inst,
-                    branch }));
+                    branch,
+                    reason: {
+                        type: 'invalid_token',
+                    },
+                });
                 return;
             }
-            else if (recordName && !instResult.inst) {
-                yield this.sendError(connectionId, -1, {
+        }
+        if (recordName) {
+            const config = await this._config.getSubscriptionConfiguration();
+            const instResult = await this._getInst(recordName, inst, currentConnection === null || currentConnection === void 0 ? void 0 : currentConnection.userId, config);
+            if (instResult.success === false) {
+                await this.sendError(connectionId, -1, instResult);
+                return;
+            }
+            else if (!instResult.inst) {
+                await this.sendError(connectionId, -1, {
                     success: false,
                     errorCode: 'inst_not_found',
                     errorMessage: 'The inst was not found.',
+                });
+                return;
+            }
+        }
+        await this._messenger.sendMessage([connectionId], {
+            type: 'repo/connection_count',
+            recordName,
+            inst,
+            branch,
+            count: count,
+        });
+    }
+    /**
+     * Gets the data from the given branch in the given inst.
+     * @param userId The ID of the user that is currently logged in.
+     * @param recordName The name of the record that the inst is in. Null if accessing a public inst.
+     * @param inst The name of the inst.
+     * @param branch The name of the branch in the inst.
+     * @param auxVersion The AUX version to return.
+     */
+    async getBranchData(userId, recordName, inst, branch, auxVersion = 1) {
+        var _a;
+        console.log(`[WebsocketController] [namespace: ${recordName}/${inst}/${branch}] Get Data`);
+        if (recordName) {
+            const config = await this._config.getSubscriptionConfiguration();
+            const instResult = await this._getInst(recordName, inst, userId, config);
+            if (instResult.success === false) {
+                return instResult;
+            }
+            else if (!instResult.inst) {
+                return {
+                    success: false,
+                    errorCode: 'inst_not_found',
+                    errorMessage: 'The inst was not found.',
+                };
+            }
+        }
+        const updates = (_a = (await this._instStore.getCurrentUpdates(recordName, inst, branch))) !== null && _a !== void 0 ? _a : {
+            updates: [],
+            timestamps: [],
+            instSizeInBytes: 0,
+        };
+        if (auxVersion === 1) {
+            const partition = new YjsPartitionImpl({ type: 'yjs' });
+            for (let updateBase64 of updates.updates) {
+                const update = toByteArray(updateBase64);
+                applyUpdate(partition.doc, update);
+            }
+            return {
+                success: true,
+                data: {
+                    version: 1,
+                    state: partition.state,
+                },
+            };
+        }
+        else {
+            let stored = [];
+            for (let i = 0; i < updates.updates.length; i++) {
+                stored.push({
+                    id: i,
+                    update: updates.updates[i],
+                    timestamp: updates.timestamps[i],
+                });
+            }
+            return {
+                success: true,
+                data: {
+                    version: 2,
+                    updates: stored,
+                },
+            };
+        }
+    }
+    async listInsts(recordName, userId, startingInst) {
+        try {
+            if (!recordName) {
+                return {
+                    success: true,
+                    insts: [],
+                    totalCount: 0,
+                };
+            }
+            const contextResult = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName: recordName,
+                userId,
+            });
+            if (contextResult.success === false) {
+                return contextResult;
+            }
+            const context = contextResult.context;
+            const authorizeResult = await this._policies.authorizeUserAndInstances(context, {
+                resourceKind: 'inst',
+                action: 'list',
+                userId,
+                markers: [PRIVATE_MARKER],
+                instances: [],
+            });
+            if (authorizeResult.success === false) {
+                return authorizeResult;
+            }
+            const metricsResult = await this._metrics.getSubscriptionInstMetricsByRecordName(recordName);
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getSubscriptionFeatures(config, metricsResult.subscriptionStatus, metricsResult.subscriptionId, metricsResult.subscriptionType);
+            if (!features.insts.allowed) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'Insts are not allowed for this subscription.',
+                };
+            }
+            const instsResult = await this._instStore.listInstsByRecord(recordName, startingInst);
+            if (!instsResult.success) {
+                return instsResult;
+            }
+            return {
+                success: true,
+                insts: instsResult.insts,
+                totalCount: instsResult.totalCount,
+            };
+        }
+        catch (err) {
+            console.error(`[WebsocketController] A server error occurred while listing insts:`, err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async getUpdates(connectionId, recordName, inst, branch) {
+        var _a;
+        if (!branch) {
+            console.warn('[CasualRepoServer] Trying to get branch with a null branch!');
+            return;
+        }
+        const connection = await this._connectionStore.getConnection(connectionId);
+        if (!connection) {
+            console.error(`[WebsocketController] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Unable to get_updates. Connection not found!`);
+            await this.sendError(connectionId, -1, {
+                success: false,
+                errorCode: 'invalid_connection_state',
+                errorMessage: `A server error occurred. (namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId})`,
+                recordName: recordName,
+                inst: inst,
+                branch: branch,
+            });
+            await this.messenger.disconnect(connectionId);
+            return;
+        }
+        if (connection.token && recordName) {
+            const authorized = await this._connectionStore.isAuthorizedInst(connectionId, recordName, inst, 'token');
+            if (!authorized) {
+                await this.sendError(connectionId, -1, {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to access this inst.',
                     recordName,
                     inst,
                     branch,
+                    reason: {
+                        type: 'invalid_token',
+                    },
                 });
                 return;
             }
-            const updates = (_a = (yield this._instStore.getAllUpdates(recordName, inst, branch))) !== null && _a !== void 0 ? _a : {
-                updates: [],
-                timestamps: [],
-            };
-            yield this._messenger.sendMessage([connection.serverConnectionId], {
-                type: 'repo/add_updates',
+        }
+        // const namespace = branchNamespace(recordName, inst, branch);
+        console.log(`[WebsocketController] [namespace: ${recordName}/${inst}/${branch}, connectionId: ${connectionId}] Get Updates`);
+        const config = await this._config.getSubscriptionConfiguration();
+        const instResult = await this._getInst(recordName, inst, connection.userId, config);
+        if (instResult.success === false) {
+            await this.sendError(connectionId, -1, {
+                ...instResult,
                 recordName,
                 inst,
-                branch: branch,
-                updates: updates.updates,
-                timestamps: updates.timestamps,
+                branch,
+            });
+            return;
+        }
+        else if (recordName && !instResult.inst) {
+            await this.sendError(connectionId, -1, {
+                success: false,
+                errorCode: 'inst_not_found',
+                errorMessage: 'The inst was not found.',
+                recordName,
+                inst,
+                branch,
             });
+            return;
+        }
+        const updates = (_a = (await this._instStore.getAllUpdates(recordName, inst, branch))) !== null && _a !== void 0 ? _a : {
+            updates: [],
+            timestamps: [],
+        };
+        await this._messenger.sendMessage([connection.serverConnectionId], {
+            type: 'repo/add_updates',
+            recordName,
+            inst,
+            branch: branch,
+            updates: updates.updates,
+            timestamps: updates.timestamps,
         });
     }
-    eraseInst(recordKeyOrName, inst, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const context = yield this._policies.constructAuthorizationContext({
-                    recordKeyOrRecordName: recordKeyOrName,
-                    userId,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const recordName = context.context.recordName;
-                const storedInst = yield this._instStore.getInstByName(recordName, inst);
-                if (!storedInst) {
-                    return {
-                        success: true,
-                    };
-                }
-                const authResult = yield this._policies.authorizeUserAndInstances(context.context, {
-                    resourceKind: 'inst',
-                    resourceId: inst,
-                    action: 'delete',
-                    markers: storedInst.markers,
-                    userId,
-                    instances: [],
-                });
-                if (authResult.success === false) {
-                    return authResult;
-                }
-                yield this._instStore.deleteInst(recordName, inst);
+    async eraseInst(recordKeyOrName, inst, userId) {
+        try {
+            const context = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName: recordKeyOrName,
+                userId,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            const recordName = context.context.recordName;
+            const storedInst = await this._instStore.getInstByName(recordName, inst);
+            if (!storedInst) {
                 return {
                     success: true,
                 };
             }
-            catch (err) {
-                console.error('[WebsocketController] [eraseInst] Error while erasing inst.', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
-                };
+            const authResult = await this._policies.authorizeUserAndInstances(context.context, {
+                resourceKind: 'inst',
+                resourceId: inst,
+                action: 'delete',
+                markers: storedInst.markers,
+                userId,
+                instances: [],
+            });
+            if (authResult.success === false) {
+                return authResult;
             }
-        });
+            await this._instStore.deleteInst(recordName, inst);
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            console.error('[WebsocketController] [eraseInst] Error while erasing inst.', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
     }
     /**
      * Processes a webhook and returns the status code that should be returned.
@@ -1055,182 +1223,369 @@ export class WebsocketController {
      * @param headers The headers that were included in the request.
      * @param data The data included in the request.
      */
-    webhook(recordName, inst, branch, method, url, headers, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: Change webhooks to be records.
-            if (recordName) {
-                return;
-            }
-            // const namespace = branchNamespace(recordName, inst, branch);
-            const b = yield this._instStore.getBranchByName(recordName, inst, branch);
-            if (!b) {
-                return 404;
-            }
-            const connectedDevices = yield this._connectionStore.getConnectionsByBranch('branch', recordName, inst, branch);
-            if (connectedDevices.some((d) => !d)) {
-                return 500;
-            }
-            if (connectedDevices.length <= 0) {
-                return 404;
-            }
-            // TODO: Replace with system that selects target devices with better uniformity
-            // than Math.random().
-            const randomDeviceIndex = Math.min(connectedDevices.length - 1, Math.max(Math.floor(Math.random() * connectedDevices.length), 0));
-            const randomDevice = connectedDevices[randomDeviceIndex];
-            if (!randomDevice) {
-                return 500;
-            }
-            const a = action(ON_WEBHOOK_ACTION_NAME, null, null, {
-                method,
-                url,
-                headers,
-                data,
-            });
-            yield this._messenger.sendMessage([randomDevice.serverConnectionId], {
-                type: 'repo/receive_action',
-                recordName,
-                inst,
-                branch,
-                action: a,
-            });
-            return 200;
+    async webhook(recordName, inst, branch, method, url, headers, data) {
+        // TODO: Change webhooks to be records.
+        if (recordName) {
+            return;
+        }
+        // const namespace = branchNamespace(recordName, inst, branch);
+        const b = await this._instStore.getBranchByName(recordName, inst, branch);
+        if (!b) {
+            return 404;
+        }
+        const connectedDevices = await this._connectionStore.getConnectionsByBranch('branch', recordName, inst, branch);
+        if (connectedDevices.some((d) => !d)) {
+            return 500;
+        }
+        if (connectedDevices.length <= 0) {
+            return 404;
+        }
+        // TODO: Replace with system that selects target devices with better uniformity
+        // than Math.random().
+        const randomDeviceIndex = Math.min(connectedDevices.length - 1, Math.max(Math.floor(Math.random() * connectedDevices.length), 0));
+        const randomDevice = connectedDevices[randomDeviceIndex];
+        if (!randomDevice) {
+            return 500;
+        }
+        const a = action(ON_WEBHOOK_ACTION_NAME, null, null, {
+            method,
+            url,
+            headers,
+            data,
+        });
+        await this._messenger.sendMessage([randomDevice.serverConnectionId], {
+            type: 'repo/receive_action',
+            recordName,
+            inst,
+            branch,
+            action: a,
         });
+        return 200;
     }
     /**
      * Requests that the user be given permission to access the given resource.
      * @param connectionId The ID of the connection that is making the request.
      * @param event The request missing permission event.
      */
-    requestMissingPermission(connectionId, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this._connectionStore.getConnection(connectionId);
-            if (!connection) {
-                console.error(`[CausalRepoServer] [connectionId: ${connectionId}] Unable to request permission. Connection not found!`);
-                yield this.sendError(connectionId, -1, {
-                    success: false,
-                    errorCode: 'invalid_connection_state',
-                    errorMessage: `A server error occurred. (connectionId: ${connectionId})`,
-                });
-                yield this.messenger.disconnect(connectionId);
-                return;
-            }
-            if (event.reason.type !== 'missing_permission') {
-                yield this._messenger.sendMessage([connectionId], {
-                    type: 'permission/request/missing/response',
-                    success: false,
-                    recordName: event.reason.recordName,
-                    resourceKind: event.reason.resourceKind,
-                    resourceId: event.reason.resourceId,
-                    subjectType: event.reason.subjectType,
-                    subjectId: event.reason.subjectId,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'It is only possible to request missing permissions.',
-                });
-                return;
-            }
-            else if (event.reason.resourceKind !== 'inst') {
-                yield this._messenger.sendMessage([connectionId], {
-                    type: 'permission/request/missing/response',
-                    success: false,
-                    recordName: event.reason.recordName,
-                    resourceKind: event.reason.resourceKind,
-                    resourceId: event.reason.resourceId,
-                    subjectType: event.reason.subjectType,
-                    subjectId: event.reason.subjectId,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'Permissions can only be requested to access insts.',
-                });
-                return;
-            }
-            else if (event.reason.subjectType !== 'user' ||
-                event.reason.subjectId !== connection.userId) {
-                yield this._messenger.sendMessage([connectionId], {
-                    type: 'permission/request/missing/response',
-                    success: false,
-                    recordName: event.reason.recordName,
-                    resourceKind: event.reason.resourceKind,
-                    resourceId: event.reason.resourceId,
-                    subjectType: event.reason.subjectType,
-                    subjectId: event.reason.subjectId,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'Permissions can only be requested for the current user.',
-                });
-                return;
-            }
-            const connections = yield this._connectionStore.getConnectionsByBranch('branch', event.reason.recordName, event.reason.resourceId, DEFAULT_BRANCH_NAME);
-            if (connections.length > 0) {
-                const userInfoResult = yield this._auth.getPublicUserInfo(connection.userId);
-                let userInfo = null;
-                if (userInfoResult.success === false) {
-                    console.error('[WebsocketController] [requestMissingPermission] Error while getting user info.', userInfoResult);
-                }
-                else {
-                    userInfo = userInfoResult.user;
-                }
-                const inst = `${event.reason.resourceKind}/${event.reason.resourceId}`;
-                const branch = `${event.reason.subjectType}/${event.reason.subjectId}`;
-                yield this._connectionStore.saveBranchConnection(Object.assign(Object.assign({}, connection), { serverConnectionId: connectionId, mode: 'missing_permission', recordName: event.reason.recordName, inst: inst, branch: branch, temporary: true }));
-                yield this._messenger.sendMessage(connections.map((c) => c.serverConnectionId), {
-                    type: 'permission/request/missing',
-                    reason: event.reason,
-                    connection: connectionInfo(connection),
-                    user: userInfo,
-                });
+    async requestMissingPermission(connectionId, event) {
+        const connection = await this._connectionStore.getConnection(connectionId);
+        if (!connection) {
+            console.error(`[WebsocketController] [connectionId: ${connectionId}] Unable to request permission. Connection not found!`);
+            await this.sendError(connectionId, -1, {
+                success: false,
+                errorCode: 'invalid_connection_state',
+                errorMessage: `A server error occurred. (connectionId: ${connectionId})`,
+            });
+            await this.messenger.disconnect(connectionId);
+            return;
+        }
+        if (event.reason.type !== 'missing_permission') {
+            await this._messenger.sendMessage([connectionId], {
+                type: 'permission/request/missing/response',
+                success: false,
+                recordName: event.reason.recordName,
+                resourceKind: event.reason.resourceKind,
+                resourceId: event.reason.resourceId,
+                subjectType: event.reason.subjectType,
+                subjectId: event.reason.subjectId,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'It is only possible to request missing permissions.',
+            });
+            return;
+        }
+        else if (event.reason.resourceKind !== 'inst') {
+            await this._messenger.sendMessage([connectionId], {
+                type: 'permission/request/missing/response',
+                success: false,
+                recordName: event.reason.recordName,
+                resourceKind: event.reason.resourceKind,
+                resourceId: event.reason.resourceId,
+                subjectType: event.reason.subjectType,
+                subjectId: event.reason.subjectId,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'Permissions can only be requested to access insts.',
+            });
+            return;
+        }
+        else if (event.reason.subjectType !== 'user' ||
+            event.reason.subjectId !== connection.userId) {
+            await this._messenger.sendMessage([connectionId], {
+                type: 'permission/request/missing/response',
+                success: false,
+                recordName: event.reason.recordName,
+                resourceKind: event.reason.resourceKind,
+                resourceId: event.reason.resourceId,
+                subjectType: event.reason.subjectType,
+                subjectId: event.reason.subjectId,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'Permissions can only be requested for the current user.',
+            });
+            return;
+        }
+        const connections = await this._connectionStore.getConnectionsByBranch('branch', event.reason.recordName, event.reason.resourceId, DEFAULT_BRANCH_NAME);
+        if (connections.length > 0) {
+            const userInfoResult = await this._auth.getPublicUserInfo(connection.userId);
+            let userInfo = null;
+            if (userInfoResult.success === false) {
+                console.error('[WebsocketController] [requestMissingPermission] Error while getting user info.', userInfoResult);
             }
             else {
-                yield this._messenger.sendMessage([connectionId], {
-                    type: 'permission/request/missing/response',
-                    success: false,
-                    recordName: event.reason.recordName,
-                    resourceKind: event.reason.resourceKind,
-                    resourceId: event.reason.resourceId,
-                    subjectType: event.reason.subjectType,
-                    subjectId: event.reason.subjectId,
-                    errorCode: 'unacceptable_request',
-                    errorMessage: 'There are no currently no users available that can grant access to the inst.',
-                });
-                return;
-            }
+                userInfo = userInfoResult.user;
+            }
+            const inst = `${event.reason.resourceKind}/${event.reason.resourceId}`;
+            const branch = `${event.reason.subjectType}/${event.reason.subjectId}`;
+            await this._connectionStore.saveBranchConnection({
+                ...connection,
+                serverConnectionId: connectionId,
+                mode: 'missing_permission',
+                recordName: event.reason.recordName,
+                inst: inst,
+                branch: branch,
+                temporary: true,
+            });
+            await this._messenger.sendMessage(connections.map((c) => c.serverConnectionId), {
+                type: 'permission/request/missing',
+                reason: event.reason,
+                connection: connectionInfo(connection),
+                user: userInfo,
+            });
+        }
+        else {
+            await this._messenger.sendMessage([connectionId], {
+                type: 'permission/request/missing/response',
+                success: false,
+                recordName: event.reason.recordName,
+                resourceKind: event.reason.resourceKind,
+                resourceId: event.reason.resourceId,
+                subjectType: event.reason.subjectType,
+                subjectId: event.reason.subjectId,
+                errorCode: 'unacceptable_request',
+                errorMessage: 'There are no currently no users available that can grant access to the inst.',
+            });
+            return;
+        }
+    }
+    /**
+     * Responds to a missing permission request.
+     * @param connectionId The ID of the connection that is responding to the request.
+     * @param event The response to the missing permission request.
+     */
+    async respondToPermissionRequest(connectionId, event) {
+        const connection = await this._connectionStore.getConnection(connectionId);
+        if (!connection) {
+            console.error(`[WebsocketController] [connectionId: ${connectionId}] Unable to respond to permission request. Connection not found!`);
+            await this.sendError(connectionId, -1, {
+                success: false,
+                errorCode: 'invalid_connection_state',
+                errorMessage: `A server error occurred. (connectionId: ${connectionId})`,
+            });
+            await this.messenger.disconnect(connectionId);
+            return;
+        }
+        const inst = `${event.resourceKind}/${event.resourceId}`;
+        const branch = `${event.subjectType}/${event.subjectId}`;
+        const otherConnections = await this._connectionStore.getConnectionsByBranch('missing_permission', event.recordName, inst, branch);
+        if (otherConnections.length > 0) {
+            for (let c of otherConnections) {
+                await this._connectionStore.deleteBranchConnection(c.serverConnectionId, 'missing_permission', event.recordName, inst, branch);
+            }
+            await this._messenger.sendMessage(otherConnections.map((c) => c.serverConnectionId), {
+                type: 'permission/request/missing/response',
+                ...event,
+                connection: connectionInfo(connection),
+            });
+        }
+    }
+    /**
+     * Attempts to install a package into an inst.
+     * @param request The request to load the package.
+     */
+    async installPackage(request) {
+        var _a, _b;
+        if (!this._packageVersions) {
+            return {
+                success: false,
+                errorCode: 'not_supported',
+                errorMessage: 'Package loading is not supported.',
+            };
+        }
+        const userId = request.userId;
+        const key = (_a = request.package.key) !== null && _a !== void 0 ? _a : {};
+        console.log(`[CausalRepoServer] [namespace: ${request.recordName}/${request.inst}, ${userId}, package: ${request.package.recordName}/${request.package.address}@${formatVersionSpecifier(key)}] Install Package`);
+        const p = await this._packageVersions.getItem({
+            recordName: request.package.recordName,
+            address: request.package.address,
+            key,
+            userId: userId,
+            instances: request.instances,
+        });
+        if (p.success === false) {
+            console.error(`[CausalRepoServer] [userId: ${userId}] Unable to load package.`, p);
+            return p;
+        }
+        if (p.auxFile.success === false) {
+            console.error(`[CausalRepoServer] [userId: ${userId}] Unable to load package file.`, p.auxFile);
+            return p.auxFile;
+        }
+        const loadedPackageStore = this._instStore;
+        const loadedPackage = await loadedPackageStore.isPackageLoaded(request.recordName, request.inst, p.item.packageId);
+        if (loadedPackage) {
+            // Already loaded
+            console.log(`[CausalRepoServer] [userId: ${userId}] Package already loaded.`);
+            return {
+                success: true,
+                packageLoadId: loadedPackage.id,
+                package: p.item,
+            };
+        }
+        // check that the user and target inst has the ability to run the package
+        const context = await this._policies.constructAuthorizationContext({
+            recordKeyOrRecordName: request.package.recordName,
+            userId,
+        });
+        if (context.success === false) {
+            return context;
+        }
+        const authorization = await this._policies.authorizeUserAndInstances(context.context, {
+            userId,
+            instances: [formatInstId(request.recordName, request.inst)],
+            resourceKind: 'package.version',
+            resourceId: p.item.address,
+            action: 'run',
+            markers: p.item.markers,
+        });
+        if (authorization.success === false) {
+            return authorization;
+        }
+        const fileResponse = await fetch(p.auxFile.requestUrl, {
+            method: p.auxFile.requestMethod,
+            headers: new Headers(p.auxFile.requestHeaders),
         });
+        if (fileResponse.status >= 300) {
+            console.error(`[CausalRepoServer] [userId: ${userId}] Unable to load package file.`);
+            // Failed
+            return {
+                success: false,
+                errorCode: 'invalid_file_data',
+                errorMessage: 'The package file could not be loaded.',
+            };
+        }
+        const json = await fileResponse.text();
+        const packageData = tryParseJson(json);
+        if (packageData.success === false) {
+            console.error(`[CausalRepoServer] [userId: ${userId}] Unable to parse package file.`, packageData);
+            return {
+                success: false,
+                errorCode: 'invalid_file_data',
+                errorMessage: 'The package file could not be parsed. It must be valid JSON.',
+            };
+        }
+        const parsed = STORED_AUX_SCHEMA.safeParse(packageData.value);
+        if (parsed.success === false) {
+            console.error(`[CausalRepoServer] [userId: ${userId}] Unable to parse package file.`, packageData);
+            return {
+                success: false,
+                errorCode: 'invalid_file_data',
+                errorMessage: 'The package file could not be parsed.',
+                issues: parsed.error.issues,
+            };
+        }
+        const updates = parsed.data.version === 2
+            ? parsed.data.updates.map((u) => u.update)
+            : [
+                constructInitializationUpdate(createInitializationUpdate(Object.values(parsed.data.state))).update,
+            ];
+        const timestamps = parsed.data.version === 2
+            ? parsed.data.updates.map((u) => u.timestamp)
+            : [0];
+        const branch = (_b = request.branch) !== null && _b !== void 0 ? _b : DEFAULT_BRANCH_NAME;
+        const result = await this.addUserUpdates({
+            userId: request.userId,
+            userRole: request.userRole,
+            recordName: request.recordName,
+            inst: request.inst,
+            branch,
+            updates: updates,
+            timestamps: timestamps,
+        });
+        if (result.success === false) {
+            return result;
+        }
+        const loadedPackageId = uuidv7();
+        await loadedPackageStore.saveLoadedPackage({
+            id: loadedPackageId,
+            recordName: request.recordName,
+            inst: request.inst,
+            branch,
+            packageId: p.item.packageId,
+            packageVersionId: p.item.id,
+            userId: userId,
+        });
+        return {
+            success: true,
+            packageLoadId: loadedPackageId,
+            package: p.item,
+        };
     }
-    /**
-     * Responds to a missing permission request.
-     * @param connectionId The ID of the connection that is responding to the request.
-     * @param event The response to the missing permission request.
-     */
-    respondToPermissionRequest(connectionId, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this._connectionStore.getConnection(connectionId);
-            if (!connection) {
-                console.error(`[CausalRepoServer] [connectionId: ${connectionId}] Unable to respond to permission request. Connection not found!`);
-                yield this.sendError(connectionId, -1, {
+    async listInstalledPackages(request) {
+        if (!this._packageVersions) {
+            return {
+                success: false,
+                errorCode: 'not_supported',
+                errorMessage: 'Packages are not supported.',
+            };
+        }
+        if (request.recordName) {
+            const context = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName: request.recordName,
+                userId: request.userId,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            const recordName = context.context.recordName;
+            const instName = request.inst;
+            const savedInst = await this._instStore.getInstByName(recordName, instName);
+            if (!savedInst) {
+                return {
                     success: false,
-                    errorCode: 'invalid_connection_state',
-                    errorMessage: `A server error occurred. (connectionId: ${connectionId})`,
-                });
-                yield this.messenger.disconnect(connectionId);
-                return;
+                    errorCode: 'inst_not_found',
+                    errorMessage: 'The inst was not found.',
+                };
             }
-            const inst = `${event.resourceKind}/${event.resourceId}`;
-            const branch = `${event.subjectType}/${event.subjectId}`;
-            const otherConnections = yield this._connectionStore.getConnectionsByBranch('missing_permission', event.recordName, inst, branch);
-            if (otherConnections.length > 0) {
-                for (let c of otherConnections) {
-                    yield this._connectionStore.deleteBranchConnection(c.serverConnectionId, 'missing_permission', event.recordName, inst, branch);
-                }
-                yield this._messenger.sendMessage(otherConnections.map((c) => c.serverConnectionId), Object.assign(Object.assign({ type: 'permission/request/missing/response' }, event), { connection: connectionInfo(connection) }));
+            const authResult = await this._policies.authorizeUserAndInstances(context.context, {
+                resourceKind: 'inst',
+                resourceId: instName,
+                action: 'read',
+                markers: savedInst.markers,
+                userId: request.userId,
+                instances: request.instances,
+            });
+            if (authResult.success === false) {
+                return authResult;
             }
-        });
+        }
+        const packages = await this._instStore.listLoadedPackages(request.recordName, request.inst);
+        return {
+            success: true,
+            packages: packages.map((p) => ({
+                id: p.id,
+                recordName: p.recordName,
+                inst: p.inst,
+                branch: p.branch,
+                packageId: p.packageId,
+                packageVersionId: p.packageVersionId,
+                userId: p.userId,
+            })),
+        };
     }
-    syncTime(connectionId, event, requestTime) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._messenger.sendMessage([connectionId], {
-                type: 'sync/time/response',
-                id: event.id,
-                clientRequestTime: event.clientRequestTime,
-                serverReceiveTime: requestTime,
-                serverTransmitTime: Date.now(),
-            });
+    async syncTime(connectionId, event, requestTime) {
+        await this._messenger.sendMessage([connectionId], {
+            type: 'sync/time/response',
+            id: event.id,
+            clientRequestTime: event.clientRequestTime,
+            serverReceiveTime: requestTime,
+            serverTransmitTime: Date.now(),
         });
     }
     /**
@@ -1240,127 +1595,119 @@ export class WebsocketController {
      * @param totalHits The total number of hits by the connection.
      * @param timeMs The current time in unix time in miliseconds.
      */
-    rateLimitExceeded(connectionId, retryAfter, totalHits, timeMs) {
+    async rateLimitExceeded(connectionId, retryAfter, totalHits, timeMs) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const lastHit = (_a = (yield this._connectionStore.getConnectionRateLimitExceededTime(connectionId))) !== null && _a !== void 0 ? _a : -Infinity;
-            const difference = timeMs - lastHit;
-            yield this._connectionStore.setConnectionRateLimitExceededTime(connectionId, timeMs);
-            if (difference >= 1000) {
-                yield this._messenger.sendMessage([connectionId], {
-                    type: 'rate_limit_exceeded',
-                    retryAfter,
-                    totalHits,
-                });
-            }
-        });
+        const lastHit = (_a = (await this._connectionStore.getConnectionRateLimitExceededTime(connectionId))) !== null && _a !== void 0 ? _a : -Infinity;
+        const difference = timeMs - lastHit;
+        await this._connectionStore.setConnectionRateLimitExceededTime(connectionId, timeMs);
+        if (difference >= 1000) {
+            await this._messenger.sendMessage([connectionId], {
+                type: 'rate_limit_exceeded',
+                retryAfter,
+                totalHits,
+            });
+        }
     }
     /**
      * Processes the given upload request.
      * @param connectionId The ID of the connection that is requesting the upload.
      * @param requestId The ID of the request.
      */
-    uploadRequest(connectionId, requestId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const result = yield this._messenger.presignMessageUpload();
-                if (result.success === false) {
-                    console.log(`[WebsocketController] [uploadRequest] Upload requests are not supported!`);
-                    yield this.sendError(connectionId, requestId, {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'Upload requests are not supported.',
-                    });
-                    return;
-                }
-                yield this.sendEvent(connectionId, [
-                    WebsocketEventTypes.UploadResponse,
-                    requestId,
-                    result.uploadUrl,
-                    result.uploadMethod,
-                    result.uploadHeaders,
-                ]);
-            }
-            catch (err) {
-                console.error('[WebsocketController] [uploadRequest] Error while processing upload request.', err);
-                yield this.sendError(connectionId, requestId, {
+    async uploadRequest(connectionId, requestId) {
+        try {
+            const result = await this._messenger.presignMessageUpload();
+            if (result.success === false) {
+                console.log(`[WebsocketController] [uploadRequest] Upload requests are not supported!`);
+                await this.sendError(connectionId, requestId, {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'Error while processing upload request.',
+                    errorCode: 'not_supported',
+                    errorMessage: 'Upload requests are not supported.',
                 });
+                return;
             }
-        });
+            await this.sendEvent(connectionId, [
+                WebsocketEventTypes.UploadResponse,
+                requestId,
+                result.uploadUrl,
+                result.uploadMethod,
+                result.uploadHeaders,
+            ]);
+        }
+        catch (err) {
+            console.error('[WebsocketController] [uploadRequest] Error while processing upload request.', err);
+            await this.sendError(connectionId, requestId, {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'Error while processing upload request.',
+            });
+        }
     }
-    downloadRequest(connectionId, requestId, url, method, headers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const message = yield this._messenger.downloadMessage(url, method, headers);
-                if (message === undefined) {
-                    console.log(`[WebsocketController] [downloadRequest] Download requests are not supported!`);
-                    return {
-                        success: false,
-                        errorCode: 'not_supported',
-                        errorMessage: 'Download requests are not supported.',
-                    };
-                }
-                else if (message === null) {
-                    return {
-                        success: false,
-                        errorCode: 'message_not_found',
-                        errorMessage: 'Message not found.',
-                    };
-                }
-                else {
-                    return {
-                        success: true,
-                        requestId,
-                        message,
-                    };
-                }
+    async downloadRequest(connectionId, requestId, url, method, headers) {
+        try {
+            const message = await this._messenger.downloadMessage(url, method, headers);
+            if (message === undefined) {
+                console.log(`[WebsocketController] [downloadRequest] Download requests are not supported!`);
+                return {
+                    success: false,
+                    errorCode: 'not_supported',
+                    errorMessage: 'Download requests are not supported.',
+                };
             }
-            catch (err) {
-                console.error('[WebsocketController] [downloadRequest] Error while processing download request.', err);
+            else if (message === null) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'Error while processing download request.',
+                    errorCode: 'message_not_found',
+                    errorMessage: 'Message not found.',
                 };
             }
-        });
+            else {
+                return {
+                    success: true,
+                    requestId,
+                    message,
+                };
+            }
+        }
+        catch (err) {
+            console.error('[WebsocketController] [downloadRequest] Error while processing download request.', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'Error while processing download request.',
+            };
+        }
     }
     /**
      * Saves all of the permanent branches that are currently in memory.
      * @param timeout The timeout for the operation. Defaults to 30 seconds.
      */
-    savePermanentBranches(timeout = 30000) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const store = this._instStore;
-            if (store instanceof SplitInstRecordsStore) {
-                const unlock = yield store.temp.acquireLock(SAVE_PERMANENT_BRANCHES_LOCK, timeout);
-                if (!unlock) {
-                    console.log(`[WebsocketController] [savePermanentBranches] Unable to acquire lock.`);
-                    return;
-                }
-                console.log('[WebsocketController] [savePermanentBranches] Lock acquired.');
-                try {
-                    const generation = yield store.temp.getDirtyBranchGeneration();
-                    store.temp.setDirtyBranchGeneration(uuid());
-                    const branches = yield store.temp.listDirtyBranches(generation);
-                    for (let branch of branches) {
-                        if (!branch.recordName) {
-                            continue;
-                        }
-                        yield this._saveBranchUpdates(store, branch);
+    async savePermanentBranches(timeout = 30000) {
+        const store = this._instStore;
+        if (store instanceof SplitInstRecordsStore) {
+            const unlock = await store.temp.acquireLock(SAVE_PERMANENT_BRANCHES_LOCK, timeout);
+            if (!unlock) {
+                console.log(`[WebsocketController] [savePermanentBranches] Unable to acquire lock.`);
+                return;
+            }
+            console.log('[WebsocketController] [savePermanentBranches] Lock acquired.');
+            try {
+                const generation = await store.temp.getDirtyBranchGeneration();
+                store.temp.setDirtyBranchGeneration(uuid());
+                const branches = await store.temp.listDirtyBranches(generation);
+                for (let branch of branches) {
+                    if (!branch.recordName) {
+                        continue;
                     }
-                    yield store.temp.clearDirtyBranches(generation);
-                    console.log(`[WebsocketController] [savePermanentBranches] Saved.`);
-                }
-                finally {
-                    unlock();
-                    console.log('[WebsocketController] [savePermanentBranches] Released lock.');
+                    await this._saveBranchUpdates(store, branch);
                 }
+                await store.temp.clearDirtyBranches(generation);
+                console.log(`[WebsocketController] [savePermanentBranches] Saved.`);
             }
-        });
+            finally {
+                unlock();
+                console.log('[WebsocketController] [savePermanentBranches] Released lock.');
+            }
+        }
     }
     /**
      * Gets or creates the inst with the given name in the given record.
@@ -1373,147 +1720,135 @@ export class WebsocketController {
      * @param userId The ID of the user that is trying to access the inst.
      * @param context The authorization context.
      */
-    _getOrCreateInst(recordName, instName, userId, config, context = null) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let inst = null;
-            let features = null;
-            if (recordName) {
-                const getInstResult = yield this._getInst(recordName, instName, userId, config, context);
-                if (getInstResult.success === false) {
-                    return getInstResult;
-                }
-                const savedInst = getInstResult.inst;
+    async _getOrCreateInst(recordName, instName, userId, config, context = null) {
+        let inst = null;
+        let features = null;
+        if (recordName) {
+            const getInstResult = await this._getInst(recordName, instName, userId, config, context);
+            if (getInstResult.success === false) {
+                return getInstResult;
+            }
+            const savedInst = getInstResult.inst;
+            if (!context) {
+                context = getInstResult.context;
+            }
+            if (!features) {
+                features = getInstResult.features;
+            }
+            if (!savedInst) {
                 if (!context) {
-                    context = getInstResult.context;
-                }
-                if (!features) {
-                    features = getInstResult.features;
-                }
-                if (!savedInst) {
-                    if (!context) {
-                        const contextResult = yield this._policies.constructAuthorizationContext({
-                            recordKeyOrRecordName: recordName,
-                            userId,
-                        });
-                        if (contextResult.success === false) {
-                            return contextResult;
-                        }
-                        context = contextResult.context;
-                    }
-                    const authorizationResult = yield this._policies.authorizeUserAndInstancesForResources(context, {
-                        userId: userId,
-                        instances: [],
-                        resources: [
-                            {
-                                resourceKind: 'inst',
-                                resourceId: instName,
-                                action: 'create',
-                                markers: [PRIVATE_MARKER],
-                            },
-                            {
-                                resourceKind: 'marker',
-                                resourceId: PRIVATE_MARKER,
-                                action: 'assign',
-                                markers: [ACCOUNT_MARKER],
-                            },
-                            {
-                                resourceKind: 'inst',
-                                resourceId: instName,
-                                action: 'read',
-                                markers: [PRIVATE_MARKER],
-                            },
-                        ],
+                    const contextResult = await this._policies.constructAuthorizationContext({
+                        recordKeyOrRecordName: recordName,
+                        userId,
                     });
-                    if (authorizationResult.success === false) {
-                        console.log('[WebsocketController] Unable to authorize inst creation.', authorizationResult);
-                        return authorizationResult;
-                    }
-                    // const authorizeCreateResult =
-                    //     await this._policies.authorizeUserAndInstances(context, {
-                    //         resourceKind: 'inst',
-                    //         resourceId: instName,
-                    //         action: 'create',
-                    //         markers: [PRIVATE_MARKER],
-                    //         userId,
-                    //         instances: [],
-                    //     });
-                    // if (authorizeCreateResult.success === false) {
-                    //     console.log(
-                    //         '[WebsocketController] Unable to authorize inst creation.',
-                    //         authorizeCreateResult
-                    //     );
-                    //     return authorizeCreateResult;
-                    // }
-                    // const authorizeReadResult =
-                    //     await this._policies.authorizeUserAndInstances(context, {
-                    //         resourceKind: 'inst',
-                    //         resourceId: instName,
-                    //         action: 'read',
-                    //         markers: [PRIVATE_MARKER],
-                    //         userId,
-                    //         instances: [],
-                    //     });
-                    // if (authorizeReadResult.success === false) {
-                    //     console.log(
-                    //         '[WebsocketController] Unable to authorize inst creation.',
-                    //         authorizeReadResult
-                    //     );
-                    //     return authorizeReadResult;
-                    // }
-                    const instMetrics = yield this._metrics.getSubscriptionInstMetricsByRecordName(recordName);
-                    features = getSubscriptionFeatures(config, instMetrics.subscriptionStatus, instMetrics.subscriptionId, instMetrics.subscriptionType);
-                    if (!features.insts.allowed) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'Insts are not allowed for this subscription.',
-                        };
-                    }
-                    else if (typeof features.insts.maxInsts === 'number' &&
-                        instMetrics.totalInsts >= features.insts.maxInsts) {
-                        return {
-                            success: false,
-                            errorCode: 'subscription_limit_reached',
-                            errorMessage: 'The maximum number of insts has been reached.',
-                        };
+                    if (contextResult.success === false) {
+                        return contextResult;
                     }
-                    // Create the inst
-                    inst = {
-                        recordName: recordName,
-                        inst: instName,
-                        markers: [PRIVATE_MARKER],
-                        subscriptionId: instMetrics.subscriptionId,
-                        subscriptionStatus: instMetrics.subscriptionStatus,
-                        subscriptionType: instMetrics.subscriptionType,
+                    context = contextResult.context;
+                }
+                const authorizationResult = await this._policies.authorizeUserAndInstancesForResources(context, {
+                    userId: userId,
+                    instances: [],
+                    resources: [
+                        {
+                            resourceKind: 'inst',
+                            resourceId: instName,
+                            action: 'create',
+                            markers: [PRIVATE_MARKER],
+                        },
+                        {
+                            resourceKind: 'marker',
+                            resourceId: PRIVATE_MARKER,
+                            action: 'assign',
+                            markers: [ACCOUNT_MARKER],
+                        },
+                        {
+                            resourceKind: 'inst',
+                            resourceId: instName,
+                            action: 'read',
+                            markers: [PRIVATE_MARKER],
+                        },
+                    ],
+                });
+                if (authorizationResult.success === false) {
+                    console.log('[WebsocketController] Unable to authorize inst creation.', authorizationResult);
+                    return authorizationResult;
+                }
+                // const authorizeCreateResult =
+                //     await this._policies.authorizeUserAndInstances(context, {
+                //         resourceKind: 'inst',
+                //         resourceId: instName,
+                //         action: 'create',
+                //         markers: [PRIVATE_MARKER],
+                //         userId,
+                //         instances: [],
+                //     });
+                // if (authorizeCreateResult.success === false) {
+                //     console.log(
+                //         '[WebsocketController] Unable to authorize inst creation.',
+                //         authorizeCreateResult
+                //     );
+                //     return authorizeCreateResult;
+                // }
+                // const authorizeReadResult =
+                //     await this._policies.authorizeUserAndInstances(context, {
+                //         resourceKind: 'inst',
+                //         resourceId: instName,
+                //         action: 'read',
+                //         markers: [PRIVATE_MARKER],
+                //         userId,
+                //         instances: [],
+                //     });
+                // if (authorizeReadResult.success === false) {
+                //     console.log(
+                //         '[WebsocketController] Unable to authorize inst creation.',
+                //         authorizeReadResult
+                //     );
+                //     return authorizeReadResult;
+                // }
+                const instMetrics = await this._metrics.getSubscriptionInstMetricsByRecordName(recordName);
+                features = getSubscriptionFeatures(config, instMetrics.subscriptionStatus, instMetrics.subscriptionId, instMetrics.subscriptionType);
+                if (!features.insts.allowed) {
+                    return {
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'Insts are not allowed for this subscription.',
                     };
-                    const result = yield this._instStore.saveInst(inst);
-                    if (result.success === false) {
-                        console.log('[WebsocketController] Unable to save inst.', result);
-                        return result;
-                    }
                 }
-                else {
-                    inst = savedInst;
+                else if (typeof features.insts.maxInsts === 'number' &&
+                    instMetrics.totalInsts >= features.insts.maxInsts) {
+                    return {
+                        success: false,
+                        errorCode: 'subscription_limit_reached',
+                        errorMessage: 'The maximum number of insts has been reached.',
+                    };
+                }
+                // Create the inst
+                inst = {
+                    recordName: recordName,
+                    inst: instName,
+                    markers: [PRIVATE_MARKER],
+                    subscriptionId: instMetrics.subscriptionId,
+                    subscriptionStatus: instMetrics.subscriptionStatus,
+                    subscriptionType: instMetrics.subscriptionType,
+                };
+                const result = await this._instStore.saveInst(inst);
+                if (result.success === false) {
+                    console.log('[WebsocketController] Unable to save inst.', result);
+                    return result;
                 }
             }
             else {
-                // null record name means public temporary inst
-                const userInfo = yield this._authStore.findUser(userId);
-                if (userInfo) {
-                    const userPrivacyFeatures = userInfo.privacyFeatures;
-                    if (userPrivacyFeatures) {
-                        if (!userPrivacyFeatures.allowPublicInsts) {
-                            return {
-                                success: false,
-                                errorCode: 'not_authorized',
-                                errorMessage: 'Public insts are not allowed.',
-                            };
-                        }
-                    }
-                }
-                else {
-                    const privoConfig = yield this._config.getPrivoConfiguration();
-                    if (privoConfig) {
+                inst = savedInst;
+            }
+        }
+        else {
+            // null record name means public temporary inst
+            const userInfo = await this._authStore.findUser(userId);
+            if (userInfo) {
+                const userPrivacyFeatures = userInfo.privacyFeatures;
+                if (userPrivacyFeatures) {
+                    if (!userPrivacyFeatures.allowPublicInsts) {
                         return {
                             success: false,
                             errorCode: 'not_authorized',
@@ -1522,13 +1857,23 @@ export class WebsocketController {
                     }
                 }
             }
-            return {
-                success: true,
-                inst,
-                context,
-                features,
-            };
-        });
+            else {
+                const privoConfig = await this._config.getPrivoConfiguration();
+                if (privoConfig) {
+                    return {
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'Public insts are not allowed.',
+                    };
+                }
+            }
+        }
+        return {
+            success: true,
+            inst,
+            context,
+            features,
+        };
     }
     /**
      * Gets the inst with the given name in the given record.
@@ -1540,154 +1885,144 @@ export class WebsocketController {
      * @param instName The name of the inst.
      * @param userId The ID of the user that is trying to access the inst.
      */
-    _getInst(recordName, instName, userId, config, context = null) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let inst = null;
-            let features = null;
-            if (recordName) {
-                const savedInst = yield this._instStore.getInstByName(recordName, instName);
-                if (savedInst) {
-                    features = getSubscriptionFeatures(config, savedInst.subscriptionStatus, savedInst.subscriptionId, savedInst.subscriptionType);
-                    if (!features.insts.allowed) {
-                        return {
-                            success: false,
-                            errorCode: 'not_authorized',
-                            errorMessage: 'Insts are not allowed for this subscription.',
-                        };
-                    }
-                    if (!context) {
-                        const contextResult = yield this._policies.constructAuthorizationContext({
-                            recordKeyOrRecordName: recordName,
-                            userId,
-                        });
-                        if (contextResult.success === false) {
-                            return contextResult;
-                        }
-                        context = contextResult.context;
-                    }
-                    const authorizeResult = yield this._policies.authorizeUserAndInstances(context, {
-                        resourceKind: 'inst',
-                        resourceId: instName,
-                        action: 'read',
-                        markers: savedInst.markers,
+    async _getInst(recordName, instName, userId, config, context = null) {
+        let inst = null;
+        let features = null;
+        if (recordName) {
+            const savedInst = await this._instStore.getInstByName(recordName, instName);
+            if (savedInst) {
+                features = getSubscriptionFeatures(config, savedInst.subscriptionStatus, savedInst.subscriptionId, savedInst.subscriptionType);
+                if (!features.insts.allowed) {
+                    return {
+                        success: false,
+                        errorCode: 'not_authorized',
+                        errorMessage: 'Insts are not allowed for this subscription.',
+                    };
+                }
+                if (!context) {
+                    const contextResult = await this._policies.constructAuthorizationContext({
+                        recordKeyOrRecordName: recordName,
                         userId,
-                        instances: [],
                     });
-                    if (authorizeResult.success === false) {
-                        console.log('[WebsocketController] Unable to authorize inst read.', authorizeResult);
-                        return authorizeResult;
+                    if (contextResult.success === false) {
+                        return contextResult;
                     }
+                    context = contextResult.context;
+                }
+                const authorizeResult = await this._policies.authorizeUserAndInstances(context, {
+                    resourceKind: 'inst',
+                    resourceId: instName,
+                    action: 'read',
+                    markers: savedInst.markers,
+                    userId,
+                    instances: [],
+                });
+                if (authorizeResult.success === false) {
+                    console.log('[WebsocketController] Unable to authorize inst read.', authorizeResult);
+                    return authorizeResult;
                 }
-                return {
-                    success: true,
-                    inst: savedInst,
-                    context,
-                    features,
-                };
             }
             return {
                 success: true,
-                inst,
+                inst: savedInst,
                 context,
                 features,
             };
-        });
+        }
+        return {
+            success: true,
+            inst,
+            context,
+            features,
+        };
     }
-    _getOrCreateBranch(recordName, inst, branch, temporary, linkedInst) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (temporary) {
-                let b = yield this._temporaryStore.getBranchByName(recordName, inst, branch);
-                if (!b) {
-                    // Save the branch to the temp store
-                    yield this._temporaryStore.saveBranchInfo({
-                        recordName: recordName,
-                        inst: inst,
-                        branch: branch,
-                        temporary: true,
-                        linkedInst: linkedInst,
-                    });
-                    b = yield this._temporaryStore.getBranchByName(recordName, inst, branch);
-                }
-                return b;
+    async _getOrCreateBranch(recordName, inst, branch, temporary, linkedInst) {
+        if (temporary) {
+            let b = await this._temporaryStore.getBranchByName(recordName, inst, branch);
+            if (!b) {
+                // Save the branch to the temp store
+                await this._temporaryStore.saveBranchInfo({
+                    recordName: recordName,
+                    inst: inst,
+                    branch: branch,
+                    temporary: true,
+                    linkedInst: linkedInst,
+                });
+                b = await this._temporaryStore.getBranchByName(recordName, inst, branch);
             }
-            else {
-                let b = yield this._instStore.getBranchByName(recordName, inst, branch);
-                if (!b) {
-                    // Save the branch to the inst store
-                    yield this._instStore.saveBranch({
-                        branch: branch,
-                        inst: inst,
-                        recordName: recordName,
-                        temporary: temporary || false,
-                    });
-                    b = yield this._instStore.getBranchByName(recordName, inst, branch);
-                }
-                return b;
+            return b;
+        }
+        else {
+            let b = await this._instStore.getBranchByName(recordName, inst, branch);
+            if (!b) {
+                // Save the branch to the inst store
+                await this._instStore.saveBranch({
+                    branch: branch,
+                    inst: inst,
+                    recordName: recordName,
+                    temporary: temporary || false,
+                });
+                b = await this._instStore.getBranchByName(recordName, inst, branch);
             }
-        });
+            return b;
+        }
     }
-    _saveBranchUpdates(store, branch) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log(`[WebsocketController] Saving branch updates for ${branch.recordName}/${branch.inst}/${branch.branch}`);
-            let [updateCount, size] = yield Promise.all([
-                store.temp.countBranchUpdates(branch.recordName, branch.inst, branch.branch),
-                store.temp.getBranchSize(branch.recordName, branch.inst, branch.branch),
-            ]);
-            if (updateCount <= 0) {
-                console.log(`[WebsocketController] Branch has no updates to save.`);
-                return;
-            }
-            const branchInfo = yield store.getBranchByName(branch.recordName, branch.inst, branch.branch);
-            if (!branchInfo) {
-                console.log(`[WebsocketController] Branch info not found.`);
-                return;
-            }
-            if (branchInfo.temporary) {
-                console.log(`[WebsocketController] Branch is temporary.`);
+    async _saveBranchUpdates(store, branch) {
+        console.log(`[WebsocketController] Saving branch updates for ${branch.recordName}/${branch.inst}/${branch.branch}`);
+        let [updateCount, size] = await Promise.all([
+            store.temp.countBranchUpdates(branch.recordName, branch.inst, branch.branch),
+            store.temp.getBranchSize(branch.recordName, branch.inst, branch.branch),
+        ]);
+        if (updateCount <= 0) {
+            console.log(`[WebsocketController] Branch has no updates to save.`);
+            return;
+        }
+        const branchInfo = await store.getBranchByName(branch.recordName, branch.inst, branch.branch);
+        if (!branchInfo) {
+            console.log(`[WebsocketController] Branch info not found.`);
+            return;
+        }
+        if (branchInfo.temporary) {
+            console.log(`[WebsocketController] Branch is temporary.`);
+            return;
+        }
+        const updates = await store.temp.getUpdates(branch.recordName, branch.inst, branch.branch);
+        if (updates) {
+            const doc = new Doc({
+                gc: true,
+            });
+            for (let update of updates.updates) {
+                const bytes = toByteArray(update);
+                applyUpdate(doc, bytes);
+            }
+            const mergedBytes = encodeStateAsUpdate(doc);
+            const mergedBase64 = fromByteArray(mergedBytes);
+            const permanentReplaceResult = await store.perm.replaceCurrentUpdates(branch.recordName, branch.inst, branch.branch, mergedBase64, mergedBase64.length);
+            if (permanentReplaceResult.success === false) {
+                console.error(`[WebsocketController] Failed to replace permanent updates.`, permanentReplaceResult);
                 return;
             }
-            const updates = yield store.temp.getUpdates(branch.recordName, branch.inst, branch.branch);
-            if (updates) {
-                const doc = new Doc({
-                    gc: true,
-                });
-                for (let update of updates.updates) {
-                    const bytes = toByteArray(update);
-                    applyUpdate(doc, bytes);
-                }
-                const mergedBytes = encodeStateAsUpdate(doc);
-                const mergedBase64 = fromByteArray(mergedBytes);
-                const permanentReplaceResult = yield store.perm.replaceCurrentUpdates(branch.recordName, branch.inst, branch.branch, mergedBase64, mergedBase64.length);
-                if (permanentReplaceResult.success === false) {
-                    console.error(`[WebsocketController] Failed to replace permanent updates.`, permanentReplaceResult);
-                    return;
-                }
-                yield store.temp.addUpdates(branch.recordName, branch.inst, branch.branch, [mergedBase64], mergedBase64.length);
-                yield store.temp.trimUpdates(branch.recordName, branch.inst, branch.branch, updateCount);
-                yield Promise.all([
-                    store.temp.addBranchSize(branch.recordName, branch.inst, branch.branch, -size),
-                    store.temp.addInstSize(branch.recordName, branch.inst, -size),
-                ]);
-            }
-            else {
-                console.log(`[WebsocketController] No updates found.`);
-            }
-            console.log(`[WebsocketController] Updates complete.`);
-        });
-    }
-    sendError(connectionId, requestId, info) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendEvent(connectionId, [
-                WebsocketEventTypes.Error,
-                requestId,
-                info,
+            await store.temp.addUpdates(branch.recordName, branch.inst, branch.branch, [mergedBase64], mergedBase64.length);
+            await store.temp.trimUpdates(branch.recordName, branch.inst, branch.branch, updateCount);
+            await Promise.all([
+                store.temp.addBranchSize(branch.recordName, branch.inst, branch.branch, -size),
+                store.temp.addInstSize(branch.recordName, branch.inst, -size),
             ]);
-        });
+        }
+        else {
+            console.log(`[WebsocketController] No updates found.`);
+        }
+        console.log(`[WebsocketController] Updates complete.`);
     }
-    sendEvent(connectionId, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._messenger.sendEvent(connectionId, event);
-        });
+    async sendError(connectionId, requestId, info) {
+        await this.sendEvent(connectionId, [
+            WebsocketEventTypes.Error,
+            requestId,
+            info,
+        ]);
+    }
+    async sendEvent(connectionId, event) {
+        await this._messenger.sendEvent(connectionId, event);
     }
 }
 __decorate([
@@ -1705,6 +2040,9 @@ __decorate([
 __decorate([
     traced(TRACE_NAME)
 ], WebsocketController.prototype, "addUpdates", null);
+__decorate([
+    traced(TRACE_NAME)
+], WebsocketController.prototype, "addUserUpdates", null);
 __decorate([
     traced(TRACE_NAME)
 ], WebsocketController.prototype, "sendAction", null);
@@ -1738,6 +2076,12 @@ __decorate([
 __decorate([
     traced(TRACE_NAME)
 ], WebsocketController.prototype, "respondToPermissionRequest", null);
+__decorate([
+    traced(TRACE_NAME)
+], WebsocketController.prototype, "installPackage", null);
+__decorate([
+    traced(TRACE_NAME)
+], WebsocketController.prototype, "listInstalledPackages", null);
 __decorate([
     traced(TRACE_NAME)
 ], WebsocketController.prototype, "syncTime", null);