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

package/vm/BaseAuxChannel.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { Subject, firstValueFrom } from 'rxjs';
 import { tap, first, startWith } from 'rxjs/operators';
 import { BOT_SPACE_TAG, iteratePartitions, hasValue, asyncResult, addDebugApi, stateUpdatedEvent, registerBuiltinPortal, defineGlobalBot, merge, asyncError, botAdded, botUpdated, createBot, getBotSpace, remapProgressPercent, PartitionAuthSource, action, ON_COLLABORATION_ENABLED, ON_ALLOW_COLLABORATION_UPGRADE, ON_DISALLOW_COLLABORATION_UPGRADE, } from '@casual-simulation/aux-common';
@@ -14,7 +5,7 @@ import { AuxPartitionRealtimeEditModeProvider, AuxRuntime, isPromise, } from '@c
 import { AuxHelper } from './AuxHelper';
 import { buildVersionNumber } from './AuxConfig';
 import { StatusHelper } from './StatusHelper';
-import { flatMap, mapKeys, mapValues, pick, transform, } from 'lodash';
+import { flatMap, mapKeys, mapValues, pick, transform } from 'lodash';
 import { CustomAppHelper } from '../portals/CustomAppHelper';
 import { v4 as uuid } from 'uuid';
 export class BaseAuxChannel {
@@ -107,127 +98,117 @@ export class BaseAuxChannel {
         });
         addDebugApi('getChannel', () => this);
     }
-    init(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (onLocalEvents) {
-                this.onLocalEvents.subscribe(handleTransferError((e) => onLocalEvents(e), 'onLocalEvents'));
-            }
-            if (onStateUpdated) {
-                this.onStateUpdated.subscribe(handleTransferError((s) => onStateUpdated(s), 'onStateUpdated'));
-            }
-            if (onVersionUpdated) {
-                this.onVersionUpdated.subscribe(handleTransferError((v) => onVersionUpdated(v), 'onVersionUpdated'));
-            }
-            if (onConnectionStateChanged) {
-                this.onConnectionStateChanged.subscribe(handleTransferError((s) => onConnectionStateChanged(s), 'onConnectionStateChanged'));
-            }
-            if (onDeviceEvents) {
-                this.onDeviceEvents.subscribe(handleTransferError((e) => onDeviceEvents(e), 'onDeviceEvents'));
-            }
-            if (onSubChannelAdded) {
-                this.onSubChannelAdded.subscribe(handleTransferError((s) => onSubChannelAdded(s), 'onSubChannelAdded'));
-            }
-            if (onSubChannelRemoved) {
-                this.onSubChannelRemoved.subscribe(handleTransferError((s) => onSubChannelRemoved(s), 'onSubChannelRemoved'));
-            }
-            if (onAuthMessage) {
-                this.onAuthMessage.subscribe(handleTransferError((m) => onAuthMessage(m), 'onAuthMessage'));
-            }
-            // if (onError) {
-            //     this.onError.subscribe(onError);
-            // }
-            return yield this._init();
-        });
+    async init(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage) {
+        if (onLocalEvents) {
+            this.onLocalEvents.subscribe(handleTransferError((e) => onLocalEvents(e), 'onLocalEvents'));
+        }
+        if (onStateUpdated) {
+            this.onStateUpdated.subscribe(handleTransferError((s) => onStateUpdated(s), 'onStateUpdated'));
+        }
+        if (onVersionUpdated) {
+            this.onVersionUpdated.subscribe(handleTransferError((v) => onVersionUpdated(v), 'onVersionUpdated'));
+        }
+        if (onConnectionStateChanged) {
+            this.onConnectionStateChanged.subscribe(handleTransferError((s) => onConnectionStateChanged(s), 'onConnectionStateChanged'));
+        }
+        if (onDeviceEvents) {
+            this.onDeviceEvents.subscribe(handleTransferError((e) => onDeviceEvents(e), 'onDeviceEvents'));
+        }
+        if (onSubChannelAdded) {
+            this.onSubChannelAdded.subscribe(handleTransferError((s) => onSubChannelAdded(s), 'onSubChannelAdded'));
+        }
+        if (onSubChannelRemoved) {
+            this.onSubChannelRemoved.subscribe(handleTransferError((s) => onSubChannelRemoved(s), 'onSubChannelRemoved'));
+        }
+        if (onAuthMessage) {
+            this.onAuthMessage.subscribe(handleTransferError((m) => onAuthMessage(m), 'onAuthMessage'));
+        }
+        // if (onError) {
+        //     this.onError.subscribe(onError);
+        // }
+        return await this._init();
+    }
+    async initAndWait(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage) {
+        const promise = firstValueFrom(this.onConnectionStateChanged.pipe(first((s) => s.type === 'init')));
+        await this.init(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage);
+        await promise;
+    }
+    async registerListeners(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage) {
+        if (onLocalEvents) {
+            this.onLocalEvents.subscribe(handleTransferError((e) => onLocalEvents(e), 'onLocalEvents'));
+        }
+        if (onStateUpdated) {
+            this.onStateUpdated
+                .pipe(startWith(stateUpdatedEvent(this._helper.botsState)))
+                .subscribe(handleTransferError((s) => onStateUpdated(s), 'onStateUpdated'));
+        }
+        if (onVersionUpdated) {
+            this.onVersionUpdated
+                .pipe(startWith(this._version))
+                .subscribe(handleTransferError((v) => onVersionUpdated(v), 'onVersionUpdated'));
+        }
+        if (onConnectionStateChanged) {
+            this.onConnectionStateChanged
+                .pipe(startWith({
+                type: 'init',
+            }, { type: 'sync', synced: true }))
+                .subscribe(handleTransferError((s) => onConnectionStateChanged(s), 'onConnectionStateChanged'));
+        }
+        if (onDeviceEvents) {
+            this.onDeviceEvents.subscribe(handleTransferError((e) => onDeviceEvents(e), 'onDeviceEvents'));
+        }
+        if (onSubChannelAdded) {
+            this.onSubChannelAdded.subscribe(handleTransferError((s) => onSubChannelAdded(s), 'onSubChannelAdded'));
+        }
+        if (onSubChannelRemoved) {
+            this.onSubChannelRemoved.subscribe(handleTransferError((s) => onSubChannelRemoved(s), 'onSubChannelRemoved'));
+        }
+        if (onAuthMessage) {
+            this.onAuthMessage.subscribe(handleTransferError((m) => onAuthMessage(m), 'onAuthMessage'));
+        }
     }
