@encorejs/saaz 1.0.0

package/dist/front/FrontIdbAdapter.js

@@ -0,0 +1,159 @@
+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 { openDB } from 'idb';
+export class FrontIDBAdapter {
+    constructor(_idbName, _currentSessionName) {
+        this._idbName = _idbName;
+        this._currentSessionName = _currentSessionName;
+        this._dbPromise = this._initializeDB();
+    }
+    _initializeDB() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return openDB(this._idbName, 1, {
+                upgrade(db) {
+                    const singularValueStore = db.createObjectStore('singularValues', {
+                        keyPath: 'sessionAndKey',
+                    });
+                    singularValueStore.createIndex('session', 'session');
+                    const listsStore = db.createObjectStore('lists', {
+                        keyPath: 'sessionAndKeyAndId',
+                    });
+                    listsStore.createIndex('session', 'session');
+                    listsStore.createIndex('sessionAndKey', 'sessionAndKey');
+                },
+            });
+        });
+    }
+    get ready() {
+        return this._dbPromise;
+    }
+    transaction(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.ready;
+            const tx = db.transaction(['singularValues', 'lists'], 'readwrite');
+            const t = new IDBTransaction(tx);
+            return yield fn(t);
+        });
+    }
+    get(key, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.transaction(({ get }) => get(key, session));
+        });
+    }
+    getList(key, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.transaction(({ getList }) => getList(key, session));
+        });
+    }
+}
+class IDBTransaction {
+    constructor(_tx) {
+        this._tx = _tx;
+    }
+    get(key, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionAndKey = `${session}/${key}`;
+            const store = this._tx.objectStore('singularValues');
+            const v = (yield store.get(sessionAndKey));
+            return v === null || v === void 0 ? void 0 : v.value;
+        });
+    }
+    getAll(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this._tx.objectStore('singularValues').index('session');
+            const all = yield index.getAll();
+            const record = {};
+            for (const row of all) {
+                record[row.session] = row.value;
+            }
+            return record;
+        });
+    }
+    set(key, value, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionAndKey = `${session}/${key}`;
+            const store = this._tx.objectStore('singularValues');
+            const s = {
+                sessionAndKey: sessionAndKey,
+                value,
+                session,
+                key,
+            };
+            yield store.put(s);
+        });
+    }
+    deleteSession(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            {
+                const store = this._tx.objectStore('singularValues');
+                const index = store.index('session');
+                const sessionIndex = yield index.getAllKeys(session);
+                for (const key of sessionIndex) {
+                    yield store.delete(key);
+                }
+            }
+            const listsStore = this._tx.objectStore('lists');
+            const listsIndex = listsStore.index('session');
+            const listsSessionIndex = yield listsIndex.getAllKeys(session);
+            for (const key of listsSessionIndex) {
+                yield listsStore.delete(key);
+            }
+        });
+    }
+    pushToList(key, rows, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const store = this._tx.objectStore('lists');
+            for (const row of rows) {
+                const listItem = {
+                    key,
+                    session,
+                    value: row,
+                    sessionAndKeyAndId: `${session}/${key}/${row.id}`,
+                    sessionAndKey: `${session}/${key}`,
+                };
+                const existingItem = yield store.get(listItem.sessionAndKeyAndId);
+                if (existingItem) {
+                    throw new Error(`Cannot push to list "${key}" because an entry with id "${row.id}" already exists`);
+                }
+                // Save the row with key and id properties
+                yield store.put(listItem);
+            }
+        });
+    }
+    getList(key, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const store = this._tx.objectStore('lists');
+            const keyIndex = store.index('sessionAndKey');
+            const sessionAndKey = `${session}/${key}`;
+            const all = yield keyIndex.getAll(sessionAndKey);
+            return all.map((s) => s.value);
+        });
+    }
+    pluckFromList(key, ids, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const store = this._tx.objectStore('lists');
+            const results = [];
+            for (const id of ids) {
+                const sessionAndKeyAndId = `${session}/${key}/${id}`;
+                const item = yield store.get(sessionAndKeyAndId);
+                if (item) {
+                    results.push(item.value);
+                    // IDB `delete` takes a key, not the record object (passing the object
+                    // throws a DataError at runtime).
+                    yield store.delete(sessionAndKeyAndId);
+                }
+                else {
+                    results.push(undefined);
+                }
+            }
+            return results;
+        });
+    }
+}

