@tldraw/sync-core 4.3.0-canary.c7096a59bf3b → 4.3.0-canary.d039f3a1ab8f

package/dist-cjs/lib/InMemorySyncStorage.js

@@ -0,0 +1,289 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InMemorySyncStorage_exports = {};
+__export(InMemorySyncStorage_exports, {
+  DEFAULT_INITIAL_SNAPSHOT: () => DEFAULT_INITIAL_SNAPSHOT,
+  InMemorySyncStorage: () => InMemorySyncStorage,
+  MAX_TOMBSTONES: () => MAX_TOMBSTONES,
+  TOMBSTONE_PRUNE_BUFFER_SIZE: () => TOMBSTONE_PRUNE_BUFFER_SIZE
+});
+module.exports = __toCommonJS(InMemorySyncStorage_exports);
+var import_state = require("@tldraw/state");
+var import_store = require("@tldraw/store");
+var import_tlschema = require("@tldraw/tlschema");
+var import_utils = require("@tldraw/utils");
+const TOMBSTONE_PRUNE_BUFFER_SIZE = 1e3;
+const MAX_TOMBSTONES = 5e3;
+const DEFAULT_INITIAL_SNAPSHOT = {
+  documentClock: 0,
+  tombstoneHistoryStartsAtClock: 0,
+  schema: (0, import_tlschema.createTLSchema)().serialize(),
+  documents: [
+    {
+      state: import_tlschema.DocumentRecordType.create({ id: import_tlschema.TLDOCUMENT_ID }),
+      lastChangedClock: 0
+    },
+    {
+      state: import_tlschema.PageRecordType.create({
+        id: "page:page",
+        name: "Page 1",
+        index: "a1"
+      }),
+      lastChangedClock: 0
+    }
+  ]
+};
+class InMemorySyncStorage {
+  /** @internal */
+  documents;
+  /** @internal */
+  tombstones;
+  /** @internal */
+  schema;
+  /** @internal */
+  documentClock;
+  /** @internal */
+  tombstoneHistoryStartsAtClock;
+  listeners = /* @__PURE__ */ new Set();
+  onChange(callback) {
+    let didDelete = false;
+    queueMicrotask(() => {
+      if (didDelete) return;
+      this.listeners.add(callback);
+    });
+    return () => {
+      if (didDelete) return;
+      didDelete = true;
+      this.listeners.delete(callback);
+    };
+  }
+  constructor({
+    snapshot = DEFAULT_INITIAL_SNAPSHOT,
+    onChange
+  } = {}) {
+    const maxClockValue = Math.max(
+      0,
+      ...Object.values(snapshot.tombstones ?? {}),
+      ...Object.values(snapshot.documents.map((d) => d.lastChangedClock))
+    );
+    this.documents = new import_store.AtomMap(
+      "room documents",
+      snapshot.documents.map((d) => [
+        d.state.id,
+        { state: (0, import_store.devFreeze)(d.state), lastChangedClock: d.lastChangedClock }
+      ])
+    );
+    const documentClock = Math.max(maxClockValue, snapshot.documentClock ?? snapshot.clock ?? 0);
+    this.documentClock = (0, import_state.atom)("document clock", documentClock);
+    const tombstoneHistoryStartsAtClock = Math.min(
+      snapshot.tombstoneHistoryStartsAtClock ?? documentClock,
+      documentClock
+    );
+    this.tombstoneHistoryStartsAtClock = (0, import_state.atom)(
+      "tombstone history starts at clock",
+      tombstoneHistoryStartsAtClock
+    );
+    this.schema = (0, import_state.atom)("schema", snapshot.schema ?? (0, import_tlschema.createTLSchema)().serializeEarliestVersion());
+    this.tombstones = new import_store.AtomMap(
+      "room tombstones",
+      // If the tombstone history starts now (or we didn't have the
+      // tombstoneHistoryStartsAtClock) then there are no tombstones
+      tombstoneHistoryStartsAtClock === documentClock ? [] : (0, import_utils.objectMapEntries)(snapshot.tombstones ?? {})
+    );
+    if (onChange) {
+      this.onChange(onChange);
+    }
+  }
+  transaction(callback, opts) {
+    const clockBefore = this.documentClock.get();
+    const trackChanges = opts?.emitChanges === "always";
+    const txn = new InMemorySyncStorageTransaction(this);
+    let result;
+    let changes;
+    try {
+      result = (0, import_state.transaction)(() => {
+        return callback(txn);
+      });
+      if (trackChanges) {
+        changes = txn.getChangesSince(clockBefore)?.diff;
+      }
+    } catch (error) {
+      console.error("Error in transaction", error);
+      throw error;
+    } finally {
+      txn.close();
+    }
+    if (typeof result === "object" && result && "then" in result && typeof result.then === "function") {
+      const err = new Error("Transaction must return a value, not a promise");
+      console.error(err);
+      throw err;
+    }
+    const clockAfter = this.documentClock.get();
+    const didChange = clockAfter > clockBefore;
+    if (didChange) {
+      queueMicrotask(() => {
+        const props = {
+          id: opts?.id,
+          documentClock: clockAfter
+        };
+        for (const listener of this.listeners) {
+          try {
+            listener(props);
+          } catch (error) {
+            console.error("Error in onChange callback", error);
+          }
+        }
+      });
+    }
+    return { documentClock: clockAfter, didChange: clockAfter > clockBefore, result, changes };
+  }
+  getClock() {
+    return this.documentClock.get();
+  }
+  /** @internal */
+  pruneTombstones = (0, import_utils.throttle)(
+    () => {
+      if (this.tombstones.size > MAX_TOMBSTONES) {
+        const tombstones = Array.from(this.tombstones);
+        tombstones.sort((a, b) => a[1] - b[1]);
+        let cutoff = TOMBSTONE_PRUNE_BUFFER_SIZE + this.tombstones.size - MAX_TOMBSTONES;
+        while (cutoff < tombstones.length && tombstones[cutoff - 1][1] === tombstones[cutoff][1]) {
+          cutoff++;
+        }
+        const oldestRemaining = tombstones[cutoff];
+        this.tombstoneHistoryStartsAtClock.set(oldestRemaining?.[1] ?? this.documentClock.get());
+        const toDelete = tombstones.slice(0, cutoff);
+        this.tombstones.deleteMany(toDelete.map(([id]) => id));
+      }
+    },
+    1e3,
+    // prevent this from running synchronously to avoid blocking requests
+    { leading: false }
+  );
+  getSnapshot() {
+    return {
+      tombstoneHistoryStartsAtClock: this.tombstoneHistoryStartsAtClock.get(),
+      documentClock: this.documentClock.get(),
+      documents: Array.from(this.documents.values()),
+      tombstones: Object.fromEntries(this.tombstones.entries()),
+      schema: this.schema.get()
+    };
+  }
+}
+class InMemorySyncStorageTransaction {
+  constructor(storage) {
+    this.storage = storage;
+    this._clock = this.storage.documentClock.get();
+  }
+  _clock;
+  _closed = false;
+  /** @internal */
+  close() {
+    this._closed = true;
+  }
+  assertNotClosed() {
+    (0, import_utils.assert)(!this._closed, "Transaction has ended, iterator cannot be consumed");
+  }
+  getClock() {
+    return this._clock;
+  }
+  didIncrementClock = false;
+  getNextClock() {
+    if (!this.didIncrementClock) {
+      this.didIncrementClock = true;
+      this._clock = this.storage.documentClock.set(this.storage.documentClock.get() + 1);
+    }
+    return this._clock;
+  }
+  get(id) {
+    this.assertNotClosed();
+    return this.storage.documents.get(id)?.state;
+  }
+  set(id, record) {
+    this.assertNotClosed();
+    (0, import_utils.assert)(id === record.id, `Record id mismatch: key does not match record.id`);
+    const clock = this.getNextClock();
+    if (this.storage.tombstones.has(id)) {
+      this.storage.tombstones.delete(id);
+    }
+    this.storage.documents.set(id, {
+      state: (0, import_store.devFreeze)(record),
+      lastChangedClock: clock
+    });
+  }
+  delete(id) {
+    this.assertNotClosed();
+    if (!this.storage.documents.has(id)) return;
+    const clock = this.getNextClock();
+    this.storage.documents.delete(id);
+    this.storage.tombstones.set(id, clock);
+    this.storage.pruneTombstones();
+  }
+  *entries() {
+    this.assertNotClosed();
+    for (const [id, record] of this.storage.documents.entries()) {
+      this.assertNotClosed();
+      yield [id, record.state];
+    }
+  }
+  *keys() {
+    this.assertNotClosed();
+    for (const key of this.storage.documents.keys()) {
+      this.assertNotClosed();
+      yield key;
+    }
+  }
+  *values() {
+    this.assertNotClosed();
+    for (const record of this.storage.documents.values()) {
+      this.assertNotClosed();
+      yield record.state;
+    }
+  }
+  getSchema() {
+    this.assertNotClosed();
+    return this.storage.schema.get();
+  }
+  setSchema(schema) {
+    this.assertNotClosed();
+    this.storage.schema.set(schema);
+  }
+  getChangesSince(sinceClock) {
+    this.assertNotClosed();
+    const clock = this.storage.documentClock.get();
+    if (sinceClock === clock) return void 0;
+    if (sinceClock > clock) {
+      sinceClock = -1;
+    }
+    const diff = { puts: {}, deletes: [] };
+    const wipeAll = sinceClock < this.storage.tombstoneHistoryStartsAtClock.get();
+    for (const doc of this.storage.documents.values()) {
+      if (wipeAll || doc.lastChangedClock > sinceClock) {
+        diff.puts[doc.state.id] = doc.state;
+      }
+    }
+    for (const [id, clock2] of this.storage.tombstones.entries()) {
+      if (clock2 > sinceClock) {
+        diff.deletes.push(id);
+      }
+    }
+    return { diff, wipeAll };
+  }
+}
+//# sourceMappingURL=InMemorySyncStorage.js.map