-    initAndWait(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promise = firstValueFrom(this.onConnectionStateChanged.pipe(first((s) => s.type === 'init')));
-            yield this.init(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage);
-            yield promise;
+    async _init() {
+        this._initStartTime = performance.now();
+        this._handleStatusUpdated({
+            type: 'progress',
+            message: 'Creating causal tree...',
+            progress: 0.1,
         });
-    }
-    registerListeners(onLocalEvents, onDeviceEvents, onStateUpdated, onVersionUpdated, onConnectionStateChanged, onError, onSubChannelAdded, onSubChannelRemoved, onAuthMessage) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (onLocalEvents) {
-                this.onLocalEvents.subscribe(handleTransferError((e) => onLocalEvents(e), 'onLocalEvents'));
-            }
-            if (onStateUpdated) {
-                this.onStateUpdated
-                    .pipe(startWith(stateUpdatedEvent(this._helper.botsState)))
-                    .subscribe(handleTransferError((s) => onStateUpdated(s), 'onStateUpdated'));
-            }
-            if (onVersionUpdated) {
-                this.onVersionUpdated
-                    .pipe(startWith(this._version))
-                    .subscribe(handleTransferError((v) => onVersionUpdated(v), 'onVersionUpdated'));
-            }
-            if (onConnectionStateChanged) {
-                this.onConnectionStateChanged
-                    .pipe(startWith({
-                    type: 'init',
-                }, { type: 'sync', synced: true }))
-                    .subscribe(handleTransferError((s) => onConnectionStateChanged(s), 'onConnectionStateChanged'));
-            }
-            if (onDeviceEvents) {
-                this.onDeviceEvents.subscribe(handleTransferError((e) => onDeviceEvents(e), 'onDeviceEvents'));
-            }
-            if (onSubChannelAdded) {
-                this.onSubChannelAdded.subscribe(handleTransferError((s) => onSubChannelAdded(s), 'onSubChannelAdded'));
-            }
-            if (onSubChannelRemoved) {
-                this.onSubChannelRemoved.subscribe(handleTransferError((s) => onSubChannelRemoved(s), 'onSubChannelRemoved'));
-            }
-            if (onAuthMessage) {
-                this.onAuthMessage.subscribe(handleTransferError((m) => onAuthMessage(m), 'onAuthMessage'));
-            }
-        });
-    }
-    _init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._initStartTime = performance.now();
-            this._handleStatusUpdated({
-                type: 'progress',
-                message: 'Creating causal tree...',
-                progress: 0.1,
-            });
-            this._partitions = {};
-            this._partitionEditModeProvider =
-                new AuxPartitionRealtimeEditModeProvider(this._partitions);
-            this._authSource = new PartitionAuthSource();
-            this._subs.push(this._authSource.onAuthMessage.subscribe(this._onAuthMessage));
-            this._services = {
-                authSource: this._authSource,
-            };
-            let partitions = [];
-            for (let [key, partitionConfig] of iteratePartitions(this._config.partitions)) {
-                if (!Object.prototype.hasOwnProperty.call(this._config.partitions, key)) {
-                    continue;
-                }
-                const partition = yield this._createPartition(partitionConfig, this._services);
-                if (partition) {
-                    partition.space = key;
-                    this._partitions[key] = partition;
-                    partitions.push(partition);
-                }
-                else {
-                    throw new Error(`[BaseAuxChannel] Unable to build partition: ${key}`);
-                }
+        this._partitions = {};
+        this._partitionEditModeProvider =
+            new AuxPartitionRealtimeEditModeProvider(this._partitions);
+        this._authSource = new PartitionAuthSource();
+        this._subs.push(this._authSource.onAuthMessage.subscribe(this._onAuthMessage));
+        this._services = {
+            authSource: this._authSource,
+        };
+        let partitions = [];
+        for (let [key, partitionConfig] of iteratePartitions(this._config.partitions)) {
+            const partition = await this._createPartition(partitionConfig, this._services);
+            if (partition) {
+                partition.space = key;
+                this._partitions[key] = partition;
+                partitions.push(partition);
             }
-            this._statusHelper = new StatusHelper(partitions.map((p) => p.onStatusUpdated));
-            let statusMapper = remapProgressPercent(0.3, 0.6);
-            this._subs.push(this._statusHelper, this._statusHelper.updates
-                .pipe(tap((state) => this._handleStatusUpdated(statusMapper(state))))
-                .subscribe({ error: (e) => console.error(e) }), ...flatMap(partitions, (p) => this._getCleanupSubscriptionsForPartition(p)));
-            this._handleStatusUpdated({
-                type: 'progress',
-                message: 'Initializing causal tree...',
-                progress: 0.2,
-            });
-            for (let partition of partitions) {
-                partition.connect();
+            else {
+                console.error('[BaseAuxChannel] Unable to create partition:', key, partitionConfig);
+                throw new Error(`[BaseAuxChannel] Unable to build partition: ${key}`);
             }
-            return null;
+        }
+        this._statusHelper = new StatusHelper(partitions.map((p) => p.onStatusUpdated));
+        let statusMapper = remapProgressPercent(0.3, 0.6);
+        this._subs.push(this._statusHelper, this._statusHelper.updates
+            .pipe(tap((state) => this._handleStatusUpdated(statusMapper(state))))
+            .subscribe({ error: (e) => console.error(e) }), ...flatMap(partitions, (p) => this._getCleanupSubscriptionsForPartition(p)));
+        this._handleStatusUpdated({
+            type: 'progress',
+            message: 'Initializing causal tree...',
+            progress: 0.2,
         });
+        for (let partition of partitions) {
+            partition.connect();
+        }
+        return null;
     }
     _getCleanupSubscriptionsForPartition(partition) {
         return [
@@ -241,126 +222,106 @@ export class BaseAuxChannel {
     _getCleanupSubscriptionsForSharedDocument(doc) {
         return [doc, doc.onError.subscribe((err) => this._handleError(err))];
     }
-    sendEvents(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._hasInitialState) {
-                if (this._tagNameMapper) {
-                    let mappedEvents = [];
-                    for (let event of events) {
-                        if (event.type === 'update_bot') {
-                            mappedEvents.push(botUpdated(event.id, mapBotTagsAndSpace(event.update, this._tagNameMapper.reverse, (s) => s, null)));
-                        }
-                        else if (event.type === 'add_bot') {
-                            mappedEvents.push(botAdded(mapBotTagsAndSpace(event.bot, this._tagNameMapper.reverse, (s) => s, 'shared')));
-                        }
-                        else {
-                            mappedEvents.push(event);
-                        }
+    async sendEvents(events) {
+        if (this._hasInitialState) {
+            if (this._tagNameMapper) {
+                let mappedEvents = [];
+                for (let event of events) {
+                    if (event.type === 'update_bot') {
+                        mappedEvents.push(botUpdated(event.id, mapBotTagsAndSpace(event.update, this._tagNameMapper.reverse, (s) => s, null)));
+                    }
+                    else if (event.type === 'add_bot') {
+                        mappedEvents.push(botAdded(mapBotTagsAndSpace(event.bot, this._tagNameMapper.reverse, (s) => s, 'shared')));
+                    }
+                    else {
+                        mappedEvents.push(event);
                     }
-                    events = mappedEvents;
                 }
-                yield this._helper.transaction(...events);
-            }
-            else {
-                this._eventBuffer.push(...events);
-            }
-        });
-    }
-    shout(eventName, botIds, arg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._runtime) {
-                throw new Error('Unable to execute a shout without being initialized.');
+                events = mappedEvents;
             }
-            const result = this._runtime.shout(eventName, botIds, arg);
-            const final = isPromise(result) ? yield result : result;
-            return {
-                actions: final.actions,
-                results: yield Promise.all(final.results),
-            };
-        });
+            await this._helper.transaction(...events);
+        }
+        else {
+            this._eventBuffer.push(...events);
+        }
     }
-    formulaBatch(formulas) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._helper.formulaBatch(formulas);
-        });
+    async shout(eventName, botIds, arg) {
+        if (!this._runtime) {
+            throw new Error('Unable to execute a shout without being initialized.');
+        }
+        const result = this._runtime.shout(eventName, botIds, arg);
+        const final = isPromise(result) ? await result : result;
+        return {
+            actions: final.actions,
+            results: await Promise.all(final.results),
+        };
     }