package/dist/front/FrontMemoryAdapter.d.ts

@@ -0,0 +1,16 @@
+import type { FrontStorageAdapterTransaction } from '../types';
+import type { FrontStorageAdapter } from '../types';
+export declare class FrontMemoryAdapter implements FrontStorageAdapter {
+    private _state;
+    private _readyDeferred;
+    private _lastTransactionPromise;
+    export(): unknown;
+    constructor(state?: unknown);
+    get ready(): Promise<void>;
+    transaction<T>(fn: (opts: FrontStorageAdapterTransaction) => Promise<T>): Promise<T>;
+    get<T>(key: string, session: string): Promise<T | void>;
+    getList<T extends {
+        id: string;
+    }>(key: string, session: string): Promise<T[]>;
+}
+//# sourceMappingURL=FrontMemoryAdapter.d.ts.map

package/dist/front/FrontMemoryAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrontMemoryAdapter.d.ts","sourceRoot":"","sources":["../../src/front/FrontMemoryAdapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,8BAA8B,EAAC,MAAM,UAAU,CAAA;AAC7E,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,UAAU,CAAA;AAGjD,qBAAa,kBAAmB,YAAW,mBAAmB;IAC5D,OAAO,CAAC,MAAM,CAWI;IAElB,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,uBAAuB,CAAmC;IAElE,MAAM,IAAI,OAAO;gBAIL,KAAK,CAAC,EAAE,OAAO;IAQ3B,IAAI,KAAK,kBAER;IAEK,WAAW,CAAC,CAAC,EACjB,EAAE,EAAE,CAAC,IAAI,EAAE,8BAA8B,KAAK,OAAO,CAAC,CAAC,CAAC,GACvD,OAAO,CAAC,CAAC,CAAC;IA0BP,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAIvD,OAAO,CAAC,CAAC,SAAS;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,EAClC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,EAAE,CAAC;CAGhB"}

package/dist/front/FrontMemoryAdapter.js

@@ -0,0 +1,156 @@
+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 { createDraft, current, finishDraft } from 'immer';
+import { defer } from '@encorejs/utils/defer';
+export class FrontMemoryAdapter {
+    export() {
+        return this._state;
+    }
+    constructor(state) {
+        this._state = { sessions: {} };
+        this._readyDeferred = defer();
+        this._lastTransactionPromise = Promise.resolve();
+        if (state) {
+            this._state = state;
+        }
+        // nothing to initialize, so just resolve the promise
+        this._readyDeferred.resolve();
+    }
+    get ready() {
+        return this._readyDeferred.promise;
+    }
+    transaction(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deferred = defer();
+            const oldTransactionPromise = this._lastTransactionPromise;
+            this._lastTransactionPromise = deferred.promise;
+            try {
+                yield oldTransactionPromise;
+            }
+            catch (err) {
+                // ignore the error. it'll be handled elsewhere
+            }
+            yield this.ready;
+            const originalState = this._state;
+            const draft = createDraft(originalState);
+            const t = new Transaction(draft);
+            try {
+                const result = yield fn(t);
+                this._state = finishDraft(draft);
+                return result;
+            }
+            catch (error) {
+                throw error;
+            }
+            finally {
+                deferred.resolve();
+            }
+        });
+    }
+    get(key, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.transaction(({ get }) => get(key, session));
+        });
+    }
+    getList(key, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.transaction(({ getList }) => getList(key, session));
+        });
+    }
+}
+class Transaction {
+    constructor(_draft) {
+        this._draft = _draft;
+    }
+    get(key, session) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_b = current((_a = this._draft.sessions[session]) === null || _a === void 0 ? void 0 : _a.keyval)) === null || _b === void 0 ? void 0 : _b[key];
+        });
+    }
+    set(key, value, session) {
+        var _a;
+        var _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = (_b = this._draft.sessions)[session]) !== null && _a !== void 0 ? _a : (_b[session] = { keyval: {}, lists: {} });
+            const s = this._draft.sessions[session];
+            s.keyval[key] = value;
+        });
+    }
+    getAll(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vals = {};
+            for (const [sessionId, v] of Object.entries(this._draft.sessions)) {
+                if (!v)
+                    continue;
+                if (Object.hasOwn(v.keyval, key)) {
+                    const value = v.keyval[key];
+                    if (value === undefined)
+                        continue;
+                    vals[sessionId] = value;
+                }
+            }
+            return vals;
+        });
+    }
+    deleteSession(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            delete this._draft.sessions[session];
+        });
+    }
+    pushToList(key, rows, session) {
+        var _a;
+        var _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = (_b = this._draft.sessions)[session]) !== null && _a !== void 0 ? _a : (_b[session] = { keyval: {}, lists: {} });
+            const s = this._draft.sessions[session];
+            if (!s.lists[key]) {
+                s.lists[key] = [];
+            }
+            const list = s.lists[key];
+            if (list.some((row) => rows.some((r) => r.id === row.id))) {
+                throw new Error(`Cannot push to list "${key}" because one or more rows already exist`);
+            }
+            list.push(...rows);
+        });
+    }
+    getList(key, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const s = this._draft.sessions[session];
+            if (!(s === null || s === void 0 ? void 0 : s.lists[key])) {
+                return [];
+            }
+            return current(s === null || s === void 0 ? void 0 : s.lists)[key];
+        });
+    }
+    pluckFromList(key, ids, session) {
+        var _a;
+        var _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = (_b = this._draft.sessions)[session]) !== null && _a !== void 0 ? _a : (_b[session] = { keyval: {}, lists: {} });
+            const s = this._draft.sessions[session];
+            if (!s.lists[key]) {
+                return [];
+            }
+            const list = s.lists[key];
+            return ids.map((id) => {
+                const index = list.findIndex((row) => row.id === id);
+                if (index === -1) {
+                    return undefined;
+                }
+                else {
+                    const row = list[index];
+                    list.splice(index, 1);
+                    return row;
+                }
+            });
+        });
+    }
+}