package/dist-cjs/lib/InMemorySyncStorage.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/InMemorySyncStorage.ts"],
+  "sourcesContent": ["import { atom, Atom, transaction } from '@tldraw/state'\nimport { AtomMap, devFreeze, SerializedSchema, UnknownRecord } from '@tldraw/store'\nimport {\n\tcreateTLSchema,\n\tDocumentRecordType,\n\tPageRecordType,\n\tTLDOCUMENT_ID,\n\tTLPageId,\n} from '@tldraw/tlschema'\nimport { assert, IndexKey, objectMapEntries, throttle } from '@tldraw/utils'\nimport { RoomSnapshot } from './TLSyncRoom'\nimport {\n\tTLSyncForwardDiff,\n\tTLSyncStorage,\n\tTLSyncStorageGetChangesSinceResult,\n\tTLSyncStorageOnChangeCallbackProps,\n\tTLSyncStorageTransaction,\n\tTLSyncStorageTransactionCallback,\n\tTLSyncStorageTransactionOptions,\n\tTLSyncStorageTransactionResult,\n} from './TLSyncStorage'\n\n/** @internal */\nexport const TOMBSTONE_PRUNE_BUFFER_SIZE = 1000\n/** @internal */\nexport const MAX_TOMBSTONES = 5000\n\n/**\n * Default initial snapshot for a new room.\n * @public\n */\nexport const DEFAULT_INITIAL_SNAPSHOT = {\n\tdocumentClock: 0,\n\ttombstoneHistoryStartsAtClock: 0,\n\tschema: createTLSchema().serialize(),\n\tdocuments: [\n\t\t{\n\t\t\tstate: DocumentRecordType.create({ id: TLDOCUMENT_ID }),\n\t\t\tlastChangedClock: 0,\n\t\t},\n\t\t{\n\t\t\tstate: PageRecordType.create({\n\t\t\t\tid: 'page:page' as TLPageId,\n\t\t\t\tname: 'Page 1',\n\t\t\t\tindex: 'a1' as IndexKey,\n\t\t\t}),\n\t\t\tlastChangedClock: 0,\n\t\t},\n\t],\n}\n\n/**\n * In-memory implementation of TLSyncStorage using AtomMap for documents and tombstones,\n * and atoms for clock values. This is the default storage implementation used by TLSyncRoom.\n *\n * @public\n */\nexport class InMemorySyncStorage<R extends UnknownRecord> implements TLSyncStorage<R> {\n\t/** @internal */\n\tdocuments: AtomMap<string, { state: R; lastChangedClock: number }>\n\t/** @internal */\n\ttombstones: AtomMap<string, number>\n\t/** @internal */\n\tschema: Atom<SerializedSchema>\n\t/** @internal */\n\tdocumentClock: Atom<number>\n\t/** @internal */\n\ttombstoneHistoryStartsAtClock: Atom<number>\n\n\tprivate listeners = new Set<(arg: TLSyncStorageOnChangeCallbackProps) => unknown>()\n\tonChange(callback: (arg: TLSyncStorageOnChangeCallbackProps) => unknown): () => void {\n\t\tlet didDelete = false\n\t\t// we put the callback registration in a microtask because the callback is invoked\n\t\t// in a microtask, and so this makes sure the callback is invoked after all the updates\n\t\t// that happened in the current callstack before this onChange registration have been processed.\n\t\tqueueMicrotask(() => {\n\t\t\tif (didDelete) return\n\t\t\tthis.listeners.add(callback)\n\t\t})\n\t\treturn () => {\n\t\t\tif (didDelete) return\n\t\t\tdidDelete = true\n\t\t\tthis.listeners.delete(callback)\n\t\t}\n\t}\n\n\tconstructor({\n\t\tsnapshot = DEFAULT_INITIAL_SNAPSHOT,\n\t\tonChange,\n\t}: {\n\t\tsnapshot?: RoomSnapshot\n\t\tonChange?(arg: TLSyncStorageOnChangeCallbackProps): unknown\n\t} = {}) {\n\t\tconst maxClockValue = Math.max(\n\t\t\t0,\n\t\t\t...Object.values(snapshot.tombstones ?? {}),\n\t\t\t...Object.values(snapshot.documents.map((d) => d.lastChangedClock))\n\t\t)\n\t\tthis.documents = new AtomMap(\n\t\t\t'room documents',\n\t\t\tsnapshot.documents.map((d) => [\n\t\t\t\td.state.id,\n\t\t\t\t{ state: devFreeze(d.state) as R, lastChangedClock: d.lastChangedClock },\n\t\t\t])\n\t\t)\n\t\tconst documentClock = Math.max(maxClockValue, snapshot.documentClock ?? snapshot.clock ?? 0)\n\n\t\tthis.documentClock = atom('document clock', documentClock)\n\t\t// math.min to make sure the tombstone history starts at or before the document clock\n\t\tconst tombstoneHistoryStartsAtClock = Math.min(\n\t\t\tsnapshot.tombstoneHistoryStartsAtClock ?? documentClock,\n\t\t\tdocumentClock\n\t\t)\n\t\tthis.tombstoneHistoryStartsAtClock = atom(\n\t\t\t'tombstone history starts at clock',\n\t\t\ttombstoneHistoryStartsAtClock\n\t\t)\n\t\t// eslint-disable-next-line @typescript-eslint/no-deprecated\n\t\tthis.schema = atom('schema', snapshot.schema ?? createTLSchema().serializeEarliestVersion())\n\t\tthis.tombstones = new AtomMap(\n\t\t\t'room tombstones',\n\t\t\t// If the tombstone history starts now (or we didn't have the\n\t\t\t// tombstoneHistoryStartsAtClock) then there are no tombstones\n\t\t\ttombstoneHistoryStartsAtClock === documentClock\n\t\t\t\t? []\n\t\t\t\t: objectMapEntries(snapshot.tombstones ?? {})\n\t\t)\n\t\tif (onChange) {\n\t\t\tthis.onChange(onChange)\n\t\t}\n\t}\n\n\ttransaction<T>(\n\t\tcallback: TLSyncStorageTransactionCallback<R, T>,\n\t\topts?: TLSyncStorageTransactionOptions\n\t): TLSyncStorageTransactionResult<T, R> {\n\t\tconst clockBefore = this.documentClock.get()\n\t\tconst trackChanges = opts?.emitChanges === 'always'\n\t\tconst txn = new InMemorySyncStorageTransaction<R>(this)\n\t\tlet result: T\n\t\tlet changes: TLSyncForwardDiff<R> | undefined\n\t\ttry {\n\t\t\tresult = transaction(() => {\n\t\t\t\treturn callback(txn as any)\n\t\t\t}) as T\n\t\t\tif (trackChanges) {\n\t\t\t\tchanges = txn.getChangesSince(clockBefore)?.diff\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tconsole.error('Error in transaction', error)\n\t\t\tthrow error\n\t\t} finally {\n\t\t\ttxn.close()\n\t\t}\n\t\tif (\n\t\t\ttypeof result === 'object' &&\n\t\t\tresult &&\n\t\t\t'then' in result &&\n\t\t\ttypeof result.then === 'function'\n\t\t) {\n\t\t\tconst err = new Error('Transaction must return a value, not a promise')\n\t\t\tconsole.error(err)\n\t\t\tthrow err\n\t\t}\n\n\t\tconst clockAfter = this.documentClock.get()\n\t\tconst didChange = clockAfter > clockBefore\n\t\tif (didChange) {\n\t\t\t// todo: batch these updates\n\t\t\tqueueMicrotask(() => {\n\t\t\t\tconst props: TLSyncStorageOnChangeCallbackProps = {\n\t\t\t\t\tid: opts?.id,\n\t\t\t\t\tdocumentClock: clockAfter,\n\t\t\t\t}\n\t\t\t\tfor (const listener of this.listeners) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tlistener(props)\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tconsole.error('Error in onChange callback', error)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t})\n\t\t}\n\t\t// InMemorySyncStorage applies changes verbatim, so we only emit changes\n\t\t// when 'always' is specified (not for 'when-different')\n\t\treturn { documentClock: clockAfter, didChange: clockAfter > clockBefore, result, changes }\n\t}\n\n\tgetClock(): number {\n\t\treturn this.documentClock.get()\n\t}\n\n\t/** @internal */\n\tpruneTombstones = throttle(\n\t\t() => {\n\t\t\tif (this.tombstones.size > MAX_TOMBSTONES) {\n\t\t\t\tconst tombstones = Array.from(this.tombstones)\n\t\t\t\t// sort entries in ascending order by clock (oldest first)\n\t\t\t\ttombstones.sort((a, b) => a[1] - b[1])\n\t\t\t\t// determine how many to delete, avoiding partial history for a clock value\n\t\t\t\tlet cutoff = TOMBSTONE_PRUNE_BUFFER_SIZE + this.tombstones.size - MAX_TOMBSTONES\n\t\t\t\twhile (cutoff < tombstones.length && tombstones[cutoff - 1][1] === tombstones[cutoff][1]) {\n\t\t\t\t\tcutoff++\n\t\t\t\t}\n\n\t\t\t\t// Set history start to the oldest remaining tombstone's clock\n\t\t\t\t// (or documentClock if we're deleting everything)\n\t\t\t\tconst oldestRemaining = tombstones[cutoff]\n\t\t\t\tthis.tombstoneHistoryStartsAtClock.set(oldestRemaining?.[1] ?? this.documentClock.get())\n\n\t\t\t\t// Delete the oldest tombstones (first cutoff entries)\n\t\t\t\tconst toDelete = tombstones.slice(0, cutoff)\n\t\t\t\tthis.tombstones.deleteMany(toDelete.map(([id]) => id))\n\t\t\t}\n\t\t},\n\t\t1000,\n\t\t// prevent this from running synchronously to avoid blocking requests\n\t\t{ leading: false }\n\t)\n\n\tgetSnapshot(): RoomSnapshot {\n\t\treturn {\n\t\t\ttombstoneHistoryStartsAtClock: this.tombstoneHistoryStartsAtClock.get(),\n\t\t\tdocumentClock: this.documentClock.get(),\n\t\t\tdocuments: Array.from(this.documents.values()),\n\t\t\ttombstones: Object.fromEntries(this.tombstones.entries()),\n\t\t\tschema: this.schema.get(),\n\t\t}\n\t}\n}\n\n/**\n * Transaction implementation for InMemorySyncStorage.\n * Provides access to documents, tombstones, and metadata within a transaction.\n *\n * @internal\n */\nclass InMemorySyncStorageTransaction<R extends UnknownRecord>\n\timplements TLSyncStorageTransaction<R>\n{\n\tprivate _clock\n\tprivate _closed = false\n\n\tconstructor(private storage: InMemorySyncStorage<R>) {\n\t\tthis._clock = this.storage.documentClock.get()\n\t}\n\n\t/** @internal */\n\tclose() {\n\t\tthis._closed = true\n\t}\n\n\tprivate assertNotClosed() {\n\t\tassert(!this._closed, 'Transaction has ended, iterator cannot be consumed')\n\t}\n\n\tgetClock(): number {\n\t\treturn this._clock\n\t}\n\n\tprivate didIncrementClock: boolean = false\n\tprivate getNextClock(): number {\n\t\tif (!this.didIncrementClock) {\n\t\t\tthis.didIncrementClock = true\n\t\t\tthis._clock = this.storage.documentClock.set(this.storage.documentClock.get() + 1)\n\t\t}\n\t\treturn this._clock\n\t}\n\n\tget(id: string): R | undefined {\n\t\tthis.assertNotClosed()\n\t\treturn this.storage.documents.get(id)?.state\n\t}\n\n\tset(id: string, record: R): void {\n\t\tthis.assertNotClosed()\n\t\tassert(id === record.id, `Record id mismatch: key does not match record.id`)\n\t\tconst clock = this.getNextClock()\n\t\t// Automatically clear tombstone if it exists\n\t\tif (this.storage.tombstones.has(id)) {\n\t\t\tthis.storage.tombstones.delete(id)\n\t\t}\n\t\tthis.storage.documents.set(id, {\n\t\t\tstate: devFreeze(record) as R,\n\t\t\tlastChangedClock: clock,\n\t\t})\n\t}\n\n\tdelete(id: string): void {\n\t\tthis.assertNotClosed()\n\t\t// Only create a tombstone if the record actually exists\n\t\tif (!this.storage.documents.has(id)) return\n\t\tconst clock = this.getNextClock()\n\t\tthis.storage.documents.delete(id)\n\t\tthis.storage.tombstones.set(id, clock)\n\t\tthis.storage.pruneTombstones()\n\t}\n\n\t*entries(): IterableIterator<[string, R]> {\n\t\tthis.assertNotClosed()\n\t\tfor (const [id, record] of this.storage.documents.entries()) {\n\t\t\tthis.assertNotClosed()\n\t\t\tyield [id, record.state]\n\t\t}\n\t}\n\n\t*keys(): IterableIterator<string> {\n\t\tthis.assertNotClosed()\n\t\tfor (const key of this.storage.documents.keys()) {\n\t\t\tthis.assertNotClosed()\n\t\t\tyield key\n\t\t}\n\t}\n\n\t*values(): IterableIterator<R> {\n\t\tthis.assertNotClosed()\n\t\tfor (const record of this.storage.documents.values()) {\n\t\t\tthis.assertNotClosed()\n\t\t\tyield record.state\n\t\t}\n\t}\n\n\tgetSchema(): SerializedSchema {\n\t\tthis.assertNotClosed()\n\t\treturn this.storage.schema.get()\n\t}\n\n\tsetSchema(schema: SerializedSchema): void {\n\t\tthis.assertNotClosed()\n\t\tthis.storage.schema.set(schema)\n\t}\n\n\tgetChangesSince(sinceClock: number): TLSyncStorageGetChangesSinceResult<R> | undefined {\n\t\tthis.assertNotClosed()\n\t\tconst clock = this.storage.documentClock.get()\n\t\tif (sinceClock === clock) return undefined\n\t\tif (sinceClock > clock) {\n\t\t\t// something went wrong, wipe the slate clean\n\t\t\tsinceClock = -1\n\t\t}\n\t\tconst diff: TLSyncForwardDiff<R> = { puts: {}, deletes: [] }\n\t\tconst wipeAll = sinceClock < this.storage.tombstoneHistoryStartsAtClock.get()\n\t\tfor (const doc of this.storage.documents.values()) {\n\t\t\tif (wipeAll || doc.lastChangedClock > sinceClock) {\n\t\t\t\t// For historical changes, we don't have \"from\" state, so use added\n\t\t\t\tdiff.puts[doc.state.id] = doc.state as R\n\t\t\t}\n\t\t}\n\t\tfor (const [id, clock] of this.storage.tombstones.entries()) {\n\t\t\tif (clock > sinceClock) {\n\t\t\t\t// For tombstones, we don't have the removed record, use placeholder\n\t\t\t\tdiff.deletes.push(id)\n\t\t\t}\n\t\t}\n\t\treturn { diff, wipeAll }\n\t}\n}\n"],
+  "mappings": "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",
+  "names": ["clock"]
+}