-    forkAux(newId) {
-        return __awaiter(this, void 0, void 0, function* () { });
+    async formulaBatch(formulas) {
+        return this._helper.formulaBatch(formulas);
     }
-    exportBots(botIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._helper.exportBots(botIds);
-        });
+    async forkAux(newId) { }
+    async exportBots(botIds) {
+        return this._helper.exportBots(botIds);
     }
     /**
      * Exports the causal tree for the simulation.
      */
-    export() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let final = {};
-            const state = this._helper.publicBotsState;
-            for (let key in state) {
-                const bot = state[key];
-                final[key] = pick(bot, 'id', 'tags', BOT_SPACE_TAG);
-            }
-            return {
-                version: 1,
-                state: final,
-            };
-        });
+    async export() {
+        let final = {};
+        const state = this._helper.publicBotsState;
+        for (let key in state) {
+            const bot = state[key];
+            final[key] = pick(bot, 'id', 'tags', BOT_SPACE_TAG);
+        }
+        return {
+            version: 1,
+            state: final,
+        };
     }
-    getTags() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._helper.getTags();
-        });
+    async getTags() {
+        return this._helper.getTags();
     }
-    updateDevice(device) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let previousDevice = this._config.config.device;
-            this._config.config.device = device;
-            if (this._runtime) {
-                this._runtime.context.device = device;
-            }
-            if (this._helper) {
-                if (!previousDevice.isCollaborative) {
-                    if (!device.isCollaborative) {
-                        if (device.allowCollaborationUpgrade &&
-                            !previousDevice.allowCollaborationUpgrade) {
-                            yield this.sendEvents([
-                                action(ON_ALLOW_COLLABORATION_UPGRADE),
-                            ]);
-                        }
-                        else if (!device.allowCollaborationUpgrade &&
-                            previousDevice.allowCollaborationUpgrade) {
-                            yield this.sendEvents([
-                                action(ON_DISALLOW_COLLABORATION_UPGRADE),
-                            ]);
-                        }
+    async updateDevice(device) {
+        let previousDevice = this._config.config.device;
+        this._config.config.device = device;
+        if (this._runtime) {
+            this._runtime.context.device = device;
+        }
+        if (this._helper) {
+            if (!previousDevice.isCollaborative) {
+                if (!device.isCollaborative) {
+                    if (device.allowCollaborationUpgrade &&
+                        !previousDevice.allowCollaborationUpgrade) {
+                        await this.sendEvents([
+                            action(ON_ALLOW_COLLABORATION_UPGRADE),
+                        ]);
                     }
-                    else {
-                        yield this.sendEvents([action(ON_COLLABORATION_ENABLED)]);
+                    else if (!device.allowCollaborationUpgrade &&
+                        previousDevice.allowCollaborationUpgrade) {
+                        await this.sendEvents([
+                            action(ON_DISALLOW_COLLABORATION_UPGRADE),
+                        ]);
                     }
                 }
+                else {
+                    await this.sendEvents([action(ON_COLLABORATION_ENABLED)]);
+                }
             }
-        });
+        }
     }
-    sendAuthMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._authSource.sendAuthMessage(message);
-        });
+    async sendAuthMessage(message) {
+        this._authSource.sendAuthMessage(message);
     }
     /**
      * Sends the given list of remote events to their destinations.
      * @param events The events.
      */