package/dist/front/FrontStorage.d.ts

@@ -0,0 +1,23 @@
+import type { SessionState, FrontStorageAdapterTransaction, Transaction } from '../types';
+import type { FrontStorageAdapter } from '../types';
+export declare class FrontStorage {
+    readonly dbName: string;
+    private readonly _adapter;
+    constructor(dbName: string, _adapter: FrontStorageAdapter);
+    transaction<T>(fn: (opts: FrontStorageTransaction) => Promise<T>): Promise<T>;
+}
+declare class FrontStorageTransactionImpl {
+    private _adapterTransaction;
+    constructor(_adapterTransaction: FrontStorageAdapterTransaction);
+    setSessionState(s: SessionState<unknown>, session: string): Promise<void>;
+    getSessionState(session: string): Promise<SessionState<unknown> | undefined>;
+    deleteSession(session: string): Promise<void>;
+    getMostRecentlySyncedSessionState(): Promise<SessionState<unknown> | undefined>;
+    getOptimisticUpdates(session: string): Promise<Transaction[]>;
+    pluckOptimisticUpdates(transactions: Pick<Transaction, 'peerClock'>[], session: string): Promise<void>;
+    getAllExistingSessionIds(): Promise<string[]>;
+    pushOptimisticUpdates(transactions: Transaction[], session: string): Promise<void>;
+}
+export type FrontStorageTransaction = FrontStorageTransactionImpl;
+export {};
+//# sourceMappingURL=FrontStorage.d.ts.map

package/dist/front/FrontStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrontStorage.d.ts","sourceRoot":"","sources":["../../src/front/FrontStorage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,YAAY,EACZ,8BAA8B,EAC9B,WAAW,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,UAAU,CAAA;AAEjD,qBAAa,YAAY;IAErB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBADhB,MAAM,EAAE,MAAM,EACN,QAAQ,EAAE,mBAAmB;IAG1C,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,uBAAuB,KAAK,OAAO,CAAC,CAAC,CAAC;CAMvE;AAED,cAAM,2BAA2B;IACnB,OAAO,CAAC,mBAAmB;gBAAnB,mBAAmB,EAAE,8BAA8B;IAEjE,eAAe,CAAC,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM;IAMzD,eAAe,CACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;IAKvC,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7C,iCAAiC,IAAI,OAAO,CAChD,YAAY,CAAC,OAAO,CAAC,GAAG,SAAS,CAClC;IAgBK,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAQ7D,sBAAsB,CAC1B,YAAY,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,EAAE,EAC9C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC;IAQV,wBAAwB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAK7C,qBAAqB,CACzB,YAAY,EAAE,WAAW,EAAE,EAC3B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC;CAajB;AAED,MAAM,MAAM,uBAAuB,GAAG,2BAA2B,CAAA"}

