@encorejs/saaz 1.0.0

package/dist/front/SaazFront.js

@@ -0,0 +1,756 @@
+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 { applyOptimisticUpdateToState, recordInvokations, } from '../shared/transactions';
+import { FrontStorage } from './FrontStorage';
+import { ensureStateIsUptodate } from '../shared/utils';
+import { debounce } from 'lodash-es';
+import { Atom, prism, val } from '@encorejs/dataverse';
+import waitForPrism from '@encorejs/utils/waitForPrism';
+import { subscribeDebounced } from '@encorejs/utils/subscribeDebounced';
+import fastDeepEqual from 'fast-deep-equal';
+import { diff } from 'jest-diff';
+import { jsonFromCell, makeDraft } from '../rogue';
+import memoizeFn from '@encorejs/utils/memoizeFn';
+import { nanoid } from 'nanoid';
+import { defer } from '@encorejs/utils/defer';
+const emptyObject = {};
+const MAX_UNDO_STACK_SIZE = 1000;
+const PEERID_LENGTH = 32;
+const LOCK_PREFIX = 'theatrejs-saaz-closed-session-lock/';
+export class SaazFront {
+    constructor(opts) {
+        var _a;
+        /**
+         * A counter that is used to generate unique ids for temp transactions.
+         */
+        this._tempTransactionCounter = 0;
+        /**
+         * A list of functions that will be called when the frontend is destroyed.
+         */
+        this._teardownCallbacks = [];
+        /**
+         * We use dataverse prisms to derive several values from the atom. This makes the reactive parts of the code easier to maintain.
+         */
+        this._prisms = {
+            base: prism(() => {
+                var _a;
+                return ((_a = val(this._atom.pointer.sessionState.snapshot)) !== null && _a !== void 0 ? _a : val(this._atom.pointer.emptySnapshot));
+            }),
+            optimisticState: prism(() => {
+                var _a;
+                const base = this._prisms.base.getValue();
+                let stateSoFar = base;
+                // this may become a bottleneck
+                const closedSessions = val(this._atom.pointer.closedSessions);
+                for (const session of closedSessions) {
+                    for (const update of session.optimisticUpdates) {
+                        stateSoFar = this._cachedApplyTransactionToState(update, base, stateSoFar);
+                    }
+                }
+                const optimisticUpdates = val(this._atom.pointer.optimisticUpdatesQueue);
+                const lastIncorporatedPeerClock = (_a = val(this._atom.pointer.sessionState.lastIncorporatedPeerClock)) !== null && _a !== void 0 ? _a : -1;
+                for (const update of optimisticUpdates) {
+                    // if the update has already been incorporated into the backend state, skip it (it'll be garbage collected soon)
+                    if (update.peerClock <= lastIncorporatedPeerClock)
+                        continue;
+                    stateSoFar = this._cachedApplyTransactionToState(update, base, stateSoFar);
+                }
+                return stateSoFar;
+            }),
+            withTemps: prism(() => {
+                let currentState = this._prisms.optimisticState.getValue();
+                const temps = val(this._atom.pointer.tempTransactions);
+                for (const temp of temps) {
+                    ;
+                    [currentState] = applyOptimisticUpdateToState(temp, currentState, this._schema, true);
+                }
+                return currentState;
+            }),
+            withPeers: prism(() => {
+                let currentState = this._prisms.withTemps.getValue();
+                for (const [peerId, presence] of Object.entries(val(this._atom.pointer.allPeersPresenceState))) {
+                    if (peerId === this._peerId)
+                        continue;
+                    if (!presence)
+                        continue;
+                    for (const temp of presence.tempTransactions) {
+                        ;
+                        [currentState] = applyOptimisticUpdateToState(temp, currentState, this._schema, true);
+                    }
+                }
+                return currentState;
+            }),
+            countOfUnpushedUpdatesToBackend: prism(() => {
+                return val(this._atom.pointer.optimisticUpdatesQueue).length;
+            }),
+            allSyncedToFrontStorage: prism(() => {
+                var _a, _b;
+                // if not initialized, then we're not synced
+                if (!val(this._atom.pointer.initialized))
+                    return false;
+                // backendClock as of the last time the front communicated with the backend
+                const backendClock = (_a = val(this._atom.pointer.sessionState.backendClock)) !== null && _a !== void 0 ? _a : -1;
+                // backendClock as of the last time we stored the backend's state in the front storage
+                const lastStoredBackendClock = (_b = val(this._atom.pointer.frontStorageStateMirror.backendState.backendClock)) !== null && _b !== void 0 ? _b : -1;
+                // if we haven't yet stored the backend's state in the front storage, return false
+                if (backendClock !== lastStoredBackendClock)
+                    return false;
+                // TODO: how about closed sessions?
+                const outstandingUpdates = val(this._atom.pointer.optimisticUpdatesQueue);
+                const storedUpdates = val(this._atom.pointer.frontStorageStateMirror.optimisticUpdatesQueue);
+                if (outstandingUpdates.length === 0) {
+                    // there are no outstanding optimistic updates (they're all incorporated into the backend state),
+                    // so we can assume that the front storage is up to date. Note that front storage may not have
+                    // gartbage collected the old updates yet, but that's ok. they'll be garbage collected eventually.
+                    return true;
+                }
+                const lastOutstandingUpdate = outstandingUpdates[outstandingUpdates.length - 1];
+                const lastStoredUpdate = storedUpdates[storedUpdates.length - 1];
+                if (lastStoredUpdate &&
+                    lastStoredUpdate.peerClock === lastOutstandingUpdate.peerClock) {
+                    // the last outstanding update is the same as the last stored update, so we can assume that the front storage is up to date.
+                    return true;
+                }
+                else {
+                    // the front storage has yet to catch up
+                    return false;
+                }
+            }),
+        };
+        this._caches = {
+            transactionToState: new WeakMap(),
+        };
+        if (opts.diskSnapshot) {
+            this._diskSnapshot = Object.assign(Object.assign({}, opts.diskSnapshot), { snapshot: ensureStateIsUptodate(opts.diskSnapshot.snapshot, opts.schema) });
+        }
+        else {
+            this._diskSnapshot = null;
+        }
+        this._atom = new Atom({
+            optimisticUpdatesQueue: [],
+            emptySnapshot: ensureStateIsUptodate(null, opts.schema),
+            sessionState: null,
+            tempTransactions: [],
+            allPeersPresenceState: emptyObject,
+            initialized: false,
+            frontStorageStateMirror: {
+                backendState: null,
+                optimisticUpdatesQueue: [],
+            },
+            peerClock: -1,
+            closedSessions: [],
+            undoRedo: {
+                stack: [],
+                cursor: 0,
+            },
+        });
+        this._initializedPromise = waitForPrism(prism(() => val(this._atom.pointer.initialized)), (v) => v === true);
+        if (opts.keepPrismsHot !== false) {
+            this._teardownCallbacks.push(this._prisms.withPeers.keepHot());
+        }
+        this._schema = opts.schema;
+        this._peerId = (_a = opts.peerId) !== null && _a !== void 0 ? _a : nanoid(PEERID_LENGTH);
+        this._backend = opts.backend;
+        this._dbName = opts.dbName;
+        this._storage = new FrontStorage(this._dbName, opts.storageAdapter);
+        void this._init();
+    }
+    _init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._loadClosedSessions();
+            // The most recent backend state that one of the closed sessions has cached.
+            // We can use this until we get the first update from the backend
+            const cachedBackendState = yield this._storage.transaction((t) => __awaiter(this, void 0, void 0, function* () { return t.getMostRecentlySyncedSessionState(); }));
+            // this will create the database and start a transaction
+            yield this._storage.transaction((t) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const initialSnapshot = this._diskSnapshot;
+                if (!cachedBackendState) {
+                    // there are no closed/crashed sessions that have a backend state.
+                    this._setSessionState({
+                        backendClock: (_a = initialSnapshot === null || initialSnapshot === void 0 ? void 0 : initialSnapshot.clock) !== null && _a !== void 0 ? _a : null,
+                        lastIncorporatedPeerClock: null,
+                        lastSyncTime: null,
+                        snapshot: (_b = initialSnapshot === null || initialSnapshot === void 0 ? void 0 : initialSnapshot.snapshot) !== null && _b !== void 0 ? _b : null,
+                        peerId: this._peerId,
+                    });
+                }
+                else {
+                    if (initialSnapshot) {
+                        // TODO
+                        throw new Error(`Not implemented`);
+                    }
+                    else {
+                        this._atom.setByPointer((p) => p.sessionState, {
+                            lastSyncTime: null,
+                            backendClock: (_c = cachedBackendState.backendClock) !== null && _c !== void 0 ? _c : null,
+                            lastIncorporatedPeerClock: null,
+                            peerId: this._peerId,
+                            snapshot: ensureStateIsUptodate(cachedBackendState.snapshot, this._schema),
+                        });
+                    }
+                }
+                this._atom.setByPointer((p) => p.initialized, true);
+            }));
+            this._teardownCallbacks.push(this._subscribeToBackend(), this._reflectBackendStateToStorage(), this._reflectOptimisticUpdatesToStorage(), this._reflectPresenceToBackend(), this._removeStalePeerPresenceStates(), this._reflectUpdatesToBackend(), this._gcClosedSessions());
+        });
+    }
+    _loadClosedSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // in case there are crashed/closed sesions that haven't synced
+            // with backend yet, let's take them over
+            const closedSessionsLocks = yield this._acquireLocksOnClosedSessions();
+            const closedSessions = yield this._storage.transaction((t) => __awaiter(this, void 0, void 0, function* () {
+                return yield Promise.all(closedSessionsLocks.map((closedSessionLock) => __awaiter(this, void 0, void 0, function* () {
+                    return {
+                        optimisticUpdates: yield t.getOptimisticUpdates(closedSessionLock.peerId),
+                        peerId: closedSessionLock.peerId,
+                        lastIncorporatedPeerClock: null,
+                    };
+                })));
+            }));
+            this._atom.setByPointer((p) => p.closedSessions, closedSessions);
+        });
+    }
+    _acquireLocksOnClosedSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allPeerIds = yield this._storage.transaction((t) => __awaiter(this, void 0, void 0, function* () { return t.getAllExistingSessionIds(); }));
+            const all = yield Promise.all(allPeerIds.map((peerId) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const d = defer();
+                    void navigator.locks.request(LOCK_PREFIX + peerId, {
+                        mode: 'exclusive',
+                        ifAvailable: true,
+                        steal: false,
+                    }, (lock) => __awaiter(this, void 0, void 0, function* () {
+                        if (!lock) {
+                            d.resolve(undefined);
+                            return;
+                        }
+                        const unlockDeferred = defer();
+                        let locked = true;
+                        d.resolve({
+                            peerId,
+                            unlock: () => {
+                                if (!locked)
+                                    return;
+                                locked = false;
+                                unlockDeferred.resolve();
+                            },
+                        });
+                        yield unlockDeferred.promise;
+                    }));
+                    return d.promise;
+                }
+                catch (error) {
+                    return undefined;
+                }
+            })));
+            return all.filter((v) => !!v);
+        });
+    }
+    teardown() {
+        for (const cb of this._teardownCallbacks) {
+            cb();
+        }
+        this._teardownCallbacks.length = 0;
+    }
+    _removeStalePeerPresenceStates() {
+        const schedule = debounce(() => {
+            this._atom.setByPointer((p) => p.allPeersPresenceState, emptyObject);
+        }, 1000 * 15);
+        return this._atom.onChangeByPointer((p) => p.allPeersPresenceState, schedule);
+    }
+    _reflectPresenceToBackend() {
+        let lastTempTransactions = [];
+        let lastUpdateSent = 0;
+        return subscribeDebounced(this._atom.pointer.tempTransactions, (tempTransactions) => __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            if (!fastDeepEqual(tempTransactions, lastTempTransactions) ||
+                now - lastUpdateSent > 1000 * 5) {
+                lastTempTransactions = tempTransactions;
+                lastUpdateSent = now;
+                void this._backend.updatePresence({
+                    peerId: this._peerId,
+                    presence: { tempTransactions },
+                });
+            }
+            yield new Promise((resolve) => setTimeout(resolve, 30));
+        }));
+    }
+    _reflectUpdatesToBackend() {
+        const p = prism(() => {
+            var _a, _b;
+            const closedSessions = val(this._atom.pointer.closedSessions);
+            for (const closedSession of closedSessions) {
+                const updatesLeftToPush = closedSession.optimisticUpdates.filter((update) => { var _a; return update.peerClock > ((_a = closedSession.lastIncorporatedPeerClock) !== null && _a !== void 0 ? _a : -1); });
+                if (updatesLeftToPush.length > 0) {
+                    return {
+                        peerId: closedSession.peerId,
+                        lastIncorporatedPeerClock: (_a = closedSession.lastIncorporatedPeerClock) !== null && _a !== void 0 ? _a : -1,
+                        updates: updatesLeftToPush,
+                    };
+                }
+            }
+            // no closed sessions left to sync. let's sync the current session
+            const lastIncorporatedPeerClock = (_b = val(this._atom.pointer.sessionState.lastIncorporatedPeerClock)) !== null && _b !== void 0 ? _b : -1;
+            const updatesLeftToPush = val(this._atom.pointer.optimisticUpdatesQueue).filter((update) => update.peerClock > lastIncorporatedPeerClock);
+            return {
+                updates: updatesLeftToPush,
+                lastIncorporatedPeerClock,
+                peerId: this._peerId,
+            };
+        });
+        return subscribeDebounced(p, ({ updates, peerId }) => __awaiter(this, void 0, void 0, function* () {
+            if (updates.length === 0)
+                return;
+            const backendClock = val(this._atom.pointer.sessionState.backendClock);
+            try {
+                const res = yield this._backend.applyUpdates({
+                    backendClock,
+                    peerId,
+                    updates,
+                });
+                if (res.ok) {
+                    this._processBackendUpdate(res);
+                }
+                else {
+                    console.error(res.error);
+                    throw new Error('Backend rejected optimistic update');
+                }
+            }
+            catch (errs) {
+                console.error(errs);
+            }
+        }));
+    }
+    _processBackendUpdate(s) {
+        const originalBackendState = this._atom.get().sessionState;
+        if (!originalBackendState) {
+            throw new Error('backend state not initialized');
+        }
+        if (!s.hasUpdates) {
+            this._setSessionState(Object.assign(Object.assign({}, originalBackendState), { lastSyncTime: Date.now(), peerId: s.peerId, lastIncorporatedPeerClock: s.lastIncorporatedPeerClock }));
+            return;
+        }
+        else {
+            const { snapshot } = s;
+            if (snapshot.type !== 'Snapshot') {
+                throw new Error('Non-snapshot updates not implemented');
+            }
+            this._setSessionState({
+                backendClock: s.clock,
+                lastIncorporatedPeerClock: s.lastIncorporatedPeerClock,
+                lastSyncTime: Date.now(),
+                snapshot: snapshot.value,
+                peerId: s.peerId,
+            });
+        }
+    }
+    _reflectBackendStateToStorage() {
+        return subscribeDebounced(this._atom.pointer.sessionState, (backendState) => __awaiter(this, void 0, void 0, function* () {
+            if (!backendState)
+                return;
+            try {
+                yield this._storage.transaction((t) => __awaiter(this, void 0, void 0, function* () {
+                    yield t.setSessionState(backendState, this._peerId);
+                }));
+                this._atom.setByPointer((p) => p.frontStorageStateMirror.backendState, backendState);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }));
+    }
+    _gcClosedSessions() {
+        return subscribeDebounced(this._atom.pointer.closedSessions, (closedSessions) => __awaiter(this, void 0, void 0, function* () {
+            const sessionsWithNoUpdates = closedSessions.filter((s) => s.optimisticUpdates.length === 0);
+            for (const emptySession of sessionsWithNoUpdates) {
+                this._atom.reduceByPointer((p) => p.closedSessions, (a) => a.filter((c) => c.peerId !== emptySession.peerId));
+                yield this._storage.transaction((t) => __awaiter(this, void 0, void 0, function* () {
+                    yield t.deleteSession(emptySession.peerId);
+                }));
+                void this._backend.closePeer({ peerId: emptySession.peerId });
+            }
+        }));
+    }
+    _reflectOptimisticUpdatesToStorage() {
+        return subscribeDebounced(this._atom.pointer.optimisticUpdatesQueue, (memory) => __awaiter(this, void 0, void 0, function* () {
+            const last = this._atom.get().frontStorageStateMirror.optimisticUpdatesQueue;
+            if (memory.length === 0 && last.length === 0)
+                return;
+            const toPush = [];
+            const toPluck = [];
+            for (const transacion of memory) {
+                const existing = last.find((t) => t.peerClock === transacion.peerClock);
+                if (!existing) {
+                    toPush.push(transacion);
+                }
+                else {
+                    toPluck.push(existing);
+                }
+            }
+            try {
+                yield this._storage.transaction((t) => __awaiter(this, void 0, void 0, function* () {
+                    yield t.pushOptimisticUpdates(toPush, this._peerId);
+                    yield t.pluckOptimisticUpdates(toPluck, this._peerId);
+                }));
+                this._atom.setByPointer((p) => p.frontStorageStateMirror.optimisticUpdatesQueue, memory);
+            }
+            catch (error) {
+                console.error(error);
+                return;
+            }
+        }));
+    }
+    _cachedApplyTransactionToState(transaction, base, before) {
+        let cache = this._caches.transactionToState.get(transaction);
+        if (cache) {
+            if (cache.before === before) {
+                return cache.after;
+            }
+        }
+        const [after] = applyOptimisticUpdateToState(transaction, before, this._schema, true);
+        if (!cache) {
+            cache = { before: before, after: after, base };
+            this._caches.transactionToState.set(transaction, cache);
+        }
+        else {
+            cache.before = before;
+            cache.after = after;
+            cache.base = base;
+        }
+        return after;
+    }
+    _setSessionState(opts) {
+        var _a, _b;
+        const s = Object.assign(Object.assign({}, opts), { value: ensureStateIsUptodate(opts.snapshot, this._schema) });
+        if (s.peerId === this._peerId) {
+            this._atom.setByPointer((p) => p.sessionState, s);
+            // let's GC the updates the backend has incorporated
+            const lastAcknowledgedPeerClock = (_a = s.lastIncorporatedPeerClock) !== null && _a !== void 0 ? _a : -1;
+            const existingQueue = this._atom.get().optimisticUpdatesQueue;
+            if (existingQueue.length > 0 &&
+                existingQueue[0].peerClock <= lastAcknowledgedPeerClock) {
+                const newQueue = existingQueue.filter((update) => update.peerClock > lastAcknowledgedPeerClock);
+                this._atom.setByPointer((p) => p.optimisticUpdatesQueue, newQueue);
+            }
+        }
+        else {
+            // the session state comes from an update belonging to a different session. let's update the
+            // snapshot/backendClock and other relevant bits, but keep peerId and lastIncorporatedPeerClock unchanged
+            this._atom.reduceByPointer((p) => p.sessionState, (oldSessionstate) => {
+                var _a;
+                return {
+                    backendClock: s.backendClock,
+                    lastSyncTime: s.lastSyncTime,
+                    peerId: this._peerId,
+                    lastIncorporatedPeerClock: (_a = oldSessionstate === null || oldSessionstate === void 0 ? void 0 : oldSessionstate.lastIncorporatedPeerClock) !== null && _a !== void 0 ? _a : null,
+                    snapshot: s.snapshot,
+                };
+            });
+            const lastAcknowledgedPeerClock = (_b = s.lastIncorporatedPeerClock) !== null && _b !== void 0 ? _b : -1;
+            const index = this._atom
+                .get()
+                .closedSessions.findIndex((s) => s.peerId === this._peerId);
+            if (index === -1)
+                return;
+            const closedSession = this._atom.get().closedSessions[index];
+            if (!closedSession) {
+                return;
+            }
+            const existingQueue = closedSession.optimisticUpdates;
+            if (existingQueue.length > 0 &&
+                existingQueue[0].peerClock <= lastAcknowledgedPeerClock) {
+                const newQueue = existingQueue.filter((update) => update.peerClock > lastAcknowledgedPeerClock);
+                this._atom.setByPointer((p) => p.closedSessions[index], {
+                    optimisticUpdates: newQueue,
+                    lastIncorporatedPeerClock: s.lastIncorporatedPeerClock,
+                    peerId: s.peerId,
+                });
+            }
+        }
+    }
+    _pullUpdatesFromBackend() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const originalBackendState = this._atom.get().sessionState;
+            if (!originalBackendState) {
+                throw new Error('backend state not initialized');
+            }
+            const s = yield this._backend.getUpdatesSinceClock({
+                clock: (_a = originalBackendState.backendClock) !== null && _a !== void 0 ? _a : null,
+                peerId: this._peerId,
+            });
+            this._processBackendUpdate(s);
+        });
+    }
+    _subscribeToBackend() {
+        void this._pullUpdatesFromBackend();
+        const stop = this._backend.subscribe({
+            peerId: this._peerId,
+        }, (s) => __awaiter(this, void 0, void 0, function* () {
+            if (s.shouldCheckForUpdates) {
+                void this._pullUpdatesFromBackend().catch((err) => {
+                    console.error(err);
+                });
+            }
+            this._atom.setByPointer((p) => p.allPeersPresenceState, s.presence);
+        }));
+        const unsub = () => {
+            void stop.then((s) => stop);
+        };
+        return unsub;
+    }
+    get state() {
+        return finalState(this._prisms.withPeers.getValue());
+    }
+    get isReady() {
+        return this._atom.get().initialized === true;
+    }
+    get ready() {
+        return this._initializedPromise;
+    }
+    tx(editorFn, draftFn, undoable = true) {
+        const [update, isEmpty, backwardOps] = this._createTransaction(this._prisms.optimisticState.getValue(), editorFn, draftFn);
+        if (isEmpty)
+            return;
+        this._pushOptimisticUpdate(update, undoable ? backwardOps : []);
+    }
+    tempTx(editorFn, draftFn, existingTempTransaction) {
+        if (existingTempTransaction) {
+            existingTempTransaction.recapture(editorFn, draftFn);
+            return existingTempTransaction;
+        }
+        const [o, originalIsEmpty, originalBackwardOps] = this._createTransaction(this._prisms.optimisticState.getValue(), editorFn, draftFn);
+        const originalTransaction = Object.assign(Object.assign({}, o), { tempId: this._tempTransactionCounter++, backwardOps: originalBackwardOps });
+        this._setTempTransaction(originalTransaction.tempId, originalTransaction);
+        let currentTransaction = originalTransaction;
+        let currentIsEmpty = originalIsEmpty;
+        let transactionState = 'alive';
+        const commit = (undoable = true) => {
+            if (transactionState !== 'alive') {
+                throw new Error('Transaction is already ' + transactionState);
+            }
+            transactionState = 'committed';
+            this._setTempTransaction(originalTransaction.tempId, undefined);
+            if (currentIsEmpty)
+                return;
+            const finalUpdate = Object.assign({}, currentTransaction);
+            this._pushOptimisticUpdate(finalUpdate, undoable ? currentTransaction.backwardOps : []);
+        };
+        const discard = () => {
+            if (transactionState !== 'alive') {
+                throw new Error('Transaction is already ' + transactionState);
+            }
+            transactionState = 'discarded';
+            this._setTempTransaction(originalTransaction.tempId, undefined);
+        };
+        const recapture = (editorFn, draftFn) => {
+            if (transactionState !== 'alive') {
+                throw new Error('Transaction is already ' + transactionState);
+            }
+            const [update, newIsEmpty, backwardOps] = this._createTransaction(this._prisms.optimisticState.getValue(), editorFn, draftFn);
+            const newTransaction = Object.assign(Object.assign({}, update), { tempId: originalTransaction.tempId, backwardOps });
+            currentTransaction = newTransaction;
+            currentIsEmpty = newIsEmpty;
+            this._setTempTransaction(originalTransaction.tempId, newTransaction);
+        };
+        const reset = () => {
+            if (transactionState !== 'alive') {
+                throw new Error('Transaction is already ' + transactionState);
+            }
+            this._setTempTransaction(originalTransaction.tempId, undefined);
+        };
+        return { commit, discard: discard, recapture, reset };
+    }
+    _setTempTransaction(id, transaction) {
+        const prev = this._atom.get().tempTransactions;
+        const existingIndex = prev.findIndex((t) => t.tempId === id);
+        const next = [...prev];
+        let changed = false;
+        if (existingIndex > -1) {
+            next.splice(existingIndex, 1);
+            changed = true;
+        }
+        if (transaction) {
+            if (existingIndex > -1) {
+                next.splice(existingIndex, 0, transaction);
+                changed = true;
+            }
+            else {
+                next.push(transaction);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this._atom.setByPointer((p) => p.tempTransactions, next);
+        }
+    }
+    _createTransaction(fullSnapshot, editorFn, draftFn, warnIfNoInvokations = false) {
+        const invokations = editorFn
+            ? recordInvokations(this._schema.editors, editorFn)
+            : [];
+        if (invokations.length === 0) {
+            if (warnIfNoInvokations && editorFn)
+                console.info(`Transaction didn't invoke any editors. It's a no-op.`);
+        }
+        let backwardOps = [];
+        let draftOps = [];
+        if (typeof draftFn === 'function') {
+            const [draft, fin] = makeDraft(fullSnapshot.cell);
+            draftFn(draft);
+            const [_, forwardOps, _backwardOps] = fin();
+            if (forwardOps.length > 0) {
+                draftOps = forwardOps;
+                backwardOps = _backwardOps;
+            }
+        }
+        const [producedSnapshot, generatorRecordings] = applyOptimisticUpdateToState({ invokations, generatorRecordings: {}, draftOps }, fullSnapshot, this._schema, false);
+        const transaction = {
+            invokations,
+            generatorRecordings: generatorRecordings,
+            draftOps: draftOps,
+            peerId: this._peerId,
+        };
+        if (process.env.NODE_ENV !== 'production' && editorFn) {
+            if (!fastDeepEqual(invokations, recordInvokations(this._schema.editors, editorFn))) {
+                throw new Error(`Transaction function seems to invoke different editors each time it is called. This means it is not deterministic, and running it several times will create different states. To fix this, make sure the transaction calls exactly the same editors, in the same order, with the same arguments`);
+            }
+            const [secondSnapshot] = applyOptimisticUpdateToState(transaction, fullSnapshot, this._schema, true);
+            if (!fastDeepEqual(secondSnapshot, producedSnapshot)) {
+                // at least one editor is not deterministic
+                // let's see if we can find which one it is, to help the user debug
+                let invokationsSoFar = [];
+                for (const invokation of invokations) {
+                    // run each invokation one-by-one, and see which one produces a different snapshot
+                    invokationsSoFar = [...invokationsSoFar, invokation];
+                    // first call
+                    const [newSnapshot1] = applyOptimisticUpdateToState({
+                        invokations: invokationsSoFar,
+                        generatorRecordings: transaction.generatorRecordings,
+                        draftOps: transaction.draftOps,
+                    }, fullSnapshot, this._schema, true);
+                    // second call
+                    const [newSnapshot2] = applyOptimisticUpdateToState({
+                        invokations: invokationsSoFar,
+                        generatorRecordings: transaction.generatorRecordings,
+                        draftOps: transaction.draftOps,
+                    }, fullSnapshot, this._schema, true);
+                    if (!fastDeepEqual(newSnapshot1, newSnapshot2)) {
+                        // found the culprit
+                        throw new Error(`Transaction is not deterministic, because editor ${invokation[0]}(${JSON.stringify(invokation[1])}) is not deterministic. It produces different results when called twice. \n${diff(newSnapshot1, newSnapshot2)}`);
+                    }
+                }
+                // couldn't find which editor is not deterministic. let's just throw a generic error
+                const diffString = diff(producedSnapshot, secondSnapshot);
+                throw new Error(`The second invocation of the transaction produced a different state than the first invocation. \n${diffString}`);
+            }
+        }
+        return [
+            transaction,
+            invokations.length === 0 && transaction.draftOps.length === 0,
+            backwardOps,
+        ];
+    }
+    waitForStorageSync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield waitForPrism(this._prisms.allSyncedToFrontStorage, (v) => v === true);
+        });
+    }
+    _pushOptimisticUpdate(updateWithoutPeerClock, 
+    // if defined, then it'll constitute an undo-able operation
+    backwardOps) {
+        const clockBefore = this._atom.get().peerClock;
+        const newClock = clockBefore + 1;
+        const transaction = {
+            generatorRecordings: updateWithoutPeerClock.generatorRecordings,
+            invokations: updateWithoutPeerClock.invokations,
+            peerId: updateWithoutPeerClock.peerId,
+            peerClock: newClock,
+            draftOps: updateWithoutPeerClock.draftOps,
+        };
+        this._atom.reduce((state) => (Object.assign(Object.assign({}, state), { peerClock: newClock, optimisticUpdatesQueue: [...state.optimisticUpdatesQueue, transaction] })));
+        if ((backwardOps === null || backwardOps === void 0 ? void 0 : backwardOps.length) === 0) {
+            // console.log('no backward ops', transaction.draftOps)
+        }
+        if (backwardOps && backwardOps.length > 0)
+            this._addToUndoStack({ backwardOps, forwardOps: transaction.draftOps });
+    }
+    waitForBackendSync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ready;
+            yield waitForPrism(this._prisms.countOfUnpushedUpdatesToBackend, (v) => v === 0);
+        });
+    }
+    _addToUndoStack(op) {
+        this._atom.reduceByPointer((p) => p.undoRedo, (o) => {
+            let stack = 
+            // copy the stack
+            [...o.stack]
+                // and only keep the items that are before the cursor (so if the user has undone, and then does a new operation, we'll discard the redo stack)
+                .slice(o.cursor);
+            stack.unshift(op);
+            if (stack.length > MAX_UNDO_STACK_SIZE)
+                stack.length = MAX_UNDO_STACK_SIZE;
+            return {
+                cursor: 0,
+                stack,
+            };
+        });
+    }
+    undo() {
+        const undoRedo = this._atom.get().undoRedo;
+        if (undoRedo.cursor >= undoRedo.stack.length)
+            return;
+        const item = undoRedo.stack[undoRedo.cursor];
+        this._atom.reduceByPointer((p) => p.undoRedo, (o) => {
+            return Object.assign(Object.assign({}, o), { cursor: o.cursor + 1 });
+        });
+        this._pushOptimisticUpdate({
+            draftOps: item.backwardOps,
+            generatorRecordings: {},
+            invokations: [],
+            peerId: this._peerId,
+        }, undefined);
+    }
+    redo() {
+        const undoRedo = this._atom.get().undoRedo;
+        if (undoRedo.cursor === 0)
+            return;
+        const item = undoRedo.stack[undoRedo.cursor - 1];
+        this._atom.reduceByPointer((p) => p.undoRedo, (o) => {
+            return Object.assign(Object.assign({}, o), { cursor: o.cursor - 1 });
+        });
+        this._pushOptimisticUpdate({
+            draftOps: item.forwardOps,
+            generatorRecordings: {},
+            invokations: [],
+            peerId: this._peerId,
+        }, undefined);
+    }
+    subscribe(fn) {
+        const withPeers = this._prisms.withPeers;
+        let oldState = withPeers.getValue();
+        return withPeers.onStale(() => {
+            const newState = withPeers.getValue();
+            if (newState !== oldState) {
+                oldState = newState;
+                fn(finalState(newState));
+            }
+        });
+    }
+}
+const finalState = memoizeFn((s) => {
+    return {
+        op: s.op,
+        cell: jsonFromCell(s.cell),
+    };
+});