@liveblocks/core 2.14.0 → 2.15.0

package/dist/index.mjs

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "2.14.0";
+var PKG_VERSION = "2.15.0";
 var PKG_FORMAT = "esm";
 
 // src/dupe-detection.ts
@@ -304,19 +304,6 @@ function Promise_withResolvers() {
 // src/lib/EventSource.ts
 function makeEventSource() {
   const _observers = /* @__PURE__ */ new Set();
-  let _buffer = null;
-  function pause() {
-    _buffer = [];
-  }
-  function unpause() {
-    if (_buffer === null) {
-      return;
-    }
-    for (const event of _buffer) {
-      notify(event);
-    }
-    _buffer = null;
-  }
   function subscribe(callback) {
     _observers.add(callback);
     return () => _observers.delete(callback);
@@ -338,32 +325,22 @@ function makeEventSource() {
       });
     }).finally(() => unsub?.());
   }
-  function notifyOrBuffer(event) {
-    if (_buffer !== null) {
-      _buffer.push(event);
-    } else {
-      notify(event);
-    }
-  }
   function notify(event) {
     _observers.forEach((callback) => callback(event));
   }
-  function _forceClear() {
-    _observers.clear();
-  }
   function count() {
     return _observers.size;
   }
   return {
     // Private/internal control over event emission
-    notify: notifyOrBuffer,
+    notify,
     subscribe,
     subscribeOnce,
-    _forceClear,
     count,
     waitUntil,
-    pause,
-    unpause,
+    [Symbol.dispose]: () => {
+      _observers.clear();
+    },
     // Publicly exposable subscription API
     observable: {
       subscribe,
@@ -372,6 +349,41 @@ function makeEventSource() {
     }
   };
 }