package/dist/front/FrontStorage.js

@@ -0,0 +1,85 @@
+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());
+    });
+};
+export class FrontStorage {
+    constructor(dbName, _adapter) {
+        this.dbName = dbName;
+        this._adapter = _adapter;
+    }
+    transaction(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._adapter.transaction((adapterOpts) => __awaiter(this, void 0, void 0, function* () {
+                const t = new FrontStorageTransactionImpl(adapterOpts);
+                return yield fn(t);
+            }));
+        });
+    }
+}
+class FrontStorageTransactionImpl {
+    constructor(_adapterTransaction) {
+        this._adapterTransaction = _adapterTransaction;
+    }
+    setSessionState(s, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: serializing the state every time this changes probably wastes IO.
+            // better to create a writeahead log and compact it every once in a while
+            yield this._adapterTransaction.set('sessionState', s, session);
+        });
+    }
+    getSessionState(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const v = this._adapterTransaction.get('sessionState', session);
+            return v;
+        });
+    }
+    deleteSession(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._adapterTransaction.deleteSession(session);
+        });
+    }
+    getMostRecentlySyncedSessionState() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const allSessionStates = this._adapterTransaction.getAll('sessionState');
+            let latest;
+            for (const [peerId, sessionState] of Object.entries(allSessionStates)) {
+                if (typeof sessionState.backendClock === 'number' &&
+                    sessionState.backendClock > ((_a = latest === null || latest === void 0 ? void 0 : latest.backendClock) !== null && _a !== void 0 ? _a : -1)) {
+                    latest = sessionState;
+                }
+            }
+            return latest;
+        });
+    }
+    getOptimisticUpdates(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const s = yield this._adapterTransaction.getList('optimisticUpdates', session);
+            return s.map((t) => t.transaction);
+        });
+    }
+    pluckOptimisticUpdates(transactions, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._adapterTransaction.pluckFromList('optimisticUpdates', transactions.map(({ peerClock }) => '#' + peerClock), session);
+        });
+    }
+    getAllExistingSessionIds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const all = yield this._adapterTransaction.getAll('session');
+            return Object.keys(all);
+        });
+    }
+    pushOptimisticUpdates(transactions, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._adapterTransaction.pushToList('optimisticUpdates', transactions.map((t) => ({
+                id: '#' + t.peerClock,
+                transaction: t,
+            })), session);
+        });
+    }
+}

package/dist/front/SaazFront.d.ts