package/dist-cjs/lib/RoomSession.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/RoomSession.ts"],
-  "sourcesContent": ["import { SerializedSchema, UnknownRecord } from '@tldraw/store'\nimport { TLRoomSocket } from './TLSyncRoom'\nimport { TLSocketServerSentDataEvent } from './protocol'\n\n/**\n * Enumeration of possible states for a room session during its lifecycle.\n *\n * Room sessions progress through these states as clients connect, authenticate,\n * and disconnect from collaborative rooms.\n *\n * @internal\n */\nexport const RoomSessionState = {\n\t/** Session is waiting for the initial connect message from the client */\n\tAwaitingConnectMessage: 'awaiting-connect-message',\n\t/** Session is disconnected but waiting for final cleanup before removal */\n\tAwaitingRemoval: 'awaiting-removal',\n\t/** Session is fully connected and actively synchronizing */\n\tConnected: 'connected',\n} as const\n\n/**\n * Type representing the possible states a room session can be in.\n *\n * @example\n * ```ts\n * const sessionState: RoomSessionState = RoomSessionState.Connected\n * if (sessionState === RoomSessionState.AwaitingConnectMessage) {\n *   console.log('Session waiting for connect message')\n * }\n * ```\n *\n * @internal\n */\nexport type RoomSessionState = (typeof RoomSessionState)[keyof typeof RoomSessionState]\n\n/**\n * Maximum time in milliseconds to wait for a connect message after socket connection.\n *\n * If a client connects but doesn't send a connect message within this time,\n * the session will be terminated.\n *\n * @public\n */\nexport const SESSION_START_WAIT_TIME = 10000\n\n/**\n * Time in milliseconds to wait before completely removing a disconnected session.\n *\n * This grace period allows for quick reconnections without losing session state,\n * which is especially helpful for brief network interruptions.\n *\n * @public\n */\nexport const SESSION_REMOVAL_WAIT_TIME = 5000\n\n/**\n * Maximum time in milliseconds a connected session can remain idle before cleanup.\n *\n * Sessions that don't receive any messages or interactions for this duration\n * may be considered for cleanup to free server resources.\n *\n * @public\n */\nexport const SESSION_IDLE_TIMEOUT = 20000\n\n/**\n * Base properties shared by all room session states.\n *\n * @internal\n */\nexport interface RoomSessionBase<R extends UnknownRecord, Meta> {\n\t/** Unique identifier for this session */\n\tsessionId: string\n\t/** Presence identifier for live cursor/selection tracking, if available */\n\tpresenceId: string | null\n\t/** WebSocket connection wrapper for this session */\n\tsocket: TLRoomSocket<R>\n\t/** Custom metadata associated with this session */\n\tmeta: Meta\n\t/** Whether this session has read-only permissions */\n\tisReadonly: boolean\n\t/** Whether this session requires legacy protocol rejection handling */\n\trequiresLegacyRejection: boolean\n\t/** Whether this session supports string append operations */\n\tsupportsStringAppend: boolean\n}\n\n/**\n * Represents a client session within a collaborative room, tracking the connection\n * state, permissions, and synchronization details for a single user.\n *\n * Each session corresponds to one WebSocket connection and progresses through\n * different states during its lifecycle. The session type is a discriminated union\n * based on the current state, ensuring type safety when accessing state-specific properties.\n *\n * @example\n * ```ts\n * // Check session state and access appropriate properties\n * function handleSession(session: RoomSession<MyRecord, UserMeta>) {\n *   switch (session.state) {\n *     case RoomSessionState.AwaitingConnectMessage:\n *       console.log(`Session ${session.sessionId} started at ${session.sessionStartTime}`)\n *       break\n *     case RoomSessionState.Connected:\n *       console.log(`Connected session has ${session.outstandingDataMessages.length} pending messages`)\n *       break\n *     case RoomSessionState.AwaitingRemoval:\n *       console.log(`Session will be removed at ${session.cancellationTime}`)\n *       break\n *   }\n * }\n * ```\n *\n * @internal\n */\nexport type RoomSession<R extends UnknownRecord, Meta> =\n\t| (RoomSessionBase<R, Meta> & {\n\t\t\t/** Current state of the session */\n\t\t\tstate: typeof RoomSessionState.AwaitingConnectMessage\n\t\t\t/** Timestamp when the session was created */\n\t\t\tsessionStartTime: number\n\t  })\n\t| (RoomSessionBase<R, Meta> & {\n\t\t\t/** Current state of the session */\n\t\t\tstate: typeof RoomSessionState.AwaitingRemoval\n\t\t\t/** Timestamp when the session was marked for removal */\n\t\t\tcancellationTime: number\n\t  })\n\t| (RoomSessionBase<R, Meta> & {\n\t\t\t/** Current state of the session */\n\t\t\tstate: typeof RoomSessionState.Connected\n\t\t\t/** Serialized schema information for this connected session */\n\t\t\tserializedSchema: SerializedSchema\n\t\t\t/** Timestamp of the last interaction or message from this session */\n\t\t\tlastInteractionTime: number\n\t\t\t/** Timer for debouncing operations, if active */\n\t\t\tdebounceTimer: ReturnType<typeof setTimeout> | null\n\t\t\t/** Queue of data messages waiting to be sent to this session */\n\t\t\toutstandingDataMessages: TLSocketServerSentDataEvent<R>[]\n\t  })\n"],
+  "sourcesContent": ["import { SerializedSchema, UnknownRecord } from '@tldraw/store'\nimport { TLRoomSocket } from './TLSyncRoom'\nimport { TLSocketServerSentDataEvent } from './protocol'\n\n/**\n * Enumeration of possible states for a room session during its lifecycle.\n *\n * Room sessions progress through these states as clients connect, authenticate,\n * and disconnect from collaborative rooms.\n *\n * @internal\n */\nexport const RoomSessionState = {\n\t/** Session is waiting for the initial connect message from the client */\n\tAwaitingConnectMessage: 'awaiting-connect-message',\n\t/** Session is disconnected but waiting for final cleanup before removal */\n\tAwaitingRemoval: 'awaiting-removal',\n\t/** Session is fully connected and actively synchronizing */\n\tConnected: 'connected',\n} as const\n\n/**\n * Type representing the possible states a room session can be in.\n *\n * @example\n * ```ts\n * const sessionState: RoomSessionState = RoomSessionState.Connected\n * if (sessionState === RoomSessionState.AwaitingConnectMessage) {\n *   console.log('Session waiting for connect message')\n * }\n * ```\n *\n * @internal\n */\nexport type RoomSessionState = (typeof RoomSessionState)[keyof typeof RoomSessionState]\n\n/**\n * Maximum time in milliseconds to wait for a connect message after socket connection.\n *\n * If a client connects but doesn't send a connect message within this time,\n * the session will be terminated.\n *\n * @public\n */\nexport const SESSION_START_WAIT_TIME = 10000\n\n/**\n * Time in milliseconds to wait before completely removing a disconnected session.\n *\n * This grace period allows for quick reconnections without losing session state,\n * which is especially helpful for brief network interruptions.\n *\n * @public\n */\nexport const SESSION_REMOVAL_WAIT_TIME = 5000\n\n/**\n * Maximum time in milliseconds a connected session can remain idle before cleanup.\n *\n * Sessions that don't receive any messages or interactions for this duration\n * may be considered for cleanup to free server resources.\n *\n * @public\n */\nexport const SESSION_IDLE_TIMEOUT = 20000\n\n/**\n * Base properties shared by all room session states.\n *\n * @internal\n */\nexport interface RoomSessionBase<R extends UnknownRecord, Meta> {\n\t/** Unique identifier for this session */\n\tsessionId: string\n\t/** Presence identifier for live cursor/selection tracking, if available */\n\tpresenceId: string | null\n\t/** WebSocket connection wrapper for this session */\n\tsocket: TLRoomSocket<R>\n\t/** Custom metadata associated with this session */\n\tmeta: Meta\n\t/** Whether this session has read-only permissions */\n\tisReadonly: boolean\n\t/** Whether this session requires legacy protocol rejection handling */\n\trequiresLegacyRejection: boolean\n\t/** Whether this session supports string append operations */\n\tsupportsStringAppend: boolean\n}\n\n/**\n * Represents a client session within a collaborative room, tracking the connection\n * state, permissions, and synchronization details for a single user.\n *\n * Each session corresponds to one WebSocket connection and progresses through\n * different states during its lifecycle. The session type is a discriminated union\n * based on the current state, ensuring type safety when accessing state-specific properties.\n *\n * @example\n * ```ts\n * // Check session state and access appropriate properties\n * function handleSession(session: RoomSession<MyRecord, UserMeta>) {\n *   switch (session.state) {\n *     case RoomSessionState.AwaitingConnectMessage:\n *       console.log(`Session ${session.sessionId} started at ${session.sessionStartTime}`)\n *       break\n *     case RoomSessionState.Connected:\n *       console.log(`Connected session has ${session.outstandingDataMessages.length} pending messages`)\n *       break\n *     case RoomSessionState.AwaitingRemoval:\n *       console.log(`Session will be removed at ${session.cancellationTime}`)\n *       break\n *   }\n * }\n * ```\n *\n * @internal\n */\nexport type RoomSession<R extends UnknownRecord, Meta> =\n\t| (RoomSessionBase<R, Meta> & {\n\t\t\t/** Current state of the session */\n\t\t\tstate: typeof RoomSessionState.AwaitingConnectMessage\n\t\t\t/** Timestamp when the session was created */\n\t\t\tsessionStartTime: number\n\t  })\n\t| (RoomSessionBase<R, Meta> & {\n\t\t\t/** Current state of the session */\n\t\t\tstate: typeof RoomSessionState.AwaitingRemoval\n\t\t\t/** Timestamp when the session was marked for removal */\n\t\t\tcancellationTime: number\n\t  })\n\t| (RoomSessionBase<R, Meta> & {\n\t\t\t/** Current state of the session */\n\t\t\tstate: typeof RoomSessionState.Connected\n\t\t\t/** Serialized schema information for this connected session */\n\t\t\tserializedSchema: SerializedSchema\n\t\t\t/** Whether this session requires down migrations */\n\t\t\trequiresDownMigrations: boolean\n\t\t\t/** Timestamp of the last interaction or message from this session */\n\t\t\tlastInteractionTime: number\n\t\t\t/** Timer for debouncing operations, if active */\n\t\t\tdebounceTimer: ReturnType<typeof setTimeout> | null\n\t\t\t/** Queue of data messages waiting to be sent to this session */\n\t\t\toutstandingDataMessages: TLSocketServerSentDataEvent<R>[]\n\t  })\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYO,MAAM,mBAAmB;AAAA;AAAA,EAE/B,wBAAwB;AAAA;AAAA,EAExB,iBAAiB;AAAA;AAAA,EAEjB,WAAW;AACZ;AAyBO,MAAM,0BAA0B;AAUhC,MAAM,4BAA4B;AAUlC,MAAM,uBAAuB;",
   "names": []
 }