+function makeBufferableEventSource() {
+  const eventSource2 = makeEventSource();
+  let _buffer = null;
+  function pause() {
+    _buffer = [];
+  }
+  function unpause() {
+    if (_buffer === null) {
+      return;
+    }
+    for (const event of _buffer) {
+      eventSource2.notify(event);
+    }
+    _buffer = null;
+  }
+  function notifyOrBuffer(event) {
+    if (_buffer !== null) {
+      _buffer.push(event);
+    } else {
+      eventSource2.notify(event);
+    }
+  }
+  return {
+    ...eventSource2,
+    notify: notifyOrBuffer,
+    pause,
+    unpause,
+    [Symbol.dispose]: () => {
+      eventSource2[Symbol.dispose]();
+      if (_buffer !== null) {
+        _buffer.length = 0;
+      }
+    }
+  };
+}
 
 // src/lib/stringify.ts
 function stringify(object, ...args) {
@@ -391,6 +403,10 @@ function stringify(object, ...args) {
 // src/lib/batch.ts
 var DEFAULT_SIZE = 50;
 var BatchCall = class {
+  input;
+  resolve;
+  reject;
+  promise;
   constructor(input) {
     this.input = input;
     const { promise, resolve, reject } = Promise_withResolvers();
@@ -400,35 +416,39 @@ var BatchCall = class {
   }
 };
 var Batch = class {
+  #queue = [];
+  #callback;
+  #size;
+  #delay;
+  #delayTimeoutId;
+  error = false;
   constructor(callback, options) {
-    this.queue = [];
-    this.error = false;
-    this.callback = callback;
-    this.size = options.size ?? DEFAULT_SIZE;
-    this.delay = options.delay;
+    this.#callback = callback;
+    this.#size = options.size ?? DEFAULT_SIZE;
+    this.#delay = options.delay;
   }
-  clearDelayTimeout() {
-    if (this.delayTimeoutId !== void 0) {
-      clearTimeout(this.delayTimeoutId);
-      this.delayTimeoutId = void 0;
+  #clearDelayTimeout() {
+    if (this.#delayTimeoutId !== void 0) {
+      clearTimeout(this.#delayTimeoutId);
+      this.#delayTimeoutId = void 0;
     }
   }
-  schedule() {
-    if (this.queue.length === this.size) {
-      void this.flush();
-    } else if (this.queue.length === 1) {
-      this.clearDelayTimeout();
-      this.delayTimeoutId = setTimeout(() => void this.flush(), this.delay);
+  #schedule() {
+    if (this.#queue.length === this.#size) {
+      void this.#flush();
+    } else if (this.#queue.length === 1) {
+      this.#clearDelayTimeout();
+      this.#delayTimeoutId = setTimeout(() => void this.#flush(), this.#delay);
     }
   }
-  async flush() {
-    if (this.queue.length === 0) {
+  async #flush() {
+    if (this.#queue.length === 0) {
       return;
     }
-    const calls = this.queue.splice(0);
+    const calls = this.#queue.splice(0);
     const inputs = calls.map((call) => call.input);
     try {
-      const results = await this.callback(inputs);
+      const results = await this.#callback(inputs);
       this.error = false;
       calls.forEach((call, index) => {
         const result = results?.[index];
@@ -454,24 +474,24 @@ var Batch = class {
     }
   }
   get(input) {
-    const existingCall = this.queue.find(
+    const existingCall = this.#queue.find(
       (call2) => stringify(call2.input) === stringify(input)
     );
     if (existingCall) {
       return existingCall.promise;
     }
     const call = new BatchCall(input);
-    this.queue.push(call);
-    this.schedule();
+    this.#queue.push(call);
+    this.#schedule();
     return call.promise;
   }
   clear() {
-    this.queue = [];
+    this.#queue = [];
     this.error = false;
-    this.clearDelayTimeout();
+    this.#clearDelayTimeout();
   }
 };
-function createBatchStore(batch) {
+function createBatchStore(batch2) {
   const cache = /* @__PURE__ */ new Map();
   const eventSource2 = makeEventSource();
   function getCacheKey(args) {
@@ -498,7 +518,7 @@ function createBatchStore(batch) {
     }
     try {
       setStateAndNotify(cacheKey, { isLoading: true });
-      const result = await batch.get(input);
+      const result = await batch2.get(input);
       setStateAndNotify(cacheKey, { isLoading: false, data: result });
     } catch (error3) {
       setStateAndNotify(cacheKey, {
@@ -515,7 +535,7 @@ function createBatchStore(batch) {
     return [...cache.keys()];
   }
   function getBatch() {
-    return batch;
+    return batch2;
   }
   return {
     ...eventSource2.observable,
@@ -1067,7 +1087,7 @@ function createApiClient({
   function getOrCreateAttachmentUrlsStore(roomId) {
     let store = getAttachmentUrlsBatchStoreByRoom.get(roomId);
     if (store === void 0) {
-      const batch = new Batch(
+      const batch2 = new Batch(
         async (batchedAttachmentIds) => {
           const attachmentIds = batchedAttachmentIds.flat();
           const { urls } = await httpClient.post(
@@ -1090,14 +1110,14 @@ function createApiClient({
           delay: 50
         }
       );
-      store = createBatchStore(batch);
+      store = createBatchStore(batch2);
       getAttachmentUrlsBatchStoreByRoom.set(roomId, store);
     }
     return store;
   }
   function getAttachmentUrl(options) {
-    const batch = getOrCreateAttachmentUrlsStore(options.roomId).getBatch();
-    return batch.get(options.attachmentId);
+    const batch2 = getOrCreateAttachmentUrlsStore(options.roomId).getBatch();
+    return batch2.get(options.attachmentId);
   }
   async function getNotificationSettings(options) {
     return httpClient.get(
@@ -1124,9 +1144,9 @@ function createApiClient({
   }
   const markInboxNotificationsAsReadBatchByRoom = /* @__PURE__ */ new Map();
   function getOrCreateMarkInboxNotificationsAsReadBatch(roomId) {
-    let batch = markInboxNotificationsAsReadBatchByRoom.get(roomId);
-    if (batch === void 0) {
-      batch = new Batch(
+    let batch2 = markInboxNotificationsAsReadBatchByRoom.get(roomId);
+    if (batch2 === void 0) {
+      batch2 = new Batch(
         async (batchedInboxNotificationIds) => {
           const inboxNotificationIds = batchedInboxNotificationIds.flat();
           await httpClient.post(
@@ -1143,13 +1163,13 @@ function createApiClient({
           delay: 50
         }
       );
-      markInboxNotificationsAsReadBatchByRoom.set(roomId, batch);
+      markInboxNotificationsAsReadBatchByRoom.set(roomId, batch2);
     }
-    return batch;
+    return batch2;
   }
   async function markRoomInboxNotificationAsRead(options) {
-    const batch = getOrCreateMarkInboxNotificationsAsReadBatch(options.roomId);
-    return batch.get(options.inboxNotificationId);
+    const batch2 = getOrCreateMarkInboxNotificationsAsReadBatch(options.roomId);
+    return batch2.get(options.inboxNotificationId);
   }
   async function createTextMention(options) {
     await httpClient.rawPost(
@@ -1455,9 +1475,11 @@ function getBearerTokenFromAuthValue(authValue) {
   }
 }
 var HttpClient = class {
+  #baseUrl;
+  #fetchPolyfill;
   constructor(baseUrl, fetchPolyfill) {
-    this._baseUrl = baseUrl;
-    this._fetchPolyfill = fetchPolyfill;
+    this.#baseUrl = baseUrl;
+    this.#fetchPolyfill = fetchPolyfill;
   }
   // ------------------------------------------------------------------
   // Public methods
@@ -1475,12 +1497,12 @@ var HttpClient = class {
    *   5. ...but silently return `{}` if that parsing fails
    *   6. Throw HttpError if response is an error
    */
-  async rawFetch(endpoint, authValue, options, params) {
+  async #rawFetch(endpoint, authValue, options, params) {
     if (!endpoint.startsWith("/v2/c/")) {
       raise("This client can only be used to make /v2/c/* requests");
     }
-    const url2 = urljoin(this._baseUrl, endpoint, params);
-    return await this._fetchPolyfill(url2, {
+    const url2 = urljoin(this.#baseUrl, endpoint, params);
+    return await this.#fetchPolyfill(url2, {
       ...options,
       headers: {
         // These headers are default, but can be overriden by custom headers
@@ -1507,8 +1529,8 @@ var HttpClient = class {
    *   5. ...but silently return `{}` if that parsing fails (🤔)
    *   6. Throw HttpError if response is an error
    */
-  async fetch(endpoint, authValue, options, params) {
-    const response = await this.rawFetch(endpoint, authValue, options, params);
+  async #fetch(endpoint, authValue, options, params) {
+    const response = await this.#rawFetch(endpoint, authValue, options, params);
     if (!response.ok) {
       let error3;
       try {
@@ -1533,7 +1555,7 @@ var HttpClient = class {
    * @deprecated Ideally, use .get() instead.
    */
   async rawGet(endpoint, authValue, params, options) {
-    return await this.rawFetch(endpoint, authValue, options, params);
+    return await this.#rawFetch(endpoint, authValue, options, params);
   }
   /**
    * Makes a POST request and returns the raw response.
@@ -1541,7 +1563,7 @@ var HttpClient = class {
    * @deprecated Ideally, use .post() instead.
    */
   async rawPost(endpoint, authValue, body) {
-    return await this.rawFetch(endpoint, authValue, {
+    return await this.#rawFetch(endpoint, authValue, {
       method: "POST",
       body: JSON.stringify(body)
     });
@@ -1552,21 +1574,21 @@ var HttpClient = class {
    * @deprecated Ideally, use .delete() instead.
    */
   async rawDelete(endpoint, authValue) {
-    return await this.rawFetch(endpoint, authValue, { method: "DELETE" });
+    return await this.#rawFetch(endpoint, authValue, { method: "DELETE" });
   }
   /**
    * Makes a GET request, and return the JSON response.
    * Will throw if the reponse is a non-2xx.
    */
   async get(endpoint, authValue, params, options) {
-    return await this.fetch(endpoint, authValue, options, params);
+    return await this.#fetch(endpoint, authValue, options, params);
   }
   /**
    * Makes a POST request, and return the JSON response.
    * Will throw if the reponse is a non-2xx.
    */
   async post(endpoint, authValue, body, options, params) {
-    return await this.fetch(
+    return await this.#fetch(
       endpoint,
       authValue,
       {
@@ -1582,14 +1604,14 @@ var HttpClient = class {
    * Will throw if the reponse is a non-2xx.
    */
   async delete(endpoint, authValue) {
-    return await this.fetch(endpoint, authValue, { method: "DELETE" });
+    return await this.#fetch(endpoint, authValue, { method: "DELETE" });
   }
   /**
    * Makes a PUT request for a Blob body, and return the JSON response.
    * Will throw if the reponse is a non-2xx.
    */
   async putBlob(endpoint, authValue, blob, params, options) {
-    return await this.fetch(
+    return await this.#fetch(
       endpoint,
       authValue,
       {
@@ -1660,11 +1682,12 @@ function patterns(targetState, levels) {
   return result;
 }
 var SafeContext = class {
+  #curr;
   constructor(initialContext) {
-    this.curr = initialContext;
+    this.#curr = initialContext;
   }
   get current() {
-    return this.curr;
+    return this.#curr;
   }
   /**
    * Call a callback function that allows patching of the context, by
@@ -1675,10 +1698,10 @@ var SafeContext = class {
     const self = this;
     let allowed = true;
     const patchableContext = {
-      ...this.curr,
+      ...this.#curr,
       patch(patch) {
         if (allowed) {
-          self.curr = Object.assign({}, self.curr, patch);
+          self.#curr = Object.assign({}, self.#curr, patch);
           for (const pair of Object.entries(patch)) {
             const [key, value] = pair;
             if (key !== "patch") {
@@ -1697,12 +1720,42 @@ var SafeContext = class {
 };
 var nextId = 1;
 var FSM = class {
+  id;
+  // Indicates whether this state machine is still being configured, has
+  // started, or has terminated
+  #runningState;
+  #currentContext;
+  #states;
+  #currentStateOrNull;
+  #allowedTransitions;
+  #eventHub;
+  events;
+  //
+  // The cleanup stack is a stack of (optional) callback functions that will
+  // be run when exiting the current state. If a state (or state group) does
+  // not have an exit handler, then the entry for that level may be
+  // `undefined`, but there will be an explicit entry in the stack for it.
+  //
+  // This will always be true:
+  //
+  //   cleanupStack.length == currentState.split('.').length + 1
+  //
+  // Each stack level represents a different state "group".
+  //
+  // For example, if you are in a state named `foo.bar.qux`, then the stack
+  // will contain the exit handler for `foo.bar.qux` (at the top), then
+  // `foo.bar.*`, then `foo.*`, and finally, `*`.
+  //
+  #cleanupStack;
+  #enterFns;
+  // Used to provide better error messages
+  #knownEventTypes;
   /**
    * Returns the initial state, which is defined by the first call made to
    * .addState().
    */
-  get initialState() {
-    const result = this.states.values()[Symbol.iterator]().next();
+  get #initialState() {
+    const result = this.#states.values()[Symbol.iterator]().next();
     if (result.done) {
       throw new Error("No states defined yet");
     } else {
@@ -1710,25 +1763,25 @@ var FSM = class {
     }
   }
   get currentState() {
-    if (this.currentStateOrNull === null) {
-      if (this.runningState === 0 /* NOT_STARTED_YET */) {
+    if (this.#currentStateOrNull === null) {
+      if (this.#runningState === 0 /* NOT_STARTED_YET */) {
         throw new Error("Not started yet");
       } else {
         throw new Error("Already stopped");
       }
     }
-    return this.currentStateOrNull;
+    return this.#currentStateOrNull;
   }
   /**
    * Starts the machine by entering the initial state.
    */
   start() {
-    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+    if (this.#runningState !== 0 /* NOT_STARTED_YET */) {
       throw new Error("State machine has already started");
     }
-    this.runningState = 1 /* STARTED */;
-    this.currentStateOrNull = this.initialState;
-    this.enter(null);
+    this.#runningState = 1 /* STARTED */;
+    this.#currentStateOrNull = this.#initialState;
+    this.#enter(null);
     return this;
   }
   /**
@@ -1736,24 +1789,24 @@ var FSM = class {
    * handlers for the current state, but not enter a new state.
    */
   stop() {
-    if (this.runningState !== 1 /* STARTED */) {
+    if (this.#runningState !== 1 /* STARTED */) {
       throw new Error("Cannot stop a state machine that hasn't started yet");
     }
-    this.exit(null);
-    this.runningState = 2 /* STOPPED */;
-    this.currentStateOrNull = null;
+    this.#exit(null);
+    this.#runningState = 2 /* STOPPED */;
+    this.#currentStateOrNull = null;
   }
   constructor(initialContext) {
     this.id = nextId++;
-    this.runningState = 0 /* NOT_STARTED_YET */;
-    this.currentStateOrNull = null;
-    this.states = /* @__PURE__ */ new Set();
-    this.enterFns = /* @__PURE__ */ new Map();
-    this.cleanupStack = [];
-    this.knownEventTypes = /* @__PURE__ */ new Set();
-    this.allowedTransitions = /* @__PURE__ */ new Map();
-    this.currentContext = new SafeContext(initialContext);
-    this.eventHub = {
+    this.#runningState = 0 /* NOT_STARTED_YET */;
+    this.#currentStateOrNull = null;
+    this.#states = /* @__PURE__ */ new Set();
+    this.#enterFns = /* @__PURE__ */ new Map();
+    this.#cleanupStack = [];
+    this.#knownEventTypes = /* @__PURE__ */ new Set();
+    this.#allowedTransitions = /* @__PURE__ */ new Map();
+    this.#currentContext = new SafeContext(initialContext);
+    this.#eventHub = {
       didReceiveEvent: makeEventSource(),
       willTransition: makeEventSource(),
       didIgnoreEvent: makeEventSource(),
@@ -1761,30 +1814,30 @@ var FSM = class {
       didEnterState: makeEventSource()
     };
     this.events = {
-      didReceiveEvent: this.eventHub.didReceiveEvent.observable,
-      willTransition: this.eventHub.willTransition.observable,
-      didIgnoreEvent: this.eventHub.didIgnoreEvent.observable,
-      willExitState: this.eventHub.willExitState.observable,
-      didEnterState: this.eventHub.didEnterState.observable
+      didReceiveEvent: this.#eventHub.didReceiveEvent.observable,
+      willTransition: this.#eventHub.willTransition.observable,
+      didIgnoreEvent: this.#eventHub.didIgnoreEvent.observable,
+      willExitState: this.#eventHub.willExitState.observable,
+      didEnterState: this.#eventHub.didEnterState.observable
     };
   }
   get context() {
-    return this.currentContext.current;
+    return this.#currentContext.current;
   }
   /**
    * Define an explicit finite state in the state machine.
    */
   addState(state) {
-    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+    if (this.#runningState !== 0 /* NOT_STARTED_YET */) {
       throw new Error("Already started");
     }
-    this.states.add(state);
+    this.#states.add(state);
     return this;
   }
   onEnter(nameOrPattern, enterFn) {
-    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+    if (this.#runningState !== 0 /* NOT_STARTED_YET */) {
       throw new Error("Already started");
-    } else if (this.enterFns.has(nameOrPattern)) {
+    } else if (this.#enterFns.has(nameOrPattern)) {
       throw new Error(
         // TODO We _currently_ don't support multiple .onEnters() for the same
         // state, but this is not a fundamental limitation. Just not
@@ -1792,7 +1845,7 @@ var FSM = class {
         `enter/exit function for ${nameOrPattern} already exists`
       );
     }
-    this.enterFns.set(nameOrPattern, enterFn);
+    this.#enterFns.set(nameOrPattern, enterFn);
     return this;
   }
   /**
@@ -1826,22 +1879,22 @@ var FSM = class {
       const signal = abortController.signal;
       const timeoutId = maxTimeout ? setTimeout(() => {
         const reason = new Error("Timed out");
-        this.transition({ type: "ASYNC_ERROR", reason }, onError);
+        this.#transition({ type: "ASYNC_ERROR", reason }, onError);
       }, maxTimeout) : void 0;
       let done = false;
-      void promiseFn(this.currentContext.current, signal).then(
+      void promiseFn(this.#currentContext.current, signal).then(
         // On OK
         (data) => {
           if (!signal.aborted) {
             done = true;
-            this.transition({ type: "ASYNC_OK", data }, onOK);
+            this.#transition({ type: "ASYNC_OK", data }, onOK);
           }
         },
         // On Error
         (reason) => {
           if (!signal.aborted) {
             done = true;
-            this.transition({ type: "ASYNC_ERROR", reason }, onError);
+            this.#transition({ type: "ASYNC_ERROR", reason }, onError);
           }
         }
       );
@@ -1853,22 +1906,22 @@ var FSM = class {
       };
     });
   }
-  getStatesMatching(nameOrPattern) {
+  #getStatesMatching(nameOrPattern) {
     const matches = [];
     if (nameOrPattern === "*") {
-      for (const state of this.states) {
+      for (const state of this.#states) {
         matches.push(state);
       }
     } else if (nameOrPattern.endsWith(".*")) {
       const prefix = nameOrPattern.slice(0, -1);
-      for (const state of this.states) {
+      for (const state of this.#states) {
         if (state.startsWith(prefix)) {
           matches.push(state);
         }
       }
     } else {
       const name = nameOrPattern;
-      if (this.states.has(name)) {
+      if (this.#states.has(name)) {
         matches.push(name);
       }
     }
@@ -1890,14 +1943,14 @@ var FSM = class {
    * such events will get ignored.
    */
   addTransitions(nameOrPattern, mapping) {
-    if (this.runningState !== 0 /* NOT_STARTED_YET */) {
+    if (this.#runningState !== 0 /* NOT_STARTED_YET */) {
       throw new Error("Already started");
     }
-    for (const srcState of this.getStatesMatching(nameOrPattern)) {
-      let map = this.allowedTransitions.get(srcState);
+    for (const srcState of this.#getStatesMatching(nameOrPattern)) {
+      let map = this.#allowedTransitions.get(srcState);
       if (map === void 0) {
         map = /* @__PURE__ */ new Map();
-        this.allowedTransitions.set(srcState, map);
+        this.#allowedTransitions.set(srcState, map);
       }
       for (const [type, target_] of Object.entries(mapping)) {
         if (map.has(type)) {
@@ -1906,7 +1959,7 @@ var FSM = class {
           );
         }
         const target = target_;
-        this.knownEventTypes.add(type);
+        this.#knownEventTypes.add(type);
         if (target !== void 0) {
           const targetFn = typeof target === "function" ? target : () => target;
           map.set(type, targetFn);
@@ -1927,17 +1980,17 @@ var FSM = class {
    */
   addTimedTransition(stateOrPattern, after2, target) {
     return this.onEnter(stateOrPattern, () => {
-      const ms = typeof after2 === "function" ? after2(this.currentContext.current) : after2;
+      const ms = typeof after2 === "function" ? after2(this.#currentContext.current) : after2;
       const timeoutID = setTimeout(() => {
-        this.transition({ type: "TIMER" }, target);
+        this.#transition({ type: "TIMER" }, target);
       }, ms);
       return () => {
         clearTimeout(timeoutID);
       };
     });
   }
-  getTargetFn(eventName) {
-    return this.allowedTransitions.get(this.currentState)?.get(eventName);
+  #getTargetFn(eventName) {
+    return this.#allowedTransitions.get(this.currentState)?.get(eventName);
   }
   /**
    * Exits the current state, and executes any necessary cleanup functions.
@@ -1949,12 +2002,12 @@ var FSM = class {
    * `foo.bar.qux` to `bla.bla`, then the level is 3.
    * If `null`, it will exit all levels.
    */
-  exit(levels) {
-    this.eventHub.willExitState.notify(this.currentState);
-    this.currentContext.allowPatching((patchableContext) => {
-      levels = levels ?? this.cleanupStack.length;
+  #exit(levels) {
+    this.#eventHub.willExitState.notify(this.currentState);
+    this.#currentContext.allowPatching((patchableContext) => {
+      levels = levels ?? this.#cleanupStack.length;
       for (let i = 0; i < levels; i++) {
-        this.cleanupStack.pop()?.(patchableContext);
+        this.#cleanupStack.pop()?.(patchableContext);
       }
     });
   }
@@ -1962,51 +2015,51 @@ var FSM = class {
    * Enters the current state, and executes any necessary onEnter handlers.
    * Call this directly _after_ setting the current state to the next state.
    */
-  enter(levels) {
+  #enter(levels) {
     const enterPatterns = patterns(
       this.currentState,
       levels ?? this.currentState.split(".").length + 1
     );
-    this.currentContext.allowPatching((patchableContext) => {
+    this.#currentContext.allowPatching((patchableContext) => {
       for (const pattern of enterPatterns) {
-        const enterFn = this.enterFns.get(pattern);
+        const enterFn = this.#enterFns.get(pattern);
         const cleanupFn = enterFn?.(patchableContext);
         if (typeof cleanupFn === "function") {
-          this.cleanupStack.push(cleanupFn);
+          this.#cleanupStack.push(cleanupFn);
         } else {
-          this.cleanupStack.push(null);
+          this.#cleanupStack.push(null);
         }
       }
     });
-    this.eventHub.didEnterState.notify(this.currentState);
+    this.#eventHub.didEnterState.notify(this.currentState);
   }
   /**
    * Sends an event to the machine, which may cause an internal state
    * transition to happen. When that happens, will trigger side effects.
    */
   send(event) {
-    if (!this.knownEventTypes.has(event.type)) {
+    if (!this.#knownEventTypes.has(event.type)) {
       throw new Error(`Invalid event ${JSON.stringify(event.type)}`);
     }
-    if (this.runningState === 2 /* STOPPED */) {
+    if (this.#runningState === 2 /* STOPPED */) {
       return;
     }
-    const targetFn = this.getTargetFn(event.type);
+    const targetFn = this.#getTargetFn(event.type);
     if (targetFn !== void 0) {
-      return this.transition(event, targetFn);
+      return this.#transition(event, targetFn);
     } else {
-      this.eventHub.didIgnoreEvent.notify(event);
+      this.#eventHub.didIgnoreEvent.notify(event);
     }
   }
-  transition(event, target) {
-    this.eventHub.didReceiveEvent.notify(event);
+  #transition(event, target) {
+    this.#eventHub.didReceiveEvent.notify(event);
     const oldState = this.currentState;
     const targetFn = typeof target === "function" ? target : () => target;
-    const nextTarget = targetFn(event, this.currentContext.current);
+    const nextTarget = targetFn(event, this.#currentContext.current);
     let nextState;
     let effects = void 0;
     if (nextTarget === null) {
-      this.eventHub.didIgnoreEvent.notify(event);
+      this.#eventHub.didIgnoreEvent.notify(event);
       return;
     }
     if (typeof nextTarget === "string") {
@@ -2015,18 +2068,18 @@ var FSM = class {
       nextState = nextTarget.target;
       effects = Array.isArray(nextTarget.effect) ? nextTarget.effect : [nextTarget.effect];
     }
-    if (!this.states.has(nextState)) {
+    if (!this.#states.has(nextState)) {
       throw new Error(`Invalid next state name: ${JSON.stringify(nextState)}`);
     }
-    this.eventHub.willTransition.notify({ from: oldState, to: nextState });
+    this.#eventHub.willTransition.notify({ from: oldState, to: nextState });
     const [up, down] = distance(this.currentState, nextState);
     if (up > 0) {
-      this.exit(up);
+      this.#exit(up);
     }
-    this.currentStateOrNull = nextState;
+    this.#currentStateOrNull = nextState;
     if (effects !== void 0) {
       const effectsToRun = effects;
-      this.currentContext.allowPatching((patchableContext) => {
+      this.#currentContext.allowPatching((patchableContext) => {
         for (const effect of effectsToRun) {
           if (typeof effect === "function") {
             effect(patchableContext, event);
@@ -2037,7 +2090,7 @@ var FSM = class {
       });
     }
     if (down > 0) {
-      this.enter(down);
+      this.#enter(down);
     }
   }
 };
@@ -2243,7 +2296,7 @@ function defineConnectivityEvents(machine) {
 }
 var assign = (patch) => (ctx) => ctx.patch(patch);
 function createConnectionStateMachine(delegates, options) {
-  const onMessage = makeEventSource();
+  const onMessage = makeBufferableEventSource();
   onMessage.pause();
   const onLiveblocksError = makeEventSource();
   function fireErrorEvent(errmsg, errcode) {
@@ -2612,18 +2665,21 @@ function createConnectionStateMachine(delegates, options) {
   };
 }
 var ManagedSocket = class {
+  #machine;
+  #cleanups;
+  events;
   constructor(delegates, enableDebugLogging = false, waitForActorId = true) {
     const { machine, events, cleanups } = createConnectionStateMachine(
       delegates,
       { waitForActorId, enableDebugLogging }
     );
-    this.machine = machine;
+    this.#machine = machine;
     this.events = events;
-    this.cleanups = cleanups;
+    this.#cleanups = cleanups;
   }
   getStatus() {
     try {
-      return toNewConnectionStatus(this.machine);
+      return toNewConnectionStatus(this.#machine);
     } catch {
       return "initial";
     }
@@ -2632,28 +2688,28 @@ var ManagedSocket = class {
    * Returns the current auth authValue.
    */
   get authValue() {
-    return this.machine.context.authValue;
+    return this.#machine.context.authValue;
   }
   /**
    * Call this method to try to connect to a WebSocket. This only has an effect
    * if the machine is idle at the moment, otherwise this is a no-op.
    */
   connect() {
-    this.machine.send({ type: "CONNECT" });
+    this.#machine.send({ type: "CONNECT" });
   }
   /**
    * If idle, will try to connect. Otherwise, it will attempt to reconnect to
    * the socket, potentially obtaining a new authValue first, if needed.
    */
   reconnect() {
-    this.machine.send({ type: "RECONNECT" });
+    this.#machine.send({ type: "RECONNECT" });
   }
   /**
    * Call this method to disconnect from the current WebSocket. Is going to be
    * a no-op if there is no active connection.
    */
   disconnect() {
-    this.machine.send({ type: "DISCONNECT" });
+    this.#machine.send({ type: "DISCONNECT" });
   }
   /**
    * Call this to stop the machine and run necessary cleanup functions. After
@@ -2661,9 +2717,9 @@ var ManagedSocket = class {
    * letting the instance get garbage collected.
    */
   destroy() {
-    this.machine.stop();
+    this.#machine.stop();
     let cleanup;
-    while (cleanup = this.cleanups.pop()) {
+    while (cleanup = this.#cleanups.pop()) {
       cleanup();
     }
   }
@@ -2672,7 +2728,7 @@ var ManagedSocket = class {
    * message if this is somehow impossible.
    */
   send(data) {
-    const socket = this.machine.context?.socket;
+    const socket = this.#machine.context?.socket;
     if (socket === null) {
       warn("Cannot send: not connected yet", data);
     } else if (socket.readyState !== 1) {
@@ -2686,7 +2742,7 @@ var ManagedSocket = class {
    * Not ideal to keep exposed :(
    */
   _privateSendMachineEvent(event) {
-    this.machine.send(event);
+    this.#machine.send(event);
   }
 };
 
@@ -3158,68 +3214,35 @@ function unlinkDevTools(roomId) {
   });
 }
 
-// src/lib/create-store.ts
-function createStore(initialState) {
-  let notifyImmediately = true;
-  let dirty = false;
-  let state = initialState;
-  const subscribers = /* @__PURE__ */ new Set();
-  function get() {
-    return state;
-  }
-  function set(callback) {
-    const oldState = state;
-    const newState = callback(oldState);
-    if (newState !== oldState) {
-      state = newState;
-      dirty = true;
-    }
-    if (notifyImmediately) {
-      notify();
-    }
-  }
-  function notify() {
-    if (!dirty) {
-      return;
-    }
-    dirty = false;
-    for (const subscriber of subscribers) {
-      subscriber(state);
-    }
-  }
-  function batch(cb) {
-    if (notifyImmediately === false) {
-      return cb();
-    }
-    notifyImmediately = false;
-    try {
-      cb();
-    } finally {
-      notifyImmediately = true;
-      notify();
-    }
-  }
-  function subscribe(callback) {
-    subscribers.add(callback);
-    return () => {
-      subscribers.delete(callback);
-    };
-  }
-  return {
-    get,
-    set,
-    batch,
-    subscribe
-  };
-}
-
 // src/lib/freeze.ts
 var freeze = process.env.NODE_ENV === "production" ? (
   /* istanbul ignore next */
   (x) => x
 ) : Object.freeze;
 
-// src/refs/ImmutableRef.ts
+// src/lib/signals.ts
+var kSinks = Symbol("kSinks");
+var kTrigger = Symbol("kTrigger");
+var signalsToTrigger = null;
+function batch(callback) {
+  if (signalsToTrigger !== null) {
+    callback();
+    return;
+  }
+  signalsToTrigger = /* @__PURE__ */ new Set();
+  try {
+    callback();
+  } finally {
+    for (const signal of signalsToTrigger) {
+      signal[kTrigger]();
+    }
+    signalsToTrigger = null;
+  }
+}
+function enqueueTrigger(signal) {
+  if (!signalsToTrigger) raise("Expected to be in an active batch");
+  signalsToTrigger.add(signal);
+}
 function merge(target, patch) {
   let updated = false;
   const newValue = { ...target };
@@ -3237,57 +3260,218 @@ function merge(target, patch) {
   });
   return updated ? newValue : target;
 }
-var ImmutableRef = class {
-  constructor() {
-    this._ev = makeEventSource();
+var AbstractSignal = class {
+  /** @internal */
+  equals;
+  #eventSource;
+  /** @internal */
+  [kSinks];
+  constructor(equals) {
+    this.equals = equals ?? Object.is;
+    this.#eventSource = makeEventSource();
+    this[kSinks] = /* @__PURE__ */ new Set();
+    this.get = this.get.bind(this);
+    this.subscribe = this.subscribe.bind(this);
+    this.subscribeOnce = this.subscribeOnce.bind(this);
+  }
+  [Symbol.dispose]() {
+    this.#eventSource[Symbol.dispose]();
+    this.#eventSource = "(disposed)";
+    this.equals = "(disposed)";
+  }
+  get hasWatchers() {
+    if (this.#eventSource.count() > 0) return true;
+    for (const sink of this[kSinks]) {
+      if (sink.hasWatchers) {
+        return true;
+      }
+    }
+    return false;
   }
-  get didInvalidate() {
-    return this._ev.observable;
+  [kTrigger]() {
+    this.#eventSource.notify();
+    for (const sink of this[kSinks]) {
+      enqueueTrigger(sink);
+    }
   }
-  invalidate() {
-    if (this._cache !== null) {
-      this._cache = null;
-      this._ev.notify();
+  subscribe(callback) {
+    return this.#eventSource.subscribe(callback);
+  }
+  subscribeOnce(callback) {
+    const unsub = this.subscribe(() => {
+      unsub();
+      return callback();
+    });
+    return unsub;
+  }
+  waitUntil() {
+    throw new Error("waitUntil not supported on Signals");
+  }
+  markSinksDirty() {
+    for (const sink of this[kSinks]) {
+      sink.markDirty();
     }
   }
-  get current() {
-    return this._cache ?? (this._cache = this._toImmutable());
+  addSink(sink) {
+    this[kSinks].add(sink);
+  }
+  removeSink(sink) {
+    this[kSinks].delete(sink);
+  }
+  asReadonly() {
+    return this;
   }
 };
-
-// src/refs/ValueRef.ts
-var ValueRef = class extends ImmutableRef {
-  constructor(initialValue) {
-    super();
-    this._value = freeze(initialValue);
+var Signal = class extends AbstractSignal {
+  #value;
+  constructor(value, equals) {
+    super(equals);
+    this.#value = freeze(value);
   }
-  /** @internal */
-  _toImmutable() {
-    return this._value;
+  [Symbol.dispose]() {
+    super[Symbol.dispose]();
+    this.#value = "(disposed)";
+  }
+  get() {
+    return this.#value;
   }
   set(newValue) {
-    if (this._value !== newValue) {
-      this._value = freeze(newValue);
-      this.invalidate();
+    batch(() => {
+      if (typeof newValue === "function") {
+        newValue = newValue(this.#value);
+      }
+      if (!this.equals(this.#value, newValue)) {
+        this.#value = freeze(newValue);
+        this.markSinksDirty();
+        enqueueTrigger(this);
+      }
+    });
+  }
+};
+var PatchableSignal = class extends Signal {
+  constructor(data) {
+    super(freeze(compactObject(data)));
+  }
+  set() {
+    throw new Error("Don't call .set() directly, use .patch()");
+  }
+  /**
+   * Patches the current object.
+   */
+  patch(patch) {
+    super.set((old) => merge(old, patch));
+  }
+};
+var INITIAL = Symbol();
+var DerivedSignal = class _DerivedSignal extends AbstractSignal {
+  #prevValue;
+  #dirty;
+  // When true, the value in #value may not be up-to-date and needs re-checking
+  #parents;
+  #transform;
+  // prettier-ignore
+  static from(...args) {
+    const last = args.pop();
+    if (typeof last !== "function")
+      raise("Invalid .from() call, last argument expected to be a function");
+    if (typeof args[args.length - 1] === "function") {
+      const equals = last;
+      const transform = args.pop();
+      return new _DerivedSignal(args, transform, equals);
+    } else {
+      const transform = last;
+      return new _DerivedSignal(args, transform);
+    }
+  }
+  constructor(parents, transform, equals) {
+    super(equals);
+    this.#dirty = true;
+    this.#prevValue = INITIAL;
+    this.#parents = parents;
+    this.#transform = transform;
+    for (const parent of parents) {
+      parent.addSink(this);
+    }
+  }
+  [Symbol.dispose]() {
+    for (const parent of this.#parents) {
+      parent.removeSink(this);
+    }
+    this.#prevValue = "(disposed)";
+    this.#parents = "(disposed)";
+    this.#transform = "(disposed)";
+  }
+  get isDirty() {
+    return this.#dirty;
+  }
+  #recompute() {
+    const derived = this.#transform(...this.#parents.map((p) => p.get()));
+    this.#dirty = false;
+    if (!this.equals(this.#prevValue, derived)) {
+      this.#prevValue = derived;
+      return true;
+    }
+    return false;
+  }
+  markDirty() {
+    if (!this.#dirty) {
+      this.#dirty = true;
+      this.markSinksDirty();
+    }
+  }
+  get() {
+    if (this.#dirty) {
+      this.#recompute();
+    }
+    return this.#prevValue;
+  }
+  /**
+   * Called by the Signal system if one or more of the dependent signals have
+   * changed. In the case of a DerivedSignal, we'll only want to re-evaluate
+   * the actual value if it's being watched, or any of their sinks are being
+   * watched actively.
+   */
+  [kTrigger]() {
+    if (!this.hasWatchers) {
+      return;
+    }
+    const updated = this.#recompute();
+    if (updated) {
+      super[kTrigger]();
     }
   }
 };
-var DerivedRef = class extends ImmutableRef {
-  constructor(...args) {
+var MutableSignal = class extends AbstractSignal {
+  #state;
+  constructor(initialState) {
     super();
-    const transformFn = args.pop();
-    const otherRefs = args;
-    this._refs = otherRefs;
-    this._refs.forEach((ref) => {
-      ref.didInvalidate.subscribe(() => this.invalidate());
-    });
-    this._transform = transformFn;
+    this.#state = initialState;
   }
-  /** @internal */
-  _toImmutable() {
-    return this._transform(
-      ...this._refs.map((ref) => ref.current)
-    );
+  [Symbol.dispose]() {
+    super[Symbol.dispose]();
+    this.#state = "(disposed)";
+  }
+  get() {
+    return this.#state;
+  }
+  /**
+   * Invokes a callback function that is allowed to mutate the given state
+   * value. Do not change the value outside of the callback.
+   *
+   * If the callback explicitly returns `false`, it's assumed that the state
+   * was not changed.
+   */
+  mutate(callback) {
+    batch(() => {
+      const result = callback ? callback(this.#state) : true;
+      if (result !== null && typeof result === "object" && "then" in result) {
+        raise("MutableSignal.mutate() does not support async callbacks");
+      }
+      if (result !== false) {
+        this.markSinksDirty();
+        enqueueTrigger(this);
+      }
+    });
   }
 };
 
@@ -3455,10 +3639,10 @@ function Orphaned(oldKey, oldPos = asPos(oldKey)) {
   return Object.freeze({ type: "Orphaned", oldKey, oldPos });
 }
 var AbstractCrdt = class {
-  constructor() {
-    /** @internal */
-    this._parent = NoParent;
-  }
+  //                  ^^^^^^^^^^^^ TODO: Make this an interface
+  #pool;
+  #id;
+  #parent = NoParent;
   /** @internal */
   _getParentKeyOrThrow() {
     switch (this.parent.type) {
@@ -3487,18 +3671,18 @@ var AbstractCrdt = class {
   }
   /** @internal */
   get _pool() {
-    return this.__pool;
+    return this.#pool;
   }
   get roomId() {
-    return this.__pool ? this.__pool.roomId : null;
+    return this.#pool ? this.#pool.roomId : null;
   }
   /** @internal */
   get _id() {
-    return this.__id;
+    return this.#id;
   }
   /** @internal */
   get parent() {
-    return this._parent;
+    return this.#parent;
   }
   /** @internal */
   get _parentKey() {
@@ -3532,12 +3716,12 @@ var AbstractCrdt = class {
         if (this.parent.node !== newParentNode) {
           throw new Error("Cannot set parent: node already has a parent");
         } else {
-          this._parent = HasParent(newParentNode, newParentKey);
+          this.#parent = HasParent(newParentNode, newParentKey);
           return;
         }
       case "Orphaned":
       case "NoParent": {
-        this._parent = HasParent(newParentNode, newParentKey);
+        this.#parent = HasParent(newParentNode, newParentKey);
         return;
       }
       default:
@@ -3546,25 +3730,25 @@ var AbstractCrdt = class {
   }
   /** @internal */
   _attach(id, pool) {
-    if (this.__id || this.__pool) {
+    if (this.#id || this.#pool) {
       throw new Error("Cannot attach node: already attached");
     }
     pool.addNode(id, crdtAsLiveNode(this));
-    this.__id = id;
-    this.__pool = pool;
+    this.#id = id;
+    this.#pool = pool;
   }
   /** @internal */
   _detach() {
-    if (this.__pool && this.__id) {
-      this.__pool.deleteNode(this.__id);
+    if (this.#pool && this.#id) {
+      this.#pool.deleteNode(this.#id);
     }
     switch (this.parent.type) {
       case "HasParent": {
-        this._parent = Orphaned(this.parent.key, this.parent.pos);
+        this.#parent = Orphaned(this.parent.key, this.parent.pos);
         break;
       }
       case "NoParent": {
-        this._parent = NoParent;
+        this.#parent = NoParent;
         break;
       }
       case "Orphaned": {
@@ -3573,8 +3757,13 @@ var AbstractCrdt = class {
       default:
         assertNever(this.parent, "Unknown state");
     }
-    this.__pool = void 0;
+    this.#pool = void 0;
   }
+  /** This caches the result of the last .toImmutable() call for this Live node. */
+  #cachedImmutable;
+  #cachedTreeNodeKey;
+  /** This caches the result of the last .toTreeNode() call for this Live node. */
+  #cachedTreeNode;
   /**
    * @internal
    *
@@ -3583,9 +3772,9 @@ var AbstractCrdt = class {
    * mutation to the Live node.
    */
   invalidate() {
-    if (this._cachedImmutable !== void 0 || this._cachedTreeNode !== void 0) {
-      this._cachedImmutable = void 0;
-      this._cachedTreeNode = void 0;
+    if (this.#cachedImmutable !== void 0 || this.#cachedTreeNode !== void 0) {
+      this.#cachedImmutable = void 0;
+      this.#cachedTreeNode = void 0;
       if (this.parent.type === "HasParent") {
         this.parent.node.invalidate();
       }
@@ -3597,20 +3786,20 @@ var AbstractCrdt = class {
    * Return an snapshot of this Live tree for use in DevTools.
    */
   toTreeNode(key) {
-    if (this._cachedTreeNode === void 0 || this._cachedTreeNodeKey !== key) {
-      this._cachedTreeNodeKey = key;
-      this._cachedTreeNode = this._toTreeNode(key);
+    if (this.#cachedTreeNode === void 0 || this.#cachedTreeNodeKey !== key) {
+      this.#cachedTreeNodeKey = key;
+      this.#cachedTreeNode = this._toTreeNode(key);
     }
-    return this._cachedTreeNode;
+    return this.#cachedTreeNode;
   }
   /**
    * Return an immutable snapshot of this Live node and its children.
    */
   toImmutable() {
-    if (this._cachedImmutable === void 0) {
-      this._cachedImmutable = this._toImmutable();
+    if (this.#cachedImmutable === void 0) {
+      this.#cachedImmutable = this._toImmutable();
     }
-    return this._cachedImmutable;
+    return this.#cachedImmutable;
   }
 };
 
@@ -3631,12 +3820,13 @@ function isChildCrdt(crdt) {
 
 // src/crdts/LiveRegister.ts
 var LiveRegister = class _LiveRegister extends AbstractCrdt {
+  #data;
   constructor(data) {
     super();
-    this._data = data;
+    this.#data = data;
   }
   get data() {
-    return this._data;
+    return this.#data;
   }
   /** @internal */
   static _deserialize([id, item], _parentToChildren, pool) {
@@ -3692,12 +3882,12 @@ var LiveRegister = class _LiveRegister extends AbstractCrdt {
       type: "Json",
       id: this._id ?? nanoid(),
       key,
-      payload: this._data
+      payload: this.#data
     };
   }
   /** @internal */
   _toImmutable() {
-    return this._data;
+    return this.#data;
   }
   clone() {
     return deepClone(this.data);
@@ -3711,17 +3901,21 @@ function compareNodePosition(itemA, itemB) {
   return posA === posB ? 0 : posA < posB ? -1 : 1;
 }
 var LiveList = class _LiveList extends AbstractCrdt {
+  // TODO: Naive array at first, find a better data structure. Maybe an Order statistics tree?
+  #items;
+  #implicitlyDeletedItems;
+  #unacknowledgedSets;
   constructor(items) {
     super();
-    this._items = [];
-    this._implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
-    this._unacknowledgedSets = /* @__PURE__ */ new Map();
+    this.#items = [];
+    this.#implicitlyDeletedItems = /* @__PURE__ */ new WeakSet();
+    this.#unacknowledgedSets = /* @__PURE__ */ new Map();
     let position = void 0;
     for (const item of items) {
       const newPosition = makePosition(position);
       const node = lsonToLiveNode(item);
       node._setParentLink(this, newPosition);
-      this._items.push(node);
+      this.#items.push(node);
       position = newPosition;
     }
   }
@@ -3762,7 +3956,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       parentKey
     };
     ops.push(op);
-    for (const item of this._items) {
+    for (const item of this.#items) {
       const parentKey2 = item._getParentKeyOrThrow();
       const childOps = HACK_addIntentAndDeletedIdToOperation(
         item._toOps(this._id, parentKey2, pool),
@@ -3770,7 +3964,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       );
       const childOpId = childOps[0].opId;
       if (childOpId !== void 0) {
-        this._unacknowledgedSets.set(parentKey2, childOpId);
+        this.#unacknowledgedSets.set(parentKey2, childOpId);
       }
       ops.push(...childOps);
     }
@@ -3782,36 +3976,35 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * Adds a new item into the sorted list, in the correct position.
    */
   _insertAndSort(item) {
-    this._items.push(item);
+    this.#items.push(item);
     this._sortItems();
   }
   /** @internal */
   _sortItems() {
-    this._items.sort(compareNodePosition);
+    this.#items.sort(compareNodePosition);
     this.invalidate();
   }
   /** @internal */
   _indexOfPosition(position) {
-    return this._items.findIndex(
+    return this.#items.findIndex(
       (item) => item._getParentKeyOrThrow() === position
     );
   }
   /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
-    for (const item of this._items) {
+    for (const item of this.#items) {
       item._attach(pool.generateId(), pool);
     }
   }
   /** @internal */
   _detach() {
     super._detach();
-    for (const item of this._items) {
+    for (const item of this.#items) {
       item._detach();
     }
   }
-  /** @internal */
-  _applySetRemote(op) {
+  #applySetRemote(op) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
@@ -3822,10 +4015,10 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const deletedId = op.deletedId;
     const indexOfItemWithSamePosition = this._indexOfPosition(key);
     if (indexOfItemWithSamePosition !== -1) {
-      const itemWithSamePosition = this._items[indexOfItemWithSamePosition];
+      const itemWithSamePosition = this.#items[indexOfItemWithSamePosition];
       if (itemWithSamePosition._id === deletedId) {
         itemWithSamePosition._detach();
-        this._items[indexOfItemWithSamePosition] = child;
+        this.#items[indexOfItemWithSamePosition] = child;
         return {
           modified: makeUpdate(this, [
             setDelta(indexOfItemWithSamePosition, child)
@@ -3833,12 +4026,12 @@ var LiveList = class _LiveList extends AbstractCrdt {
           reverse: []
         };
       } else {
-        this._implicitlyDeletedItems.add(itemWithSamePosition);
-        this._items[indexOfItemWithSamePosition] = child;
+        this.#implicitlyDeletedItems.add(itemWithSamePosition);
+        this.#items[indexOfItemWithSamePosition] = child;
         const delta = [
           setDelta(indexOfItemWithSamePosition, child)
         ];
-        const deleteDelta2 = this._detachItemAssociatedToSetOperation(
+        const deleteDelta2 = this.#detachItemAssociatedToSetOperation(
           op.deletedId
         );
         if (deleteDelta2) {
@@ -3851,7 +4044,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     } else {
       const updates = [];
-      const deleteDelta2 = this._detachItemAssociatedToSetOperation(
+      const deleteDelta2 = this.#detachItemAssociatedToSetOperation(
         op.deletedId
       );
       if (deleteDelta2) {
@@ -3865,26 +4058,25 @@ var LiveList = class _LiveList extends AbstractCrdt {
       };
     }
   }
-  /** @internal */
-  _applySetAck(op) {
+  #applySetAck(op) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
     const delta = [];
-    const deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+    const deletedDelta = this.#detachItemAssociatedToSetOperation(op.deletedId);
     if (deletedDelta) {
       delta.push(deletedDelta);
     }
-    const unacknowledgedOpId = this._unacknowledgedSets.get(op.parentKey);
+    const unacknowledgedOpId = this.#unacknowledgedSets.get(op.parentKey);
     if (unacknowledgedOpId !== void 0) {
       if (unacknowledgedOpId !== op.opId) {
         return delta.length === 0 ? { modified: false } : { modified: makeUpdate(this, delta), reverse: [] };
       } else {
-        this._unacknowledgedSets.delete(op.parentKey);
+        this.#unacknowledgedSets.delete(op.parentKey);
       }
     }
     const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey);
-    const existingItem = this._items.find((item) => item._id === op.id);
+    const existingItem = this.#items.find((item) => item._id === op.id);
     if (existingItem !== void 0) {
       if (existingItem._parentKey === op.parentKey) {
         return {
@@ -3893,16 +4085,16 @@ var LiveList = class _LiveList extends AbstractCrdt {
         };
       }
       if (indexOfItemWithSamePosition !== -1) {
-        this._implicitlyDeletedItems.add(
-          this._items[indexOfItemWithSamePosition]
+        this.#implicitlyDeletedItems.add(
+          this.#items[indexOfItemWithSamePosition]
         );
-        const [prevNode] = this._items.splice(indexOfItemWithSamePosition, 1);
+        const [prevNode] = this.#items.splice(indexOfItemWithSamePosition, 1);
         delta.push(deleteDelta(indexOfItemWithSamePosition, prevNode));
       }
-      const prevIndex = this._items.indexOf(existingItem);
+      const prevIndex = this.#items.indexOf(existingItem);
       existingItem._setParentLink(this, op.parentKey);
       this._sortItems();
-      const newIndex = this._items.indexOf(existingItem);
+      const newIndex = this.#items.indexOf(existingItem);
       if (newIndex !== prevIndex) {
         delta.push(moveDelta(prevIndex, newIndex, existingItem));
       }
@@ -3912,11 +4104,11 @@ var LiveList = class _LiveList extends AbstractCrdt {
       };
     } else {
       const orphan = this._pool.getNode(op.id);
-      if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+      if (orphan && this.#implicitlyDeletedItems.has(orphan)) {
         orphan._setParentLink(this, op.parentKey);
-        this._implicitlyDeletedItems.delete(orphan);
+        this.#implicitlyDeletedItems.delete(orphan);
         this._insertAndSort(orphan);
-        const recreatedItemIndex = this._items.indexOf(orphan);
+        const recreatedItemIndex = this.#items.indexOf(orphan);
         return {
           modified: makeUpdate(this, [
             // If there is an item at this position, update is a set, else it's an insert
@@ -3927,9 +4119,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
         };
       } else {
         if (indexOfItemWithSamePosition !== -1) {
-          this._items.splice(indexOfItemWithSamePosition, 1);
+          this.#items.splice(indexOfItemWithSamePosition, 1);
         }
-        const { newItem, newIndex } = this._createAttachItemAndSort(
+        const { newItem, newIndex } = this.#createAttachItemAndSort(
           op,
           op.parentKey
         );
@@ -3946,9 +4138,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
   }
   /**
    * Returns the update delta of the deletion or null
-   * @internal
    */
-  _detachItemAssociatedToSetOperation(deletedId) {
+  #detachItemAssociatedToSetOperation(deletedId) {
     if (deletedId === void 0 || this._pool === void 0) {
       return null;
     }
@@ -3962,25 +4153,23 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
     return result.modified.updates[0];
   }
-  /** @internal */
-  _applyRemoteInsert(op) {
+  #applyRemoteInsert(op) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
     }
     const key = asPos(op.parentKey);
     const existingItemIndex = this._indexOfPosition(key);
     if (existingItemIndex !== -1) {
-      this._shiftItemPosition(existingItemIndex, key);
+      this.#shiftItemPosition(existingItemIndex, key);
     }
-    const { newItem, newIndex } = this._createAttachItemAndSort(op, key);
+    const { newItem, newIndex } = this.#createAttachItemAndSort(op, key);
     return {
       modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
       reverse: []
     };
   }
-  /** @internal */
-  _applyInsertAck(op) {
-    const existingItem = this._items.find((item) => item._id === op.id);
+  #applyInsertAck(op) {
+    const existingItem = this.#items.find((item) => item._id === op.id);
     const key = asPos(op.parentKey);
     const itemIndexAtPosition = this._indexOfPosition(key);
     if (existingItem) {
@@ -3989,9 +4178,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
           modified: false
         };
       } else {
-        const oldPositionIndex = this._items.indexOf(existingItem);
+        const oldPositionIndex = this.#items.indexOf(existingItem);
         if (itemIndexAtPosition !== -1) {
-          this._shiftItemPosition(itemIndexAtPosition, key);
+          this.#shiftItemPosition(itemIndexAtPosition, key);
         }
         existingItem._setParentLink(this, key);
         this._sortItems();
@@ -4008,9 +4197,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     } else {
       const orphan = nn(this._pool).getNode(op.id);
-      if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+      if (orphan && this.#implicitlyDeletedItems.has(orphan)) {
         orphan._setParentLink(this, key);
-        this._implicitlyDeletedItems.delete(orphan);
+        this.#implicitlyDeletedItems.delete(orphan);
         this._insertAndSort(orphan);
         const newIndex = this._indexOfPosition(key);
         return {
@@ -4019,9 +4208,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
         };
       } else {
         if (itemIndexAtPosition !== -1) {
-          this._shiftItemPosition(itemIndexAtPosition, key);
+          this.#shiftItemPosition(itemIndexAtPosition, key);
         }
-        const { newItem, newIndex } = this._createAttachItemAndSort(op, key);
+        const { newItem, newIndex } = this.#createAttachItemAndSort(op, key);
         return {
           modified: makeUpdate(this, [insertDelta(newIndex, newItem)]),
           reverse: []
@@ -4029,8 +4218,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     }
   }
-  /** @internal */
-  _applyInsertUndoRedo(op) {
+  #applyInsertUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
     if (this._pool?.getNode(id) !== void 0) {
@@ -4041,8 +4229,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const existingItemIndex = this._indexOfPosition(key);
     let newKey = key;
     if (existingItemIndex !== -1) {
-      const before2 = this._items[existingItemIndex]?._parentPos;
-      const after2 = this._items[existingItemIndex + 1]?._parentPos;
+      const before2 = this.#items[existingItemIndex]?._parentPos;
+      const after2 = this.#items[existingItemIndex + 1]?._parentPos;
       newKey = makePosition(before2, after2);
       child._setParentLink(this, newKey);
     }
@@ -4053,28 +4241,27 @@ var LiveList = class _LiveList extends AbstractCrdt {
       reverse: [{ type: 5 /* DELETE_CRDT */, id }]
     };
   }
-  /** @internal */
-  _applySetUndoRedo(op) {
+  #applySetUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
     if (this._pool?.getNode(id) !== void 0) {
       return { modified: false };
     }
-    this._unacknowledgedSets.set(key, nn(op.opId));
+    this.#unacknowledgedSets.set(key, nn(op.opId));
     const indexOfItemWithSameKey = this._indexOfPosition(key);
     child._attach(id, nn(this._pool));
     child._setParentLink(this, key);
     const newKey = key;
     if (indexOfItemWithSameKey !== -1) {
-      const existingItem = this._items[indexOfItemWithSameKey];
+      const existingItem = this.#items[indexOfItemWithSameKey];
       existingItem._detach();
-      this._items[indexOfItemWithSameKey] = child;
+      this.#items[indexOfItemWithSameKey] = child;
       const reverse = HACK_addIntentAndDeletedIdToOperation(
         existingItem._toOps(nn(this._id), key, this._pool),
         op.id
       );
       const delta = [setDelta(indexOfItemWithSameKey, child)];
-      const deletedDelta = this._detachItemAssociatedToSetOperation(
+      const deletedDelta = this.#detachItemAssociatedToSetOperation(
         op.deletedId
       );
       if (deletedDelta) {
@@ -4086,7 +4273,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       };
     } else {
       this._insertAndSort(child);
-      this._detachItemAssociatedToSetOperation(op.deletedId);
+      this.#detachItemAssociatedToSetOperation(op.deletedId);
       const newIndex = this._indexOfPosition(newKey);
       return {
         reverse: [{ type: 5 /* DELETE_CRDT */, id }],
@@ -4102,19 +4289,19 @@ var LiveList = class _LiveList extends AbstractCrdt {
     let result;
     if (op.intent === "set") {
       if (source === 1 /* REMOTE */) {
-        result = this._applySetRemote(op);
+        result = this.#applySetRemote(op);
       } else if (source === 2 /* ACK */) {
-        result = this._applySetAck(op);
+        result = this.#applySetAck(op);
       } else {
-        result = this._applySetUndoRedo(op);
+        result = this.#applySetUndoRedo(op);
       }
     } else {
       if (source === 1 /* REMOTE */) {
-        result = this._applyRemoteInsert(op);
+        result = this.#applyRemoteInsert(op);
       } else if (source === 2 /* ACK */) {
-        result = this._applyInsertAck(op);
+        result = this.#applyInsertAck(op);
       } else {
-        result = this._applyInsertUndoRedo(op);
+        result = this.#applyInsertUndoRedo(op);
       }
     }
     if (result.modified !== false) {
@@ -4127,13 +4314,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (child) {
       const parentKey = nn(child._parentKey);
       const reverse = child._toOps(nn(this._id), parentKey, this._pool);
-      const indexToDelete = this._items.indexOf(child);
+      const indexToDelete = this.#items.indexOf(child);
       if (indexToDelete === -1) {
         return {
           modified: false
         };
       }
-      const [previousNode] = this._items.splice(indexToDelete, 1);
+      const [previousNode] = this.#items.splice(indexToDelete, 1);
       this.invalidate();
       child._detach();
       return {
@@ -4143,13 +4330,12 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
     return { modified: false };
   }
-  /** @internal */
-  _applySetChildKeyRemote(newKey, child) {
-    if (this._implicitlyDeletedItems.has(child)) {
-      this._implicitlyDeletedItems.delete(child);
+  #applySetChildKeyRemote(newKey, child) {
+    if (this.#implicitlyDeletedItems.has(child)) {
+      this.#implicitlyDeletedItems.delete(child);
       child._setParentLink(this, newKey);
       this._insertAndSort(child);
-      const newIndex = this._items.indexOf(child);
+      const newIndex = this.#items.indexOf(child);
       return {
         modified: makeUpdate(this, [insertDelta(newIndex, child)]),
         reverse: []
@@ -4163,10 +4349,10 @@ var LiveList = class _LiveList extends AbstractCrdt {
     }
     const existingItemIndex = this._indexOfPosition(newKey);
     if (existingItemIndex === -1) {
-      const previousIndex = this._items.indexOf(child);
+      const previousIndex = this.#items.indexOf(child);
       child._setParentLink(this, newKey);
       this._sortItems();
-      const newIndex = this._items.indexOf(child);
+      const newIndex = this.#items.indexOf(child);
       if (newIndex === previousIndex) {
         return {
           modified: false
@@ -4177,14 +4363,14 @@ var LiveList = class _LiveList extends AbstractCrdt {
         reverse: []
       };
     } else {
-      this._items[existingItemIndex]._setParentLink(
+      this.#items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
+        makePosition(newKey, this.#items[existingItemIndex + 1]?._parentPos)
       );
-      const previousIndex = this._items.indexOf(child);
+      const previousIndex = this.#items.indexOf(child);
       child._setParentLink(this, newKey);
       this._sortItems();
-      const newIndex = this._items.indexOf(child);
+      const newIndex = this.#items.indexOf(child);
       if (newIndex === previousIndex) {
         return {
           modified: false
@@ -4196,16 +4382,15 @@ var LiveList = class _LiveList extends AbstractCrdt {
       };
     }
   }
-  /** @internal */
-  _applySetChildKeyAck(newKey, child) {
+  #applySetChildKeyAck(newKey, child) {
     const previousKey = nn(child._parentKey);
-    if (this._implicitlyDeletedItems.has(child)) {
+    if (this.#implicitlyDeletedItems.has(child)) {
       const existingItemIndex = this._indexOfPosition(newKey);
-      this._implicitlyDeletedItems.delete(child);
+      this.#implicitlyDeletedItems.delete(child);
       if (existingItemIndex !== -1) {
-        this._items[existingItemIndex]._setParentLink(
+        this.#items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
+          makePosition(newKey, this.#items[existingItemIndex + 1]?._parentPos)
         );
       }
       child._setParentLink(this, newKey);
@@ -4219,17 +4404,17 @@ var LiveList = class _LiveList extends AbstractCrdt {
           modified: false
         };
       }
-      const previousIndex = this._items.indexOf(child);
+      const previousIndex = this.#items.indexOf(child);
       const existingItemIndex = this._indexOfPosition(newKey);
       if (existingItemIndex !== -1) {
-        this._items[existingItemIndex]._setParentLink(
+        this.#items[existingItemIndex]._setParentLink(
           this,
-          makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
+          makePosition(newKey, this.#items[existingItemIndex + 1]?._parentPos)
         );
       }
       child._setParentLink(this, newKey);
       this._sortItems();
-      const newIndex = this._items.indexOf(child);
+      const newIndex = this.#items.indexOf(child);
       if (previousIndex === newIndex) {
         return {
           modified: false
@@ -4244,20 +4429,19 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     }
   }
-  /** @internal */
-  _applySetChildKeyUndoRedo(newKey, child) {
+  #applySetChildKeyUndoRedo(newKey, child) {
     const previousKey = nn(child._parentKey);
-    const previousIndex = this._items.indexOf(child);
+    const previousIndex = this.#items.indexOf(child);
     const existingItemIndex = this._indexOfPosition(newKey);
     if (existingItemIndex !== -1) {
-      this._items[existingItemIndex]._setParentLink(
+      this.#items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, this._items[existingItemIndex + 1]?._parentPos)
+        makePosition(newKey, this.#items[existingItemIndex + 1]?._parentPos)
       );
     }
     child._setParentLink(this, newKey);
     this._sortItems();
-    const newIndex = this._items.indexOf(child);
+    const newIndex = this.#items.indexOf(child);
     if (previousIndex === newIndex) {
       return {
         modified: false
@@ -4277,11 +4461,11 @@ var LiveList = class _LiveList extends AbstractCrdt {
   /** @internal */
   _setChildKey(newKey, child, source) {
     if (source === 1 /* REMOTE */) {
-      return this._applySetChildKeyRemote(newKey, child);
+      return this.#applySetChildKeyRemote(newKey, child);
     } else if (source === 2 /* ACK */) {
-      return this._applySetChildKeyAck(newKey, child);
+      return this.#applySetChildKeyAck(newKey, child);
     } else {
-      return this._applySetChildKeyUndoRedo(newKey, child);
+      return this.#applySetChildKeyUndoRedo(newKey, child);
     }
   }
   /** @internal */
@@ -4303,7 +4487,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * Returns the number of elements.
    */
   get length() {
-    return this._items.length;
+    return this.#items.length;
   }
   /**
    * Adds one element to the end of the LiveList.
@@ -4320,13 +4504,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
    */
   insert(element, index) {
     this._pool?.assertStorageIsWritable();
-    if (index < 0 || index > this._items.length) {
+    if (index < 0 || index > this.#items.length) {
       throw new Error(
-        `Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`
+        `Cannot insert list item at index "${index}". index should be between 0 and ${this.#items.length}`
       );
     }
-    const before2 = this._items[index - 1] ? this._items[index - 1]._parentPos : void 0;
-    const after2 = this._items[index] ? this._items[index]._parentPos : void 0;
+    const before2 = this.#items[index - 1] ? this.#items[index - 1]._parentPos : void 0;
+    const after2 = this.#items[index] ? this.#items[index]._parentPos : void 0;
     const position = makePosition(before2, after2);
     const value = lsonToLiveNode(element);
     value._setParentLink(this, position);
@@ -4353,7 +4537,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (targetIndex < 0) {
       throw new Error("targetIndex cannot be less than 0");
     }
-    if (targetIndex >= this._items.length) {
+    if (targetIndex >= this.#items.length) {
       throw new Error(
         "targetIndex cannot be greater or equal than the list length"
       );
@@ -4361,20 +4545,20 @@ var LiveList = class _LiveList extends AbstractCrdt {
     if (index < 0) {
       throw new Error("index cannot be less than 0");
     }
-    if (index >= this._items.length) {
+    if (index >= this.#items.length) {
       throw new Error("index cannot be greater or equal than the list length");
     }
     let beforePosition = null;
     let afterPosition = null;
     if (index < targetIndex) {
-      afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._parentPos;
-      beforePosition = this._items[targetIndex]._parentPos;
+      afterPosition = targetIndex === this.#items.length - 1 ? void 0 : this.#items[targetIndex + 1]._parentPos;
+      beforePosition = this.#items[targetIndex]._parentPos;
     } else {
-      afterPosition = this._items[targetIndex]._parentPos;
-      beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1]._parentPos;
+      afterPosition = this.#items[targetIndex]._parentPos;
+      beforePosition = targetIndex === 0 ? void 0 : this.#items[targetIndex - 1]._parentPos;
     }
     const position = makePosition(beforePosition, afterPosition);
-    const item = this._items[index];
+    const item = this.#items[index];
     const previousPosition = item._getParentKeyOrThrow();
     item._setParentLink(this, position);
     this._sortItems();
@@ -4408,14 +4592,14 @@ var LiveList = class _LiveList extends AbstractCrdt {
    */
   delete(index) {
     this._pool?.assertStorageIsWritable();
-    if (index < 0 || index >= this._items.length) {
+    if (index < 0 || index >= this.#items.length) {
       throw new Error(
-        `Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
+        `Cannot delete list item at index "${index}". index should be between 0 and ${this.#items.length - 1}`
       );
     }
-    const item = this._items[index];
+    const item = this.#items[index];
     item._detach();
-    const [prev] = this._items.splice(index, 1);
+    const [prev] = this.#items.splice(index, 1);
     this.invalidate();
     if (this._pool) {
       const childRecordId = item._id;
@@ -4445,7 +4629,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       const ops = [];
       const reverseOps = [];
       const updateDelta = [];
-      for (const item of this._items) {
+      for (const item of this.#items) {
         item._detach();
         const childId = item._id;
         if (childId) {
@@ -4460,33 +4644,33 @@ var LiveList = class _LiveList extends AbstractCrdt {
           updateDelta.push(deleteDelta(0, item));
         }
       }
-      this._items = [];
+      this.#items = [];
       this.invalidate();
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(nn(this._id), makeUpdate(this, updateDelta));
       this._pool.dispatch(ops, reverseOps, storageUpdates);
     } else {
-      for (const item of this._items) {
+      for (const item of this.#items) {
         item._detach();
       }
-      this._items = [];
+      this.#items = [];
       this.invalidate();
     }
   }
   set(index, item) {
     this._pool?.assertStorageIsWritable();
-    if (index < 0 || index >= this._items.length) {
+    if (index < 0 || index >= this.#items.length) {
       throw new Error(
-        `Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`
+        `Cannot set list item at index "${index}". index should be between 0 and ${this.#items.length - 1}`
       );
     }
-    const existingItem = this._items[index];
+    const existingItem = this.#items[index];
     const position = existingItem._getParentKeyOrThrow();
     const existingId = existingItem._id;
     existingItem._detach();
     const value = lsonToLiveNode(item);
     value._setParentLink(this, position);
-    this._items[index] = value;
+    this.#items[index] = value;
     this.invalidate();
     if (this._pool && this._id) {
       const id = this._pool.generateId();
@@ -4497,7 +4681,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
         value._toOps(this._id, position, this._pool),
         existingId
       );
-      this._unacknowledgedSets.set(position, nn(ops[0].opId));
+      this.#unacknowledgedSets.set(position, nn(ops[0].opId));
       const reverseOps = HACK_addIntentAndDeletedIdToOperation(
         existingItem._toOps(this._id, position, void 0),
         id
@@ -4509,7 +4693,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * Returns an Array of all the elements in the LiveList.
    */
   toArray() {
-    return this._items.map(
+    return this.#items.map(
       (entry) => liveNodeToLson(entry)
       //                               ^^^^^^^^
       //                               FIXME! This isn't safe.
@@ -4560,10 +4744,10 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @returns The element at the specified index or undefined.
    */
   get(index) {
-    if (index < 0 || index >= this._items.length) {
+    if (index < 0 || index >= this.#items.length) {
       return void 0;
     }
-    return liveNodeToLson(this._items[index]);
+    return liveNodeToLson(this.#items[index]);
   }
   /**
    * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
@@ -4589,7 +4773,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
    * @returns An array with each element being the result of the callback function.
    */
   map(callback) {
-    return this._items.map(
+    return this.#items.map(
       (entry, i) => callback(
         liveNodeToLson(entry),
         //                    ^^^^^^^^
@@ -4607,10 +4791,9 @@ var LiveList = class _LiveList extends AbstractCrdt {
     return this.toArray().some(predicate);
   }
   [Symbol.iterator]() {
-    return new LiveListIterator(this._items);
+    return new LiveListIterator(this.#items);
   }
-  /** @internal */
-  _createAttachItemAndSort(op, key) {
+  #createAttachItemAndSort(op, key) {
     const newItem = creationOpToLiveNode(op);
     newItem._attach(op.id, nn(this._pool));
     newItem._setParentLink(this, key);
@@ -4618,13 +4801,12 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const newIndex = this._indexOfPosition(key);
     return { newItem, newIndex };
   }
-  /** @internal */
-  _shiftItemPosition(index, key) {
+  #shiftItemPosition(index, key) {
     const shiftedPosition = makePosition(
       key,
-      this._items.length > index + 1 ? this._items[index + 1]?._parentPos : void 0
+      this.#items.length > index + 1 ? this.#items[index + 1]?._parentPos : void 0
     );
-    this._items[index]._setParentLink(this, shiftedPosition);
+    this.#items[index]._setParentLink(this, shiftedPosition);
   }
   /** @internal */
   _toTreeNode(key) {
@@ -4632,7 +4814,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       type: "LiveList",
       id: this._id ?? nanoid(),
       key,
-      payload: this._items.map(
+      payload: this.#items.map(
         (item, index) => item.toTreeNode(index.toString())
       )
     };
@@ -4642,22 +4824,23 @@ var LiveList = class _LiveList extends AbstractCrdt {
   }
   /** @internal */
   _toImmutable() {
-    const result = this._items.map((node) => node.toImmutable());
+    const result = this.#items.map((node) => node.toImmutable());
     return process.env.NODE_ENV === "production" ? result : Object.freeze(result);
   }
   clone() {
-    return new _LiveList(this._items.map((item) => item.clone()));
+    return new _LiveList(this.#items.map((item) => item.clone()));
   }
 };
 var LiveListIterator = class {
+  #innerIterator;
   constructor(items) {
-    this._innerIterator = items[Symbol.iterator]();
+    this.#innerIterator = items[Symbol.iterator]();
   }
   [Symbol.iterator]() {
     return this;
   }
   next() {
-    const result = this._innerIterator.next();
+    const result = this.#innerIterator.next();
     if (result.done) {
       return {
         done: true,
@@ -4721,9 +4904,11 @@ function HACK_addIntentAndDeletedIdToOperation(ops, deletedId) {
 
 // src/crdts/LiveMap.ts
 var LiveMap = class _LiveMap extends AbstractCrdt {
+  #map;
+  #unacknowledgedSet;
   constructor(entries2) {
     super();
-    this.unacknowledgedSet = /* @__PURE__ */ new Map();
+    this.#unacknowledgedSet = /* @__PURE__ */ new Map();
     if (entries2) {
       const mappedEntries = [];
       for (const [key, value] of entries2) {
@@ -4731,14 +4916,12 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
         node._setParentLink(this, key);
         mappedEntries.push([key, node]);
       }
-      this._map = new Map(mappedEntries);
+      this.#map = new Map(mappedEntries);
     } else {
-      this._map = /* @__PURE__ */ new Map();
+      this.#map = /* @__PURE__ */ new Map();
     }
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _toOps(parentId, parentKey, pool) {
     if (this._id === void 0) {
       throw new Error("Cannot serialize item is not attached");
@@ -4752,14 +4935,12 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
       parentKey
     };
     ops.push(op);
-    for (const [key, value] of this._map) {
+    for (const [key, value] of this.#map) {
       ops.push(...value._toOps(this._id, key, pool));
     }
     return ops;
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   static _deserialize([id, _item], parentToChildren, pool) {
     const map = new _LiveMap();
     map._attach(id, pool);
@@ -4770,25 +4951,21 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
     for (const [id2, crdt] of children) {
       const child = deserialize([id2, crdt], parentToChildren, pool);
       child._setParentLink(map, crdt.parentKey);
-      map._map.set(crdt.parentKey, child);
+      map.#map.set(crdt.parentKey, child);
       map.invalidate();
     }
     return map;
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
-    for (const [_key, value] of this._map) {
+    for (const [_key, value] of this.#map) {
       if (isLiveNode(value)) {
         value._attach(pool.generateId(), pool);
       }
     }
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _attachChild(op, source) {
     if (this._pool === void 0) {
       throw new Error("Can't attach child if managed pool is not present");
@@ -4800,17 +4977,17 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
       return { modified: false };
     }
     if (source === 2 /* ACK */) {
-      const lastUpdateOpId = this.unacknowledgedSet.get(key);
+      const lastUpdateOpId = this.#unacknowledgedSet.get(key);
       if (lastUpdateOpId === opId) {
-        this.unacknowledgedSet.delete(key);
+        this.#unacknowledgedSet.delete(key);
         return { modified: false };
       } else if (lastUpdateOpId !== void 0) {
         return { modified: false };
       }
     } else if (source === 1 /* REMOTE */) {
-      this.unacknowledgedSet.delete(key);
+      this.#unacknowledgedSet.delete(key);
     }
-    const previousValue = this._map.get(key);
+    const previousValue = this.#map.get(key);
     let reverse;
     if (previousValue) {
       const thisId = nn(this._id);
@@ -4821,7 +4998,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
     }
     child._setParentLink(this, key);
     child._attach(id, this._pool);
-    this._map.set(key, child);
+    this.#map.set(key, child);
     this.invalidate();
     return {
       modified: {
@@ -4832,25 +5009,21 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
       reverse
     };
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _detach() {
     super._detach();
-    for (const item of this._map.values()) {
+    for (const item of this.#map.values()) {
       item._detach();
     }
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _detachChild(child) {
     const id = nn(this._id);
     const parentKey = nn(child._parentKey);
     const reverse = child._toOps(id, parentKey, this._pool);
-    for (const [key, value] of this._map) {
+    for (const [key, value] of this.#map) {
       if (value === child) {
-        this._map.delete(key);
+        this.#map.delete(key);
         this.invalidate();
       }
     }
@@ -4862,9 +5035,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
     };
     return { modified: storageUpdate, reverse };
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _serialize() {
     if (this.parent.type !== "HasParent") {
       throw new Error("Cannot serialize LiveMap if parent is missing");
@@ -4881,7 +5052,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * @returns The element associated with the specified key, or undefined if the key can't be found in the LiveMap.
    */
   get(key) {
-    const value = this._map.get(key);
+    const value = this.#map.get(key);
     if (value === void 0) {
       return void 0;
     }
@@ -4894,13 +5065,13 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    */
   set(key, value) {
     this._pool?.assertStorageIsWritable();
-    const oldValue = this._map.get(key);
+    const oldValue = this.#map.get(key);
     if (oldValue) {
       oldValue._detach();
     }
     const item = lsonToLiveNode(value);
     item._setParentLink(this, key);
-    this._map.set(key, item);
+    this.#map.set(key, item);
     this.invalidate();
     if (this._pool && this._id) {
       const id = this._pool.generateId();
@@ -4912,7 +5083,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
         updates: { [key]: { type: "update" } }
       });
       const ops = item._toOps(this._id, key, this._pool);
-      this.unacknowledgedSet.set(key, nn(ops[0].opId));
+      this.#unacknowledgedSet.set(key, nn(ops[0].opId));
       this._pool.dispatch(
         item._toOps(this._id, key, this._pool),
         oldValue ? oldValue._toOps(this._id, key) : [{ type: 5 /* DELETE_CRDT */, id }],
@@ -4924,14 +5095,14 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * Returns the number of elements in the LiveMap.
    */
   get size() {
-    return this._map.size;
+    return this.#map.size;
   }
   /**
    * Returns a boolean indicating whether an element with the specified key exists or not.
    * @param key The key of the element to test for presence.
    */
   has(key) {
-    return this._map.has(key);
+    return this.#map.has(key);
   }
   /**
    * Removes the specified element by key.
@@ -4940,12 +5111,12 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    */
   delete(key) {
     this._pool?.assertStorageIsWritable();
-    const item = this._map.get(key);
+    const item = this.#map.get(key);
     if (item === void 0) {
       return false;
     }
     item._detach();
-    this._map.delete(key);
+    this.#map.delete(key);
     this.invalidate();
     if (this._pool && item._id) {
       const thisId = nn(this._id);
@@ -4973,7 +5144,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * Returns a new Iterator object that contains the [key, value] pairs for each element.
    */
   entries() {
-    const innerIterator = this._map.entries();
+    const innerIterator = this.#map.entries();
     return {
       [Symbol.iterator]() {
         return this;
@@ -5005,13 +5176,13 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    * Returns a new Iterator object that contains the keys for each element.
    */
   keys() {
-    return this._map.keys();
+    return this.#map.keys();
   }
   /**
    * Returns a new Iterator object that contains the values for each element.
    */
   values() {
-    const innerIterator = this._map.values();
+    const innerIterator = this.#map.values();
     return {
       [Symbol.iterator]() {
         return this;
@@ -5044,7 +5215,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
       type: "LiveMap",
       id: this._id ?? nanoid(),
       key,
-      payload: Array.from(this._map.entries()).map(
+      payload: Array.from(this.#map.entries()).map(
         ([key2, val]) => val.toTreeNode(key2)
       )
     };
@@ -5055,22 +5226,23 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
   /** @internal */
   _toImmutable() {
     const result = /* @__PURE__ */ new Map();
-    for (const [key, value] of this._map) {
+    for (const [key, value] of this.#map) {
       result.set(key, value.toImmutable());
     }
     return freeze(result);
   }
   clone() {
     return new _LiveMap(
-      Array.from(this._map).map(([key, node]) => [key, node.clone()])
+      Array.from(this.#map).map(([key, node]) => [key, node.clone()])
     );
   }
 };
 
 // src/crdts/LiveObject.ts
 var LiveObject = class _LiveObject extends AbstractCrdt {
-  /** @internal */
-  static _buildRootAndParentToChildren(items) {
+  #map;
+  #propToLastUpdate;
+  static #buildRootAndParentToChildren(items) {
     const parentToChildren = /* @__PURE__ */ new Map();
     let root = null;
     for (const [id, crdt] of items) {
@@ -5093,7 +5265,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   }
   /** @internal */
   static _fromItems(items, pool) {
-    const [root, parentToChildren] = _LiveObject._buildRootAndParentToChildren(items);
+    const [root, parentToChildren] = _LiveObject.#buildRootAndParentToChildren(items);
     return _LiveObject._deserialize(
       root,
       parentToChildren,
@@ -5102,7 +5274,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   }
   constructor(obj = {}) {
     super();
-    this._propToLastUpdate = /* @__PURE__ */ new Map();
+    this.#propToLastUpdate = /* @__PURE__ */ new Map();
     const o = compactObject(obj);
     for (const key of Object.keys(o)) {
       const value = o[key];
@@ -5110,7 +5282,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         value._setParentLink(this, key);
       }
     }
-    this._map = new Map(Object.entries(o));
+    this.#map = new Map(Object.entries(o));
   }
   /** @internal */
   _toOps(parentId, parentKey, pool) {
@@ -5128,7 +5300,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       data: {}
     };
     ops.push(op);
-    for (const [key, value] of this._map) {
+    for (const [key, value] of this.#map) {
       if (isLiveNode(value)) {
         ops.push(...value._toOps(this._id, key, pool));
       } else {
@@ -5154,7 +5326,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       if (isLiveStructure(child)) {
         child._setParentLink(liveObj, crdt.parentKey);
       }
-      liveObj._map.set(crdt.parentKey, child);
+      liveObj.#map.set(crdt.parentKey, child);
       liveObj.invalidate();
     }
     return liveObj;
@@ -5162,7 +5334,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   /** @internal */
   _attach(id, pool) {
     super._attach(id, pool);
-    for (const [_key, value] of this._map) {
+    for (const [_key, value] of this.#map) {
       if (isLiveNode(value)) {
         value._attach(pool.generateId(), pool);
       }
@@ -5176,22 +5348,22 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
     const { id, opId, parentKey: key } = op;
     const child = creationOpToLson(op);
     if (this._pool.getNode(id) !== void 0) {
-      if (this._propToLastUpdate.get(key) === opId) {
-        this._propToLastUpdate.delete(key);
+      if (this.#propToLastUpdate.get(key) === opId) {
+        this.#propToLastUpdate.delete(key);
       }
       return { modified: false };
     }
     if (source === 0 /* UNDOREDO_RECONNECT */) {
-      this._propToLastUpdate.set(key, nn(opId));
-    } else if (this._propToLastUpdate.get(key) === void 0) {
-    } else if (this._propToLastUpdate.get(key) === opId) {
-      this._propToLastUpdate.delete(key);
+      this.#propToLastUpdate.set(key, nn(opId));
+    } else if (this.#propToLastUpdate.get(key) === void 0) {
+    } else if (this.#propToLastUpdate.get(key) === opId) {
+      this.#propToLastUpdate.delete(key);
       return { modified: false };
     } else {
       return { modified: false };
     }
     const thisId = nn(this._id);
-    const previousValue = this._map.get(key);
+    const previousValue = this.#map.get(key);
     let reverse;
     if (isLiveNode(previousValue)) {
       reverse = previousValue._toOps(thisId, key);
@@ -5207,7 +5379,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         }
       ];
     }
-    this._map.set(key, child);
+    this.#map.set(key, child);
     this.invalidate();
     if (isLiveStructure(child)) {
       child._setParentLink(this, key);
@@ -5228,9 +5400,9 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       const id = nn(this._id);
       const parentKey = nn(child._parentKey);
       const reverse = child._toOps(id, parentKey, this._pool);
-      for (const [key, value] of this._map) {
+      for (const [key, value] of this.#map) {
         if (value === child) {
-          this._map.delete(key);
+          this.#map.delete(key);
           this.invalidate();
         }
       }
@@ -5246,12 +5418,10 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
     }
     return { modified: false };
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _detach() {
     super._detach();
-    for (const value of this._map.values()) {
+    for (const value of this.#map.values()) {
       if (isLiveNode(value)) {
         value._detach();
       }
@@ -5260,18 +5430,16 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   /** @internal */
   _apply(op, isLocal) {
     if (op.type === 3 /* UPDATE_OBJECT */) {
-      return this._applyUpdate(op, isLocal);
+      return this.#applyUpdate(op, isLocal);
     } else if (op.type === 6 /* DELETE_OBJECT_KEY */) {
-      return this._applyDeleteObjectKey(op, isLocal);
+      return this.#applyDeleteObjectKey(op, isLocal);
     }
     return super._apply(op, isLocal);
   }
-  /**
-   * @internal
-   */
+  /** @internal */
   _serialize() {
     const data = {};
-    for (const [key, value] of this._map) {
+    for (const [key, value] of this.#map) {
       if (!isLiveNode(value)) {
         data[key] = value;
       }
@@ -5290,8 +5458,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       };
     }
   }
-  /** @internal */
-  _applyUpdate(op, isLocal) {
+  #applyUpdate(op, isLocal) {
     let isModified = false;
     const id = nn(this._id);
     const reverse = [];
@@ -5301,7 +5468,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       data: {}
     };
     for (const key in op.data) {
-      const oldValue = this._map.get(key);
+      const oldValue = this.#map.get(key);
       if (isLiveNode(oldValue)) {
         reverse.push(...oldValue._toOps(id, key));
         oldValue._detach();
@@ -5318,22 +5485,22 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         continue;
       }
       if (isLocal) {
-        this._propToLastUpdate.set(key, nn(op.opId));
-      } else if (this._propToLastUpdate.get(key) === void 0) {
+        this.#propToLastUpdate.set(key, nn(op.opId));
+      } else if (this.#propToLastUpdate.get(key) === void 0) {
         isModified = true;
-      } else if (this._propToLastUpdate.get(key) === op.opId) {
-        this._propToLastUpdate.delete(key);
+      } else if (this.#propToLastUpdate.get(key) === op.opId) {
+        this.#propToLastUpdate.delete(key);
         continue;
       } else {
         continue;
       }
-      const oldValue = this._map.get(key);
+      const oldValue = this.#map.get(key);
       if (isLiveNode(oldValue)) {
         oldValue._detach();
       }
       isModified = true;
       updateDelta[key] = { type: "update" };
-      this._map.set(key, value);
+      this.#map.set(key, value);
       this.invalidate();
     }
     if (Object.keys(reverseUpdate.data).length !== 0) {
@@ -5348,16 +5515,15 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       reverse
     } : { modified: false };
   }
-  /** @internal */
-  _applyDeleteObjectKey(op, isLocal) {
+  #applyDeleteObjectKey(op, isLocal) {
     const key = op.key;
-    if (this._map.has(key) === false) {
+    if (this.#map.has(key) === false) {
       return { modified: false };
     }
-    if (!isLocal && this._propToLastUpdate.get(key) !== void 0) {
+    if (!isLocal && this.#propToLastUpdate.get(key) !== void 0) {
       return { modified: false };
     }
-    const oldValue = this._map.get(key);
+    const oldValue = this.#map.get(key);
     const id = nn(this._id);
     let reverse = [];
     if (isLiveNode(oldValue)) {
@@ -5372,7 +5538,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         }
       ];
     }
-    this._map.delete(key);
+    this.#map.delete(key);
     this.invalidate();
     return {
       modified: {
@@ -5387,7 +5553,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * Transform the LiveObject into a javascript object
    */
   toObject() {
-    return Object.fromEntries(this._map);
+    return Object.fromEntries(this.#map);
   }
   /**
    * Adds or updates a property with a specified key and a value.
@@ -5403,7 +5569,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
    * @param key The key of the property to get
    */
   get(key) {
-    return this._map.get(key);
+    return this.#map.get(key);
   }
   /**
    * Deletes a key from the LiveObject
@@ -5412,7 +5578,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   delete(key) {
     this._pool?.assertStorageIsWritable();
     const keyAsString = key;
-    const oldValue = this._map.get(keyAsString);
+    const oldValue = this.#map.get(keyAsString);
     if (oldValue === void 0) {
       return;
     }
@@ -5420,7 +5586,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       if (isLiveNode(oldValue)) {
         oldValue._detach();
       }
-      this._map.delete(keyAsString);
+      this.#map.delete(keyAsString);
       this.invalidate();
       return;
     }
@@ -5437,7 +5603,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         }
       ];
     }
-    this._map.delete(keyAsString);
+    this.#map.delete(keyAsString);
     this.invalidate();
     const storageUpdates = /* @__PURE__ */ new Map();
     storageUpdates.set(this._id, {
@@ -5470,14 +5636,14 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         if (newValue === void 0) {
           continue;
         }
-        const oldValue = this._map.get(key);
+        const oldValue = this.#map.get(key);
         if (isLiveNode(oldValue)) {
           oldValue._detach();
         }
         if (isLiveNode(newValue)) {
           newValue._setParentLink(this, key);
         }
-        this._map.set(key, newValue);
+        this.#map.set(key, newValue);
         this.invalidate();
       }
       return;
@@ -5497,7 +5663,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       if (newValue === void 0) {
         continue;
       }
-      const oldValue = this._map.get(key);
+      const oldValue = this.#map.get(key);
       if (isLiveNode(oldValue)) {
         reverseOps.push(...oldValue._toOps(this._id, key));
         oldValue._detach();
@@ -5514,14 +5680,14 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
           (op) => op.parentId === this._id
         );
         if (createCrdtOp) {
-          this._propToLastUpdate.set(key, nn(createCrdtOp.opId));
+          this.#propToLastUpdate.set(key, nn(createCrdtOp.opId));
         }
         ops.push(...newAttachChildOps);
       } else {
         updatedProps[key] = newValue;
-        this._propToLastUpdate.set(key, opId);
+        this.#propToLastUpdate.set(key, opId);
       }
-      this._map.set(key, newValue);
+      this.#map.set(key, newValue);
       this.invalidate();
       updateDelta[key] = { type: "update" };
     }
@@ -5558,7 +5724,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
       type: "LiveObject",
       id: nodeId,
       key,
-      payload: Array.from(this._map.entries()).map(
+      payload: Array.from(this.#map.entries()).map(
         ([key2, value]) => isLiveNode(value) ? value.toTreeNode(key2) : { type: "Json", id: `${nodeId}:${key2}`, key: key2, payload: value }
       )
     };
@@ -5566,7 +5732,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   /** @internal */
   _toImmutable() {
     const result = {};
-    for (const [key, val] of this._map) {
+    for (const [key, val] of this.#map) {
       result[key] = isLiveStructure(val) ? val.toImmutable() : val;
     }
     return process.env.NODE_ENV === "production" ? result : Object.freeze(result);
@@ -5574,7 +5740,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   clone() {
     return new _LiveObject(
       Object.fromEntries(
-        Array.from(this._map).map(([key, value]) => [
+        Array.from(this.#map).map(([key, value]) => [
           key,
           isLiveStructure(value) ? value.clone() : deepClone(value)
         ])
@@ -5868,7 +6034,7 @@ var ClientMsgCode = /* @__PURE__ */ ((ClientMsgCode2) => {
   return ClientMsgCode2;
 })(ClientMsgCode || {});
 
-// src/refs/OthersRef.ts
+// src/refs/ManagedOthers.ts
 function makeUser(conn, presence) {
   const { connectionId, id, info } = conn;
   const canWrite = canWriteStorage(conn.scopes);
@@ -5885,98 +6051,110 @@ function makeUser(conn, presence) {
     })
   );
 }
-var OthersRef = class extends ImmutableRef {
-  //
-  // --------------------------------------------------------------
-  //
+var ManagedOthers = class {
+  // Track mutable state internally, but signal to the outside when the
+  // observable derived state changes only
+  #internal;
+  #userCache;
+  // The "clean" signal that is exposed to the outside world
+  signal;
   constructor() {
-    super();
-    this._connections = /* @__PURE__ */ new Map();
-    this._presences = /* @__PURE__ */ new Map();
-    this._users = /* @__PURE__ */ new Map();
-  }
-  connectionIds() {
-    return this._connections.keys();
-  }
-  /** @internal */
-  _toImmutable() {
-    const users = compact(
-      Array.from(this._presences.keys()).map(
-        (connectionId) => this.getUser(Number(connectionId))
+    this.#internal = new MutableSignal({
+      connections: /* @__PURE__ */ new Map(),
+      presences: /* @__PURE__ */ new Map()
+    });
+    this.signal = DerivedSignal.from(
+      this.#internal,
+      (_ignore) => compact(
+        Array.from(this.#internal.get().presences.keys()).map(
+          (connectionId) => this.getUser(Number(connectionId))
+        )
       )
     );
-    return users;
+    this.#userCache = /* @__PURE__ */ new Map();
+  }
+  // Shorthand for .signal.get()
+  get() {
+    return this.signal.get();
+  }
+  connectionIds() {
+    return this.#internal.get().connections.keys();
   }
   clearOthers() {
-    this._connections = /* @__PURE__ */ new Map();
-    this._presences = /* @__PURE__ */ new Map();
-    this._users = /* @__PURE__ */ new Map();
-    this.invalidate();
+    this.#internal.mutate((state) => {
+      state.connections.clear();
+      state.presences.clear();
+      this.#userCache.clear();
+    });
   }
-  /** @internal */
-  _getUser(connectionId) {
-    const conn = this._connections.get(connectionId);
-    const presence = this._presences.get(connectionId);
+  #_getUser(connectionId) {
+    const state = this.#internal.get();
+    const conn = state.connections.get(connectionId);
+    const presence = state.presences.get(connectionId);
     if (conn !== void 0 && presence !== void 0) {
       return makeUser(conn, presence);
     }
     return void 0;
   }
   getUser(connectionId) {
-    const cachedUser = this._users.get(connectionId);
+    const cachedUser = this.#userCache.get(connectionId);
     if (cachedUser) {
       return cachedUser;
     }
-    const computedUser = this._getUser(connectionId);
+    const computedUser = this.#_getUser(connectionId);
     if (computedUser) {
-      this._users.set(connectionId, computedUser);
+      this.#userCache.set(connectionId, computedUser);
       return computedUser;
     }
     return void 0;
   }
-  /** @internal */
-  _invalidateUser(connectionId) {
-    if (this._users.has(connectionId)) {
-      this._users.delete(connectionId);
-    }
-    this.invalidate();
+  #invalidateUser(connectionId) {
+    this.#userCache.delete(connectionId);
   }
   /**
    * Records a known connection. This records the connection ID and the
    * associated metadata.
    */
   setConnection(connectionId, metaUserId, metaUserInfo, scopes) {
-    this._connections.set(
-      connectionId,
-      freeze({
+    this.#internal.mutate((state) => {
+      state.connections.set(
         connectionId,
-        id: metaUserId,
-        info: metaUserInfo,
-        scopes
-      })
-    );
-    if (this._presences.has(connectionId)) {
-      this._invalidateUser(connectionId);
-    }
+        freeze({
+          connectionId,
+          id: metaUserId,
+          info: metaUserInfo,
+          scopes
+        })
+      );
+      if (!state.presences.has(connectionId)) {
+        return false;
+      }
+      return this.#invalidateUser(connectionId);
+    });
   }
   /**
    * Removes a known connectionId. Removes both the connection's metadata and
    * the presence information.
    */
   removeConnection(connectionId) {
-    this._connections.delete(connectionId);
-    this._presences.delete(connectionId);
-    this._invalidateUser(connectionId);
+    this.#internal.mutate((state) => {
+      state.connections.delete(connectionId);
+      state.presences.delete(connectionId);
+      this.#invalidateUser(connectionId);
+    });
   }
   /**
    * Stores a new user from a full presence update. If the user already exists,
    * its known presence data is overwritten.
    */
   setOther(connectionId, presence) {
-    this._presences.set(connectionId, freeze(compactObject(presence)));
-    if (this._connections.has(connectionId)) {
-      this._invalidateUser(connectionId);
-    }
+    this.#internal.mutate((state) => {
+      state.presences.set(connectionId, freeze(compactObject(presence)));
+      if (!state.connections.has(connectionId)) {
+        return false;
+      }
+      return this.#invalidateUser(connectionId);
+    });
   }
   /**
    * Patches the presence data for an existing "other". If we don't know the
@@ -5984,38 +6162,18 @@ var OthersRef = class extends ImmutableRef {
    * full .setOther() call first.
    */
   patchOther(connectionId, patch) {
-    const oldPresence = this._presences.get(connectionId);
-    if (oldPresence === void 0) {
-      return;
-    }
-    const newPresence = merge(oldPresence, patch);
-    if (oldPresence !== newPresence) {
-      this._presences.set(connectionId, freeze(newPresence));
-      this._invalidateUser(connectionId);
-    }
-  }
-};
-
-// src/refs/PatchableRef.ts
-var PatchableRef = class extends ImmutableRef {
-  constructor(data) {
-    super();
-    this._data = freeze(compactObject(data));
-  }
-  /** @internal */
-  _toImmutable() {
-    return this._data;
-  }
-  /**
-   * Patches the current object.
-   */
-  patch(patch) {
-    const oldData = this._data;
-    const newData = merge(oldData, patch);
-    if (oldData !== newData) {
-      this._data = freeze(newData);
-      this.invalidate();
-    }
+    this.#internal.mutate((state) => {
+      const oldPresence = state.presences.get(connectionId);
+      if (oldPresence === void 0) {
+        return false;
+      }
+      const newPresence = merge(oldPresence, patch);
+      if (oldPresence === newPresence) {
+        return false;
+      }
+      state.presences.set(connectionId, freeze(newPresence));
+      return this.#invalidateUser(connectionId);
+    });
   }
 };
 
@@ -6092,10 +6250,10 @@ function createRoom(options, config) {
       messages: [],
       storageOperations: []
     },
-    staticSessionInfo: new ValueRef(null),
-    dynamicSessionInfo: new ValueRef(null),
-    myPresence: new PatchableRef(initialPresence),
-    others: new OthersRef(),
+    staticSessionInfoSig: new Signal(null),
+    dynamicSessionInfoSig: new Signal(null),
+    myPresence: new PatchableSignal(initialPresence),
+    others: new ManagedOthers(),
     initialStorage,
     idFactory: null,
     // The Yjs provider associated to this room
@@ -6114,8 +6272,6 @@ function createRoom(options, config) {
     // Debug
     opStackTraces: process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new Map() : void 0
   };
-  const doNotBatchUpdates = (cb) => cb();
-  const batchUpdates = config.unstable_batchedUpdates ?? doNotBatchUpdates;
   let lastTokenKey;
   function onStatusDidChange(newStatus) {
     const authValue = managedSocket.authValue;
@@ -6125,46 +6281,38 @@ function createRoom(options, config) {
         lastTokenKey = tokenKey;
         if (authValue.type === "secret") {
           const token = authValue.token.parsed;
-          context.staticSessionInfo.set({
+          context.staticSessionInfoSig.set({
             userId: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.id : token.uid,
             userInfo: token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.info : token.ui
           });
         } else {
-          context.staticSessionInfo.set({
+          context.staticSessionInfoSig.set({
             userId: void 0,
             userInfo: void 0
           });
         }
       }
     }
-    batchUpdates(() => {
-      eventHub.status.notify(newStatus);
-      notifySelfChanged(doNotBatchUpdates);
-    });
+    eventHub.status.notify(newStatus);
+    notifySelfChanged();
   }
   let _connectionLossTimerId;
   let _hasLostConnection = false;
   function handleConnectionLossEvent(newStatus) {
     if (newStatus === "reconnecting") {
       _connectionLossTimerId = setTimeout(() => {
-        batchUpdates(() => {
-          eventHub.lostConnection.notify("lost");
-          _hasLostConnection = true;
-          context.others.clearOthers();
-          notify({ others: [{ type: "reset" }] }, doNotBatchUpdates);
-        });
+        eventHub.lostConnection.notify("lost");
+        _hasLostConnection = true;
+        context.others.clearOthers();
+        notify({ others: [{ type: "reset" }] });
       }, config.lostConnectionTimeout);
     } else {
       clearTimeout(_connectionLossTimerId);
       if (_hasLostConnection) {
         if (newStatus === "disconnected") {
-          batchUpdates(() => {
-            eventHub.lostConnection.notify("failed");
-          });
+          eventHub.lostConnection.notify("failed");
         } else {
-          batchUpdates(() => {
-            eventHub.lostConnection.notify("restored");
-          });
+          eventHub.lostConnection.notify("restored");
         }
         _hasLostConnection = false;
       }
@@ -6177,7 +6325,7 @@ function createRoom(options, config) {
         // Because context.me.current is a readonly object, we'll have to
         // make a copy here. Otherwise, type errors happen later when
         // "patching" my presence.
-        { ...context.myPresence.current }
+        { ...context.myPresence.get() }
       )
     };
     if (_getStorage$ !== null) {
@@ -6194,14 +6342,12 @@ function createRoom(options, config) {
   managedSocket.events.didConnect.subscribe(onDidConnect);
   managedSocket.events.didDisconnect.subscribe(onDidDisconnect);
   managedSocket.events.onLiveblocksError.subscribe((err) => {
-    batchUpdates(() => {
-      if (process.env.NODE_ENV !== "production") {
-        error2(
-          `Connection to websocket server closed. Reason: ${err.message} (code: ${err.code}).`
-        );
-      }
-      eventHub.error.notify(err);
-    });
+    if (process.env.NODE_ENV !== "production") {
+      error2(
+        `Connection to websocket server closed. Reason: ${err.message} (code: ${err.code}).`
+      );
+    }
+    eventHub.error.notify(err);
   });
   const pool = {
     roomId: config.roomId,
@@ -6237,16 +6383,14 @@ function createRoom(options, config) {
         }
         activeBatch.reverseOps.unshift(...reverse);
       } else {
-        batchUpdates(() => {
-          addToUndoStack(reverse, doNotBatchUpdates);
-          context.redoStack.length = 0;
-          dispatchOps(ops);
-          notify({ storageUpdates }, doNotBatchUpdates);
-        });
+        addToUndoStack(reverse);
+        context.redoStack.length = 0;
+        dispatchOps(ops);
+        notify({ storageUpdates });
       }
     },
     assertStorageIsWritable: () => {
-      const scopes = context.dynamicSessionInfo.current?.scopes;
+      const scopes = context.dynamicSessionInfoSig.get()?.scopes;
       if (scopes === void 0) {
         return;
       }
@@ -6302,7 +6446,7 @@ function createRoom(options, config) {
   }
   function sendMessages(messages) {
     const serializedPayload = JSON.stringify(messages);
-    const nonce = context.dynamicSessionInfo.current?.nonce;
+    const nonce = context.dynamicSessionInfoSig.get()?.nonce;
     if (config.unstable_fallbackToHTTP && nonce) {
       const size = new TextEncoder().encode(serializedPayload).length;
       if (size > MAX_SOCKET_MESSAGE_SIZE) {
@@ -6319,9 +6463,9 @@ function createRoom(options, config) {
     }
     managedSocket.send(serializedPayload);
   }
-  const self = new DerivedRef(
-    context.staticSessionInfo,
-    context.dynamicSessionInfo,
+  const self = DerivedSignal.from(
+    context.staticSessionInfoSig,
+    context.dynamicSessionInfoSig,
     context.myPresence,
     (staticSession, dynamicSession, myPresence) => {
       if (staticSession === null || dynamicSession === null) {
@@ -6340,29 +6484,27 @@ function createRoom(options, config) {
     }
   );
   let _lastSelf;
-  function notifySelfChanged(batchedUpdatesWrapper) {
-    const currSelf = self.current;
+  function notifySelfChanged() {
+    const currSelf = self.get();
     if (currSelf !== null && currSelf !== _lastSelf) {
-      batchedUpdatesWrapper(() => {
-        eventHub.self.notify(currSelf);
-      });
+      eventHub.self.notify(currSelf);
       _lastSelf = currSelf;
     }
   }
-  const selfAsTreeNode = new DerivedRef(
+  const selfAsTreeNode = DerivedSignal.from(
     self,
     (me) => me !== null ? userToTreeNode("Me", me) : null
   );
-  function createOrUpdateRootFromMessage(message, batchedUpdatesWrapper) {
+  function createOrUpdateRootFromMessage(message) {
     if (message.items.length === 0) {
       throw new Error("Internal error: cannot load storage without items");
     }
     if (context.root !== void 0) {
-      updateRoot(message.items, batchedUpdatesWrapper);
+      updateRoot(message.items);
     } else {
       context.root = LiveObject._fromItems(message.items, pool);
     }
-    const canWrite = self.current?.canWrite ?? true;
+    const canWrite = self.get()?.canWrite ?? true;
     const stackSizeBefore = context.undoStack.length;
     for (const key in context.initialStorage) {
       if (context.root.get(key) === void 0) {
@@ -6377,7 +6519,7 @@ function createRoom(options, config) {
     }
     context.undoStack.length = stackSizeBefore;
   }
-  function updateRoot(items, batchedUpdatesWrapper) {
+  function updateRoot(items) {
     if (context.root === void 0) {
       return;
     }
@@ -6387,45 +6529,43 @@ function createRoom(options, config) {
     }
     const ops = getTreesDiffOperations(currentItems, new Map(items));
     const result = applyOps(ops, false);
-    notify(result.updates, batchedUpdatesWrapper);
+    notify(result.updates);
   }
-  function _addToRealUndoStack(historyOps, batchedUpdatesWrapper) {
+  function _addToRealUndoStack(historyOps) {
     if (context.undoStack.length >= 50) {
       context.undoStack.shift();
     }
     context.undoStack.push(historyOps);
-    onHistoryChange(batchedUpdatesWrapper);
+    onHistoryChange();
   }
-  function addToUndoStack(historyOps, batchedUpdatesWrapper) {
+  function addToUndoStack(historyOps) {
     if (context.pausedHistory !== null) {
       context.pausedHistory.unshift(...historyOps);
     } else {
-      _addToRealUndoStack(historyOps, batchedUpdatesWrapper);
+      _addToRealUndoStack(historyOps);
     }
   }
-  function notify(updates, batchedUpdatesWrapper) {
+  function notify(updates) {
     const storageUpdates = updates.storageUpdates;
     const othersUpdates = updates.others;
-    batchedUpdatesWrapper(() => {
-      if (othersUpdates !== void 0 && othersUpdates.length > 0) {
-        const others = context.others.current;
-        for (const event of othersUpdates) {
-          eventHub.others.notify({ ...event, others });
-        }
-      }
-      if (updates.presence ?? false) {
-        notifySelfChanged(doNotBatchUpdates);
-        eventHub.myPresence.notify(context.myPresence.current);
+    if (othersUpdates !== void 0 && othersUpdates.length > 0) {
+      const others = context.others.get();
+      for (const event of othersUpdates) {
+        eventHub.others.notify({ ...event, others });
       }
-      if (storageUpdates !== void 0 && storageUpdates.size > 0) {
-        const updates2 = Array.from(storageUpdates.values());
-        eventHub.storageBatch.notify(updates2);
-      }
-      notifyStorageStatus();
-    });
+    }
+    if (updates.presence ?? false) {
+      notifySelfChanged();
+      eventHub.myPresence.notify(context.myPresence.get());
+    }
+    if (storageUpdates !== void 0 && storageUpdates.size > 0) {
+      const updates2 = Array.from(storageUpdates.values());
+      eventHub.storageBatch.notify(updates2);
+    }
+    notifyStorageStatus();
   }
   function getConnectionId() {
-    const info = context.dynamicSessionInfo.current;
+    const info = context.dynamicSessionInfoSig.get();
     if (info) {
       return info.actor;
     }
@@ -6454,7 +6594,7 @@ function createRoom(options, config) {
           data: {}
         };
         for (const key in op.data) {
-          reverse.data[key] = context.myPresence.current[key];
+          reverse.data[key] = context.myPresence.get()[key];
         }
         context.myPresence.patch(op.data);
         if (context.buffer.presenceUpdates === null) {
@@ -6563,7 +6703,7 @@ function createRoom(options, config) {
         continue;
       }
       context.buffer.presenceUpdates.data[key] = overrideValue;
-      oldValues[key] = context.myPresence.current[key];
+      oldValues[key] = context.myPresence.get()[key];
     }
     context.myPresence.patch(patch);
     if (context.activeBatch) {
@@ -6576,15 +6716,10 @@ function createRoom(options, config) {
       context.activeBatch.updates.presence = true;
     } else {
       flushNowOrSoon();
-      batchUpdates(() => {
-        if (options2?.addToHistory) {
-          addToUndoStack(
-            [{ type: "presence", data: oldValues }],
-            doNotBatchUpdates
-          );
-        }
-        notify({ presence: true }, doNotBatchUpdates);
-      });
+      if (options2?.addToHistory) {
+        addToUndoStack([{ type: "presence", data: oldValues }]);
+      }
+      notify({ presence: true });
     }
   }
   function onUpdatePresenceMessage(message) {
@@ -6617,14 +6752,14 @@ function createRoom(options, config) {
     }
     return null;
   }
-  function onRoomStateMessage(message, batchedUpdatesWrapper) {
-    context.dynamicSessionInfo.set({
+  function onRoomStateMessage(message) {
+    context.dynamicSessionInfoSig.set({
       actor: message.actor,
       nonce: message.nonce,
       scopes: message.scopes
     });
     context.idFactory = makeIdFactory(message.actor);
-    notifySelfChanged(batchedUpdatesWrapper);
+    notifySelfChanged();
     for (const connectionId of context.others.connectionIds()) {
       const user = message.users[connectionId];
       if (user === void 0) {
@@ -6649,10 +6784,8 @@ function createRoom(options, config) {
   function canRedo() {
     return context.redoStack.length > 0;
   }
-  function onHistoryChange(batchedUpdatesWrapper) {
-    batchedUpdatesWrapper(() => {
-      eventHub.history.notify({ canUndo: canUndo(), canRedo: canRedo() });
-    });
+  function onHistoryChange() {
+    eventHub.history.notify({ canUndo: canUndo(), canRedo: canRedo() });
   }
   function onUserJoinedMessage(message) {
     context.others.setConnection(
@@ -6663,7 +6796,7 @@ function createRoom(options, config) {
     );
     context.buffer.messages.push({
       type: 100 /* UPDATE_PRESENCE */,
-      data: context.myPresence.current,
+      data: context.myPresence.get(),
       targetActor: message.actor
     });
     flushNowOrSoon();
@@ -6686,7 +6819,7 @@ function createRoom(options, config) {
       return compact([parseServerMessage(data)]);
     }
   }
-  function applyAndSendOps(offlineOps, batchedUpdatesWrapper) {
+  function applyAndSendOps(offlineOps) {
     if (offlineOps.size === 0) {
       return;
     }
@@ -6697,7 +6830,7 @@ function createRoom(options, config) {
       type: 201 /* UPDATE_STORAGE */,
       ops: result.ops
     });
-    notify(result.updates, batchedUpdatesWrapper);
+    notify(result.updates);
     sendMessages(messages);
   }
   function handleServerMessage(event) {
@@ -6712,104 +6845,102 @@ function createRoom(options, config) {
       storageUpdates: /* @__PURE__ */ new Map(),
       others: []
     };
-    batchUpdates(() => {
-      for (const message of messages) {
-        switch (message.type) {
-          case 101 /* USER_JOINED */: {
-            const userJoinedUpdate = onUserJoinedMessage(message);
-            if (userJoinedUpdate) {
-              updates.others.push(userJoinedUpdate);
-            }
-            break;
-          }
-          case 100 /* UPDATE_PRESENCE */: {
-            const othersPresenceUpdate = onUpdatePresenceMessage(message);
-            if (othersPresenceUpdate) {
-              updates.others.push(othersPresenceUpdate);
-            }
-            break;
-          }
-          case 103 /* BROADCASTED_EVENT */: {
-            const others = context.others.current;
-            eventHub.customEvent.notify({
-              connectionId: message.actor,
-              user: message.actor < 0 ? null : others.find((u) => u.connectionId === message.actor) ?? null,
-              event: message.event
-            });
-            break;
-          }
-          case 102 /* USER_LEFT */: {
-            const event2 = onUserLeftMessage(message);
-            if (event2) {
-              updates.others.push(event2);
-            }
-            break;
-          }
-          case 300 /* UPDATE_YDOC */: {
-            eventHub.ydoc.notify(message);
-            break;
-          }
-          case 104 /* ROOM_STATE */: {
-            updates.others.push(onRoomStateMessage(message, doNotBatchUpdates));
-            break;
+    for (const message of messages) {
+      switch (message.type) {
+        case 101 /* USER_JOINED */: {
+          const userJoinedUpdate = onUserJoinedMessage(message);
+          if (userJoinedUpdate) {
+            updates.others.push(userJoinedUpdate);
           }
-          case 200 /* INITIAL_STORAGE_STATE */: {
-            processInitialStorage(message);
-            break;
+          break;
+        }
+        case 100 /* UPDATE_PRESENCE */: {
+          const othersPresenceUpdate = onUpdatePresenceMessage(message);
+          if (othersPresenceUpdate) {
+            updates.others.push(othersPresenceUpdate);
           }
-          case 201 /* UPDATE_STORAGE */: {
-            const applyResult = applyOps(message.ops, false);
-            for (const [key, value] of applyResult.updates.storageUpdates) {
-              updates.storageUpdates.set(
-                key,
-                mergeStorageUpdates(updates.storageUpdates.get(key), value)
-              );
-            }
-            break;
+          break;
+        }
+        case 103 /* BROADCASTED_EVENT */: {
+          const others = context.others.get();
+          eventHub.customEvent.notify({
+            connectionId: message.actor,
+            user: message.actor < 0 ? null : others.find((u) => u.connectionId === message.actor) ?? null,
+            event: message.event
+          });
+          break;
+        }
+        case 102 /* USER_LEFT */: {
+          const event2 = onUserLeftMessage(message);
+          if (event2) {
+            updates.others.push(event2);
           }
-          case 299 /* REJECT_STORAGE_OP */: {
-            errorWithTitle(
-              "Storage mutation rejection error",
-              message.reason
+          break;
+        }
+        case 300 /* UPDATE_YDOC */: {
+          eventHub.ydoc.notify(message);
+          break;
+        }
+        case 104 /* ROOM_STATE */: {
+          updates.others.push(onRoomStateMessage(message));
+          break;
+        }
+        case 200 /* INITIAL_STORAGE_STATE */: {
+          processInitialStorage(message);
+          break;
+        }
+        case 201 /* UPDATE_STORAGE */: {
+          const applyResult = applyOps(message.ops, false);
+          for (const [key, value] of applyResult.updates.storageUpdates) {
+            updates.storageUpdates.set(
+              key,
+              mergeStorageUpdates(updates.storageUpdates.get(key), value)
             );
-            if (process.env.NODE_ENV !== "production") {
-              const traces = /* @__PURE__ */ new Set();
-              for (const opId of message.opIds) {
-                const trace = context.opStackTraces?.get(opId);
-                if (trace) {
-                  traces.add(trace);
-                }
+          }
+          break;
+        }
+        case 299 /* REJECT_STORAGE_OP */: {
+          errorWithTitle(
+            "Storage mutation rejection error",
+            message.reason
+          );
+          if (process.env.NODE_ENV !== "production") {
+            const traces = /* @__PURE__ */ new Set();
+            for (const opId of message.opIds) {
+              const trace = context.opStackTraces?.get(opId);
+              if (trace) {
+                traces.add(trace);
               }
-              if (traces.size > 0) {
-                warnWithTitle(
-                  "The following function calls caused the rejected storage mutations:",
-                  `
+            }
+            if (traces.size > 0) {
+              warnWithTitle(
+                "The following function calls caused the rejected storage mutations:",
+                `
 
 ${Array.from(traces).join("\n\n")}`
-                );
-              }
-              throw new Error(
-                `Storage mutations rejected by server: ${message.reason}`
               );
             }
-            break;
-          }
-          case 400 /* THREAD_CREATED */:
-          case 407 /* THREAD_DELETED */:
-          case 401 /* THREAD_METADATA_UPDATED */:
-          case 408 /* THREAD_UPDATED */:
-          case 405 /* COMMENT_REACTION_ADDED */:
-          case 406 /* COMMENT_REACTION_REMOVED */:
-          case 402 /* COMMENT_CREATED */:
-          case 403 /* COMMENT_EDITED */:
-          case 404 /* COMMENT_DELETED */: {
-            eventHub.comments.notify(message);
-            break;
+            throw new Error(
+              `Storage mutations rejected by server: ${message.reason}`
+            );
           }
+          break;
+        }
+        case 400 /* THREAD_CREATED */:
+        case 407 /* THREAD_DELETED */:
+        case 401 /* THREAD_METADATA_UPDATED */:
+        case 408 /* THREAD_UPDATED */:
+        case 405 /* COMMENT_REACTION_ADDED */:
+        case 406 /* COMMENT_REACTION_REMOVED */:
+        case 402 /* COMMENT_CREATED */:
+        case 403 /* COMMENT_EDITED */:
+        case 404 /* COMMENT_DELETED */: {
+          eventHub.comments.notify(message);
+          break;
         }
       }
-      notify(updates, doNotBatchUpdates);
-    });
+    }
+    notify(updates);
   }
   function flushNowOrSoon() {
     const storageOps = context.buffer.storageOperations;
@@ -6907,8 +7038,8 @@ ${Array.from(traces).join("\n\n")}`
   let _resolveStoragePromise = null;
   function processInitialStorage(message) {
     const unacknowledgedOps = new Map(context.unacknowledgedOps);
-    createOrUpdateRootFromMessage(message, doNotBatchUpdates);
-    applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
+    createOrUpdateRootFromMessage(message);
+    applyAndSendOps(unacknowledgedOps);
     _resolveStoragePromise?.();
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
@@ -6981,11 +7112,9 @@ ${Array.from(traces).join("\n\n")}`
     }
     context.pausedHistory = null;
     const result = applyOps(historyOps, true);
-    batchUpdates(() => {
-      notify(result.updates, doNotBatchUpdates);
-      context.redoStack.push(result.reverse);
-      onHistoryChange(doNotBatchUpdates);
-    });
+    notify(result.updates);
+    context.redoStack.push(result.reverse);
+    onHistoryChange();
     for (const op of result.ops) {
       if (op.type !== "presence") {
         context.buffer.storageOperations.push(op);
@@ -7003,11 +7132,9 @@ ${Array.from(traces).join("\n\n")}`
     }
     context.pausedHistory = null;
     const result = applyOps(historyOps, true);
-    batchUpdates(() => {
-      notify(result.updates, doNotBatchUpdates);
-      context.undoStack.push(result.reverse);
-      onHistoryChange(doNotBatchUpdates);
-    });
+    notify(result.updates);
+    context.undoStack.push(result.reverse);
+    onHistoryChange();
     for (const op of result.ops) {
       if (op.type !== "presence") {
         context.buffer.storageOperations.push(op);
@@ -7019,39 +7146,37 @@ ${Array.from(traces).join("\n\n")}`
     context.undoStack.length = 0;
     context.redoStack.length = 0;
   }
-  function batch(callback) {
+  function batch2(callback) {
     if (context.activeBatch) {
       return callback();
     }
     let returnValue = void 0;
-    batchUpdates(() => {
-      context.activeBatch = {
-        ops: [],
-        updates: {
-          storageUpdates: /* @__PURE__ */ new Map(),
-          presence: false,
-          others: []
-        },
-        reverseOps: []
-      };
-      try {
-        returnValue = callback();
-      } finally {
-        const currentBatch = context.activeBatch;
-        context.activeBatch = null;
-        if (currentBatch.reverseOps.length > 0) {
-          addToUndoStack(currentBatch.reverseOps, doNotBatchUpdates);
-        }
-        if (currentBatch.ops.length > 0) {
-          context.redoStack.length = 0;
-        }
-        if (currentBatch.ops.length > 0) {
-          dispatchOps(currentBatch.ops);
-        }
-        notify(currentBatch.updates, doNotBatchUpdates);
-        flushNowOrSoon();
+    context.activeBatch = {
+      ops: [],
+      updates: {
+        storageUpdates: /* @__PURE__ */ new Map(),
+        presence: false,
+        others: []
+      },
+      reverseOps: []
+    };
+    try {
+      returnValue = callback();
+    } finally {
+      const currentBatch = context.activeBatch;
+      context.activeBatch = null;
+      if (currentBatch.reverseOps.length > 0) {
+        addToUndoStack(currentBatch.reverseOps);
       }
-    });
+      if (currentBatch.ops.length > 0) {
+        context.redoStack.length = 0;
+      }
+      if (currentBatch.ops.length > 0) {
+        dispatchOps(currentBatch.ops);
+      }
+      notify(currentBatch.updates);
+      flushNowOrSoon();
+    }
     return returnValue;
   }
   function pauseHistory() {
@@ -7063,7 +7188,7 @@ ${Array.from(traces).join("\n\n")}`
     const historyOps = context.pausedHistory;
     context.pausedHistory = null;
     if (historyOps !== null && historyOps.length > 0) {
-      _addToRealUndoStack(historyOps, batchUpdates);
+      _addToRealUndoStack(historyOps);
     }
   }
   const syncSourceForStorage = config.createSyncSource();
@@ -7086,7 +7211,7 @@ ${Array.from(traces).join("\n\n")}`
     );
   }
   function isPresenceReady() {
-    return self.current !== null;
+    return self.get() !== null;
   }
   async function waitUntilPresenceReady() {
     while (!isPresenceReady()) {
@@ -7106,8 +7231,8 @@ ${Array.from(traces).join("\n\n")}`
       await getStorage();
     }
   }
-  const others_forDevTools = new DerivedRef(
-    context.others,
+  const others_forDevTools = DerivedSignal.from(
+    context.others.signal,
     (others) => others.map((other, index) => userToTreeNode(`Other ${index}`, other))
   );
   const events = {
@@ -7297,8 +7422,8 @@ ${Array.from(traces).join("\n\n")}`
         // create a version
         createTextVersion,
         // Support for the Liveblocks browser extension
-        getSelf_forDevTools: () => selfAsTreeNode.current,
-        getOthers_forDevTools: () => others_forDevTools.current,
+        getSelf_forDevTools: () => selfAsTreeNode.get(),
+        getOthers_forDevTools: () => others_forDevTools.get(),
         // prettier-ignore
         simulate: {
           // These exist only for our E2E testing app
@@ -7324,7 +7449,7 @@ ${Array.from(traces).join("\n\n")}`
       updateYDoc,
       broadcastEvent,
       // Storage
-      batch,
+      batch: batch2,
       history: {
         undo,
         redo,
@@ -7345,10 +7470,10 @@ ${Array.from(traces).join("\n\n")}`
       events,
       // Core
       getStatus: () => managedSocket.getStatus(),
-      getSelf: () => self.current,
+      getSelf: () => self.get(),
       // Presence
-      getPresence: () => context.myPresence.current,
-      getOthers: () => context.others.current,
+      getPresence: () => context.myPresence.get(),
+      getOthers: () => context.others.get(),
       // Comments
       getThreads,
       getThreadsSince,
@@ -7526,10 +7651,10 @@ function createClient(options) {
     clientOptions.backgroundKeepAliveTimeout
   );
   const baseUrl = getBaseUrl(clientOptions.baseUrl);
-  const currentUserIdStore = createStore(void 0);
+  const currentUserId = new Signal(void 0);
   const authManager = createAuthManager(options, (token) => {
     const userId = token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.id : token.uid;
-    currentUserIdStore.set(() => userId);
+    currentUserId.set(() => userId);
   });
   const fetchPolyfill = clientOptions.polyfills?.fetch || /* istanbul ignore next */
   globalThis.fetch?.bind(globalThis);
@@ -7588,7 +7713,6 @@ function createClient(options) {
           authenticate: makeAuthDelegateForRoom(roomId, authManager)
         },
         enableDebugLogging: clientOptions.enableDebugLogging,
-        unstable_batchedUpdates: options2?.unstable_batchedUpdates,
         baseUrl,
         unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP,
         unstable_streamData: !!clientOptions.unstable_streamData,
@@ -7623,7 +7747,7 @@ function createClient(options) {
   }
   function logout() {
     authManager.reset();
-    currentUserIdStore.set(() => void 0);
+    currentUserId.set(() => void 0);
     for (const { room } of roomsById.values()) {
       if (!isIdle(room.getStatus())) {
         room.reconnect();
@@ -7671,20 +7795,20 @@ function createClient(options) {
     mentionSuggestionsCache.clear();
   }
   const syncStatusSources = [];
-  const syncStatusRef = new ValueRef("synchronized");
+  const syncStatusSignal = new Signal("synchronized");
   function getSyncStatus() {
-    const status = syncStatusRef.current;
+    const status = syncStatusSignal.get();
     return status === "synchronizing" ? status : "synchronized";
   }
   function recompute() {
-    syncStatusRef.set(
-      syncStatusSources.some((src) => src.current === "synchronizing") ? "synchronizing" : syncStatusSources.some((src) => src.current === "has-local-changes") ? "has-local-changes" : "synchronized"
+    syncStatusSignal.set(
+      syncStatusSources.some((src) => src.get() === "synchronizing") ? "synchronizing" : syncStatusSources.some((src) => src.get() === "has-local-changes") ? "has-local-changes" : "synchronized"
     );
   }
   function createSyncSource() {
-    const source = new ValueRef("synchronized");
+    const source = new Signal("synchronized");
     syncStatusSources.push(source);
-    const unsub = source.didInvalidate.subscribe(() => recompute());
+    const unsub = source.subscribe(() => recompute());
     function setSyncStatus(status) {
       source.set(status);
     }
@@ -7693,7 +7817,7 @@ function createClient(options) {
       const index = syncStatusSources.findIndex((item) => item === source);
       if (index > -1) {
         const [ref] = syncStatusSources.splice(index, 1);
-        const wasStillPending = ref.current !== "synchronized";
+        const wasStillPending = ref.get() !== "synchronized";
         if (wasStillPending) {
           recompute();
         }
@@ -7703,7 +7827,7 @@ function createClient(options) {
   }
   {
     const maybePreventClose = (e) => {
-      if (clientOptions.preventUnsavedChanges && syncStatusRef.current !== "synchronized") {
+      if (clientOptions.preventUnsavedChanges && syncStatusSignal.get() !== "synchronized") {
         e.preventDefault();
       }
     };
@@ -7731,11 +7855,11 @@ function createClient(options) {
       },
       getSyncStatus,
       events: {
-        syncStatus: syncStatusRef.didInvalidate
+        syncStatus: syncStatusSignal
       },
       // Internal
       [kInternal]: {
-        currentUserIdStore,
+        currentUserId,
         mentionSuggestionsCache,
         resolveMentionSuggestions: clientOptions.resolveMentionSuggestions,
         usersStore,
@@ -7909,13 +8033,15 @@ function escapeHtml(value) {
   );
 }
 var HtmlSafeString = class {
+  #strings;
+  #values;
   constructor(strings, values) {
-    this._strings = strings;
-    this._values = values;
+    this.#strings = strings;
+    this.#values = values;
   }
   toString() {
-    return this._strings.reduce((result, str, i) => {
-      return result + escapeHtml(nn(this._values[i - 1])) + str;
+    return this.#strings.reduce((result, str, i) => {
+      return result + escapeHtml(nn(this.#values[i - 1])) + str;
     });
   }
 };
@@ -7963,13 +8089,15 @@ function escapeMarkdown(value) {
   );
 }
 var MarkdownSafeString = class {
+  #strings;
+  #values;
   constructor(strings, values) {
-    this._strings = strings;
-    this._values = values;
+    this.#strings = strings;
+    this.#values = values;
   }
   toString() {
-    return this._strings.reduce((result, str, i) => {
-      return result + escapeMarkdown(nn(this._values[i - 1])) + str;
+    return this.#strings.reduce((result, str, i) => {
+      return result + escapeMarkdown(nn(this.#values[i - 1])) + str;
     });
   }
 };
@@ -8642,9 +8770,11 @@ function bisectRight(arr, x, lt) {
   return lo;
 }
 var SortedList = class _SortedList {
+  #data;
+  #lt;
   constructor(alreadySortedList, lt) {
-    this._lt = lt;
-    this._data = alreadySortedList;
+    this.#lt = lt;
+    this.#data = alreadySortedList;
   }
   static from(arr, lt) {
     const sorted = new _SortedList([], lt);
@@ -8660,14 +8790,14 @@ var SortedList = class _SortedList {
    * Clones the sorted list to a new instance.
    */
   clone() {
-    return new _SortedList(this._data.slice(), this._lt);
+    return new _SortedList(this.#data.slice(), this.#lt);
   }
   /**
    * Adds a new item to the sorted list, such that it remains sorted.
    */
   add(value) {
-    const idx = bisectRight(this._data, value, this._lt);
-    this._data.splice(idx, 0, value);
+    const idx = bisectRight(this.#data, value, this.#lt);
+    this.#data.splice(idx, 0, value);
   }
   /**
    * Removes the given value from the sorted list, if it exists. The given
@@ -8675,25 +8805,25 @@ var SortedList = class _SortedList {
    * removed if the element exists in the sorted list multiple times.
    */
   remove(value) {
-    const idx = this._data.indexOf(value);
+    const idx = this.#data.indexOf(value);
     if (idx >= 0) {
-      this._data.splice(idx, 1);
+      this.#data.splice(idx, 1);
       return true;
     }
     return false;
   }
   get length() {
-    return this._data.length;
+    return this.#data.length;
   }
   *filter(predicate) {
-    for (const item of this._data) {
+    for (const item of this.#data) {
       if (predicate(item)) {
         yield item;
       }
     }
   }
   [Symbol.iterator]() {
-    return this._data[Symbol.iterator]();
+    return this.#data[Symbol.iterator]();
   }
 };
 
@@ -8712,15 +8842,18 @@ export {
   ClientMsgCode,
   CommentsApiError,
   CrdtType,
+  DerivedSignal,
   HttpError,
   LiveList,
   LiveMap,
   LiveObject,
+  MutableSignal,
   NotificationsApiError,
   OpCode,
   Permission,
   Promise_withResolvers,
   ServerMsgCode,
+  Signal,
   SortedList,
   TextEditorType,
   WebsocketCloseCodes,
@@ -8730,6 +8863,7 @@ export {
   assertNever,
   autoRetry,
   b64decode,
+  batch,
   chunk,
   cloneLson,
   compactObject,
@@ -8742,7 +8876,6 @@ export {
   createCommentAttachmentId,
   createCommentId,
   createInboxNotificationId,
-  createStore,
   createThreadId,
   deprecate,
   deprecateIf,