-    _sendRemoteEvents(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let [, partition] of iteratePartitions(this._partitions)) {
-                if (partition.sendRemoteEvents) {
-                    yield partition.sendRemoteEvents(events);
-                }
+    async _sendRemoteEvents(events) {
+        for (let [, partition] of iteratePartitions(this._partitions)) {
+            if (partition.sendRemoteEvents) {
+                await partition.sendRemoteEvents(events);
             }
-        });
+        }
     }
     _createAuxHelper() {
         const partitions = this._partitions;
@@ -416,73 +377,67 @@ export class BaseAuxChannel {
         }))
             .subscribe({ error: (e) => console.error(e) }));
     }
-    _ensureSetup() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // console.log('[AuxChannel] Got Tree:', this._aux.tree.site.id);
-            if (!this._runtime) {
-                this._runtime = this._createRuntime();
-                this._subs.push(this._runtime);
-            }
-            if (!this._helper) {
-                this._helper = this._createAuxHelper();
-            }
-            if (!this._portalHelper) {
-                this._portalHelper = new CustomAppHelper(this._helper);
-            }
-            if (!this._timeSync) {
-                this._timeSync = this._createTimeSyncController();
-            }
-            this._handleStatusUpdated({
-                type: 'progress',
-                message: 'Initializing user bot...',
-                progress: 0.8,
-            });
-            yield this._initUserBot();
-            this._handleStatusUpdated({
-                type: 'progress',
-                message: 'Launching interface...',
-                progress: 0.9,
-            });
-            if (!this._hasRegisteredSubs) {
-                this._hasRegisteredSubs = true;
-                this._registerSubscriptions();
-            }
-            yield this._initPortalBots();
-            yield this._initBuilderBots();
-            this._runtime.context.setLoadTime('load', performance.now() - this._initStartTime);
-            console.log('[BaseAuxChannel] Sending init event');
-            this._onConnectionStateChanged.next({
-                type: 'init',
-            });
+    async _ensureSetup() {
+        // console.log('[AuxChannel] Got Tree:', this._aux.tree.site.id);
+        if (!this._runtime) {
+            this._runtime = this._createRuntime();
+            this._subs.push(this._runtime);
+        }
+        if (!this._helper) {
+            this._helper = this._createAuxHelper();
+        }
+        if (!this._portalHelper) {
+            this._portalHelper = new CustomAppHelper(this._helper);
+        }
+        if (!this._timeSync) {
+            this._timeSync = this._createTimeSyncController();
+        }
+        this._handleStatusUpdated({
+            type: 'progress',
+            message: 'Initializing user bot...',
+            progress: 0.8,
         });
-    }
-    _handleStatusUpdated(state) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (state.type === 'progress') {
-                console.log(`[BaseAuxChannel] Loading Progress (${state.progress * 100}%): ${state.message}`);
-            }
-            if (state.type === 'authentication') {
-                console.log(`[BaseAuxChannel] Authentication (${state.authenticated}):`, state.info);
-                this._deviceInfo = state.info;
-            }
-            else if (state.type === 'sync' && state.synced) {
-                console.log(`[BaseAuxChannel] Sync (${state.synced})`);
-                yield this._ensureSetup();
-            }
-            this._onConnectionStateChanged.next(state);
+        await this._initUserBot();
+        this._handleStatusUpdated({
+            type: 'progress',
+            message: 'Launching interface...',
+            progress: 0.9,
+        });
+        if (!this._hasRegisteredSubs) {
+            this._hasRegisteredSubs = true;
+            this._registerSubscriptions();
+        }
+        await this._initPortalBots();
+        await this._initBuilderBots();
+        this._runtime.context.setLoadTime('load', performance.now() - this._initStartTime);
+        console.log('[BaseAuxChannel] Sending init event');
+        this._onConnectionStateChanged.next({
+            type: 'init',
         });
     }