package/dist-cjs/lib/TLSocketRoom.js

@@ -23,10 +23,12 @@ __export(TLSocketRoom_exports, {
 module.exports = __toCommonJS(TLSocketRoom_exports);
 var import_tlschema = require("@tldraw/tlschema");
 var import_utils = require("@tldraw/utils");
+var import_InMemorySyncStorage = require("./InMemorySyncStorage");
 var import_RoomSession = require("./RoomSession");
 var import_ServerSocketAdapter = require("./ServerSocketAdapter");
 var import_TLSyncClient = require("./TLSyncClient");
 var import_TLSyncRoom = require("./TLSyncRoom");
+var import_TLSyncStorage = require("./TLSyncStorage");
 var import_chunk = require("./chunk");
 class TLSocketRoom {
   /**
@@ -45,17 +47,29 @@ class TLSocketRoom {
    */
   constructor(opts) {
     this.opts = opts;
-    const initialSnapshot = opts.initialSnapshot && "store" in opts.initialSnapshot ? convertStoreSnapshotToRoomSnapshot(opts.initialSnapshot) : opts.initialSnapshot;
-    this.syncCallbacks = {
-      onDataChange: opts.onDataChange,
-      onPresenceChange: opts.onPresenceChange
-    };
+    if (opts.storage && opts.initialSnapshot) {
+      throw new Error("Cannot provide both storage and initialSnapshot options");
+    }
+    const storage = opts.storage ? opts.storage : new import_InMemorySyncStorage.InMemorySyncStorage({
+      snapshot: (0, import_TLSyncStorage.convertStoreSnapshotToRoomSnapshot)(
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        opts.initialSnapshot ?? import_InMemorySyncStorage.DEFAULT_INITIAL_SNAPSHOT
+      )
+    });
+    if ("onDataChange" in opts && opts.onDataChange) {
+      this.disposables.add(
+        storage.onChange(() => {
+          opts.onDataChange?.();
+        })
+      );
+    }
     this.room = new import_TLSyncRoom.TLSyncRoom({
-      ...this.syncCallbacks,
+      onPresenceChange: opts.onPresenceChange,
       schema: opts.schema ?? (0, import_tlschema.createTLSchema)(),
-      snapshot: initialSnapshot,
-      log: opts.log
+      log: opts.log,
+      storage
     });
+    this.storage = storage;
     this.room.events.on("session_removed", (args) => {
       this.sessions.delete(args.sessionId);
       if (this.opts.onSessionRemoved) {
@@ -71,7 +85,8 @@ class TLSocketRoom {
   room;
   sessions = /* @__PURE__ */ new Map();
   log;
-  syncCallbacks;
+  storage;
+  disposables = /* @__PURE__ */ new Set();
   /**
    * Returns the number of active sessions.
    * Note that this is not the same as the number of connected sockets!
@@ -255,7 +270,7 @@ class TLSocketRoom {
    * ```
    */
   getCurrentDocumentClock() {
-    return this.room.documentClock;
+    return this.storage.getClock();
   }
   /**
    * Retrieves a deeply cloned copy of a record from the document store.
@@ -276,7 +291,9 @@ class TLSocketRoom {
    * ```
    */
   getRecord(id) {
-    return (0, import_utils.structuredClone)(this.room.documents.get(id)?.state);
+    return this.storage.transaction((txn) => {
+      return (0, import_utils.structuredClone)(txn.get(id));
+    }).result;
   }
   /**
    * Returns information about all active sessions in the room. Each session
@@ -317,6 +334,7 @@ class TLSocketRoom {
    * to restore the room state later or revert to a previous version.
    *
    * @returns Complete room snapshot including documents, clock values, and tombstones
+   * @deprecated if you need to do this use
    *
    * @example
    * ```ts
@@ -330,7 +348,10 @@ class TLSocketRoom {
    * ```
    */
   getCurrentSnapshot() {
-    return this.room.getSnapshot();
+    if (this.storage.getSnapshot) {
+      return this.storage.getSnapshot();
+    }
+    throw new Error("getCurrentSnapshot is not supported for this storage type");
   }
   /**
    * Retrieves all presence records from the document store. Presence records
@@ -341,23 +362,11 @@ class TLSocketRoom {
    */
   getPresenceRecords() {
     const result = {};
-    for (const document of this.room.documents.values()) {
-      if (document.state.typeName === this.room.presenceType?.typeName) {
-        result[document.state.id] = document.state;
-      }
+    for (const presence of this.room.presenceStore.values()) {
+      result[presence.id] = presence;
     }
     return result;
   }
-  /**
-   * Returns a JSON-serialized snapshot of the current document state. This is
-   * equivalent to JSON.stringify(getCurrentSnapshot()) but provided as a convenience.
-   *
-   * @returns JSON string representation of the room snapshot
-   * @internal
-   */
-  getCurrentSerializedSnapshot() {
-    return JSON.stringify(this.room.getSnapshot());
-  }
   /**
    * Loads a document snapshot, completely replacing the current room state.
    * This will disconnect all current clients and update the document to match
@@ -377,39 +386,9 @@ class TLSocketRoom {
    * ```
    */
   loadSnapshot(snapshot) {
-    if ("store" in snapshot) {
-      snapshot = convertStoreSnapshotToRoomSnapshot(snapshot);
-    }
-    const oldRoom = this.room;
-    const oldRoomSnapshot = oldRoom.getSnapshot();
-    const oldIds = oldRoomSnapshot.documents.map((d) => d.state.id);
-    const newIds = new Set(snapshot.documents.map((d) => d.state.id));
-    const removedIds = oldIds.filter((id) => !newIds.has(id));
-    const tombstones = { ...oldRoomSnapshot.tombstones };
-    removedIds.forEach((id) => {
-      tombstones[id] = oldRoom.clock + 1;
-    });
-    newIds.forEach((id) => {
-      delete tombstones[id];
-    });
-    const newRoom = new import_TLSyncRoom.TLSyncRoom({
-      ...this.syncCallbacks,
-      schema: oldRoom.schema,
-      snapshot: {
-        clock: oldRoom.clock + 1,
-        documentClock: oldRoom.clock + 1,
-        documents: snapshot.documents.map((d) => ({
-          lastChangedClock: oldRoom.clock + 1,
-          state: d.state
-        })),
-        schema: snapshot.schema,
-        tombstones,
-        tombstoneHistoryStartsAtClock: oldRoomSnapshot.tombstoneHistoryStartsAtClock
-      },
-      log: this.log
+    this.storage.transaction((txn) => {
+      (0, import_TLSyncStorage.loadSnapshotIntoStorage)(txn, this.room.schema, snapshot);
     });
-    this.room = newRoom;
-    oldRoom.close();
   }
   /**
    * Executes a transaction to modify the document store. Changes made within the
@@ -453,9 +432,31 @@ class TLSocketRoom {
    *   }
    * })
    * ```
+   * @deprecated use the storage.transaction method instead
    */
+  // eslint-disable-next-line @typescript-eslint/no-deprecated
   async updateStore(updater) {
-    return this.room.updateStore(updater);
+    if (this.isClosed()) {
+      throw new Error("Cannot update store on a closed room");
+    }
+    const ctx = new StoreUpdateContext(
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      Object.fromEntries(this.getCurrentSnapshot().documents.map((d) => [d.state.id, d.state])),
+      this.room.schema
+    );
+    try {
+      await updater(ctx);
+    } finally {
+      ctx.close();
+    }
+    this.storage.transaction((txn) => {
+      for (const [id, record] of Object.entries(ctx.updates.puts)) {
+        txn.set(id, record);
+      }
+      for (const id of ctx.updates.deletes) {
+        txn.delete(id);
+      }
+    });
   }
   /**
    * Sends a custom message to a specific client session. This allows sending
@@ -529,6 +530,8 @@ class TLSocketRoom {
    */
   close() {
     this.room.close();
+    this.disposables.forEach((d) => d());
+    this.disposables.clear();
   }
   /**
    * Checks whether the room has been permanently closed. Closed rooms cannot
@@ -551,16 +554,61 @@ class TLSocketRoom {
     return this.room.isClosed();
   }
 }
-function convertStoreSnapshotToRoomSnapshot(snapshot) {
-  return {
-    clock: 0,
-    documentClock: 0,
-    documents: (0, import_utils.objectMapValues)(snapshot.store).map((state) => ({
-      state,
-      lastChangedClock: 0
-    })),
-    schema: snapshot.schema,
-    tombstones: {}
+class StoreUpdateContext {
+  constructor(snapshot, schema) {
+    this.snapshot = snapshot;
+    this.schema = schema;
+  }
+  updates = {
+    puts: {},
+    deletes: /* @__PURE__ */ new Set()
   };
+  put(record) {
+    if (this._isClosed) throw new Error("StoreUpdateContext is closed");
+    const recordType = (0, import_utils.getOwnProperty)(this.schema.types, record.typeName);
+    if (!recordType) {
+      throw new Error(`Missing definition for record type ${record.typeName}`);
+    }
+    const recordBefore = this.snapshot[record.id] ?? void 0;
+    recordType.validate(record, recordBefore);
+    if (record.id in this.snapshot && (0, import_utils.isEqual)(this.snapshot[record.id], record)) {
+      delete this.updates.puts[record.id];
+    } else {
+      this.updates.puts[record.id] = (0, import_utils.structuredClone)(record);
+    }
+    this.updates.deletes.delete(record.id);
+  }
+  delete(recordOrId) {
+    if (this._isClosed) throw new Error("StoreUpdateContext is closed");
+    const id = typeof recordOrId === "string" ? recordOrId : recordOrId.id;
+    delete this.updates.puts[id];
+    if (this.snapshot[id]) {
+      this.updates.deletes.add(id);
+    }
+  }
+  get(id) {
+    if (this._isClosed) throw new Error("StoreUpdateContext is closed");
+    if ((0, import_utils.hasOwnProperty)(this.updates.puts, id)) {
+      return (0, import_utils.structuredClone)(this.updates.puts[id]);
+    }
+    if (this.updates.deletes.has(id)) {
+      return null;
+    }
+    return (0, import_utils.structuredClone)(this.snapshot[id] ?? null);
+  }
+  getAll() {
+    if (this._isClosed) throw new Error("StoreUpdateContext is closed");
+    const result = Object.values(this.updates.puts);
+    for (const [id, record] of Object.entries(this.snapshot)) {
+      if (!this.updates.deletes.has(id) && !(0, import_utils.hasOwnProperty)(this.updates.puts, id)) {
+        result.push(record);
+      }
+    }
+    return (0, import_utils.structuredClone)(result);
+  }
+  _isClosed = false;
+  close() {
+    this._isClosed = true;
+  }
 }
 //# sourceMappingURL=TLSocketRoom.js.map