@liveblocks/core 2.13.3-emails2 → 2.14.0-v2encoding

package/dist/index.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/core";
-var PKG_VERSION = "2.13.3-emails2";
+var PKG_VERSION = "2.14.0-v2encoding";
 var PKG_FORMAT = "cjs";
 
 // 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(() => _optionalChain([unsub, 'optionalCall', _2 => _2()]));
   }
-  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 {
+  
+  
+  
+  
   constructor(input) {
     this.input = input;
     const { promise, resolve, reject } = Promise_withResolvers();
@@ -399,36 +415,40 @@ var BatchCall = class {
     this.reject = reject;
   }
 };
-var Batch = class {
-  constructor(callback, options) {
-    this.queue = [];
-    this.error = false;
-    this.callback = callback;
-    this.size = _nullishCoalesce(options.size, () => ( DEFAULT_SIZE));
-    this.delay = options.delay;
-  }
-  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);
-    }
-  }
-  async flush() {
-    if (this.queue.length === 0) {
+var Batch = (_class = class {
+  #queue = [];
+  #callback;
+  #size;
+  #delay;
+  #delayTimeoutId;
+  __init() {this.error = false}
+  constructor(callback, options) {;_class.prototype.__init.call(this);
+    this.#callback = callback;
+    this.#size = _nullishCoalesce(options.size, () => ( DEFAULT_SIZE));
+    this.#delay = options.delay;
+  }
+  #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);
+    }
+  }
+  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 = _optionalChain([results, 'optionalAccess', _3 => _3[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) {
+}, _class);
+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 {
+  
+  // Indicates whether this state machine is still being configured, has
+  // started, or has terminated
+  #runningState;
+  #currentContext;
+  #states;
+  #currentStateOrNull;
+  #allowedTransitions;
+  #eventHub;
+  
+  //
+  // 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 _optionalChain([this, 'access', _13 => _13.allowedTransitions, 'access', _14 => _14.get, 'call', _15 => _15(this.currentState), 'optionalAccess', _16 => _16.get, 'call', _17 => _17(eventName)]);
+  #getTargetFn(eventName) {
+    return _optionalChain([this, 'access', _13 => _13.#allowedTransitions, 'access', _14 => _14.get, 'call', _15 => _15(this.currentState), 'optionalAccess', _16 => _16.get, 'call', _17 => _17(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 = _nullishCoalesce(levels, () => ( this.cleanupStack.length));
+  #exit(levels) {
+    this.#eventHub.willExitState.notify(this.currentState);
+    this.#currentContext.allowPatching((patchableContext) => {
+      levels = _nullishCoalesce(levels, () => ( this.#cleanupStack.length));
       for (let i = 0; i < levels; i++) {
-        _optionalChain([this, 'access', _18 => _18.cleanupStack, 'access', _19 => _19.pop, 'call', _20 => _20(), 'optionalCall', _21 => _21(patchableContext)]);
+        _optionalChain([this, 'access', _18 => _18.#cleanupStack, 'access', _19 => _19.pop, 'call', _20 => _20(), 'optionalCall', _21 => _21(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,
       _nullishCoalesce(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 = _optionalChain([enterFn, 'optionalCall', _22 => _22(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;
+  
   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 (e4) {
       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 = _optionalChain([this, 'access', _43 => _43.machine, 'access', _44 => _44.context, 'optionalAccess', _45 => _45.socket]);
+    const socket = _optionalChain([this, 'access', _43 => _43.#machine, 'access', _44 => _44.context, 'optionalAccess', _45 => _45.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);
   }
 };
 
@@ -3187,7 +3243,7 @@ function createStore(initialState) {
       subscriber(state);
     }
   }
-  function batch(cb) {
+  function batch2(cb) {
     if (notifyImmediately === false) {
       return cb();
     }
@@ -3208,7 +3264,7 @@ function createStore(initialState) {
   return {
     get,
     set,
-    batch,
+    batch: batch2,
     subscribe
   };
 }
@@ -3219,7 +3275,29 @@ var freeze = process.env.NODE_ENV === "production" ? (
   (x) => x
 ) : Object.freeze;
 
-// src/refs/ImmutableRef.ts
+// src/lib/Signal.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 +3315,215 @@ function merge(target, patch) {
   });
   return updated ? newValue : target;
 }
-var ImmutableRef = class {
-  constructor() {
-    this._ev = makeEventSource();
+var AbstractSignal = class {
+  /** @internal */
+  
+  #eventSource;
+  /** @internal */
+  
+  constructor(equals) {
+    this.equals = _nullishCoalesce(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 _nullishCoalesce(this._cache, () => ( (this._cache = this._toImmutable())));
+  addSink(sink) {
+    this[kSinks].add(sink);
+  }
+  removeSink(sink) {
+    this[kSinks].delete(sink);
   }
 };
-
-// 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(this.#state);
+      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 +3691,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 +3723,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 +3768,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 +3782,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 +3809,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 +3824,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 +3838,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 +3872,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 +3934,12 @@ var LiveRegister = class _LiveRegister extends AbstractCrdt {
       type: "Json",
       id: _nullishCoalesce(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 +3953,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 +4008,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 +4016,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 +4028,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 +4067,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 +4078,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 +4096,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     } else {
       const updates = [];
-      const deleteDelta2 = this._detachItemAssociatedToSetOperation(
+      const deleteDelta2 = this.#detachItemAssociatedToSetOperation(
         op.deletedId
       );
       if (deleteDelta2) {
@@ -3865,26 +4110,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 +4137,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 +4156,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 +4171,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 +4190,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 +4205,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 +4230,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 +4249,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 +4260,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 +4270,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       }
     }
   }
-  /** @internal */
-  _applyInsertUndoRedo(op) {
+  #applyInsertUndoRedo(op) {
     const { id, parentKey: key } = op;
     const child = creationOpToLiveNode(op);
     if (_optionalChain([this, 'access', _60 => _60._pool, 'optionalAccess', _61 => _61.getNode, 'call', _62 => _62(id)]) !== void 0) {
@@ -4041,8 +4281,8 @@ var LiveList = class _LiveList extends AbstractCrdt {
     const existingItemIndex = this._indexOfPosition(key);
     let newKey = key;
     if (existingItemIndex !== -1) {
-      const before2 = _optionalChain([this, 'access', _63 => _63._items, 'access', _64 => _64[existingItemIndex], 'optionalAccess', _65 => _65._parentPos]);
-      const after2 = _optionalChain([this, 'access', _66 => _66._items, 'access', _67 => _67[existingItemIndex + 1], 'optionalAccess', _68 => _68._parentPos]);
+      const before2 = _optionalChain([this, 'access', _63 => _63.#items, 'access', _64 => _64[existingItemIndex], 'optionalAccess', _65 => _65._parentPos]);
+      const after2 = _optionalChain([this, 'access', _66 => _66.#items, 'access', _67 => _67[existingItemIndex + 1], 'optionalAccess', _68 => _68._parentPos]);
       newKey = makePosition(before2, after2);
       child._setParentLink(this, newKey);
     }
@@ -4053,28 +4293,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 (_optionalChain([this, 'access', _69 => _69._pool, 'optionalAccess', _70 => _70.getNode, 'call', _71 => _71(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 +4325,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 +4341,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 +4366,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 +4382,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 +4401,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 +4415,14 @@ var LiveList = class _LiveList extends AbstractCrdt {
         reverse: []
       };
     } else {
-      this._items[existingItemIndex]._setParentLink(
+      this.#items[existingItemIndex]._setParentLink(
         this,
-        makePosition(newKey, _optionalChain([this, 'access', _72 => _72._items, 'access', _73 => _73[existingItemIndex + 1], 'optionalAccess', _74 => _74._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _72 => _72.#items, 'access', _73 => _73[existingItemIndex + 1], 'optionalAccess', _74 => _74._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 +4434,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, _optionalChain([this, 'access', _75 => _75._items, 'access', _76 => _76[existingItemIndex + 1], 'optionalAccess', _77 => _77._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _75 => _75.#items, 'access', _76 => _76[existingItemIndex + 1], 'optionalAccess', _77 => _77._parentPos]))
         );
       }
       child._setParentLink(this, newKey);
@@ -4219,17 +4456,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, _optionalChain([this, 'access', _78 => _78._items, 'access', _79 => _79[existingItemIndex + 1], 'optionalAccess', _80 => _80._parentPos]))
+          makePosition(newKey, _optionalChain([this, 'access', _78 => _78.#items, 'access', _79 => _79[existingItemIndex + 1], 'optionalAccess', _80 => _80._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 +4481,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, _optionalChain([this, 'access', _81 => _81._items, 'access', _82 => _82[existingItemIndex + 1], 'optionalAccess', _83 => _83._parentPos]))
+        makePosition(newKey, _optionalChain([this, 'access', _81 => _81.#items, 'access', _82 => _82[existingItemIndex + 1], 'optionalAccess', _83 => _83._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 +4513,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 +4539,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 +4556,13 @@ var LiveList = class _LiveList extends AbstractCrdt {
    */
   insert(element, index) {
     _optionalChain([this, 'access', _87 => _87._pool, 'optionalAccess', _88 => _88.assertStorageIsWritable, 'call', _89 => _89()]);
-    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 +4589,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 +4597,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 +4644,14 @@ var LiveList = class _LiveList extends AbstractCrdt {
    */
   delete(index) {
     _optionalChain([this, 'access', _93 => _93._pool, 'optionalAccess', _94 => _94.assertStorageIsWritable, 'call', _95 => _95()]);
-    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 +4681,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 +4696,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) {
     _optionalChain([this, 'access', _99 => _99._pool, 'optionalAccess', _100 => _100.assertStorageIsWritable, 'call', _101 => _101()]);
-    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 +4733,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 +4745,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 +4796,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 +4825,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 +4843,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 +4853,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 ? _optionalChain([this, 'access', _102 => _102._items, 'access', _103 => _103[index + 1], 'optionalAccess', _104 => _104._parentPos]) : void 0
+      this.#items.length > index + 1 ? _optionalChain([this, 'access', _102 => _102.#items, 'access', _103 => _103[index + 1], 'optionalAccess', _104 => _104._parentPos]) : void 0
     );
-    this._items[index]._setParentLink(this, shiftedPosition);
+    this.#items[index]._setParentLink(this, shiftedPosition);
   }
   /** @internal */
   _toTreeNode(key) {
@@ -4632,7 +4866,7 @@ var LiveList = class _LiveList extends AbstractCrdt {
       type: "LiveList",
       id: _nullishCoalesce(this._id, () => ( nanoid())),
       key,
-      payload: this._items.map(
+      payload: this.#items.map(
         (item, index) => item.toTreeNode(index.toString())
       )
     };
@@ -4642,22 +4876,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 +4956,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 +4968,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 +4987,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 +5003,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 +5029,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 +5050,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 +5061,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 +5087,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 +5104,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 +5117,13 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    */
   set(key, value) {
     _optionalChain([this, 'access', _107 => _107._pool, 'optionalAccess', _108 => _108.assertStorageIsWritable, 'call', _109 => _109()]);
-    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 +5135,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 +5147,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 +5163,12 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
    */
   delete(key) {
     _optionalChain([this, 'access', _110 => _110._pool, 'optionalAccess', _111 => _111.assertStorageIsWritable, 'call', _112 => _112()]);
-    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 +5196,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 +5228,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 +5267,7 @@ var LiveMap = class _LiveMap extends AbstractCrdt {
       type: "LiveMap",
       id: _nullishCoalesce(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 +5278,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 +5317,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 +5326,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 +5334,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 +5352,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 +5378,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 +5386,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 +5400,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 +5431,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 +5452,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 +5470,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 +5482,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 +5510,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 +5520,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 +5537,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 +5567,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 +5590,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
         }
       ];
     }
-    this._map.delete(key);
+    this.#map.delete(key);
     this.invalidate();
     return {
       modified: {
@@ -5387,7 +5605,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 +5621,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 +5630,7 @@ var LiveObject = class _LiveObject extends AbstractCrdt {
   delete(key) {
     _optionalChain([this, 'access', _118 => _118._pool, 'optionalAccess', _119 => _119.assertStorageIsWritable, 'call', _120 => _120()]);
     const keyAsString = key;
-    const oldValue = this._map.get(keyAsString);
+    const oldValue = this.#map.get(keyAsString);
     if (oldValue === void 0) {
       return;
     }
@@ -5420,7 +5638,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 +5655,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 +5688,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 +5715,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 +5732,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 +5776,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 +5784,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 +5792,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 +6086,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 +6103,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
+  
   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 +6214,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 +6302,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
@@ -6125,12 +6335,12 @@ 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
           });
@@ -6177,7 +6387,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) {
@@ -6246,7 +6456,7 @@ function createRoom(options, config) {
       }
     },
     assertStorageIsWritable: () => {
-      const scopes = _optionalChain([context, 'access', _129 => _129.dynamicSessionInfo, 'access', _130 => _130.current, 'optionalAccess', _131 => _131.scopes]);
+      const scopes = _optionalChain([context, 'access', _129 => _129.dynamicSessionInfoSig, 'access', _130 => _130.get, 'call', _131 => _131(), 'optionalAccess', _132 => _132.scopes]);
       if (scopes === void 0) {
         return;
       }
@@ -6302,7 +6512,7 @@ function createRoom(options, config) {
   }
   function sendMessages(messages) {
     const serializedPayload = JSON.stringify(messages);
-    const nonce = _optionalChain([context, 'access', _132 => _132.dynamicSessionInfo, 'access', _133 => _133.current, 'optionalAccess', _134 => _134.nonce]);
+    const nonce = _optionalChain([context, 'access', _133 => _133.dynamicSessionInfoSig, 'access', _134 => _134.get, 'call', _135 => _135(), 'optionalAccess', _136 => _136.nonce]);
     if (config.unstable_fallbackToHTTP && nonce) {
       const size = new TextEncoder().encode(serializedPayload).length;
       if (size > MAX_SOCKET_MESSAGE_SIZE) {
@@ -6319,9 +6529,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) {
@@ -6341,7 +6551,7 @@ function createRoom(options, config) {
   );
   let _lastSelf;
   function notifySelfChanged(batchedUpdatesWrapper) {
-    const currSelf = self.current;
+    const currSelf = self.get();
     if (currSelf !== null && currSelf !== _lastSelf) {
       batchedUpdatesWrapper(() => {
         eventHub.self.notify(currSelf);
@@ -6349,7 +6559,7 @@ function createRoom(options, config) {
       _lastSelf = currSelf;
     }
   }
-  const selfAsTreeNode = new DerivedRef(
+  const selfAsTreeNode = DerivedSignal.from(
     self,
     (me) => me !== null ? userToTreeNode("Me", me) : null
   );
@@ -6362,7 +6572,7 @@ function createRoom(options, config) {
     } else {
       context.root = LiveObject._fromItems(message.items, pool);
     }
-    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _135 => _135.current, 'optionalAccess', _136 => _136.canWrite]), () => ( true));
+    const canWrite = _nullishCoalesce(_optionalChain([self, 'access', _137 => _137.get, 'call', _138 => _138(), 'optionalAccess', _139 => _139.canWrite]), () => ( true));
     const stackSizeBefore = context.undoStack.length;
     for (const key in context.initialStorage) {
       if (context.root.get(key) === void 0) {
@@ -6408,14 +6618,14 @@ function createRoom(options, config) {
     const othersUpdates = updates.others;
     batchedUpdatesWrapper(() => {
       if (othersUpdates !== void 0 && othersUpdates.length > 0) {
-        const others = context.others.current;
+        const others = context.others.get();
         for (const event of othersUpdates) {
           eventHub.others.notify({ ...event, others });
         }
       }
       if (_nullishCoalesce(updates.presence, () => ( false))) {
         notifySelfChanged(doNotBatchUpdates);
-        eventHub.myPresence.notify(context.myPresence.current);
+        eventHub.myPresence.notify(context.myPresence.get());
       }
       if (storageUpdates !== void 0 && storageUpdates.size > 0) {
         const updates2 = Array.from(storageUpdates.values());
@@ -6425,7 +6635,7 @@ function createRoom(options, config) {
     });
   }
   function getConnectionId() {
-    const info = context.dynamicSessionInfo.current;
+    const info = context.dynamicSessionInfoSig.get();
     if (info) {
       return info.actor;
     }
@@ -6454,7 +6664,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,11 +6773,11 @@ 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) {
-      if (_optionalChain([options2, 'optionalAccess', _137 => _137.addToHistory])) {
+      if (_optionalChain([options2, 'optionalAccess', _140 => _140.addToHistory])) {
         context.activeBatch.reverseOps.unshift({
           type: "presence",
           data: oldValues
@@ -6577,7 +6787,7 @@ function createRoom(options, config) {
     } else {
       flushNowOrSoon();
       batchUpdates(() => {
-        if (_optionalChain([options2, 'optionalAccess', _138 => _138.addToHistory])) {
+        if (_optionalChain([options2, 'optionalAccess', _141 => _141.addToHistory])) {
           addToUndoStack(
             [{ type: "presence", data: oldValues }],
             doNotBatchUpdates
@@ -6618,7 +6828,7 @@ function createRoom(options, config) {
     return null;
   }
   function onRoomStateMessage(message, batchedUpdatesWrapper) {
-    context.dynamicSessionInfo.set({
+    context.dynamicSessionInfoSig.set({
       actor: message.actor,
       nonce: message.nonce,
       scopes: message.scopes
@@ -6663,7 +6873,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();
@@ -6730,7 +6940,7 @@ function createRoom(options, config) {
             break;
           }
           case 103 /* BROADCASTED_EVENT */: {
-            const others = context.others.current;
+            const others = context.others.get();
             eventHub.customEvent.notify({
               connectionId: message.actor,
               user: message.actor < 0 ? null : _nullishCoalesce(others.find((u) => u.connectionId === message.actor), () => ( null)),
@@ -6775,7 +6985,7 @@ function createRoom(options, config) {
             if (process.env.NODE_ENV !== "production") {
               const traces = /* @__PURE__ */ new Set();
               for (const opId of message.opIds) {
-                const trace = _optionalChain([context, 'access', _139 => _139.opStackTraces, 'optionalAccess', _140 => _140.get, 'call', _141 => _141(opId)]);
+                const trace = _optionalChain([context, 'access', _142 => _142.opStackTraces, 'optionalAccess', _143 => _143.get, 'call', _144 => _144(opId)]);
                 if (trace) {
                   traces.add(trace);
                 }
@@ -6874,11 +7084,12 @@ ${Array.from(traces).join("\n\n")}`
     }
     return messages;
   }
-  function updateYDoc(update, guid) {
+  function updateYDoc(update, guid, isV2) {
     const clientMsg = {
       type: 301 /* UPDATE_YDOC */,
       update,
-      guid
+      guid,
+      v2: isV2
     };
     context.buffer.messages.push(clientMsg);
     eventHub.ydoc.notify(clientMsg);
@@ -6909,7 +7120,7 @@ ${Array.from(traces).join("\n\n")}`
     const unacknowledgedOps = new Map(context.unacknowledgedOps);
     createOrUpdateRootFromMessage(message, doNotBatchUpdates);
     applyAndSendOps(unacknowledgedOps, doNotBatchUpdates);
-    _optionalChain([_resolveStoragePromise, 'optionalCall', _142 => _142()]);
+    _optionalChain([_resolveStoragePromise, 'optionalCall', _145 => _145()]);
     notifyStorageStatus();
     eventHub.storageDidLoad.notify();
   }
@@ -6959,14 +7170,15 @@ ${Array.from(traces).join("\n\n")}`
       root: nn(context.root)
     };
   }
-  function fetchYDoc(vector, guid) {
+  function fetchYDoc(vector, guid, isV2) {
     if (!context.buffer.messages.find((m) => {
-      return m.type === 300 /* FETCH_YDOC */ && m.vector === vector && m.guid === guid;
+      return m.type === 300 /* FETCH_YDOC */ && m.vector === vector && m.guid === guid && m.v2 === isV2;
     })) {
       context.buffer.messages.push({
         type: 300 /* FETCH_YDOC */,
         vector,
-        guid
+        guid,
+        v2: isV2
       });
     }
     flushNowOrSoon();
@@ -7019,7 +7231,7 @@ ${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();
     }
@@ -7086,7 +7298,7 @@ ${Array.from(traces).join("\n\n")}`
     );
   }
   function isPresenceReady() {
-    return self.current !== null;
+    return self.get() !== null;
   }
   async function waitUntilPresenceReady() {
     while (!isPresenceReady()) {
@@ -7106,8 +7318,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 = {
@@ -7137,8 +7349,8 @@ ${Array.from(traces).join("\n\n")}`
   async function getThreads(options2) {
     return httpClient.getThreads({
       roomId,
-      query: _optionalChain([options2, 'optionalAccess', _143 => _143.query]),
-      cursor: _optionalChain([options2, 'optionalAccess', _144 => _144.cursor])
+      query: _optionalChain([options2, 'optionalAccess', _146 => _146.query]),
+      cursor: _optionalChain([options2, 'optionalAccess', _147 => _147.cursor])
     });
   }
   async function getThread(threadId) {
@@ -7239,7 +7451,7 @@ ${Array.from(traces).join("\n\n")}`
   function getNotificationSettings(options2) {
     return httpClient.getNotificationSettings({
       roomId,
-      signal: _optionalChain([options2, 'optionalAccess', _145 => _145.signal])
+      signal: _optionalChain([options2, 'optionalAccess', _148 => _148.signal])
     });
   }
   function updateNotificationSettings(settings) {
@@ -7261,7 +7473,7 @@ ${Array.from(traces).join("\n\n")}`
     {
       [kInternal]: {
         get presenceBuffer() {
-          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _146 => _146.buffer, 'access', _147 => _147.presenceUpdates, 'optionalAccess', _148 => _148.data]), () => ( null)));
+          return deepClone(_nullishCoalesce(_optionalChain([context, 'access', _149 => _149.buffer, 'access', _150 => _150.presenceUpdates, 'optionalAccess', _151 => _151.data]), () => ( null)));
         },
         // prettier-ignore
         get undoStack() {
@@ -7276,9 +7488,9 @@ ${Array.from(traces).join("\n\n")}`
           return context.yjsProvider;
         },
         setYjsProvider(newProvider) {
-          _optionalChain([context, 'access', _149 => _149.yjsProvider, 'optionalAccess', _150 => _150.off, 'call', _151 => _151("status", yjsStatusDidChange)]);
+          _optionalChain([context, 'access', _152 => _152.yjsProvider, 'optionalAccess', _153 => _153.off, 'call', _154 => _154("status", yjsStatusDidChange)]);
           context.yjsProvider = newProvider;
-          _optionalChain([newProvider, 'optionalAccess', _152 => _152.on, 'call', _153 => _153("status", yjsStatusDidChange)]);
+          _optionalChain([newProvider, 'optionalAccess', _155 => _155.on, 'call', _156 => _156("status", yjsStatusDidChange)]);
           context.yjsProviderDidChange.notify();
         },
         yjsProviderDidChange: context.yjsProviderDidChange.observable,
@@ -7297,8 +7509,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
@@ -7314,7 +7526,7 @@ ${Array.from(traces).join("\n\n")}`
       disconnect: () => managedSocket.disconnect(),
       destroy: () => {
         syncSourceForStorage.destroy();
-        _optionalChain([context, 'access', _154 => _154.yjsProvider, 'optionalAccess', _155 => _155.off, 'call', _156 => _156("status", yjsStatusDidChange)]);
+        _optionalChain([context, 'access', _157 => _157.yjsProvider, 'optionalAccess', _158 => _158.off, 'call', _159 => _159("status", yjsStatusDidChange)]);
         syncSourceForYjs.destroy();
         uninstallBgTabSpy();
         managedSocket.destroy();
@@ -7324,7 +7536,7 @@ ${Array.from(traces).join("\n\n")}`
       updateYDoc,
       broadcastEvent,
       // Storage
-      batch,
+      batch: batch2,
       history: {
         undo,
         redo,
@@ -7345,10 +7557,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,
@@ -7452,7 +7664,7 @@ function makeClassicSubscribeFn(events) {
     }
     if (isLiveNode(first)) {
       const node = first;
-      if (_optionalChain([options, 'optionalAccess', _157 => _157.isDeep])) {
+      if (_optionalChain([options, 'optionalAccess', _160 => _160.isDeep])) {
         const storageCallback = second;
         return subscribeToLiveStructureDeeply(node, storageCallback);
       } else {
@@ -7531,8 +7743,8 @@ function createClient(options) {
     const userId = token.k === "sec-legacy" /* SECRET_LEGACY */ ? token.id : token.uid;
     currentUserIdStore.set(() => userId);
   });
-  const fetchPolyfill = _optionalChain([clientOptions, 'access', _158 => _158.polyfills, 'optionalAccess', _159 => _159.fetch]) || /* istanbul ignore next */
-  _optionalChain([globalThis, 'access', _160 => _160.fetch, 'optionalAccess', _161 => _161.bind, 'call', _162 => _162(globalThis)]);
+  const fetchPolyfill = _optionalChain([clientOptions, 'access', _161 => _161.polyfills, 'optionalAccess', _162 => _162.fetch]) || /* istanbul ignore next */
+  _optionalChain([globalThis, 'access', _163 => _163.fetch, 'optionalAccess', _164 => _164.bind, 'call', _165 => _165(globalThis)]);
   const httpClient = createApiClient({
     baseUrl,
     fetchPolyfill,
@@ -7583,12 +7795,12 @@ function createClient(options) {
           createSocket: makeCreateSocketDelegateForRoom(
             roomId,
             baseUrl,
-            _optionalChain([clientOptions, 'access', _163 => _163.polyfills, 'optionalAccess', _164 => _164.WebSocket])
+            _optionalChain([clientOptions, 'access', _166 => _166.polyfills, 'optionalAccess', _167 => _167.WebSocket])
           ),
           authenticate: makeAuthDelegateForRoom(roomId, authManager)
         })),
         enableDebugLogging: clientOptions.enableDebugLogging,
-        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _165 => _165.unstable_batchedUpdates]),
+        unstable_batchedUpdates: _optionalChain([options2, 'optionalAccess', _168 => _168.unstable_batchedUpdates]),
         baseUrl,
         unstable_fallbackToHTTP: !!clientOptions.unstable_fallbackToHTTP,
         unstable_streamData: !!clientOptions.unstable_streamData,
@@ -7606,7 +7818,7 @@ function createClient(options) {
     const shouldConnect = _nullishCoalesce(options2.autoConnect, () => ( true));
     if (shouldConnect) {
       if (typeof atob === "undefined") {
-        if (_optionalChain([clientOptions, 'access', _166 => _166.polyfills, 'optionalAccess', _167 => _167.atob]) === void 0) {
+        if (_optionalChain([clientOptions, 'access', _169 => _169.polyfills, 'optionalAccess', _170 => _170.atob]) === void 0) {
           throw new Error(
             "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
           );
@@ -7618,7 +7830,7 @@ function createClient(options) {
     return leaseRoom(newRoomDetails);
   }
   function getRoom(roomId) {
-    const room = _optionalChain([roomsById, 'access', _168 => _168.get, 'call', _169 => _169(roomId), 'optionalAccess', _170 => _170.room]);
+    const room = _optionalChain([roomsById, 'access', _171 => _171.get, 'call', _172 => _172(roomId), 'optionalAccess', _173 => _173.room]);
     return room ? room : null;
   }
   function logout() {
@@ -7638,7 +7850,7 @@ function createClient(options) {
   const batchedResolveUsers = new Batch(
     async (batchedUserIds) => {
       const userIds = batchedUserIds.flat();
-      const users = await _optionalChain([resolveUsers, 'optionalCall', _171 => _171({ userIds })]);
+      const users = await _optionalChain([resolveUsers, 'optionalCall', _174 => _174({ userIds })]);
       warnIfNoResolveUsers();
       return _nullishCoalesce(users, () => ( userIds.map(() => void 0)));
     },
@@ -7656,7 +7868,7 @@ function createClient(options) {
   const batchedResolveRoomsInfo = new Batch(
     async (batchedRoomIds) => {
       const roomIds = batchedRoomIds.flat();
-      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _172 => _172({ roomIds })]);
+      const roomsInfo = await _optionalChain([resolveRoomsInfo, 'optionalCall', _175 => _175({ roomIds })]);
       warnIfNoResolveRoomsInfo();
       return _nullishCoalesce(roomsInfo, () => ( roomIds.map(() => void 0)));
     },
@@ -7671,20 +7883,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 +7905,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,12 +7915,12 @@ function createClient(options) {
   }
   {
     const maybePreventClose = (e) => {
-      if (clientOptions.preventUnsavedChanges && syncStatusRef.current !== "synchronized") {
+      if (clientOptions.preventUnsavedChanges && syncStatusSignal.get() !== "synchronized") {
         e.preventDefault();
       }
     };
     const win = typeof window !== "undefined" ? window : void 0;
-    _optionalChain([win, 'optionalAccess', _173 => _173.addEventListener, 'call', _174 => _174("beforeunload", maybePreventClose)]);
+    _optionalChain([win, 'optionalAccess', _176 => _176.addEventListener, 'call', _177 => _177("beforeunload", maybePreventClose)]);
   }
   const client = Object.defineProperty(
     {
@@ -7731,7 +7943,7 @@ function createClient(options) {
       },
       getSyncStatus,
       events: {
-        syncStatus: syncStatusRef.didInvalidate
+        syncStatus: syncStatusSignal
       },
       // Internal
       [kInternal]: {
@@ -7825,7 +8037,7 @@ var commentBodyElementsTypes = {
   mention: "inline"
 };
 function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
-  if (!body || !_optionalChain([body, 'optionalAccess', _175 => _175.content])) {
+  if (!body || !_optionalChain([body, 'optionalAccess', _178 => _178.content])) {
     return;
   }
   const element = typeof elementOrVisitor === "string" ? elementOrVisitor : void 0;
@@ -7835,13 +8047,13 @@ function traverseCommentBody(body, elementOrVisitor, possiblyVisitor) {
   for (const block of body.content) {
     if (type === "all" || type === "block") {
       if (guard(block)) {
-        _optionalChain([visitor, 'optionalCall', _176 => _176(block)]);
+        _optionalChain([visitor, 'optionalCall', _179 => _179(block)]);
       }
     }
     if (type === "all" || type === "inline") {
       for (const inline of block.children) {
         if (guard(inline)) {
-          _optionalChain([visitor, 'optionalCall', _177 => _177(inline)]);
+          _optionalChain([visitor, 'optionalCall', _180 => _180(inline)]);
         }
       }
     }
@@ -7866,7 +8078,7 @@ async function resolveUsersInCommentBody(body, resolveUsers) {
     userIds
   });
   for (const [index, userId] of userIds.entries()) {
-    const user = _optionalChain([users, 'optionalAccess', _178 => _178[index]]);
+    const user = _optionalChain([users, 'optionalAccess', _181 => _181[index]]);
     if (user) {
       resolvedUsers.set(userId, user);
     }
@@ -7909,13 +8121,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 +8177,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;
     });
   }
 };
@@ -7989,7 +8205,7 @@ var stringifyCommentBodyPlainElements = {
   text: ({ element }) => element.text,
   link: ({ element }) => _nullishCoalesce(element.text, () => ( element.url)),
   mention: ({ element, user }) => {
-    return `@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _179 => _179.name]), () => ( element.id))}`;
+    return `@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _182 => _182.name]), () => ( element.id))}`;
   }
 };
 var stringifyCommentBodyHtmlElements = {
@@ -8019,7 +8235,7 @@ var stringifyCommentBodyHtmlElements = {
     return html`<a href="${href}" target="_blank" rel="noopener noreferrer">${_nullishCoalesce(element.text, () => ( element.url))}</a>`;
   },
   mention: ({ element, user }) => {
-    return html`<span data-mention>@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _180 => _180.name]), () => ( element.id))}</span>`;
+    return html`<span data-mention>@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _183 => _183.name]), () => ( element.id))}</span>`;
   }
 };
 var stringifyCommentBodyMarkdownElements = {
@@ -8049,19 +8265,19 @@ var stringifyCommentBodyMarkdownElements = {
     return markdown`[${_nullishCoalesce(element.text, () => ( element.url))}](${href})`;
   },
   mention: ({ element, user }) => {
-    return markdown`@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _181 => _181.name]), () => ( element.id))}`;
+    return markdown`@${_nullishCoalesce(_optionalChain([user, 'optionalAccess', _184 => _184.name]), () => ( element.id))}`;
   }
 };
 async function stringifyCommentBody(body, options) {
-  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _182 => _182.format]), () => ( "plain"));
-  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _183 => _183.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
+  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _185 => _185.format]), () => ( "plain"));
+  const separator = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _186 => _186.separator]), () => ( (format === "markdown" ? "\n\n" : "\n")));
   const elements = {
     ...format === "html" ? stringifyCommentBodyHtmlElements : format === "markdown" ? stringifyCommentBodyMarkdownElements : stringifyCommentBodyPlainElements,
-    ..._optionalChain([options, 'optionalAccess', _184 => _184.elements])
+    ..._optionalChain([options, 'optionalAccess', _187 => _187.elements])
   };
   const resolvedUsers = await resolveUsersInCommentBody(
     body,
-    _optionalChain([options, 'optionalAccess', _185 => _185.resolveUsers])
+    _optionalChain([options, 'optionalAccess', _188 => _188.resolveUsers])
   );
   const blocks = body.content.flatMap((block, blockIndex) => {
     switch (block.type) {
@@ -8352,12 +8568,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _186 => _186.updates, 'access', _187 => _187[key], 'optionalAccess', _188 => _188.type]) === "update") {
+          if (_optionalChain([update, 'access', _189 => _189.updates, 'access', _190 => _190[key], 'optionalAccess', _191 => _191.type]) === "update") {
             const val = update.node.get(key);
             if (val !== void 0) {
               newState[key] = lsonToJson(val);
             }
-          } else if (_optionalChain([update, 'access', _189 => _189.updates, 'access', _190 => _190[key], 'optionalAccess', _191 => _191.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _192 => _192.updates, 'access', _193 => _193[key], 'optionalAccess', _194 => _194.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -8418,12 +8634,12 @@ function legacy_patchImmutableNode(state, path, update) {
         }
         const newState = Object.assign({}, state);
         for (const key in update.updates) {
-          if (_optionalChain([update, 'access', _192 => _192.updates, 'access', _193 => _193[key], 'optionalAccess', _194 => _194.type]) === "update") {
+          if (_optionalChain([update, 'access', _195 => _195.updates, 'access', _196 => _196[key], 'optionalAccess', _197 => _197.type]) === "update") {
             const value = update.node.get(key);
             if (value !== void 0) {
               newState[key] = lsonToJson(value);
             }
-          } else if (_optionalChain([update, 'access', _195 => _195.updates, 'access', _196 => _196[key], 'optionalAccess', _197 => _197.type]) === "delete") {
+          } else if (_optionalChain([update, 'access', _198 => _198.updates, 'access', _199 => _199[key], 'optionalAccess', _200 => _200.type]) === "delete") {
             delete newState[key];
           }
         }
@@ -8494,9 +8710,9 @@ function makePoller(callback, intervalMs, options) {
   const startTime = performance.now();
   const doc = typeof document !== "undefined" ? document : void 0;
   const win = typeof window !== "undefined" ? window : void 0;
-  const maxStaleTimeMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _198 => _198.maxStaleTimeMs]), () => ( Number.POSITIVE_INFINITY));
+  const maxStaleTimeMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _201 => _201.maxStaleTimeMs]), () => ( Number.POSITIVE_INFINITY));
   const context = {
-    inForeground: _optionalChain([doc, 'optionalAccess', _199 => _199.visibilityState]) !== "hidden",
+    inForeground: _optionalChain([doc, 'optionalAccess', _202 => _202.visibilityState]) !== "hidden",
     lastSuccessfulPollAt: startTime,
     count: 0,
     backoff: 0
@@ -8574,10 +8790,10 @@ function makePoller(callback, intervalMs, options) {
     pollNowIfStale();
   }
   function onVisibilityChange() {
-    setInForeground(_optionalChain([doc, 'optionalAccess', _200 => _200.visibilityState]) !== "hidden");
+    setInForeground(_optionalChain([doc, 'optionalAccess', _203 => _203.visibilityState]) !== "hidden");
   }
-  _optionalChain([doc, 'optionalAccess', _201 => _201.addEventListener, 'call', _202 => _202("visibilitychange", onVisibilityChange)]);
-  _optionalChain([win, 'optionalAccess', _203 => _203.addEventListener, 'call', _204 => _204("online", onVisibilityChange)]);
+  _optionalChain([doc, 'optionalAccess', _204 => _204.addEventListener, 'call', _205 => _205("visibilitychange", onVisibilityChange)]);
+  _optionalChain([win, 'optionalAccess', _206 => _206.addEventListener, 'call', _207 => _207("online", onVisibilityChange)]);
   fsm.start();
   return {
     inc,
@@ -8642,9 +8858,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 +8878,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 +8893,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]();
   }
 };