+    async _handleStatusUpdated(state) {
+        if (state.type === 'progress') {
+            console.log(`[BaseAuxChannel] Loading Progress (${state.progress * 100}%): ${state.message}`);
+        }
+        if (state.type === 'authentication') {
+            console.log(`[BaseAuxChannel] Authentication (${state.authenticated}):`, state.info);
+            this._deviceInfo = state.info;
+        }
+        else if (state.type === 'sync' && state.synced) {
+            console.log(`[BaseAuxChannel] Sync (${state.synced})`);
+            await this._ensureSetup();
+        }
+        this._onConnectionStateChanged.next(state);
+    }
     /**
      * Decides what to do with device events from partitions.
      * By default the events are processed as-is.
      * This means that the events are sent directly to the AuxHelper via this.sendEvents().
      * @param events The events.
      */
-    _handlePartitionEvents(events) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const actions = events;
-            yield this.sendEvents(actions);
-        });
+    async _handlePartitionEvents(events) {
+        const actions = events;
+        await this.sendEvents(actions);
     }
     _handleStateUpdated(event) {
         this._onStateUpdated.next(event);
@@ -528,83 +483,79 @@ export class BaseAuxChannel {
         const copiableEvents = e.filter((e) => !e.uncopiable);
         this._onLocalEvents.next(copiableEvents);
     }
-    _enableCollaboration(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!this._runtime.context.device) {
-                    if (hasValue(event.taskId)) {
-                        this.sendEvents([asyncResult(event.taskId, null)]);
-                    }
-                    return;
-                }
-                if (this._runtime.context.device.isCollaborative) {
-                    if (hasValue(event.taskId)) {
-                        this.sendEvents([asyncResult(event.taskId, null)]);
-                    }
-                    return;
-                }
-                if (!this._runtime.context.device.allowCollaborationUpgrade) {
-                    if (hasValue(event.taskId)) {
-                        this.sendEvents([
-                            asyncError(event.taskId, new Error('Collaboration upgrades are not allowed.')),
-                        ]);
-                    }
-                    return;
-                }
-                let promises = [];
-                for (let [_, partition] of iteratePartitions(this._partitions)) {
-                    if (partition.enableCollaboration) {
-                        promises.push(partition.enableCollaboration());
-                    }
-                }
-                yield Promise.all(promises);
-                this._runtime.context.device.isCollaborative = true;
-                this._runtime.context.device.allowCollaborationUpgrade = false;
+    async _enableCollaboration(event) {
+        try {
+            if (!this._runtime.context.device) {
                 if (hasValue(event.taskId)) {
                     this.sendEvents([asyncResult(event.taskId, null)]);
                 }
-                this.sendEvents([action(ON_COLLABORATION_ENABLED)]);
+                return;
             }
-            catch (err) {
-                console.error('[BaseAuxChannel] Error enabling collaboration', err);
+            if (this._runtime.context.device.isCollaborative) {
                 if (hasValue(event.taskId)) {
-                    this.sendEvents([asyncError(event.taskId, err)]);
+                    this.sendEvents([asyncResult(event.taskId, null)]);
                 }
+                return;
             }
-        });
-    }
-    _handleDeviceEvents(e) {
-        this._onDeviceEvents.next(e);
-    }
-    _loadPartition(space, config, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (space in this._partitions) {
-                console.log(`[BaseAuxChannel] Cannot load partition for "${space}" since the space is already occupied`);
+            if (!this._runtime.context.device.allowCollaborationUpgrade) {
                 if (hasValue(event.taskId)) {
-                    this.sendEvents([asyncResult(event.taskId, null)]);
+                    this.sendEvents([
+                        asyncError(event.taskId, new Error('Collaboration upgrades are not allowed.')),
+                    ]);
                 }
                 return;
             }
-            let partition = yield this._createPartition(config, this._services);
-            if (!partition) {
-                return;
+            let promises = [];
+            for (let [_, partition] of iteratePartitions(this._partitions)) {
+                if (partition.enableCollaboration) {
+                    promises.push(partition.enableCollaboration());
+                }
             }
-            this._partitions[space] = partition;
-            this.helper.addPartition(space, partition);
-            this._subs.push(...this._getCleanupSubscriptionsForPartition(partition));
+            await Promise.all(promises);
+            this._runtime.context.device.isCollaborative = true;
+            this._runtime.context.device.allowCollaborationUpgrade = false;
             if (hasValue(event.taskId)) {
-                // Wait for initial connection
-                partition.onStatusUpdated
-                    .pipe(first((status) => status.type === 'sync' && status.synced === true))
-                    .subscribe(() => {
-                    this.sendEvents([asyncResult(event.taskId, null)]);
-                });
+                this.sendEvents([asyncResult(event.taskId, null)]);
             }
-            partition.connect();
-            if (this._hasRegisteredSubs) {
-                this._registerStateSubscriptionsForPartition(partition, this._runtime);
+            this.sendEvents([action(ON_COLLABORATION_ENABLED)]);
+        }
+        catch (err) {
+            console.error('[BaseAuxChannel] Error enabling collaboration', err);
+            if (hasValue(event.taskId)) {
+                this.sendEvents([asyncError(event.taskId, err)]);
             }
-        });
+        }
+    }
+    _handleDeviceEvents(e) {
+        this._onDeviceEvents.next(e);
+    }
+    async _loadPartition(space, config, event) {
+        if (space in this._partitions) {
+            console.log(`[BaseAuxChannel] Cannot load partition for "${space}" since the space is already occupied`);
+            if (hasValue(event.taskId)) {
+                this.sendEvents([asyncResult(event.taskId, null)]);
+            }
+            return;
+        }
+        let partition = await this._createPartition(config, this._services);
+        if (!partition) {
+            return;
+        }
+        this._partitions[space] = partition;
+        this.helper.addPartition(space, partition);
+        this._subs.push(...this._getCleanupSubscriptionsForPartition(partition));
+        if (hasValue(event.taskId)) {
+            // Wait for initial connection
+            partition.onStatusUpdated
+                .pipe(first((status) => status.type === 'sync' && status.synced === true))
+                .subscribe(() => {
+                this.sendEvents([asyncResult(event.taskId, null)]);
+            });
+        }
+        partition.connect();
+        if (this._hasRegisteredSubs) {
+            this._registerStateSubscriptionsForPartition(partition, this._runtime);
+        }
     }
     /**
      * Gets the ID of the shared document that should be loaded.
@@ -619,139 +570,133 @@ export class BaseAuxChannel {
         }
         return null;
     }
-    _loadSharedDocument(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const id = this._getSharedDocId(event);
-            if (id) {
-                const doc = this._documents.get(id);
-                if (doc && !doc.closed) {
-                    if (hasValue(event.taskId)) {
-                        this.sendEvents([
-                            asyncResult(event.taskId, doc, false, true),
-                        ]);
-                    }
-                    return;
-                }
-            }
-            const config = {
-                recordName: event.recordName,
-                inst: event.inst,
-                branch: event.branch,
-                host: this._config.config.causalRepoConnectionUrl,
-                connectionProtocol: this._config.config.causalRepoConnectionProtocol,
-            };
-            if (!hasValue(event.inst) && hasValue(event.branch)) {
-                config.localPersistence = {
-                    saveToIndexedDb: true,
-                };
-            }
-            let doc = yield this._createSharedDocument(config, this._services);
-            if (!doc) {
-                return;
-            }
-            if (id) {
-                this._documents.set(id, doc);
-            }
-            this._subs.push(...this._getCleanupSubscriptionsForSharedDocument(doc));
-            if (hasValue(event.taskId)) {
-                // Wait for initial connection
-                doc.onStatusUpdated
-                    .pipe(first((status) => status.type === 'sync' && status.synced === true))
-                    .subscribe(() => {
+    async _loadSharedDocument(event) {
+        const id = this._getSharedDocId(event);
+        if (id) {
+            const doc = this._documents.get(id);
+            if (doc && !doc.closed) {
+                if (hasValue(event.taskId)) {
                     this.sendEvents([
                         asyncResult(event.taskId, doc, false, true),
                     ]);
-                });
+                }
+                return;
             }
-            doc.connect();
-        });
+        }
+        const config = {
+            recordName: event.recordName,
+            inst: event.inst,
+            branch: event.branch,
+            host: this._config.config.causalRepoConnectionUrl,
+            connectionProtocol: this._config.config.causalRepoConnectionProtocol,
+        };
+        if (!hasValue(event.inst) && hasValue(event.branch)) {
+            config.localPersistence = {
+                saveToIndexedDb: true,
+            };
+        }
+        let doc = await this._createSharedDocument(config, this._services);
+        if (!doc) {
+            return;
+        }
+        if (id) {
+            this._documents.set(id, doc);
+        }
+        this._subs.push(...this._getCleanupSubscriptionsForSharedDocument(doc));
+        if (hasValue(event.taskId)) {
+            // Wait for initial connection
+            doc.onStatusUpdated
+                .pipe(first((status) => status.type === 'sync' && status.synced === true))
+                .subscribe(() => {
+                this.sendEvents([
+                    asyncResult(event.taskId, doc, false, true),
+                ]);
+            });
+        }
+        doc.connect();
     }
-    _attachRuntime(runtime, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const newConfigBotId = uuid();
-                const channelId = uuid();
-                let initialStates = {};
-                for (let id in runtime.currentState) {
-                    const bot = runtime.currentState[id];
-                    const space = getBotSpace(bot);
-                    if (!initialStates[space]) {
-                        initialStates[space] = {};
-                    }
-                    initialStates[space][id] = createBot(id, bot.tags, space);
+    async _attachRuntime(runtime, event) {
+        try {
+            const newConfigBotId = uuid();
+            const channelId = uuid();
+            let initialStates = {};
+            for (let id in runtime.currentState) {
+                const bot = runtime.currentState[id];
+                const space = getBotSpace(bot);
+                if (!initialStates[space]) {
+                    initialStates[space] = {};
                 }
-                const partitions = mapValues(this._config.partitions, (p, space) => {
-                    var _a;
-                    return {
-                        type: 'memory',
-                        initialState: (_a = initialStates[space]) !== null && _a !== void 0 ? _a : {},
-                    };
-                });
-                const channel = this._createSubChannel(runtime, {
-                    configBotId: newConfigBotId,
-                    config: Object.assign({}, this._config.config),
-                    // Map all partitions to memory partitions for now
-                    partitions,
-                });
-                channel._runtime.userId = newConfigBotId;
-                channel._tagNameMapper = this._createTagNameMapper(event.tagNameMapper);
-                const subChannel = {
-                    getInfo: () => __awaiter(this, void 0, void 0, function* () {
-                        return ({
-                            id: channelId,
-                            configBotId: newConfigBotId,
-                            indicator: {
-                                connectionId: newConfigBotId,
-                            },
-                        });
-                    }),
-                    getChannel: () => __awaiter(this, void 0, void 0, function* () { return channel; }),
+                initialStates[space][id] = createBot(id, bot.tags, space);
+            }
+            const partitions = mapValues(this._config.partitions, (p, space) => {
+                var _a;
+                return {
+                    type: 'memory',
+                    initialState: (_a = initialStates[space]) !== null && _a !== void 0 ? _a : {},
                 };
-                this._subChannels.push({
-                    channel,
+            });
+            const channel = this._createSubChannel(runtime, {
+                configBotId: newConfigBotId,
+                config: {
+                    ...this._config.config,
+                },
+                // Map all partitions to memory partitions for now
+                partitions,
+            });
+            channel._runtime.userId = newConfigBotId;
+            channel._tagNameMapper = this._createTagNameMapper(event.tagNameMapper);
+            const subChannel = {
+                getInfo: async () => ({
                     id: channelId,
-                });
-                this._subs.push(channel);
-                this._handleSubChannelAdded(subChannel);
-                if (hasValue(event.taskId)) {
-                    this.sendEvents([asyncResult(event.taskId, null)]);
-                }
+                    configBotId: newConfigBotId,
+                    indicator: {
+                        connectionId: newConfigBotId,
+                    },
+                }),
+                getChannel: async () => channel,
+            };
+            this._subChannels.push({
+                channel,
+                id: channelId,
+            });
+            this._subs.push(channel);
+            this._handleSubChannelAdded(subChannel);
+            if (hasValue(event.taskId)) {
+                this.sendEvents([asyncResult(event.taskId, null)]);
             }
-            catch (err) {
-                if (hasValue(event.taskId)) {
-                    this.sendEvents([asyncError(event.taskId, err)]);
-                }
+        }
+        catch (err) {
+            if (hasValue(event.taskId)) {
+                this.sendEvents([asyncError(event.taskId, err)]);
             }
-        });
+        }
     }
-    _detachRuntime(runtime, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const index = this._subChannels.findIndex((c) => c.channel._runtime === runtime);
-                if (index < 0) {
-                    if (hasValue(event.taskId)) {
-                        this.sendEvents([asyncResult(event.taskId, null)]);
-                    }
-                    return;
-                }
-                const { channel, id } = this._subChannels[index];
-                channel.unsubscribe();
-                this._subChannels.splice(index, 1);
-                const subIndex = this._subs.indexOf(channel);
-                if (subIndex >= 0) {
-                    this._subs.splice(subIndex, 1);
-                }
-                this._handleSubChannelRemoved(id);
+    async _detachRuntime(runtime, event) {
+        try {
+            const index = this._subChannels.findIndex((c) => c.channel._runtime === runtime);
+            if (index < 0) {
                 if (hasValue(event.taskId)) {
                     this.sendEvents([asyncResult(event.taskId, null)]);
                 }
+                return;
             }
-            catch (err) {
-                if (hasValue(event.taskId)) {
-                    this.sendEvents([asyncError(event.taskId, err)]);
-                }
+            const { channel, id } = this._subChannels[index];
+            channel.unsubscribe();
+            this._subChannels.splice(index, 1);
+            const subIndex = this._subs.indexOf(channel);
+            if (subIndex >= 0) {
+                this._subs.splice(subIndex, 1);
             }
-        });
+            this._handleSubChannelRemoved(id);
+            if (hasValue(event.taskId)) {
+                this.sendEvents([asyncResult(event.taskId, null)]);
+            }
+        }
+        catch (err) {
+            if (hasValue(event.taskId)) {
+                this.sendEvents([asyncError(event.taskId, err)]);
+            }
+        }
     }
     _handleSubChannelAdded(subChannel) {
         this._onSubChannelAdded.next(subChannel);
@@ -817,7 +762,9 @@ export class BaseAuxChannel {
     }
     _mapTagAndSpaceNames(update, tagNameMapper) {
         const u = {
-            state: Object.assign({}, update.state),
+            state: {
+                ...update.state,
+            },
             addedBots: update.addedBots,
             removedBots: update.removedBots,
             updatedBots: update.updatedBots,
@@ -831,61 +778,55 @@ export class BaseAuxChannel {
         }
         return u;
     }
-    _initUserBot() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const userBot = this._helper.userBot;
-                yield this._helper.createOrUpdateUserBot(this._config.configBotId, userBot);
-            }
-            catch (err) {
-                console.error('[BaseAuxChannel] Unable to init user bot:', err);
-            }
-        });
+    async _initUserBot() {
+        try {
+            const userBot = this._helper.userBot;
+            await this._helper.createOrUpdateUserBot(this._config.configBotId, userBot);
+        }
+        catch (err) {
+            console.error('[BaseAuxChannel] Unable to init user bot:', err);
+        }
     }
-    _initPortalBots() {
+    async _initPortalBots() {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (((_a = this._config.config) === null || _a === void 0 ? void 0 : _a.builtinPortals) &&
+                ((_b = this._config.config) === null || _b === void 0 ? void 0 : _b.builtinPortals.length) > 0) {
+                let actions = this._config.config.builtinPortals.map((portal) => registerBuiltinPortal(portal));
+                this._runtime.process([
+                    ...actions,
+                    // Define the authBot with a random UUID so that it will be
+                    // referencable but return undefined until it is actually loaded.
+                    defineGlobalBot('auth', uuid()),
+                ]);
+            }
+        }
+        catch (err) {
+            console.error('[BaseAuxChannel] Unable to init portal bots:', err);
+        }
+    }
+    async _initBuilderBots() {
+        if (!this._config ||
+            !this._config.config ||
+            !this._config.config.builder) {
+            return;
+        }
+        if (!!this._config.config.bootstrapState) {
             try {
-                if (((_a = this._config.config) === null || _a === void 0 ? void 0 : _a.builtinPortals) &&
-                    ((_b = this._config.config) === null || _b === void 0 ? void 0 : _b.builtinPortals.length) > 0) {
-                    let actions = this._config.config.builtinPortals.map((portal) => registerBuiltinPortal(portal));
-                    this._runtime.process([
-                        ...actions,
-                        // Define the authBot with a random UUID so that it will be
-                        // referencable but return undefined until it is actually loaded.
-                        defineGlobalBot('auth', uuid()),
-                    ]);
-                }
+                await this._helper.destroyBuilderBots(this._config.config.builder);
             }
             catch (err) {
-                console.error('[BaseAuxChannel] Unable to init portal bots:', err);
-            }
-        });
-    }
-    _initBuilderBots() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._config ||
-                !this._config.config ||
-                !this._config.config.builder) {
-                return;
+                console.error('[BaseAuxChannel] Unable to destroy builder bot:', err);
             }
-            if (!!this._config.config.bootstrapState) {
-                try {
-                    yield this._helper.destroyBuilderBots(this._config.config.builder);
-                }
-                catch (err) {
-                    console.error('[BaseAuxChannel] Unable to destroy builder bot:', err);
-                }
+        }
+        else {
+            try {
+                await this._helper.createOrUpdateBuilderBots(this._config.config.builder);
             }
-            else {
-                try {
-                    yield this._helper.createOrUpdateBuilderBots(this._config.config.builder);
-                }
-                catch (err) {
-                    console.error('[BaseAuxChannel] Unable to init builder bot:', err);
-                }
+            catch (err) {
+                console.error('[BaseAuxChannel] Unable to init builder bot:', err);
             }
-        });
+        }
     }
     unsubscribe() {
         if (this.closed) {