@@ -0,0 +1,113 @@
+import type { SessionState, SaazBackInterface, Schema, TempTransactionApi, ValidOpSnapshot } from '../types';
+import type { ValidGenerators, EditorDefinitionToEditorInvocable } from '../types';
+import type { OnDiskSnapshot } from '../types';
+import type { FrontStorageAdapter } from '../types';
+export declare class SaazFront<OpSnapshot extends ValidOpSnapshot, Editors extends {}, Generators extends ValidGenerators, CellShape extends {} = {}> {
+    /**
+     * Using an atom here so we can react to changes to its state
+     */
+    private readonly _atom;
+    /**
+     * The initial snapshot that was saved to disk, and provided as opts.initialSnapshot to the constructor
+     */
+    private readonly _diskSnapshot;
+    /**
+     * The peer id of this frontend. It is supposed to be unique per-tab, and globally. If there are more than
+     * one Saaz instance per tab, then each should have its own peer id. Better to generate this via UUID.
+     *
+     * Note that the backend will associate the peerId with the user's account to make sure the peerId cannot
+     * be stolen.
+     *
+     * Each user account may have many peerIds associated with it (the user may have multiple tabs, or multiple devices open at the same time).
+     *
+     * The backend will periodically garbage-collect the peerIds that have not been used for a while. In the off-chance that a peerId is garbage-collected
+     * on the backend but the frontend still has it, the frontend will generate a new peerId and use that instead.
+     */
+    private readonly _peerId;
+    /**
+     * The name of the database. This is used to namespace the keys in the storage adapter.
+     */
+    private _dbName;
+    /**
+     * The storage adapter that the frontend uses to store its state. The storage is meant to allow the user to work offline
+     * and be able to close the tab and reopen it later and continue working.
+     */
+    private _storage;
+    /**
+     * A promise that resolves when the frontend is ready to be used. This is the same as the promise returned by the ready getter.
+     */
+    private _initializedPromise;
+    /**
+     * The backend that the frontend communicates with. In environments where the backend and the frontend are in the same process,
+     * then a reference to SaazBack can be passed here. This is useful for testing.
+     *
+     * In environments where the backend and the frontend are in different processes (a client/server setup), an object that
+     * implements `SaazBackInterface` should be passed here. See `@encorejs/sync-server` for a TRPC-based implementation.
+     */
+    private _backend;
+    /**
+     * The schema includes the shape of the snapshot, a nested object of editors, and a shallow object of generator functions.
+     */
+    private readonly _schema;
+    /**
+     * A counter that is used to generate unique ids for temp transactions.
+     */
+    private _tempTransactionCounter;
+    /**
+     * A list of functions that will be called when the frontend is destroyed.
+     */
+    private _teardownCallbacks;
+    /**
+     * We use dataverse prisms to derive several values from the atom. This makes the reactive parts of the code easier to maintain.
+     */
+    private _prisms;
+    private _caches;
+    constructor(opts: {
+        schema: Schema<OpSnapshot, Editors, Generators, CellShape>;
+        backend: SaazBackInterface;
+        diskSnapshot?: OnDiskSnapshot<OpSnapshot>;
+        peerId?: string;
+        dbName: string;
+        storageAdapter: FrontStorageAdapter;
+        /**
+         * If true (default), the frontend will keep the prisms hot. This is a perf optimization
+         */
+        keepPrismsHot?: boolean;
+    });
+    private _init;
+    private _loadClosedSessions;
+    private _acquireLocksOnClosedSessions;
+    teardown(): void;
+    private _removeStalePeerPresenceStates;
+    private _reflectPresenceToBackend;
+    private _reflectUpdatesToBackend;
+    private _processBackendUpdate;
+    private _reflectBackendStateToStorage;
+    private _gcClosedSessions;
+    private _reflectOptimisticUpdatesToStorage;
+    private _cachedApplyTransactionToState;
+    _setSessionState(opts: SessionState<OpSnapshot>): void;
+    private _pullUpdatesFromBackend;
+    private _subscribeToBackend;
+    get state(): {
+        op: OpSnapshot;
+        cell: CellShape;
+    };
+    get isReady(): boolean;
+    get ready(): Promise<unknown>;
+    tx(editorFn?: (editors: EditorDefinitionToEditorInvocable<Editors>) => void, draftFn?: (cellDraft: CellShape) => void, undoable?: boolean): void;
+    tempTx(editorFn?: (editors: EditorDefinitionToEditorInvocable<Editors>) => void, draftFn?: (cellDraft: CellShape) => void, existingTempTransaction?: TempTransactionApi<Editors, CellShape>): TempTransactionApi<Editors, CellShape>;
+    private _setTempTransaction;
+    private _createTransaction;
+    waitForStorageSync(): Promise<void>;
+    private _pushOptimisticUpdate;
+    waitForBackendSync(): Promise<void>;
+    private _addToUndoStack;
+    undo(): void;
+    redo(): void;
+    subscribe(fn: (newState: {
+        op: OpSnapshot;
+        cell: CellShape;
+    }) => void): () => void;
+}
+//# sourceMappingURL=SaazFront.d.ts.map

package/dist/front/SaazFront.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaazFront.d.ts","sourceRoot":"","sources":["../../src/front/SaazFront.ts"],"names":[],"mappings":"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"}