@liveblocks/server 1.0.1

package/dist/index.cjs

@@ -0,0 +1,3285 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// ../../node_modules/@liveblocks/core/dist/index.js
+var __defProp2 = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var PKG_NAME = "@liveblocks/core";
+var PKG_VERSION = "3.14.0-pre5";
+var PKG_FORMAT = "esm";
+var g = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+var crossLinkedDocs = "https://liveblocks.io/docs/errors/cross-linked";
+var dupesDocs = "https://liveblocks.io/docs/errors/dupes";
+var SPACE = " ";
+function error(msg) {
+  if (process.env.NODE_ENV === "production") {
+    console.error(msg);
+  } else {
+    throw new Error(msg);
+  }
+}
+function detectDupes(pkgName, pkgVersion, pkgFormat) {
+  const pkgId = Symbol.for(pkgName);
+  const pkgBuildInfo = pkgFormat ? `${pkgVersion || "dev"} (${pkgFormat})` : pkgVersion || "dev";
+  if (!g[pkgId]) {
+    g[pkgId] = pkgBuildInfo;
+  } else if (g[pkgId] === pkgBuildInfo) {
+  } else {
+    const msg = [
+      `Multiple copies of Liveblocks are being loaded in your project. This will cause issues! See ${dupesDocs + SPACE}`,
+      "",
+      "Conflicts:",
+      `- ${pkgName} ${g[pkgId]} (already loaded)`,
+      `- ${pkgName} ${pkgBuildInfo} (trying to load this now)`
+    ].join("\n");
+    error(msg);
+  }
+  if (pkgVersion && PKG_VERSION && pkgVersion !== PKG_VERSION) {
+    error(
+      [
+        `Cross-linked versions of Liveblocks found, which will cause issues! See ${crossLinkedDocs + SPACE}`,
+        "",
+        "Conflicts:",
+        `- ${PKG_NAME} is at ${PKG_VERSION}`,
+        `- ${pkgName} is at ${pkgVersion}`,
+        "",
+        "Always upgrade all Liveblocks packages to the same version number."
+      ].join("\n")
+    );
+  }
+}
+function makeEventSource() {
+  const _observers = /* @__PURE__ */ new Set();
+  function subscribe(callback) {
+    _observers.add(callback);
+    return () => _observers.delete(callback);
+  }
+  function subscribeOnce(callback) {
+    const unsub = subscribe((event) => {
+      unsub();
+      return callback(event);
+    });
+    return unsub;
+  }
+  async function waitUntil(predicate) {
+    let unsub;
+    return new Promise((res) => {
+      unsub = subscribe((event) => {
+        if (predicate === void 0 || predicate(event)) {
+          res(event);
+        }
+      });
+    }).finally(() => _optionalChain([unsub, 'optionalCall', _2 => _2()]));
+  }
+  function notify(event) {
+    let called = false;
+    for (const callback of _observers) {
+      callback(event);
+      called = true;
+    }
+    return called;
+  }
+  function count() {
+    return _observers.size;
+  }
+  return {
+    // Private/internal control over event emission
+    notify,
+    subscribe,
+    subscribeOnce,
+    count,
+    waitUntil,
+    dispose() {
+      _observers.clear();
+    },
+    // Publicly exposable subscription API
+    observable: {
+      subscribe,
+      subscribeOnce,
+      waitUntil
+    }
+  };
+}
+var freeze = process.env.NODE_ENV === "production" ? (
+  /* istanbul ignore next */
+  (x) => x
+) : Object.freeze;
+function raise(msg) {
+  throw new Error(msg);
+}
+function tryParseJson(rawMessage) {
+  try {
+    return JSON.parse(rawMessage);
+  } catch (e) {
+    return void 0;
+  }
+}
+var kSinks = Symbol("kSinks");
+var kTrigger = Symbol("kTrigger");
+var signalsToTrigger = null;
+var trackedReads = null;
+function enqueueTrigger(signal) {
+  if (!signalsToTrigger) raise("Expected to be in an active batch");
+  signalsToTrigger.add(signal);
+}
+var _a, _eventSource, _b;
+var AbstractSignal = (_b = class {
+  constructor(equals) {
+    /** @internal */
+    __publicField(this, "equals");
+    __privateAdd(this, _eventSource);
+    /** @internal */
+    __publicField(this, _a);
+    this.equals = _nullishCoalesce(equals, () => ( Object.is));
+    __privateSet(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);
+  }
+  dispose() {
+    __privateGet(this, _eventSource).dispose();
+    __privateSet(this, _eventSource, "(disposed)");
+    this.equals = "(disposed)";
+  }
+  get hasWatchers() {
+    if (__privateGet(this, _eventSource).count() > 0) return true;
+    for (const sink of this[kSinks]) {
+      if (sink.hasWatchers) {
+        return true;
+      }
+    }
+    return false;
+  }
+  [(_a = kSinks, kTrigger)]() {
+    __privateGet(this, _eventSource).notify();
+    for (const sink of this[kSinks]) {
+      enqueueTrigger(sink);
+    }
+  }
+  subscribe(callback) {
+    if (__privateGet(this, _eventSource).count() === 0) {
+      this.get();
+    }
+    return __privateGet(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();
+    }
+  }
+  addSink(sink) {
+    this[kSinks].add(sink);
+  }
+  removeSink(sink) {
+    this[kSinks].delete(sink);
+  }
+  asReadonly() {
+    return this;
+  }
+}, _eventSource = new WeakMap(), _b);
+var INITIAL = Symbol();
+var _prevValue, _dirty, _sources, _deps, _transform, __DerivedSignal_instances, recompute_fn, _a2;
+var DerivedSignal = (_a2 = class extends AbstractSignal {
+  constructor(deps, transform, equals) {
+    super(equals);
+    __privateAdd(this, __DerivedSignal_instances);
+    __privateAdd(this, _prevValue);
+    __privateAdd(this, _dirty);
+    // When true, the value in #value may not be up-to-date and needs re-checking
+    __privateAdd(this, _sources);
+    __privateAdd(this, _deps);
+    __privateAdd(this, _transform);
+    __privateSet(this, _dirty, true);
+    __privateSet(this, _prevValue, INITIAL);
+    __privateSet(this, _deps, deps);
+    __privateSet(this, _sources, /* @__PURE__ */ new Set());
+    __privateSet(this, _transform, 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 _a2(args, transform, equals);
+    } else {
+      const transform = last;
+      return new _a2(args, transform);
+    }
+  }
+  dispose() {
+    for (const src of __privateGet(this, _sources)) {
+      src.removeSink(this);
+    }
+    __privateSet(this, _prevValue, "(disposed)");
+    __privateSet(this, _sources, "(disposed)");
+    __privateSet(this, _deps, "(disposed)");
+    __privateSet(this, _transform, "(disposed)");
+  }
+  get isDirty() {
+    return __privateGet(this, _dirty);
+  }
+  markDirty() {
+    if (!__privateGet(this, _dirty)) {
+      __privateSet(this, _dirty, true);
+      this.markSinksDirty();
+    }
+  }
+  get() {
+    if (__privateGet(this, _dirty)) {
+      __privateMethod(this, __DerivedSignal_instances, recompute_fn).call(this);
+    }
+    _optionalChain([trackedReads, 'optionalAccess', _3 => _3.add, 'call', _4 => _4(this)]);
+    return __privateGet(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 = __privateMethod(this, __DerivedSignal_instances, recompute_fn).call(this);
+    if (updated) {
+      super[kTrigger]();
+    }
+  }
+}, _prevValue = new WeakMap(), _dirty = new WeakMap(), _sources = new WeakMap(), _deps = new WeakMap(), _transform = new WeakMap(), __DerivedSignal_instances = new WeakSet(), recompute_fn = function() {
+  const oldTrackedReads = trackedReads;
+  let derived;
+  trackedReads = /* @__PURE__ */ new Set();
+  try {
+    derived = __privateGet(this, _transform).call(this, ...__privateGet(this, _deps).map((p) => p.get()));
+  } finally {
+    const oldSources = __privateGet(this, _sources);
+    __privateSet(this, _sources, /* @__PURE__ */ new Set());
+    for (const sig of trackedReads) {
+      __privateGet(this, _sources).add(sig);
+      oldSources.delete(sig);
+    }
+    for (const oldSource of oldSources) {
+      oldSource.removeSink(this);
+    }
+    for (const newSource of __privateGet(this, _sources)) {
+      newSource.addSink(this);
+    }
+    trackedReads = oldTrackedReads;
+  }
+  __privateSet(this, _dirty, false);
+  if (!this.equals(__privateGet(this, _prevValue), derived)) {
+    __privateSet(this, _prevValue, derived);
+    return true;
+  }
+  return false;
+}, _a2);
+function assertNever(_value, errmsg) {
+  throw new Error(errmsg);
+}
+function assert(condition, errmsg) {
+  if (process.env.NODE_ENV !== "production") {
+    if (!condition) {
+      const err = new Error(errmsg);
+      err.name = "Assertion failure";
+      throw err;
+    }
+  }
+}
+function nn(value, errmsg = "Expected value to be non-nullable") {
+  assert(value !== null && value !== void 0, errmsg);
+  return value;
+}
+var fancy_console_exports = {};
+__export(fancy_console_exports, {
+  error: () => error2,
+  errorWithTitle: () => errorWithTitle,
+  warn: () => warn,
+  warnWithTitle: () => warnWithTitle
+});
+var badge = "background:#0e0d12;border-radius:9999px;color:#fff;padding:3px 7px;font-family:sans-serif;font-weight:600;";
+var bold = "font-weight:600";
+function wrap(method) {
+  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (
+    /* istanbul ignore next */
+    (message, ...args) => console[method]("%cLiveblocks", badge, message, ...args)
+  );
+}
+var warn = wrap("warn");
+var error2 = wrap("error");
+function wrapWithTitle(method) {
+  return typeof window === "undefined" || process.env.NODE_ENV === "test" ? console[method] : (
+    /* istanbul ignore next */
+    (title, message, ...args) => console[method](
+      `%cLiveblocks%c ${title}`,
+      badge,
+      bold,
+      message,
+      ...args
+    )
+  );
+}
+var warnWithTitle = wrapWithTitle("warn");
+var errorWithTitle = wrapWithTitle("error");
+var _defaultFn, _a3;
+var DefaultMap = (_a3 = class extends Map {
+  /**
+   * If the default function is not provided to the constructor, it has to be
+   * provided in each .getOrCreate() call individually.
+   */
+  constructor(defaultFn, entries2) {
+    super(entries2);
+    __privateAdd(this, _defaultFn);
+    __privateSet(this, _defaultFn, defaultFn);
+  }
+  /**
+   * Gets the value at the given key, or creates it.
+   *
+   * Difference from normal Map: if the key does not exist, it will be created
+   * on the fly using the factory function, and that value will get returned
+   * instead of `undefined`.
+   */
+  getOrCreate(key, defaultFn) {
+    if (super.has(key)) {
+      return super.get(key);
+    } else {
+      const fn = _nullishCoalesce(_nullishCoalesce(defaultFn, () => ( __privateGet(this, _defaultFn))), () => ( raise("DefaultMap used without a factory function")));
+      const value = fn(key);
+      this.set(key, value);
+      return value;
+    }
+  }
+}, _defaultFn = new WeakMap(), _a3);
+var ServerMsgCode = Object.freeze({
+  // For Presence
+  UPDATE_PRESENCE: 100,
+  USER_JOINED: 101,
+  USER_LEFT: 102,
+  BROADCASTED_EVENT: 103,
+  ROOM_STATE: 104,
+  // For Storage
+  STORAGE_STATE_V7: 200,
+  // Only sent in V7
+  STORAGE_CHUNK: 210,
+  // Used in V8+
+  STORAGE_STREAM_END: 211,
+  // Used in V8+
+  UPDATE_STORAGE: 201,
+  // For Yjs Docs
+  UPDATE_YDOC: 300,
+  // For Comments
+  THREAD_CREATED: 400,
+  THREAD_DELETED: 407,
+  THREAD_METADATA_UPDATED: 401,
+  THREAD_UPDATED: 408,
+  COMMENT_CREATED: 402,
+  COMMENT_EDITED: 403,
+  COMMENT_DELETED: 404,
+  COMMENT_REACTION_ADDED: 405,
+  COMMENT_REACTION_REMOVED: 406,
+  COMMENT_METADATA_UPDATED: 409,
+  // Error codes
+  REJECT_STORAGE_OP: 299
+  // Sent if a mutation was not allowed on the server (i.e. due to permissions, limit exceeded, etc)
+});
+var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_NORMAL"] = 1e3] = "CLOSE_NORMAL";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["UNEXPECTED_CONDITION"] = 1011] = "UNEXPECTED_CONDITION";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["TRY_AGAIN_LATER"] = 1013] = "TRY_AGAIN_LATER";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["INVALID_MESSAGE_FORMAT"] = 4e3] = "INVALID_MESSAGE_FORMAT";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["ROOM_ID_UPDATED"] = 4006] = "ROOM_ID_UPDATED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["KICKED"] = 4100] = "KICKED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["TOKEN_EXPIRED"] = 4109] = "TOKEN_EXPIRED";
+  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
+  return WebsocketCloseCodes2;
+})(WebsocketCloseCodes || {});
+var BACKOFF_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
+var RESET_DELAY = BACKOFF_DELAYS[0] - 1;
+function log(level, message) {
+  const logger = level === 2 ? error2 : level === 1 ? warn : (
+    /* black hole */
+    () => {
+    }
+  );
+  return () => {
+    logger(message);
+  };
+}
+var logPermanentClose = log(
+  1,
+  "Connection to WebSocket closed permanently. Won't retry."
+);
+var kInternal = Symbol();
+var EMPTY_OBJECT = Object.freeze({});
+var NULL_KEYWORD_CHARS = Array.from(new Set("null"));
+var TRUE_KEYWORD_CHARS = Array.from(new Set("true"));
+var FALSE_KEYWORD_CHARS = Array.from(new Set("false"));
+var ALL_KEYWORD_CHARS = Array.from(new Set("nulltruefalse"));
+var kWILDCARD = Symbol("*");
+var eventSource = makeEventSource();
+if (process.env.NODE_ENV !== "production" && typeof window !== "undefined") {
+  window.addEventListener("message", (event) => {
+    if (event.source === window && _optionalChain([event, 'access', _5 => _5.data, 'optionalAccess', _6 => _6.source]) === "liveblocks-devtools-panel") {
+      eventSource.notify(event.data);
+    } else {
+    }
+  });
+}
+var onMessageFromPanel = eventSource.observable;
+var loadedAt = Date.now();
+var kPlain = Symbol("notification-settings-plain");
+var MIN_CODE = 32;
+var MAX_CODE = 126;
+var NUM_DIGITS = MAX_CODE - MIN_CODE + 1;
+var ZERO = nthDigit(0);
+var ONE = nthDigit(1);
+var ZERO_NINE = ZERO + nthDigit(-1);
+function nthDigit(n) {
+  const code = MIN_CODE + (n < 0 ? NUM_DIGITS + n : n);
+  if (code < MIN_CODE || code > MAX_CODE) {
+    throw new Error(`Invalid n value: ${n}`);
+  }
+  return String.fromCharCode(code);
+}
+function makePosition(x, y) {
+  if (x !== void 0 && y !== void 0) {
+    return between(x, y);
+  } else if (x !== void 0) {
+    return after(x);
+  } else if (y !== void 0) {
+    return before(y);
+  } else {
+    return ONE;
+  }
+}
+function before(pos) {
+  const lastIndex = pos.length - 1;
+  for (let i = 0; i <= lastIndex; i++) {
+    const code = pos.charCodeAt(i);
+    if (code <= MIN_CODE) {
+      continue;
+    }
+    if (i === lastIndex) {
+      if (code === MIN_CODE + 1) {
+        return pos.substring(0, i) + ZERO_NINE;
+      } else {
+        return pos.substring(0, i) + String.fromCharCode(code - 1);
+      }
+    } else {
+      return pos.substring(0, i + 1);
+    }
+  }
+  return ONE;
+}
+var VIEWPORT_START = 2;
+var VIEWPORT_STEP = 3;
+function after(pos) {
+  for (let i = 0; i < pos.length; i++) {
+    const code = pos.charCodeAt(i);
+    if (code < MIN_CODE || code > MAX_CODE) {
+      return pos + ONE;
+    }
+  }
+  while (pos.length > 1 && pos.charCodeAt(pos.length - 1) === MIN_CODE) {
+    pos = pos.slice(0, -1);
+  }
+  if (pos.length === 0 || pos === ZERO) {
+    return ONE;
+  }
+  let viewport = VIEWPORT_START;
+  if (pos.length > VIEWPORT_START) {
+    viewport = VIEWPORT_START + Math.ceil((pos.length - VIEWPORT_START) / VIEWPORT_STEP) * VIEWPORT_STEP;
+  }
+  const result = incrementWithinViewport(pos, viewport);
+  if (result !== null) {
+    return result;
+  }
+  viewport += VIEWPORT_STEP;
+  const extendedResult = incrementWithinViewport(pos, viewport);
+  if (extendedResult !== null) {
+    return extendedResult;
+  }
+  return pos + ONE;
+}
+function incrementWithinViewport(pos, viewport) {
+  const digits = [];
+  for (let i = 0; i < viewport; i++) {
+    if (i < pos.length) {
+      digits.push(pos.charCodeAt(i) - MIN_CODE);
+    } else {
+      digits.push(0);
+    }
+  }
+  let carry = 1;
+  for (let i = viewport - 1; i >= 0 && carry; i--) {
+    const sum = digits[i] + carry;
+    if (sum >= NUM_DIGITS) {
+      digits[i] = 0;
+      carry = 1;
+    } else {
+      digits[i] = sum;
+      carry = 0;
+    }
+  }
+  if (carry) {
+    return null;
+  }
+  let result = "";
+  for (const d of digits) {
+    result += String.fromCharCode(d + MIN_CODE);
+  }
+  while (result.length > 1 && result.charCodeAt(result.length - 1) === MIN_CODE) {
+    result = result.slice(0, -1);
+  }
+  return result;
+}
+function between(lo, hi) {
+  if (lo < hi) {
+    return _between(lo, hi);
+  } else if (lo > hi) {
+    return _between(hi, lo);
+  } else {
+    throw new Error("Cannot compute value between two equal positions");
+  }
+}
+function _between(lo, hi) {
+  let index = 0;
+  const loLen = lo.length;
+  const hiLen = hi.length;
+  while (true) {
+    const loCode = index < loLen ? lo.charCodeAt(index) : MIN_CODE;
+    const hiCode = index < hiLen ? hi.charCodeAt(index) : MAX_CODE;
+    if (loCode === hiCode) {
+      index++;
+      continue;
+    }
+    if (hiCode - loCode === 1) {
+      const size = index + 1;
+      let prefix = lo.substring(0, size);
+      if (prefix.length < size) {
+        prefix += ZERO.repeat(size - prefix.length);
+      }
+      const suffix = lo.substring(size);
+      const nines = "";
+      return prefix + _between(suffix, nines);
+    } else {
+      return takeN(lo, index) + String.fromCharCode(hiCode + loCode >> 1);
+    }
+  }
+}
+function takeN(pos, n) {
+  return n < pos.length ? pos.substring(0, n) : pos + ZERO.repeat(n - pos.length);
+}
+var MIN_NON_ZERO_CODE = MIN_CODE + 1;
+function isPos(str) {
+  if (str === "") {
+    return false;
+  }
+  const lastIdx = str.length - 1;
+  const last = str.charCodeAt(lastIdx);
+  if (last < MIN_NON_ZERO_CODE || last > MAX_CODE) {
+    return false;
+  }
+  for (let i = 0; i < lastIdx; i++) {
+    const code = str.charCodeAt(i);
+    if (code < MIN_CODE || code > MAX_CODE) {
+      return false;
+    }
+  }
+  return true;
+}
+function convertToPos(str) {
+  const codes = [];
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    codes.push(code < MIN_CODE ? MIN_CODE : code > MAX_CODE ? MAX_CODE : code);
+  }
+  while (codes.length > 0 && codes[codes.length - 1] === MIN_CODE) {
+    codes.length--;
+  }
+  return codes.length > 0 ? String.fromCharCode(...codes) : (
+    // Edge case: the str was a 0-only string, which is invalid. Default back to .1
+    ONE
+  );
+}
+function asPos(str) {
+  return isPos(str) ? str : convertToPos(str);
+}
+var OpCode = Object.freeze({
+  INIT: 0,
+  SET_PARENT_KEY: 1,
+  CREATE_LIST: 2,
+  UPDATE_OBJECT: 3,
+  CREATE_OBJECT: 4,
+  DELETE_CRDT: 5,
+  DELETE_OBJECT_KEY: 6,
+  CREATE_MAP: 7,
+  CREATE_REGISTER: 8
+});
+var NoParent = Object.freeze({ type: "NoParent" });
+var CrdtType = Object.freeze({
+  OBJECT: 0,
+  LIST: 1,
+  MAP: 2,
+  REGISTER: 3
+});
+function isRootStorageNode(node) {
+  return node[0] === "root";
+}
+function isObjectStorageNode(node) {
+  return node[1].type === CrdtType.OBJECT;
+}
+function isListStorageNode(node) {
+  return node[1].type === CrdtType.LIST;
+}
+function isMapStorageNode(node) {
+  return node[1].type === CrdtType.MAP;
+}
+function isRegisterStorageNode(node) {
+  return node[1].type === CrdtType.REGISTER;
+}
+function* nodeStreamToCompactNodes(nodes) {
+  for (const node of nodes) {
+    if (isObjectStorageNode(node)) {
+      if (isRootStorageNode(node)) {
+        const id = node[0];
+        const crdt = node[1];
+        yield [id, crdt.data];
+      } else {
+        const id = node[0];
+        const crdt = node[1];
+        yield [id, CrdtType.OBJECT, crdt.parentId, crdt.parentKey, crdt.data];
+      }
+    } else if (isListStorageNode(node)) {
+      const id = node[0];
+      const crdt = node[1];
+      yield [id, CrdtType.LIST, crdt.parentId, crdt.parentKey];
+    } else if (isMapStorageNode(node)) {
+      const id = node[0];
+      const crdt = node[1];
+      yield [id, CrdtType.MAP, crdt.parentId, crdt.parentKey];
+    } else if (isRegisterStorageNode(node)) {
+      const id = node[0];
+      const crdt = node[1];
+      yield [id, CrdtType.REGISTER, crdt.parentId, crdt.parentKey, crdt.data];
+    } else {
+    }
+  }
+}
+var MAX_LIVE_OBJECT_SIZE = 128 * 1024;
+function isJsonScalar(data) {
+  return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+}
+function isJsonArray(data) {
+  return Array.isArray(data);
+}
+function isJsonObject(data) {
+  return !isJsonScalar(data) && !isJsonArray(data);
+}
+var ClientMsgCode = Object.freeze({
+  // For Presence
+  UPDATE_PRESENCE: 100,
+  BROADCAST_EVENT: 103,
+  // For Storage
+  FETCH_STORAGE: 200,
+  UPDATE_STORAGE: 201,
+  // For Yjs support
+  FETCH_YDOC: 300,
+  UPDATE_YDOC: 301
+});
+var MAX_SOCKET_MESSAGE_SIZE = 1024 * 1024 - 512;
+var htmlEscapables = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var htmlEscapablesRegex = new RegExp(
+  Object.keys(htmlEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+var markdownEscapables = {
+  _: "\\_",
+  "*": "\\*",
+  "#": "\\#",
+  "`": "\\`",
+  "~": "\\~",
+  "!": "\\!",
+  "|": "\\|",
+  "(": "\\(",
+  ")": "\\)",
+  "{": "\\{",
+  "}": "\\}",
+  "[": "\\[",
+  "]": "\\]"
+};
+var markdownEscapablesRegex = new RegExp(
+  Object.keys(markdownEscapables).map((entity) => `\\${entity}`).join("|"),
+  "g"
+);
+detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
+
+// src/decoders/ClientMsg.ts
+
+
+
+
+
+
+
+
+
+var _decoders = require('decoders');
+
+// src/decoders/jsonYolo.ts
+
+var jsonYolo = _decoders.unknown;
+var jsonObjectYolo = jsonYolo.refine(
+  (value) => value !== null && typeof value === "object" && !Array.isArray(value),
+  "Must be JSON object"
+);
+
+// src/decoders/Op.ts
+
+var updateObjectOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.UPDATE_OBJECT),
+  opId: _decoders.string,
+  id: _decoders.string,
+  data: jsonObjectYolo
+});
+var createObjectOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.CREATE_OBJECT),
+  opId: _decoders.string,
+  id: _decoders.string,
+  parentId: _decoders.string,
+  parentKey: _decoders.string,
+  data: jsonObjectYolo,
+  intent: _decoders.optional.call(void 0, _decoders.constant.call(void 0, "set")),
+  deletedId: _decoders.optional.call(void 0, _decoders.string)
+});
+var createListOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.CREATE_LIST),
+  opId: _decoders.string,
+  id: _decoders.string,
+  parentId: _decoders.string,
+  parentKey: _decoders.string,
+  intent: _decoders.optional.call(void 0, _decoders.constant.call(void 0, "set")),
+  deletedId: _decoders.optional.call(void 0, _decoders.string)
+});
+var createMapOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.CREATE_MAP),
+  opId: _decoders.string,
+  id: _decoders.string,
+  parentId: _decoders.string,
+  parentKey: _decoders.string,
+  intent: _decoders.optional.call(void 0, _decoders.constant.call(void 0, "set")),
+  deletedId: _decoders.optional.call(void 0, _decoders.string)
+});
+var createRegisterOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.CREATE_REGISTER),
+  opId: _decoders.string,
+  id: _decoders.string,
+  parentId: _decoders.string,
+  parentKey: _decoders.string,
+  data: jsonYolo,
+  intent: _decoders.optional.call(void 0, _decoders.constant.call(void 0, "set")),
+  deletedId: _decoders.optional.call(void 0, _decoders.string)
+});
+var deleteCrdtOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.DELETE_CRDT),
+  opId: _decoders.string,
+  id: _decoders.string
+});
+var setParentKeyOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.SET_PARENT_KEY),
+  opId: _decoders.string,
+  id: _decoders.string,
+  parentKey: _decoders.string
+});
+var deleteObjectKeyOp = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, OpCode.DELETE_OBJECT_KEY),
+  opId: _decoders.string,
+  id: _decoders.string,
+  key: _decoders.string
+});
+var op = _decoders.taggedUnion.call(void 0, "type", {
+  [OpCode.UPDATE_OBJECT]: updateObjectOp,
+  [OpCode.CREATE_OBJECT]: createObjectOp,
+  [OpCode.CREATE_LIST]: createListOp,
+  [OpCode.CREATE_MAP]: createMapOp,
+  [OpCode.CREATE_REGISTER]: createRegisterOp,
+  [OpCode.DELETE_CRDT]: deleteCrdtOp,
+  [OpCode.SET_PARENT_KEY]: setParentKeyOp,
+  [OpCode.DELETE_OBJECT_KEY]: deleteObjectKeyOp
+});
+
+// src/decoders/y-types.ts
+
+var guidDecoder = _decoders.uuid.refineType();
+var ROOT_YDOC_ID = "root";
+
+// src/decoders/ClientMsg.ts
+var updatePresenceClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, ClientMsgCode.UPDATE_PRESENCE),
+  data: jsonObjectYolo,
+  targetActor: _decoders.optional.call(void 0, _decoders.number)
+});
+var broadcastEventClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, ClientMsgCode.BROADCAST_EVENT),
+  event: jsonYolo
+});
+var fetchStorageClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, ClientMsgCode.FETCH_STORAGE)
+});
+var updateStorageClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, ClientMsgCode.UPDATE_STORAGE),
+  ops: _decoders.array.call(void 0, op)
+});
+var fetchYDocClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, ClientMsgCode.FETCH_YDOC),
+  vector: _decoders.string.refineType(),
+  guid: _decoders.optional.call(void 0, guidDecoder),
+  // Don't specify to update the root doc
+  v2: _decoders.optional.call(void 0, _decoders.boolean)
+});
+var updateYDocClientMsg = _decoders.object.call(void 0, {
+  type: _decoders.constant.call(void 0, ClientMsgCode.UPDATE_YDOC),
+  update: _decoders.string.refineType(),
+  guid: _decoders.optional.call(void 0, guidDecoder),
+  // Don't specify to update the root doc
+  v2: _decoders.optional.call(void 0, _decoders.boolean)
+});
+var clientMsgDecoder = _decoders.taggedUnion.call(void 0, "type", {
+  [ClientMsgCode.UPDATE_PRESENCE]: updatePresenceClientMsg,
+  [ClientMsgCode.BROADCAST_EVENT]: broadcastEventClientMsg,
+  [ClientMsgCode.FETCH_STORAGE]: fetchStorageClientMsg,
+  [ClientMsgCode.UPDATE_STORAGE]: updateStorageClientMsg,
+  [ClientMsgCode.FETCH_YDOC]: fetchYDocClientMsg,
+  [ClientMsgCode.UPDATE_YDOC]: updateYDocClientMsg
+}).describe("Must be a valid client message");
+var transientClientMsgDecoder = _decoders.taggedUnion.call(void 0, "type", {
+  // [ClientMsgCode.UPDATE_PRESENCE]: updatePresenceClientMsg,
+  // [ClientMsgCode.BROADCAST_EVENT]: broadcastEventClientMsg,
+  // [ClientMsgCode.FETCH_STORAGE]: fetchStorageClientMsg,
+  [ClientMsgCode.UPDATE_STORAGE]: updateStorageClientMsg
+  // [ClientMsgCode.FETCH_YDOC]: fetchYDocClientMsg,
+  // [ClientMsgCode.UPDATE_YDOC]: updateYDocClientMsg,
+}).describe("Must be a valid transient client message");
+
+// src/formats/LossyJson.ts
+function snapshotToLossyJson_eager(snapshot2) {
+  try {
+    return buildObject(snapshot2, "root", snapshot2.get_root().data);
+  } finally {
+    snapshot2.destroy();
+  }
+}
+function buildNode(snapshot2, id) {
+  const node = snapshot2.get_node(id);
+  if (node.type === CrdtType.OBJECT) {
+    return buildObject(snapshot2, id, node.data);
+  } else if (node.type === CrdtType.LIST) {
+    return buildList(snapshot2, id);
+  } else if (node.type === CrdtType.MAP) {
+    return buildMap(snapshot2, id);
+  } else {
+    return node.data;
+  }
+}
+function buildObject(snapshot2, id, staticData) {
+  const data = Object.assign(/* @__PURE__ */ Object.create(null), staticData);
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    data[key] = buildNode(snapshot2, childId);
+  }
+  return data;
+}
+function buildList(snapshot2, id) {
+  const data = [];
+  for (const [_, childId] of snapshot2.iter_children(id)) {
+    data.push(buildNode(snapshot2, childId));
+  }
+  return data;
+}
+function buildMap(snapshot2, id) {
+  const data = /* @__PURE__ */ Object.create(null);
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    data[key] = buildNode(snapshot2, childId);
+  }
+  return data;
+}
+function* snapshotToLossyJson_lazy(snapshot2) {
+  try {
+    const staticJson = JSON.stringify(snapshot2.get_root().data).slice(1, -1);
+    yield* emitObject(snapshot2, "root", staticJson);
+  } finally {
+    snapshot2.destroy();
+  }
+}
+function* emit(snapshot2, id) {
+  const node = snapshot2.get_node(id);
+  if (node.type === CrdtType.OBJECT) {
+    yield* emitObject(snapshot2, id, JSON.stringify(node.data).slice(1, -1));
+  } else if (node.type === CrdtType.LIST) {
+    yield* emitList(snapshot2, id);
+  } else if (node.type === CrdtType.MAP) {
+    yield* emitMap(snapshot2, id);
+  } else if (node.type === CrdtType.REGISTER) {
+    yield JSON.stringify(node.data);
+  }
+}
+function* emitObject(snapshot2, id, staticJson) {
+  let comma = staticJson.length > 0;
+  yield "{";
+  yield staticJson;
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    if (comma) yield ",";
+    else comma = true;
+    yield `${JSON.stringify(key)}:`;
+    yield* emit(snapshot2, childId);
+  }
+  yield "}";
+}
+function* emitList(snapshot2, id) {
+  let comma = false;
+  yield "[";
+  for (const [_, childId] of snapshot2.iter_children(id)) {
+    if (comma) yield ",";
+    else comma = true;
+    yield* emit(snapshot2, childId);
+  }
+  yield "]";
+}
+function* emitMap(snapshot2, id) {
+  let comma = false;
+  yield "{";
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    if (comma) yield ",";
+    else comma = true;
+    yield `${JSON.stringify(key)}:`;
+    yield* emit(snapshot2, childId);
+  }
+  yield "}";
+}
+
+// src/formats/NodeStream.ts
+function* snapshotToNodeStream(snapshot2) {
+  try {
+    yield* snapshot2.iter_all();
+  } finally {
+    snapshot2.destroy();
+  }
+}
+
+// src/formats/PlainLson.ts
+var SERVER_INIT_OP_PREFIX = "si";
+function generateId(state) {
+  return `${SERVER_INIT_OP_PREFIX}:${state.clock++}`;
+}
+function isSpecialPlainLsonValue(value) {
+  return isJsonObject(value) && value.liveblocksType !== void 0;
+}
+function* iterJson(key, data, parent, state) {
+  if (isSpecialPlainLsonValue(data)) {
+    switch (data.liveblocksType) {
+      case "LiveObject":
+        yield* iterObjectInner(key, data.data, parent, state);
+        return;
+      case "LiveList":
+        yield* iterList(key, data.data, parent, state);
+        return;
+      case "LiveMap":
+        yield* iterMap(key, data.data, parent, state);
+        return;
+      default:
+        assertNever(data, "Unknown `liveblocksType` field");
+    }
+  } else {
+    yield [
+      generateId(state),
+      {
+        type: CrdtType.REGISTER,
+        data,
+        parentId: parent[0],
+        parentKey: key
+      }
+    ];
+  }
+}
+function* iterMap(key, map, parent, state) {
+  const mapTuple = [
+    generateId(state),
+    { type: CrdtType.MAP, parentId: parent[0], parentKey: key }
+  ];
+  yield mapTuple;
+  for (const [subKey, subValue] of Object.entries(map)) {
+    yield* iterJson(subKey, subValue, mapTuple, state);
+  }
+}
+function* iterList(key, list, parent, state) {
+  const id = generateId(state);
+  const crdt = {
+    type: CrdtType.LIST,
+    parentId: parent[0],
+    parentKey: key
+  };
+  const listTuple = [id, crdt];
+  yield listTuple;
+  let position = makePosition();
+  for (const subValue of list) {
+    yield* iterJson(position, subValue, listTuple, state);
+    position = makePosition(position);
+  }
+}
+function* iterObjectInner(key, value, parent, state) {
+  const data = {};
+  const specialChildren = [];
+  for (const [subKey, subValue] of Object.entries(value)) {
+    if (isSpecialPlainLsonValue(subValue)) {
+      specialChildren.push([subKey, subValue]);
+    } else {
+      data[subKey] = subValue;
+    }
+  }
+  const objectTuple = parent !== null ? [
+    generateId(state),
+    {
+      type: CrdtType.OBJECT,
+      data,
+      parentId: parent[0],
+      parentKey: key
+    }
+  ] : ["root", { type: CrdtType.OBJECT, data }];
+  yield objectTuple;
+  for (const [subKey, subValue] of specialChildren) {
+    yield* iterJson(subKey, subValue, objectTuple, state);
+  }
+}
+function* plainLsonToNodeStream(root) {
+  const state = { clock: 1 };
+  yield* iterObjectInner("root", root.data, null, state);
+}
+function snapshotToPlainLson_eager(snapshot2) {
+  try {
+    return buildObject2(snapshot2, "root", snapshot2.get_root().data);
+  } finally {
+    snapshot2.destroy();
+  }
+}
+function buildNode2(snapshot2, id) {
+  const node = snapshot2.get_node(id);
+  if (node.type === CrdtType.OBJECT) {
+    return buildObject2(snapshot2, id, node.data);
+  } else if (node.type === CrdtType.LIST) {
+    return buildList2(snapshot2, id);
+  } else if (node.type === CrdtType.MAP) {
+    return buildMap2(snapshot2, id);
+  } else {
+    return node.data;
+  }
+}
+function buildObject2(snapshot2, id, staticData) {
+  const data = Object.assign(
+    /* @__PURE__ */ Object.create(null),
+    staticData
+  );
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    data[key] = buildNode2(snapshot2, childId);
+  }
+  return { liveblocksType: "LiveObject", data };
+}
+function buildList2(snapshot2, id) {
+  const data = [];
+  for (const [_, childId] of snapshot2.iter_children(id)) {
+    data.push(buildNode2(snapshot2, childId));
+  }
+  return { liveblocksType: "LiveList", data };
+}
+function buildMap2(snapshot2, id) {
+  const data = /* @__PURE__ */ Object.create(null);
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    data[key] = buildNode2(snapshot2, childId);
+  }
+  return { liveblocksType: "LiveMap", data };
+}
+function* snapshotToPlainLson_lazy(snapshot2) {
+  try {
+    const staticJson = JSON.stringify(snapshot2.get_root().data).slice(1, -1);
+    yield* emitObject2(snapshot2, "root", staticJson);
+  } finally {
+    snapshot2.destroy();
+  }
+}
+function* emit2(snapshot2, id) {
+  const node = snapshot2.get_node(id);
+  if (node.type === CrdtType.OBJECT) {
+    yield* emitObject2(snapshot2, id, JSON.stringify(node.data).slice(1, -1));
+  } else if (node.type === CrdtType.LIST) {
+    yield* emitList2(snapshot2, id);
+  } else if (node.type === CrdtType.MAP) {
+    yield* emitMap2(snapshot2, id);
+  } else if (node.type === CrdtType.REGISTER) {
+    yield JSON.stringify(node.data);
+  }
+}
+function* emitObject2(snapshot2, id, staticJson) {
+  let comma = staticJson.length > 0;
+  yield '{"liveblocksType":"LiveObject","data":{';
+  yield staticJson;
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    if (comma) yield ",";
+    else comma = true;
+    yield `${JSON.stringify(key)}:`;
+    yield* emit2(snapshot2, childId);
+  }
+  yield "}}";
+}
+function* emitList2(snapshot2, id) {
+  let comma = false;
+  yield '{"liveblocksType":"LiveList","data":[';
+  for (const [_, childId] of snapshot2.iter_children(id)) {
+    if (comma) yield ",";
+    else comma = true;
+    yield* emit2(snapshot2, childId);
+  }
+  yield "]}";
+}
+function* emitMap2(snapshot2, id) {
+  let comma = false;
+  yield '{"liveblocksType":"LiveMap","data":{';
+  for (const [key, childId] of snapshot2.iter_children(id)) {
+    if (comma) yield ",";
+    else comma = true;
+    yield `${JSON.stringify(key)}:`;
+    yield* emit2(snapshot2, childId);
+  }
+  yield "}}";
+}
+
+// src/lib/DefaultMap.ts
+var _defaultFn2;
+var DefaultMap2 = class extends Map {
+  /**
+   * If the default function is not provided to the constructor, it has to be
+   * provided in each .getOrCreate() call individually.
+   */
+  constructor(defaultFn, entries) {
+    super(entries);
+    __privateAdd(this, _defaultFn2);
+    __privateSet(this, _defaultFn2, defaultFn);
+  }
+  /**
+   * Gets the value at the given key, or creates it.
+   *
+   * Difference from normal Map: if the key does not exist, it will be created
+   * on the fly using the factory function, and that value will get returned
+   * instead of `undefined`.
+   */
+  getOrCreate(key, defaultFn) {
+    if (super.has(key)) {
+      return super.get(key);
+    } else {
+      const fn = _nullishCoalesce(_nullishCoalesce(defaultFn, () => ( __privateGet(this, _defaultFn2))), () => ( raise("DefaultMap used without a factory function")));
+      const value = fn(key);
+      this.set(key, value);
+      return value;
+    }
+  }
+};
+_defaultFn2 = new WeakMap();
+
+// src/lib/NestedMap.ts
+function emptyIterator() {
+  return [][Symbol.iterator]();
+}
+var _map;
+var NestedMap = class {
+  constructor() {
+    __privateAdd(this, _map);
+    __privateSet(this, _map, new DefaultMap2(() => /* @__PURE__ */ new Map()));
+  }
+  get size() {
+    let total = 0;
+    for (const value of __privateGet(this, _map).values()) {
+      total += value.size;
+    }
+    return total;
+  }
+  count(key1) {
+    return _nullishCoalesce(_optionalChain([__privateGet, 'call', _7 => _7(this, _map), 'access', _8 => _8.get, 'call', _9 => _9(key1), 'optionalAccess', _10 => _10.size]), () => ( 0));
+  }
+  *keys() {
+    for (const [key1, nested] of __privateGet(this, _map)) {
+      for (const key2 of nested.keys()) {
+        yield [key1, key2];
+      }
+    }
+  }
+  has(key1, key2) {
+    return _nullishCoalesce(_optionalChain([__privateGet, 'call', _11 => _11(this, _map), 'access', _12 => _12.get, 'call', _13 => _13(key1), 'optionalAccess', _14 => _14.has, 'call', _15 => _15(key2)]), () => ( false));
+  }
+  get(key1, key2) {
+    return _optionalChain([__privateGet, 'call', _16 => _16(this, _map), 'access', _17 => _17.get, 'call', _18 => _18(key1), 'optionalAccess', _19 => _19.get, 'call', _20 => _20(key2)]);
+  }
+  set(key1, key2, value) {
+    __privateGet(this, _map).getOrCreate(key1).set(key2, value);
+    return this;
+  }
+  delete(key1, key2) {
+    if (!__privateGet(this, _map).has(key1)) {
+      return;
+    }
+    const nested = __privateGet(this, _map).get(key1);
+    nested.delete(key2);
+    if (nested.size === 0) {
+      __privateGet(this, _map).delete(key1);
+    }
+  }
+  clear() {
+    __privateGet(this, _map).clear();
+  }
+  *[Symbol.iterator]() {
+    for (const [key1, nested] of __privateGet(this, _map)) {
+      for (const [key2, value] of nested) {
+        yield [key1, key2, value];
+      }
+    }
+  }
+  entriesAt(key1) {
+    return _nullishCoalesce(_optionalChain([__privateGet, 'call', _21 => _21(this, _map), 'access', _22 => _22.get, 'call', _23 => _23(key1), 'optionalAccess', _24 => _24.entries, 'call', _25 => _25()]), () => ( emptyIterator()));
+  }
+  *filterAt(key1, keys) {
+    const nested = __privateGet(this, _map).get(key1);
+    if (nested === void 0) {
+      return;
+    }
+    for (const k2 of keys) {
+      const value = nested.get(k2);
+      if (value !== void 0) {
+        yield [k2, value];
+      }
+    }
+  }
+  keysAt(key1) {
+    return _nullishCoalesce(_optionalChain([__privateGet, 'call', _26 => _26(this, _map), 'access', _27 => _27.get, 'call', _28 => _28(key1), 'optionalAccess', _29 => _29.keys, 'call', _30 => _30()]), () => ( emptyIterator()));
+  }
+  valuesAt(key1) {
+    return _nullishCoalesce(_optionalChain([__privateGet, 'call', _31 => _31(this, _map), 'access', _32 => _32.get, 'call', _33 => _33(key1), 'optionalAccess', _34 => _34.values, 'call', _35 => _35()]), () => ( emptyIterator()));
+  }
+  deleteAll(key1) {
+    __privateGet(this, _map).delete(key1);
+  }
+};
+_map = new WeakMap();
+
+// src/makeInMemorySnapshot.ts
+function makeInMemorySnapshot(values) {
+  const map = new Map(values);
+  if (!map.has("root")) {
+    map.set("root", { type: CrdtType.OBJECT, data: {} });
+  }
+  const entries = [];
+  const nodeStream = map;
+  for (const node of nodeStream) {
+    if (isRootStorageNode(node)) continue;
+    const [id, crdt] = node;
+    entries.push([crdt.parentId, crdt.parentKey, id]);
+  }
+  entries.sort(
+    (a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0
+  );
+  const revMap = new NestedMap();
+  for (const [parentId, parentKey, id] of entries) {
+    revMap.set(parentId, parentKey, id);
+  }
+  function get_node(id) {
+    return nn(map.get(id), `Node not found: ${id}`);
+  }
+  return {
+    get_root: () => nn(
+      map.get("root"),
+      "Root not found"
+    ),
+    get_node,
+    iter_children: (nodeId) => revMap.entriesAt(nodeId),
+    iter_all: () => map,
+    destroy() {
+      map.clear();
+      revMap.clear();
+    }
+  };
+}
+
+// src/MetadataDB.ts
+function makeMetadataDB(driver) {
+  async function get(a1, a2) {
+    if (a2 === void 0) {
+      return await driver.get_meta(a1);
+    } else {
+      return a1.value(await driver.get_meta(a2));
+    }
+  }
+  return {
+    get,
+    put: driver.put_meta.bind(driver),
+    delete: driver.delete_meta.bind(driver)
+  };
+}
+
+// src/protocol/ProtocolVersion.ts
+
+var ProtocolVersion = /* @__PURE__ */ ((ProtocolVersion2) => {
+  ProtocolVersion2[ProtocolVersion2["V7"] = 7] = "V7";
+  ProtocolVersion2[ProtocolVersion2["V8"] = 8] = "V8";
+  return ProtocolVersion2;
+})(ProtocolVersion || {});
+var protocolVersionDecoder = _decoders.enum_.call(void 0, ProtocolVersion).describe(
+  "Unsupported protocol version"
+);
+
+// src/Room.ts
+var _asyncmutex = require('async-mutex');
+
+var _itertools = require('itertools');
+var _nanoid = require('nanoid');
+
+// src/lib/Logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARNING"] = 2] = "WARNING";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+function formatError(err) {
+  const prefix = `${err.name}: ${err.message}`;
+  return (_optionalChain([err, 'access', _36 => _36.stack, 'optionalAccess', _37 => _37.startsWith, 'call', _38 => _38(prefix)]) ? err.stack : `${prefix}
+${_nullishCoalesce(err.stack, () => ( ""))}`).trimEnd();
+}
+var _cache;
+var LogTarget = class {
+  constructor(level = 1 /* INFO */) {
+    __publicField(this, "level");
+    __privateAdd(this, _cache, /* @__PURE__ */ new WeakMap());
+    this.level = typeof level === "number" ? level : _nullishCoalesce(LogLevelNames[level], () => ( 1)) /* INFO */;
+  }
+  /** Helper for formatting a log level */
+  formatLevel(level) {
+    switch (level) {
+      case 0 /* DEBUG */:
+        return "debug";
+      case 1 /* INFO */:
+        return "info";
+      case 2 /* WARNING */:
+        return "warn";
+      case 3 /* ERROR */:
+        return "error";
+      default:
+        return raise("Invalid log level");
+    }
+  }
+  /** Helper for formatting an Arg */
+  formatArg(arg) {
+    return typeof arg === "object" ? arg instanceof Error ? formatError(arg) : JSON.stringify(arg) : String(arg);
+  }
+  /**
+   * Helper for formatting a Context. Override this in a subclass to change the
+   * formatting.
+   */
+  formatContextImpl(context) {
+    const parts = [];
+    for (const [k, v] of Object.entries(_nullishCoalesce(context, () => ( {})))) {
+      if (v !== void 0) {
+        const sv = typeof v === "object" ? JSON.stringify(v) : v;
+        parts.push(`${k}=${sv}`);
+      }
+    }
+    return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+  }
+  /**
+   * Helper for formatting a Context. Will only compute the string once for
+   * every Context instance, and keep its computed string value cached for
+   * performance.
+   */
+  formatContext(context) {
+    let formatted = __privateGet(this, _cache).get(context);
+    if (formatted === void 0) {
+      formatted = this.formatContextImpl(context);
+      __privateGet(this, _cache).set(context, formatted);
+    }
+    return formatted;
+  }
+};
+_cache = new WeakMap();
+var CONSOLE_METHOD = {
+  [0 /* DEBUG */]: "info",
+  [1 /* INFO */]: "info",
+  [2 /* WARNING */]: "warn",
+  [3 /* ERROR */]: "error"
+};
+var ConsoleTarget = class extends LogTarget {
+  log(level, context, arg) {
+    console[CONSOLE_METHOD[level]](
+      this.formatArg(arg),
+      this.formatContext(context)
+    );
+  }
+};
+var LogLevelNames = {
+  debug: 0 /* DEBUG */,
+  info: 1 /* INFO */,
+  warning: 2 /* WARNING */,
+  error: 3 /* ERROR */
+};
+var Logger = class _Logger {
+  constructor(target = new ConsoleTarget(), context = {}) {
+    __publicField(this, "debug");
+    __publicField(this, "info");
+    __publicField(this, "warn");
+    __publicField(this, "error");
+    __publicField(this, "o");
+    __publicField(this, "_context");
+    __publicField(this, "_targets");
+    this._context = context;
+    this._targets = Array.isArray(target) ? target : [target];
+    const minLevel = Math.min(...this._targets.map((t) => t.level));
+    const noop = () => {
+    };
+    const makeLogFn = (lvl) => (arg) => this._targets.forEach((target2) => {
+      if (target2.level <= lvl) {
+        target2.log(lvl, this._context, arg);
+      }
+    });
+    this.o = {
+      /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+      debug: minLevel <= 0 /* DEBUG */ ? makeLogFn(0 /* DEBUG */) : void 0,
+      info: minLevel <= 1 /* INFO */ ? makeLogFn(1 /* INFO */) : void 0,
+      warn: minLevel <= 2 /* WARNING */ ? makeLogFn(2 /* WARNING */) : void 0,
+      error: minLevel <= 3 /* ERROR */ ? makeLogFn(3 /* ERROR */) : void 0
+      /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
+    };
+    this.debug = _nullishCoalesce(this.o.debug, () => ( noop));
+    this.info = _nullishCoalesce(this.o.info, () => ( noop));
+    this.warn = _nullishCoalesce(this.o.warn, () => ( noop));
+    this.error = _nullishCoalesce(this.o.error, () => ( noop));
+  }
+  /**
+   * Creates a new Logger instance with the given extra context applied. All
+   * log calls made from that new Logger will carry all current _and_ the extra
+   * context, with the extra context taking precedence. Assign an explicit
+   * `undefined` value to a key to "remove" it from the context.
+   */
+  withContext(extra) {
+    const combined = { ...this._context, ...extra };
+    return new _Logger(this._targets, combined);
+  }
+};
+
+// src/plugins/InMemoryDriver.ts
+
+
+// src/lib/text.ts
+function quote(value) {
+  return value !== void 0 ? `'${value}'` : "???";
+}
+
+// src/plugins/InMemoryDriver.ts
+function buildRevNodes(nodeStream) {
+  const result = new NestedMap();
+  for (const node of nodeStream) {
+    if (isRootStorageNode(node)) continue;
+    const [id, crdt] = node;
+    const existing = result.get(crdt.parentId, crdt.parentKey);
+    if (existing === void 0 || id > existing) {
+      result.set(crdt.parentId, crdt.parentKey, id);
+    }
+  }
+  return result;
+}
+function buildReverseLookup(nodes) {
+  const revNodes = buildRevNodes(nodes);
+  const queue = ["root"];
+  const reachableNodes = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const nodeId = queue.pop();
+    const node = nn(nodes.get(nodeId));
+    if (node.type === CrdtType.OBJECT) {
+      for (const key of revNodes.keysAt(nodeId)) {
+        delete node.data[key];
+      }
+    }
+    if (node.type !== CrdtType.REGISTER) {
+      queue.push(...revNodes.valuesAt(nodeId));
+    } else {
+      const parent = nodes.get(node.parentId);
+      if (_optionalChain([parent, 'optionalAccess', _39 => _39.type]) === CrdtType.OBJECT) {
+        continue;
+      }
+    }
+    reachableNodes.add(nodeId);
+  }
+  let deletedCount = 0;
+  for (const [id] of nodes) {
+    if (!reachableNodes.has(id)) {
+      nodes.delete(id);
+      deletedCount++;
+    }
+  }
+  return deletedCount === 0 ? revNodes : buildRevNodes(nodes);
+}
+function hasStaticDataAt(node, key) {
+  return node.type === CrdtType.OBJECT && Object.prototype.hasOwnProperty.call(node.data, key) && node.data[key] !== void 0;
+}
+var InMemoryDriver = class {
+  constructor(options) {
+    __publicField(this, "_nextActor");
+    __publicField(this, "_nodes");
+    __publicField(this, "_metadb");
+    __publicField(this, "_ydb");
+    this._nodes = /* @__PURE__ */ new Map();
+    this._metadb = /* @__PURE__ */ new Map();
+    this._ydb = /* @__PURE__ */ new Map();
+    this._nextActor = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.initialActor]), () => ( -1));
+    for (const [key, value] of _nullishCoalesce(_optionalChain([options, 'optionalAccess', _41 => _41.initialNodes]), () => ( []))) {
+      this._nodes.set(key, value);
+    }
+  }
+  raw_iter_nodes() {
+    return this._nodes[Symbol.iterator]();
+  }
+  /** Deletes all nodes and replaces them with the given document. */
+  DANGEROUSLY_reset_nodes(doc) {
+    this._nodes.clear();
+    for (const [id, node] of plainLsonToNodeStream(doc)) {
+      this._nodes.set(id, node);
+    }
+  }
+  async get_meta(key) {
+    return this._metadb.get(key);
+  }
+  async put_meta(key, value) {
+    this._metadb.set(key, value);
+  }
+  async delete_meta(key) {
+    this._metadb.delete(key);
+  }
+  next_actor() {
+    return ++this._nextActor;
+  }
+  async iter_y_updates(docId) {
+    const prefix = `${docId}@|@`;
+    return _itertools.imap.call(void 0, 
+      _itertools.ifilter.call(void 0, this._ydb.entries(), ([k]) => k.startsWith(prefix)),
+      ([k, v]) => [k.slice(prefix.length), v]
+    );
+  }
+  async write_y_updates(docId, key, data) {
+    this._ydb.set(`${docId}@|@${key}`, data);
+  }
+  async delete_y_updates(docId, keys) {
+    for (const key of keys) {
+      this._ydb.delete(`${docId}@|@${key}`);
+    }
+  }
+  /** @private Only use this in unit tests, never in production. */
+  async DANGEROUSLY_wipe_all_y_updates() {
+    this._ydb.clear();
+  }
+  // Intercept load_nodes_api to add caching layer
+  load_nodes_api() {
+    const nodes = this._nodes;
+    if (!nodes.has("root")) {
+      nodes.set("root", { type: CrdtType.OBJECT, data: {} });
+    }
+    const revNodes = buildReverseLookup(nodes);
+    function get_next_sibling(parentId, pos) {
+      let nextPos;
+      for (const siblingKey of revNodes.keysAt(parentId)) {
+        const siblingPos = asPos(siblingKey);
+        if (siblingPos > pos && (nextPos === void 0 || siblingPos < nextPos)) {
+          nextPos = siblingPos;
+        }
+      }
+      return nextPos;
+    }
+    async function set_child(id, node, allowOverwrite = false) {
+      const parentNode = nodes.get(node.parentId);
+      if (parentNode === void 0) {
+        throw new Error(`No such parent ${quote(node.parentId)}`);
+      }
+      if (node.type === CrdtType.REGISTER && parentNode.type === CrdtType.OBJECT) {
+        throw new Error("Cannot add register under object");
+      }
+      const conflictingSiblingId = revNodes.get(node.parentId, node.parentKey);
+      if (conflictingSiblingId !== id) {
+        const parentNode2 = nodes.get(node.parentId);
+        const hasConflictingData = parentNode2 !== void 0 && hasStaticDataAt(parentNode2, node.parentKey);
+        if (conflictingSiblingId !== void 0 || hasConflictingData) {
+          if (allowOverwrite) {
+            delete_child_key(node.parentId, node.parentKey);
+          } else {
+            throw new Error(`Key ${quote(node.parentKey)} already exists`);
+          }
+        }
+        revNodes.set(node.parentId, node.parentKey, id);
+      }
+      nodes.set(id, node);
+    }
+    async function move_sibling(id, newPos) {
+      const node = nodes.get(id);
+      if (_optionalChain([node, 'optionalAccess', _42 => _42.parentId]) === void 0) {
+        return;
+      }
+      if (revNodes.has(node.parentId, newPos))
+        throw new Error(`Pos ${quote(newPos)} already taken`);
+      revNodes.delete(node.parentId, node.parentKey);
+      const newNode = { ...node, parentKey: newPos };
+      nodes.set(id, newNode);
+      revNodes.set(node.parentId, newPos, id);
+    }
+    async function set_object_data(id, data, allowOverwrite = false) {
+      const node = nodes.get(id);
+      if (_optionalChain([node, 'optionalAccess', _43 => _43.type]) !== CrdtType.OBJECT) {
+        return;
+      }
+      for (const key of Object.keys(data)) {
+        const childId = revNodes.get(id, key);
+        if (childId !== void 0) {
+          if (allowOverwrite) {
+            delete_node(childId);
+          } else {
+            throw new Error(`Child node already exists under ${quote(key)}`);
+          }
+        }
+      }
+      nodes.set(id, { ...node, data: { ...node.data, ...data } });
+    }
+    function delete_node(id) {
+      const node = nodes.get(id);
+      if (_optionalChain([node, 'optionalAccess', _44 => _44.parentId]) === void 0) {
+        return;
+      }
+      revNodes.delete(node.parentId, node.parentKey);
+      const queue = [id];
+      while (queue.length > 0) {
+        const currid = queue.pop();
+        queue.push(...revNodes.valuesAt(currid));
+        nodes.delete(currid);
+        revNodes.deleteAll(currid);
+      }
+    }
+    function delete_child_key(id, key) {
+      const node = nodes.get(id);
+      if (node !== void 0 && hasStaticDataAt(node, key)) {
+        const { [key]: _, ...rest } = node.data;
+        nodes.set(id, { ...node, data: rest });
+      }
+      const childId = revNodes.get(id, key);
+      if (childId !== void 0) {
+        delete_node(childId);
+      }
+    }
+    const api = {
+      /**
+       * Return the node with the given id, or undefined if no such node exists.
+       * Must always return a valid root node for id="root", even if empty.
+       */
+      get_node: (id) => nodes.get(id),
+      /**
+       * Yield all nodes as [id, node] pairs. Must always include the root node.
+       */
+      iter_nodes: () => nodes,
+      /**
+       * Return true iff a node with the given id exists. Must return true for "root".
+       */
+      has_node: (id) => nodes.has(id),
+      /**
+       * Return the id of the child node at (parentId, parentKey), or undefined if
+       * none. Only checks child nodes registered via set_child, NOT static data
+       * keys on OBJECT nodes.
+       */
+      get_child_at: (id, key) => revNodes.get(id, key),
+      /**
+       * Return true iff a child node exists at (parentId, parentKey). Static data
+       * keys on OBJECT nodes do not count—return false for those.
+       */
+      has_child_at: (id, key) => revNodes.has(id, key),
+      /**
+       * Return the position of the closest sibling "to the right" of `pos` under
+       * parentId, or undefined if no such sibling exists. The given `pos` may, but
+       * does not have to exist already. Positions compare lexicographically.
+       */
+      get_next_sibling,
+      /**
+       * Insert a child node with the given id.
+       *
+       * If allowOverwrite=false (default): throw if a node with this id exists.
+       * If allowOverwrite=true: replace any existing node at this id, deleting its
+       * entire subtree if it has children.
+       */
+      set_child,
+      /**
+       * Change a node's parentKey, effectively repositioning the node within its
+       * parent. The new position must be free.
+       * Throw if another node already occupies (parentId, newPos).
+       */
+      move_sibling,
+      /**
+       * Delete a node and its entire subtree recursively.
+       * Ignore if id="root" (root is immortal).
+       */
+      delete_node,
+      /**
+       * Delete a key from node `id`. Handle two cases:
+       *
+       * 1. If id is an OBJECT with `key` in its data: remove that data field.
+       * 2. If a child exists at (id, key): delete that child and all its
+       *    descendants recursively.
+       *
+       * No-op if neither applies or if the node doesn't exist.
+       */
+      delete_child_key,
+      /**
+       * Replace the data object of an OBJECT node.
+       *
+       * If allowOverwrite=false (default): throw if any key in `data` conflicts
+       * with an existing child's parentKey.
+       * If allowOverwrite=true: first delete any conflicting children (and their
+       * entire subtrees), then set the data.
+       */
+      set_object_data,
+      /**
+       * Return a readable snapshot of the storage tree.
+       *
+       * @param lowMemory When true, the call site hints that the snapshot should
+       * be optimized for lower memory consumption, even if that means slower
+       * access.
+       */
+      get_snapshot(_lowMemory) {
+        return makeInMemorySnapshot(nodes);
+      }
+    };
+    return api;
+  }
+};
+function makeNewInMemoryDriver(options) {
+  return new InMemoryDriver(options);
+}
+
+// src/Storage.ts
+function accept(op2, fix) {
+  return { action: "accepted", op: op2, fix };
+}
+function ignore(ignoredOp) {
+  return { action: "ignored", ignoredOpId: ignoredOp.opId };
+}
+function nodeFromCreateChildOp(op2) {
+  switch (op2.type) {
+    case OpCode.CREATE_LIST:
+      return {
+        type: CrdtType.LIST,
+        parentId: op2.parentId,
+        parentKey: op2.parentKey
+      };
+    case OpCode.CREATE_MAP:
+      return {
+        type: CrdtType.MAP,
+        parentId: op2.parentId,
+        parentKey: op2.parentKey
+      };
+    case OpCode.CREATE_OBJECT:
+      return {
+        type: CrdtType.OBJECT,
+        parentId: op2.parentId,
+        parentKey: op2.parentKey,
+        data: op2.data
+      };
+    case OpCode.CREATE_REGISTER:
+      return {
+        type: CrdtType.REGISTER,
+        parentId: op2.parentId,
+        parentKey: op2.parentKey,
+        data: op2.data
+      };
+    default:
+      return assertNever(op2, "Unknown op code");
+  }
+}
+var Storage = class {
+  constructor(coreDriver) {
+    // The actual underlying storage API (could be backed by in-memory store,
+    // SQLite, Redis, Postgres, Cloudflare Durable Object Storage, etc.)
+    __publicField(this, "coreDriver");
+    __publicField(this, "_loadedDriver");
+    this.coreDriver = coreDriver;
+  }
+  // -------------------------------------------------------------------------
+  // Public API (for Storage)
+  // -------------------------------------------------------------------------
+  get loadedDriver() {
+    if (this._loadedDriver === void 0) {
+      throw new Error("Cannot access tree before it's been loaded");
+    }
+    return this._loadedDriver;
+  }
+  // REFACTOR NOTE: Eventually raw_iter_nodes has to be removed here
+  raw_iter_nodes() {
+    return this.coreDriver.raw_iter_nodes();
+  }
+  /**
+   * Load the room data from object storage into memory. Persisted room
+   * data consists of the main node map, which represents the Liveblocks
+   * Storage tree, and special keys where we store usage metrics, or room
+   * metadata.
+   */
+  async load(logger) {
+    this._loadedDriver = await this.coreDriver.load_nodes_api(logger);
+  }
+  unload() {
+    this._loadedDriver = void 0;
+  }
+  /**
+   * Applies a batch of Ops.
+   */
+  async applyOps(ops) {
+    const results = [];
+    for (const op2 of ops) {
+      results.push(await this.applyOp(op2));
+    }
+    return results;
+  }
+  // -------------------------------------------------------------------------
+  // Private APIs (for Storage)
+  // -------------------------------------------------------------------------
+  /**
+   * Applies a single Op.
+   */
+  async applyOp(op2) {
+    switch (op2.type) {
+      case OpCode.CREATE_LIST:
+      case OpCode.CREATE_MAP:
+      case OpCode.CREATE_REGISTER:
+      case OpCode.CREATE_OBJECT:
+        return await this.applyCreateOp(op2);
+      case OpCode.UPDATE_OBJECT:
+        return await this.applyUpdateObjectOp(op2);
+      case OpCode.SET_PARENT_KEY:
+        return await this.applySetParentKeyOp(op2);
+      case OpCode.DELETE_OBJECT_KEY:
+        return await this.applyDeleteObjectKeyOp(op2);
+      case OpCode.DELETE_CRDT:
+        return await this.applyDeleteCrdtOp(op2);
+      default:
+        if (process.env.NODE_ENV === "production") {
+          return ignore(op2);
+        } else {
+          return assertNever(op2, "Invalid op");
+        }
+    }
+  }
+  async applyCreateOp(op2) {
+    if (this.loadedDriver.has_node(op2.id)) {
+      return ignore(op2);
+    }
+    const node = nodeFromCreateChildOp(op2);
+    const parent = this.loadedDriver.get_node(node.parentId);
+    if (parent === void 0) {
+      return ignore(op2);
+    }
+    switch (parent.type) {
+      case CrdtType.OBJECT:
+        if (op2.type === OpCode.CREATE_REGISTER) {
+          return ignore(op2);
+        }
+      case CrdtType.MAP:
+        await this.loadedDriver.set_child(op2.id, node, true);
+        return accept(op2);
+      case CrdtType.LIST:
+        return this.createChildAsListItem(op2, node);
+      case CrdtType.REGISTER:
+        return ignore(op2);
+      default:
+        return assertNever(parent, "Unhandled CRDT type");
+    }
+  }
+  async createChildAsListItem(op2, node) {
+    let fix;
+    const intent = _nullishCoalesce(op2.intent, () => ( "insert"));
+    if (intent === "insert") {
+      const insertedParentKey = await this.insertIntoList(op2.id, node);
+      if (insertedParentKey !== node.parentKey) {
+        op2 = { ...op2, parentKey: insertedParentKey };
+        fix = {
+          type: OpCode.SET_PARENT_KEY,
+          id: op2.id,
+          parentKey: insertedParentKey
+        };
+        return accept(op2, fix);
+      }
+      return accept(op2);
+    } else if (intent === "set") {
+      const deletedId = op2.deletedId !== void 0 && op2.deletedId !== op2.id && _optionalChain([this, 'access', _45 => _45.loadedDriver, 'access', _46 => _46.get_node, 'call', _47 => _47(op2.deletedId), 'optionalAccess', _48 => _48.parentId]) === node.parentId ? op2.deletedId : void 0;
+      if (deletedId !== void 0) {
+        await this.loadedDriver.delete_node(deletedId);
+      }
+      const prevItemId = this.loadedDriver.get_child_at(
+        node.parentId,
+        node.parentKey
+      );
+      if (prevItemId !== void 0 && prevItemId !== deletedId) {
+        fix = {
+          type: OpCode.DELETE_CRDT,
+          id: prevItemId
+        };
+      }
+      await this.loadedDriver.set_child(op2.id, node, true);
+      return accept(op2, fix);
+    } else {
+      return assertNever(intent, "Invalid intent");
+    }
+  }
+  async applyDeleteObjectKeyOp(op2) {
+    await this.loadedDriver.delete_child_key(op2.id, op2.key);
+    return accept(op2);
+  }
+  async applyUpdateObjectOp(op2) {
+    await this.loadedDriver.set_object_data(op2.id, op2.data, true);
+    return accept(op2);
+  }
+  async applyDeleteCrdtOp(op2) {
+    await this.loadedDriver.delete_node(op2.id);
+    return accept(op2);
+  }
+  async applySetParentKeyOp(op2) {
+    const newPosition = await this.moveToPosInList(op2.id, op2.parentKey);
+    if (newPosition === void 0) {
+      return ignore(op2);
+    }
+    if (newPosition !== op2.parentKey) {
+      const modifiedOp = { ...op2, parentKey: newPosition };
+      const fix = {
+        type: OpCode.SET_PARENT_KEY,
+        id: op2.id,
+        parentKey: newPosition
+      };
+      return accept(modifiedOp, fix);
+    } else {
+      return accept(op2);
+    }
+  }
+  /**
+   * Inserts a new node in the storage tree, under a list parent. If an
+   * existing sibling node already exist under this key, however, it will look
+   * for another free position under that parent and insert it under
+   * a different parent key that is guaranteed to be available.
+   *
+   * Returns the key that was used for the insertion.
+   */
+  async insertIntoList(id, node) {
+    const key = this.findFreeListPosition(node.parentId, asPos(node.parentKey));
+    if (key !== node.parentKey) {
+      node = { ...node, parentKey: key };
+    }
+    await this.loadedDriver.set_child(id, node);
+    return node.parentKey;
+  }
+  /**
+   * Tries to move a node to the given position under the same parent. If
+   * a conflicting sibling node already exist at this position, it will use
+   * another free position instead, to avoid the conflict.
+   *
+   * Returns the position (parentKey) that the node was eventually placed at.
+   * If the node could be inserted without conflict, it will return the same
+   * parentKey position.
+   *
+   * Will return `undefined` if this action could not be interpreted. Will be
+   * a no-op for non-list items.
+   */
+  async moveToPosInList(id, targetKey) {
+    const node = this.loadedDriver.get_node(id);
+    if (_optionalChain([node, 'optionalAccess', _49 => _49.parentId]) === void 0) {
+      return;
+    }
+    if (_optionalChain([this, 'access', _50 => _50.loadedDriver, 'access', _51 => _51.get_node, 'call', _52 => _52(node.parentId), 'optionalAccess', _53 => _53.type]) !== CrdtType.LIST) {
+      return;
+    }
+    if (node.parentKey === targetKey) {
+      return targetKey;
+    }
+    const key = this.findFreeListPosition(node.parentId, asPos(targetKey));
+    if (key !== node.parentKey) {
+      await this.loadedDriver.move_sibling(id, key);
+    }
+    return key;
+  }
+  /**
+   * Checks whether the given parentKey is a "free position" under the
+   * parentId, i.e. there are no siblings that have the same key. If a sibling
+   * exists under that key, it tries to generate new positions until it finds
+   * a free slot, and returns that. The returned value is therefore always safe
+   * to use as parentKey.
+   */
+  findFreeListPosition(parentId, parentPos) {
+    if (!this.loadedDriver.has_child_at(parentId, parentPos)) {
+      return parentPos;
+    }
+    const currPos = parentPos;
+    const nextPos = this.loadedDriver.get_next_sibling(parentId, currPos);
+    if (nextPos !== void 0) {
+      return makePosition(currPos, nextPos);
+    } else {
+      return makePosition(currPos);
+    }
+  }
+};
+
+// src/YjsStorage.ts
+var _jsbase64 = require('js-base64');
+
+var _yjs = require('yjs'); var Y = _interopRequireWildcard(_yjs);
+var MAX_Y_UPDATE_SIZE = 1e5;
+var YjsStorage = class {
+  constructor(driver) {
+    __publicField(this, "driver");
+    __publicField(this, "doc", new Y.Doc());
+    // the root document
+    __publicField(this, "lastUpdatesById", /* @__PURE__ */ new Map());
+    __publicField(this, "lastSnapshotById", /* @__PURE__ */ new Map());
+    // Keeps track of which keys are loaded, so we can clean them up without calling `.list()`
+    __publicField(this, "keysById", new DefaultMap(
+      () => /* @__PURE__ */ new Set()
+    ));
+    __publicField(this, "initPromisesById", /* @__PURE__ */ new Map());
+    /**
+     * Given a record of updates, merge them and compress if savings are significant
+     */
+    __publicField(this, "_loadAndCompressYJSUpdates", async (docUpdates, doc, docId) => {
+      const SAVINGS_THRESHOLD = 0.2;
+      const updates = Object.values(docUpdates);
+      const sizeOnDisk = updates.reduce((acc, update) => {
+        return acc + update.length;
+      }, 0);
+      if (updates.length > 0) {
+        const docKeys = Object.keys(docUpdates);
+        this.keysById.set(docId, new Set(docKeys));
+        const mergedUpdate = Y.mergeUpdates(updates);
+        Y.applyUpdate(doc, mergedUpdate);
+        const garbageCollectedUpdate = Y.encodeStateAsUpdate(doc);
+        if (garbageCollectedUpdate.length < sizeOnDisk * (1 - SAVINGS_THRESHOLD)) {
+          const newKey = _nanoid.nanoid.call(void 0, );
+          await this.driver.write_y_updates(
+            docId,
+            newKey,
+            garbageCollectedUpdate
+          );
+          await this.driver.delete_y_updates(docId, docKeys);
+          this.keysById.set(docId, /* @__PURE__ */ new Set([newKey]));
+        }
+      }
+    });
+    __publicField(this, "_loadYDocFromDurableStorage", async (doc, docId) => {
+      const docUpdates = Object.fromEntries(
+        await this.driver.iter_y_updates(docId)
+      );
+      await this._loadAndCompressYJSUpdates(docUpdates, doc, docId);
+      this.lastUpdatesById.set(docId, {
+        currentKey: _nanoid.nanoid.call(void 0, ),
+        lastVector: Y.encodeStateVector(doc)
+      });
+      doc.emit("load", [doc]);
+      return doc;
+    });
+    this.driver = driver;
+    this.doc.on("subdocs", ({ removed }) => {
+      removed.forEach((subdoc) => {
+        subdoc.destroy();
+      });
+    });
+  }
+  // ------------------------------------------------------------------------------------
+  // Public API
+  // ------------------------------------------------------------------------------------
+  async getYDoc(docId) {
+    const doc = await this.loadDocByIdIfNotAlreadyLoaded(docId);
+    return doc;
+  }
+  /**
+   * If passed a state vector, an update with diff will be returned, if not the entire doc is returned.
+   *
+   * @param stateVector a base64 encoded target state vector created by running Y.encodeStateVector(Doc) on the client
+   * @returns a base64 encoded array of YJS updates
+   */
+  async getYDocUpdate(logger, stateVector = "", guid, isV2 = false) {
+    const update = await this.getYDocUpdateBinary(
+      logger,
+      stateVector,
+      guid,
+      isV2
+    );
+    if (!update) return null;
+    return _jsbase64.Base64.fromUint8Array(update);
+  }
+  async getYDocUpdateBinary(logger, stateVector = "", guid, isV2 = false) {
+    const doc = guid !== void 0 ? await this.getYSubdoc(guid) : this.doc;
+    if (!doc) {
+      return null;
+    }
+    let encodedTargetVector;
+    try {
+      encodedTargetVector = stateVector.length > 0 ? _jsbase64.Base64.toUint8Array(stateVector) : void 0;
+    } catch (e) {
+      logger.warn(
+        "Could not get update from passed vector, returning all updates"
+      );
+    }
+    if (isV2) {
+      return Y.encodeStateAsUpdateV2(doc, encodedTargetVector);
+    }
+    return Y.encodeStateAsUpdate(doc, encodedTargetVector);
+  }
+  async getYStateVector(guid) {
+    const doc = guid !== void 0 ? await this.getYSubdoc(guid) : this.doc;
+    if (!doc) {
+      return null;
+    }
+    return _jsbase64.Base64.fromUint8Array(Y.encodeStateVector(doc));
+  }
+  async getSnapshotHash(options) {
+    const doc = options.guid !== void 0 ? await this.getYSubdoc(options.guid) : this.doc;
+    if (!doc) {
+      return null;
+    }
+    const snapshot2 = this._getOrPutLastSnapshot(doc);
+    return this.calculateSnapshotHash(snapshot2, { isV2: options.isV2 });
+  }
+  /**
+   * @param update base64 encoded uint8array
+   * @returns
+   */
+  async addYDocUpdate(logger, update, guid, isV2) {
+    const doc = guid !== void 0 ? await this.getYSubdoc(guid) : this.doc;
+    if (!doc) {
+      throw new Error(`YDoc with guid ${guid} not found`);
+    }
+    try {
+      const beforeSnapshot = this._getOrPutLastSnapshot(doc);
+      const updateAsU8 = typeof update === "string" ? _jsbase64.Base64.toUint8Array(update) : update;
+      const applyUpdate2 = isV2 ? Y.applyUpdateV2 : Y.applyUpdate;
+      applyUpdate2(doc, updateAsU8, "client");
+      const afterSnapshot = this._putLastSnapshot(doc);
+      const updated = !Y.equalSnapshots(beforeSnapshot, afterSnapshot);
+      if (updated) {
+        await this.handleYDocUpdate(doc);
+      }
+      return {
+        isUpdated: updated,
+        snapshotHash: await this.calculateSnapshotHash(afterSnapshot, { isV2 })
+      };
+    } catch (e) {
+      logger.warn(`Ignored bad YDoc update: ${String(e)}`);
+      throw new Error(
+        "Bad YDoc update. Data is corrupted, or data does not match the encoding."
+      );
+    }
+  }
+  loadDocByIdIfNotAlreadyLoaded(docId) {
+    let loaded$ = this.initPromisesById.get(docId);
+    let doc = docId === ROOT_YDOC_ID ? this.doc : this.findYSubdocByGuid(docId);
+    if (!doc) {
+      doc = new Y.Doc();
+    }
+    if (loaded$ === void 0) {
+      loaded$ = this._loadYDocFromDurableStorage(doc, docId);
+      this.initPromisesById.set(docId, loaded$);
+    }
+    return loaded$;
+  }
+  async load(_logger) {
+    await this.loadDocByIdIfNotAlreadyLoaded(ROOT_YDOC_ID);
+  }
+  /**
+   * Unloads the Yjs documents from memory.
+   */
+  unload() {
+  }
+  // ------------------------------------------------------------------------------------
+  // Private APIs
+  // ------------------------------------------------------------------------------------
+  // NOTE: We could instead store the hash of snapshot instead of the whole snapshot to optimize memory usage.
+  _getOrPutLastSnapshot(doc) {
+    const docId = doc.guid === this.doc.guid ? ROOT_YDOC_ID : doc.guid;
+    const snapshot2 = this.lastSnapshotById.get(docId);
+    if (snapshot2) {
+      return snapshot2;
+    }
+    return this._putLastSnapshot(doc);
+  }
+  // NOTE: We could instead store the hash of snapshot instead of the whole snapshot to optimize memory usage.
+  _putLastSnapshot(doc) {
+    const docId = doc.guid === this.doc.guid ? ROOT_YDOC_ID : doc.guid;
+    const snapshot2 = Y.snapshot(doc);
+    this.lastSnapshotById.set(docId, snapshot2);
+    return snapshot2;
+  }
+  findYSubdocByGuid(guid) {
+    for (const subdoc of this.doc.getSubdocs()) {
+      if (subdoc.guid === guid) {
+        return subdoc;
+      }
+    }
+    return null;
+  }
+  async calculateSnapshotHash(snapshot2, { isV2 }) {
+    const encodedSnapshot = isV2 ? Y.encodeSnapshotV2(snapshot2) : Y.encodeSnapshot(snapshot2);
+    return _jsbase64.Base64.fromUint8Array(
+      new Uint8Array(
+        await crypto.subtle.digest("SHA-256", new Uint8Array(encodedSnapshot))
+      )
+    );
+  }
+  // gets a subdoc, it will be loaded if not already loaded
+  async getYSubdoc(guid) {
+    const subdoc = this.findYSubdocByGuid(guid);
+    if (!subdoc) {
+      return null;
+    }
+    await this.loadDocByIdIfNotAlreadyLoaded(guid);
+    return subdoc;
+  }
+  // When the YJS doc changes, update it in durable storage
+  async handleYDocUpdate(doc) {
+    const docId = doc.guid === this.doc.guid ? ROOT_YDOC_ID : doc.guid;
+    const docUpdateInfo = this.lastUpdatesById.get(docId);
+    const updateSinceLastVector = Y.encodeStateAsUpdate(
+      doc,
+      _optionalChain([docUpdateInfo, 'optionalAccess', _54 => _54.lastVector])
+    );
+    const storageKey = _nullishCoalesce(_optionalChain([docUpdateInfo, 'optionalAccess', _55 => _55.currentKey]), () => ( _nanoid.nanoid.call(void 0, )));
+    if (updateSinceLastVector.length > MAX_Y_UPDATE_SIZE) {
+      const newKey = _nanoid.nanoid.call(void 0, );
+      await this.driver.write_y_updates(
+        docId,
+        newKey,
+        Y.encodeStateAsUpdate(doc)
+      );
+      await this.driver.delete_y_updates(
+        docId,
+        Array.from(this.keysById.getOrCreate(docId))
+      );
+      this.keysById.set(docId, /* @__PURE__ */ new Set([newKey]));
+      this.lastUpdatesById.set(docId, {
+        currentKey: _nanoid.nanoid.call(void 0, ),
+        // start writing to a new key
+        lastVector: Y.encodeStateVector(doc)
+      });
+    } else {
+      await this.driver.write_y_updates(
+        docId,
+        storageKey,
+        updateSinceLastVector
+      );
+      const keys = [storageKey];
+      const currentKeys = this.keysById.getOrCreate(docId);
+      for (const key of keys) {
+        currentKeys.add(key);
+      }
+    }
+  }
+};
+
+// src/lib/tryCatch.ts
+async function tryCatch(promise) {
+  try {
+    const data = await (typeof promise === "function" ? promise() : promise);
+    return [data, void 0];
+  } catch (error3) {
+    return [void 0, error3];
+  }
+}
+
+// src/lib/UniqueMap.ts
+var __revMap, __keyFn;
+var UniqueMap = class extends Map {
+  constructor(keyFn) {
+    super();
+    //                  /       \
+    //        Primary key        Unique key
+    __privateAdd(this, __revMap);
+    __privateAdd(this, __keyFn);
+    __privateSet(this, __keyFn, keyFn);
+    __privateSet(this, __revMap, /* @__PURE__ */ new Map());
+  }
+  lookupPrimaryKey(uniqKey) {
+    return __privateGet(this, __revMap).get(uniqKey);
+  }
+  lookup(uniqKey) {
+    const key = __privateGet(this, __revMap).get(uniqKey);
+    return key !== void 0 ? this.get(key) : void 0;
+  }
+  set(key, value) {
+    const uniqKey = __privateGet(this, __keyFn).call(this, value);
+    const primaryKey = __privateGet(this, __revMap).get(uniqKey);
+    if (primaryKey !== void 0 && primaryKey !== key) {
+      throw new Error(`Unique key ${String(uniqKey)} already exists`);
+    }
+    __privateGet(this, __revMap).set(uniqKey, key);
+    return super.set(key, value);
+  }
+  delete(primaryKey) {
+    const value = this.get(primaryKey);
+    if (value !== void 0) {
+      const indexedKey = __privateGet(this, __keyFn).call(this, value);
+      __privateGet(this, __revMap).delete(indexedKey);
+    }
+    return super.delete(primaryKey);
+  }
+};
+__revMap = new WeakMap();
+__keyFn = new WeakMap();
+
+// src/utils.ts
+function concatUint8Arrays(arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function makeRoomStateMsg(actor, nonce, scopes, users, publicMeta) {
+  return {
+    type: ServerMsgCode.ROOM_STATE,
+    actor,
+    nonce,
+    scopes,
+    users,
+    meta: _nullishCoalesce(publicMeta, () => ( {}))
+  };
+}
+
+// src/Room.ts
+var messagesDecoder = _decoders.array.call(void 0, clientMsgDecoder);
+var HIGHEST_PROTOCOL_VERSION = Math.max(
+  ...Object.values(ProtocolVersion).filter(
+    (v) => typeof v === "number"
+  )
+);
+var SERVER_MSG_CODE_NAMES = Object.fromEntries(
+  Object.entries(ServerMsgCode).map(([k, v]) => [v, k])
+);
+var BLACK_HOLE = new Logger([
+  /* No targets, i.e. black hole logger */
+]);
+function collectSideEffects() {
+  const deferred = [];
+  return {
+    defer: (p) => void deferred.push(p),
+    waitAll: () => Promise.allSettled(deferred)
+  };
+}
+function serialize(msgs) {
+  return JSON.stringify(msgs);
+}
+function ackIgnoredOp(opId) {
+  return { type: OpCode.DELETE_CRDT, id: "ACK", opId };
+}
+function stripOpId(op2) {
+  const { opId: _, ...rest } = op2;
+  return rest;
+}
+var __socket, __debug, __lastActiveAt, __hasNotifiedClientStorageUpdateError;
+var BrowserSession = class {
+  /** @internal - Never create a BrowserSession instance manually. Use the room.startBrowserSession() API instead. */
+  constructor(ticket, socket, debug) {
+    //                        ^^ User-defined Session Metadata
+    //                            ^^ User-defined Client Metadata (sent to client in ROOM_STATE)
+    __publicField(this, "version");
+    // Liveblocks protocol version this client will speak
+    __publicField(this, "actor");
+    // Must be unique within the room
+    __publicField(this, "createdAt");
+    // Externally provided (public!) user metadata. This information will get shared with other clients
+    __publicField(this, "user");
+    __publicField(this, "scopes");
+    // Permissions for this session, sent to connected clients (so consider public info)
+    __publicField(this, "meta");
+    // Arbitrary *private* meta data to attach to this session (will NOT be shared)
+    __publicField(this, "publicMeta");
+    // Metadata sent to client in ROOM_STATE message's "meta" field
+    __privateAdd(this, __socket);
+    __privateAdd(this, __debug);
+    __privateAdd(this, __lastActiveAt);
+    // We keep a status in-memory in the session of whether we already sent a rejected ops message to the client.
+    __privateAdd(this, __hasNotifiedClientStorageUpdateError);
+    this.version = ticket.version;
+    this.actor = ticket.actor;
+    this.user = ticket.user;
+    this.scopes = ticket.scopes;
+    this.meta = _nullishCoalesce(ticket.meta, () => ( void 0));
+    this.publicMeta = ticket.publicMeta;
+    __privateSet(this, __socket, socket);
+    __privateSet(this, __debug, debug);
+    const now = /* @__PURE__ */ new Date();
+    this.createdAt = now;
+    __privateSet(this, __lastActiveAt, now);
+    __privateSet(this, __hasNotifiedClientStorageUpdateError, false);
+  }
+  get lastActiveAt() {
+    const lastPing = _optionalChain([__privateGet, 'call', _56 => _56(this, __socket), 'access', _57 => _57.getLastPongTimestamp, 'optionalCall', _58 => _58()]);
+    if (lastPing && lastPing > __privateGet(this, __lastActiveAt)) {
+      return lastPing;
+    } else {
+      return __privateGet(this, __lastActiveAt);
+    }
+  }
+  get hasNotifiedClientStorageUpdateError() {
+    return __privateGet(this, __hasNotifiedClientStorageUpdateError);
+  }
+  markActive(now = /* @__PURE__ */ new Date()) {
+    if (now > __privateGet(this, __lastActiveAt)) {
+      __privateSet(this, __lastActiveAt, now);
+    }
+  }
+  setHasNotifiedClientStorageUpdateError() {
+    __privateSet(this, __hasNotifiedClientStorageUpdateError, true);
+  }
+  sendPong() {
+    this.markActive();
+    const sent = __privateGet(this, __socket).send("pong");
+    if (__privateGet(this, __debug)) {
+      if (sent < 0) {
+        console.error(
+          `failed to send "pong" to actor=${this.actor} (back pressure)`
+        );
+      } else if (sent === 0) {
+        console.error(
+          `failed to send "pong" to actor=${this.actor} (connection issue)`
+        );
+      } else {
+        console.log(`sent to actor=${this.actor}: "pong"`);
+      }
+    }
+    return sent;
+  }
+  send(serverMsg) {
+    const data = typeof serverMsg === "string" ? serverMsg : serialize(serverMsg);
+    const sent = __privateGet(this, __socket).send(data);
+    if (__privateGet(this, __debug)) {
+      if (sent < 0) {
+        console.error(
+          `failed to send message to actor=${this.actor} (back pressure)`
+        );
+      } else if (sent === 0) {
+        console.error(
+          `failed to send message to actor=${this.actor} (connection issue)`
+        );
+      }
+      const msgs = JSON.parse(data);
+      for (const msg of Array.isArray(msgs) ? msgs : [msgs]) {
+        console.log(
+          `sent to actor=${this.actor}: [${_nullishCoalesce(SERVER_MSG_CODE_NAMES[msg.type], () => ( msg.type))}] ${JSON.stringify(msg)}`
+        );
+      }
+    }
+    return sent;
+  }
+  /**
+   * @internal
+   * Closes the socket associated to this BrowserSession.
+   *
+   * NOTE: Never call this API directly! Call .endBrowserSession() instead.
+   */
+  closeSocket(code, reason) {
+    __privateGet(this, __socket).close(code, reason);
+  }
+};
+__socket = new WeakMap();
+__debug = new WeakMap();
+__lastActiveAt = new WeakMap();
+__hasNotifiedClientStorageUpdateError = new WeakMap();
+var BackendSession = class extends BrowserSession {
+  /** @internal Never call this constructor directly */
+  constructor(ticket, socket, debug) {
+    super(ticket, socket, debug);
+  }
+};
+var __debug2, __allowStreaming;
+var Room = class {
+  constructor(meta, options) {
+    //              ^^^^^^^^^^ User-defined Room Metadata, Session Metadata, and Client Metadata
+    __publicField(this, "meta");
+    __publicField(this, "driver");
+    __publicField(this, "logger");
+    __publicField(this, "_loadData$", null);
+    __publicField(this, "_data", null);
+    __publicField(this, "_qsize", 0);
+    __publicField(this, "sessions", new UniqueMap((s) => s.actor));
+    __publicField(this, "hooks");
+    __privateAdd(this, __debug2);
+    __privateAdd(this, __allowStreaming);
+    const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _59 => _59.storage]), () => ( makeNewInMemoryDriver()));
+    this.meta = meta;
+    this.driver = driver;
+    this.logger = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _60 => _60.logger]), () => ( BLACK_HOLE));
+    __privateSet(this, __allowStreaming, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _61 => _61.allowStreaming]), () => ( true)));
+    this.hooks = {
+      isClientMsgAllowed: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.hooks, 'optionalAccess', _63 => _63.isClientMsgAllowed]), () => ( (() => {
+        return {
+          allowed: true
+        };
+      }))),
+      // YYY .load() isn't called on the RoomServer yet! As soon as it does, these hooks will get called
+      onRoomWillLoad: _optionalChain([options, 'optionalAccess', _64 => _64.hooks, 'optionalAccess', _65 => _65.onRoomWillLoad]),
+      onRoomDidLoad: _optionalChain([options, 'optionalAccess', _66 => _66.hooks, 'optionalAccess', _67 => _67.onRoomDidLoad]),
+      onRoomWillUnload: _optionalChain([options, 'optionalAccess', _68 => _68.hooks, 'optionalAccess', _69 => _69.onRoomWillUnload]),
+      onRoomDidUnload: _optionalChain([options, 'optionalAccess', _70 => _70.hooks, 'optionalAccess', _71 => _71.onRoomDidUnload]),
+      onSessionDidStart: _optionalChain([options, 'optionalAccess', _72 => _72.hooks, 'optionalAccess', _73 => _73.onSessionDidStart]),
+      onSessionDidEnd: _optionalChain([options, 'optionalAccess', _74 => _74.hooks, 'optionalAccess', _75 => _75.onSessionDidEnd]),
+      postClientMsgStorageDidUpdate: _optionalChain([options, 'optionalAccess', _76 => _76.hooks, 'optionalAccess', _77 => _77.postClientMsgStorageDidUpdate]),
+      postClientMsgYdocDidUpdate: _optionalChain([options, 'optionalAccess', _78 => _78.hooks, 'optionalAccess', _79 => _79.postClientMsgYdocDidUpdate])
+    };
+    __privateSet(this, __debug2, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _80 => _80.enableDebugLogging]), () => ( false)));
+  }
+  get loadingState() {
+    if (this._loadData$ === null) {
+      return "initial";
+    } else if (this._data === null) {
+      return "loading";
+    } else {
+      return "loaded";
+    }
+  }
+  get numSessions() {
+    return this.sessions.size;
+  }
+  // prettier-ignore
+  get storage() {
+    return this.data.storage;
+  }
+  // prettier-ignore
+  get yjsStorage() {
+    return this.data.yjsStorage;
+  }
+  // prettier-ignore
+  get mutex() {
+    return this.data.mutex;
+  }
+  // prettier-ignore
+  get data() {
+    return _nullishCoalesce(this._data, () => ( raise("Cannot use room before it's loaded")));
+  }
+  // prettier-ignore
+  // ------------------------------------------------------------------------------------
+  // Public API
+  // ------------------------------------------------------------------------------------
+  /**
+   * Initializes the Room, so it's ready to start accepting connections. Safe
+   * to call multiple times. After awaiting `room.load()` the Room is ready to
+   * be used.
+   */
+  async load(ctx) {
+    if (this._loadData$ === null) {
+      this._data = null;
+      this._loadData$ = this._load(ctx).catch((e) => {
+        this._data = null;
+        this._loadData$ = null;
+        throw e;
+      });
+    }
+    return this._loadData$;
+  }
+  /**
+   * Releases the currently-loaded storage tree from worker memory, freeing it
+   * up to be garbage collected. The next time a user will join the room, the
+   * room will be reloaded from storage.
+   */
+  unload(ctx) {
+    _optionalChain([this, 'access', _81 => _81.hooks, 'access', _82 => _82.onRoomWillUnload, 'optionalCall', _83 => _83(ctx)]);
+    if (this._data) {
+      this.storage.unload();
+      this.yjsStorage.unload();
+    }
+    this._loadData$ = null;
+    _optionalChain([this, 'access', _84 => _84.hooks, 'access', _85 => _85.onRoomDidUnload, 'optionalCall', _86 => _86(ctx)]);
+  }
+  /**
+   * Issues a Ticket with a new/unique actor ID
+   *
+   * IMPORTANT! As the caller of this function, you are responsible for
+   * ensuring you trust the values passed in here. Never pass unauthorized
+   * values in here.
+   *
+   * The returned Ticket can be turned into a active Session once the socket
+   * connection is established. If the socket is never established, this
+   * unused Ticket will simply get garbage collected.
+   */
+  async createTicket(options) {
+    const actor$ = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _87 => _87.actor]), () => ( this.getNextActor()));
+    const sessionKey = _nanoid.nanoid.call(void 0, );
+    const info = _optionalChain([options, 'optionalAccess', _88 => _88.info]);
+    const ticket = {
+      version: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _89 => _89.version]), () => ( HIGHEST_PROTOCOL_VERSION)),
+      actor: await actor$,
+      sessionKey,
+      meta: _optionalChain([options, 'optionalAccess', _90 => _90.meta]),
+      publicMeta: _optionalChain([options, 'optionalAccess', _91 => _91.publicMeta]),
+      user: _optionalChain([options, 'optionalAccess', _92 => _92.id]) ? { id: options.id, info } : { anonymousId: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _93 => _93.anonymousId]), () => ( _nanoid.nanoid.call(void 0, ))), info },
+      scopes: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _94 => _94.scopes]), () => ( ["room:write"]))
+    };
+    if (__privateGet(this, __debug2)) {
+      console.log(`new ticket created: ${JSON.stringify(ticket)}`);
+    }
+    return ticket;
+  }
+  async createBackendSession_experimental() {
+    const ticket = await this.createTicket();
+    const capturedServerMsgs = [];
+    const stub = {
+      send: (data) => {
+        if (typeof data === "string") {
+          capturedServerMsgs.push(data);
+        }
+        return 0;
+      },
+      close: () => {
+      }
+      // noop
+    };
+    const session = new BackendSession(ticket, stub, false);
+    return [session, capturedServerMsgs];
+  }
+  /**
+   * Restores the given sessions as the Room server's session list. Can only be
+   * called as long as there are no existing sessions.
+   *
+   * The key difference with the .startBrowserSession() API is that restoreSessions is
+   * used in cases where a session was hibernated and needs to be restored,
+   * without _conceptually_ starting a new session.
+   *
+   * Because there are no side effects to restoreSession, it's synchronous.
+   */
+  restoreSessions(sessions) {
+    if (this.sessions.size > 0) {
+      throw new Error("This API can only be called before any sessions exist");
+    }
+    for (const { ticket, socket, lastActivity } of sessions) {
+      const newSession = new BrowserSession(ticket, socket, __privateGet(this, __debug2));
+      this.sessions.set(ticket.sessionKey, newSession);
+      newSession.markActive(lastActivity);
+    }
+  }
+  /**
+   * Registers a new BrowserSession into the Room server's session list, along with
+   * the socket connection to use for that BrowserSession, now that it is known.
+   *
+   * This kicks off a few side effects:
+   * - Sends a ROOM_STATE message to the socket.
+   * - Broadcasts a USER_JOINED message to all other sessions in the room.
+   */
+  startBrowserSession(ticket, socket, ctx, defer = () => {
+    throw new Error(
+      "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to startBrowserSession() to collect async side effects."
+    );
+  }) {
+    let existing;
+    while ((existing = this.sessions.lookupPrimaryKey(ticket.actor)) !== void 0) {
+      this.endBrowserSession(
+        existing,
+        WebsocketCloseCodes.KICKED,
+        "Closed stale connection",
+        ctx,
+        defer
+      );
+      this.logger.warn(
+        `Previous session for actor ${ticket.actor} killed in favor of new session`
+      );
+    }
+    const newSession = new BrowserSession(ticket, socket, __privateGet(this, __debug2));
+    this.sessions.set(ticket.sessionKey, newSession);
+    const users = {};
+    for (const session of this.otherSessions(ticket.sessionKey)) {
+      users[session.actor] = {
+        id: session.user.id,
+        info: session.user.info,
+        scopes: session.scopes
+      };
+    }
+    newSession.send(
+      makeRoomStateMsg(
+        newSession.actor,
+        ticket.sessionKey,
+        // called "nonce" in the protocol
+        newSession.scopes,
+        users,
+        ticket.publicMeta
+      )
+    );
+    this.sendToOthers(
+      ticket.sessionKey,
+      {
+        type: ServerMsgCode.USER_JOINED,
+        actor: newSession.actor,
+        id: newSession.user.id,
+        info: newSession.user.info,
+        scopes: newSession.scopes
+      },
+      ctx,
+      defer
+    );
+    const p$ = _optionalChain([this, 'access', _95 => _95.hooks, 'access', _96 => _96.onSessionDidStart, 'optionalCall', _97 => _97(newSession, ctx)]);
+    if (p$) defer(p$);
+  }
+  /**
+   * Unregisters the BrowserSession for the given actor. Call this when the socket has
+   * been closed from the client's end.
+   *
+   * This kicks off a few side effects:
+   * - Broadcasts a USER_LEFT message to all other sessions in the room.
+   */
+  endBrowserSession(key, code, reason, ctx, defer = () => {
+    throw new Error(
+      "Your onSessionDidEnd handler returned a promise, but no side effect collector was provided. Pass a `defer` callback to endBrowserSession() to collect async side effects."
+    );
+  }) {
+    const sessions = this.sessions;
+    const session = sessions.get(key);
+    if (session === void 0) return;
+    session.closeSocket(code, reason);
+    const deleted = sessions.delete(key);
+    if (deleted) {
+      for (const other of this.otherSessions(key)) {
+        other.send({ type: ServerMsgCode.USER_LEFT, actor: session.actor });
+      }
+      const p$ = _optionalChain([this, 'access', _98 => _98.hooks, 'access', _99 => _99.onSessionDidEnd, 'optionalCall', _100 => _100(session, ctx)]);
+      if (p$) defer(p$);
+    }
+  }
+  /**
+   * Force-closes all sessions matching the given predicate.
+   */
+  endSessionBy(predicate, code, reason, ctx, defer = () => {
+    throw new Error(
+      "Your onSessionDidEnd handler returned a promise, but no side effect collector was provided. Pass a `defer` callback to endSessionBy() to collect async side effects."
+    );
+  }) {
+    let count = 0;
+    for (const [key, session] of this.sessions) {
+      if (predicate(session)) {
+        count++;
+        this.endBrowserSession(key, code, reason, ctx, defer);
+      }
+    }
+    return count;
+  }
+  /**
+   * Handles a raw incoming socket message, which can be a ping, or an
+   * JSON-encoded message batch.
+   */
+  async handleData(key, data, ctx, defer = () => {
+    throw new Error(
+      "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to handleData() to collect async side effects."
+    );
+  }) {
+    const text = typeof data === "string" ? data : raise("Unsupported message format");
+    if (text === "ping") {
+      await this.handlePing(key, ctx);
+    } else {
+      const json = tryParseJson(text);
+      const messages = messagesDecoder.decode(json);
+      if (!messages.ok) {
+        const reason = process.env.NODE_ENV !== "production" ? _decoders.formatInline.call(void 0, messages.error) : "Invalid message format";
+        this.endBrowserSession(
+          key,
+          WebsocketCloseCodes.INVALID_MESSAGE_FORMAT,
+          reason,
+          ctx,
+          defer
+        );
+        return;
+      }
+      if (this._qsize > 1e4) {
+      } else if (this._qsize > 5e3) {
+      }
+      this._qsize++;
+      try {
+        await this.processClientMsg(key, messages.value, ctx);
+      } finally {
+        this._qsize--;
+      }
+    }
+  }
+  /**
+   * Processes an incoming batch of 1 or more ClientMsgs on behalf of
+   * a (regular user/browser) session.
+   *
+   * IMPORTANT: Only use this API on "trusted" data!
+   * To handle untrusted input data, use `.handleData()` instead.
+   *
+   * Before calling this API, make sure:
+   * 1. The call site is entitled to call this message on behalf of this session; and
+   * 2. The ClientMsg payload has been validated to be correct.
+   */
+  async processClientMsg(key, messages, ctx) {
+    await this.load(ctx);
+    const { defer, waitAll } = collectSideEffects();
+    await this.mutex.runExclusive(
+      () => this._processClientMsg_withExclusiveAccess(key, messages, ctx, defer)
+    );
+    await waitAll();
+  }
+  /**
+   * Processes an incoming batch of 1 or more ClientMsgs on behalf of
+   * a BACKEND session.
+   *
+   * Difference 1: HTTP RESPONSE instead of WEB SOCKET RESPONSE
+   * ----------------------------------------------------------
+   * For "normal" sessions that have a socket attached, any "responses" (i.e.
+   * server messages like acks or fixops) will be sent back through that
+   * existing socket connection.
+   *
+   * The key difference when using this method is that there is no such socket,
+   * so any "response" ServerMsgs will get sent back as an HTTP response.
+   *
+   * Difference 2: No auth check
+   * ---------------------------
+   * Another key difference is that when processing a backend session, no
+   * "isClientMsgAllowed()" check is performed, because those checks assume
+   * a session.
+   */
+  async processClientMsgFromBackendSession(session, messages, ctx) {
+    await this.load(ctx);
+    const { defer, waitAll } = collectSideEffects();
+    await this.mutex.runExclusive(
+      () => this._processClientMsgFromBackendSession_withExclusiveAccess(
+        session,
+        messages,
+        ctx,
+        defer
+      )
+    );
+    await waitAll();
+  }
+  getSession(sessionKey) {
+    return this.sessions.get(sessionKey);
+  }
+  listSessions() {
+    return Array.from(this.sessions.values());
+  }
+  /**
+   * Will send the given ServerMsg to all Sessions, except the Session
+   * where the message originates from.
+   */
+  sendToOthers(sender, serverMsg, ctx, defer = () => {
+    throw new Error(
+      "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to sendToOthers() to collect async side effects."
+    );
+  }) {
+    const msg = serialize(serverMsg);
+    for (const [key, session] of this.otherSessionEntries(sender)) {
+      const success = session.send(msg);
+      if (success === 0) {
+        this.endBrowserSession(
+          key,
+          WebsocketCloseCodes.KICKED,
+          "Closed broken connection",
+          ctx,
+          defer
+        );
+      }
+    }
+  }
+  /**
+   * Will broadcast the given ServerMsg to all Sessions in the Room.
+   */
+  sendToAll(serverMsg, ctx, defer = () => {
+    throw new Error(
+      "One of your hook handlers returned a promise, but no side effect collector was provided. Pass a `defer` callback to sendToAll() to collect async side effects."
+    );
+  }) {
+    const msg = serialize(serverMsg);
+    for (const [key, session] of this.sessions) {
+      const success = session.send(msg);
+      if (success === 0) {
+        this.endBrowserSession(
+          key,
+          WebsocketCloseCodes.KICKED,
+          "Closed broken connection",
+          ctx,
+          defer
+        );
+      }
+    }
+  }
+  // ------------------------------------------------------------------------------------
+  // Private APIs
+  // ------------------------------------------------------------------------------------
+  async _loadStorage() {
+    const storage = new Storage(this.driver);
+    await storage.load(this.logger);
+    return storage;
+  }
+  async _loadYjsStorage() {
+    const yjsStorage = new YjsStorage(this.driver);
+    await yjsStorage.load(this.logger);
+    return yjsStorage;
+  }
+  // Don't ever manually call this!
+  async _load(ctx) {
+    await _optionalChain([this, 'access', _101 => _101.hooks, 'access', _102 => _102.onRoomWillLoad, 'optionalCall', _103 => _103(ctx)]);
+    const storage = await this._loadStorage();
+    const yjsStorage = await this._loadYjsStorage();
+    this._data = {
+      mutex: new (0, _asyncmutex.Mutex)(),
+      storage,
+      yjsStorage
+    };
+    await _optionalChain([this, 'access', _104 => _104.hooks, 'access', _105 => _105.onRoomDidLoad, 'optionalCall', _106 => _106(ctx)]);
+  }
+  /**
+   * Returns a new, unique, actor ID.
+   */
+  async getNextActor() {
+    return await this.driver.next_actor();
+  }
+  /**
+   * Iterates over all *other* Sessions and their session keys.
+   */
+  *otherSessionEntries(currentKey) {
+    for (const [key, session] of this.sessions) {
+      if (key !== currentKey) {
+        yield [key, session];
+      }
+    }
+  }
+  /**
+   * Iterates over all *other* Sessions.
+   */
+  *otherSessions(currentKey) {
+    for (const [key, session] of this.sessions) {
+      if (key !== currentKey) {
+        yield session;
+      }
+    }
+  }
+  /**
+   * @internal
+   * Handles an incoming ping, by sending a pong back.
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async handlePing(sessionKey, ctx) {
+    const session = this.sessions.get(sessionKey);
+    if (session === void 0) {
+      this.logger.withContext({ sessionKey }).warn("[probe] in handlePing, no such session exists");
+      return;
+    }
+    const sent = session.sendPong();
+    if (sent !== 0) {
+      await _optionalChain([this, 'access', _107 => _107.hooks, 'access', _108 => _108.onDidPong, 'optionalCall', _109 => _109(ctx)]);
+    }
+  }
+  async _processClientMsg_withExclusiveAccess(sessionKey, messages, ctx, defer) {
+    const session = this.sessions.get(sessionKey);
+    if (!session) {
+      this.logger.withContext({ sessionKey }).warn("[probe] in handleClientMsgs, no such session exists");
+      return;
+    }
+    const toFanOut = [];
+    const toReply = [];
+    const replyImmediately = (msg) => void session.send(msg);
+    const scheduleFanOut = (msg) => void toFanOut.push(msg);
+    const scheduleReply = (msg) => void toReply.push(msg);
+    for (const msg of messages) {
+      const isMsgAllowed = this.hooks.isClientMsgAllowed(msg, session);
+      if (isMsgAllowed.allowed) {
+        await this.handleOne(
+          session,
+          msg,
+          replyImmediately,
+          scheduleFanOut,
+          scheduleReply,
+          ctx,
+          defer
+        );
+      } else {
+        if (!session.hasNotifiedClientStorageUpdateError) {
+          toReply.push({
+            type: ServerMsgCode.REJECT_STORAGE_OP,
+            opIds: msg.type === ClientMsgCode.UPDATE_STORAGE ? msg.ops.map((op2) => op2.opId) : [],
+            reason: isMsgAllowed.reason
+          });
+          session.setHasNotifiedClientStorageUpdateError();
+        }
+      }
+    }
+    if (toFanOut.length > 0) {
+      this.sendToOthers(sessionKey, toFanOut, ctx, defer);
+    }
+    if (toReply.length > 0) {
+      session.send(toReply);
+    }
+  }
+  // TODO It's a bit bothering how much duplication there is between this method
+  // and the _processClientMsg_withExclusiveAccess version. A better
+  // abstraction is needed.
+  async _processClientMsgFromBackendSession_withExclusiveAccess(session, messages, ctx, defer) {
+    const toFanOut = [];
+    const toReplyImmediately = [];
+    const toReplyAfter = [];
+    const replyImmediately = (msg) => {
+      if (Array.isArray(msg)) {
+        for (const m of msg) {
+          toReplyImmediately.push(m);
+        }
+      } else {
+        toReplyImmediately.push(msg);
+      }
+    };
+    const scheduleFanOut = (msg) => void toFanOut.push(msg);
+    const scheduleReply = (msg) => void toReplyAfter.push(msg);
+    for (const msg of messages) {
+      await this.handleOne(
+        session,
+        msg,
+        replyImmediately,
+        scheduleFanOut,
+        scheduleReply,
+        ctx,
+        defer
+      );
+    }
+    if (toReplyImmediately.length > 0) {
+      session.send(toReplyImmediately);
+      toReplyImmediately.length = 0;
+    }
+    if (toFanOut.length > 0) {
+      this.sendToOthers("(transient)", toFanOut, ctx, defer);
+      toFanOut.length = 0;
+    }
+    if (toReplyAfter.length > 0) {
+      session.send(toReplyAfter);
+      toReplyAfter.length = 0;
+    }
+  }
+  async handleOne(session, msg, replyImmediately, scheduleFanOut, scheduleReply, ctx, defer) {
+    if (!this.mutex.isLocked()) {
+      throw new Error("Handling messages requires exclusive access");
+    }
+    switch (msg.type) {
+      case ClientMsgCode.UPDATE_PRESENCE: {
+        scheduleFanOut({
+          type: ServerMsgCode.UPDATE_PRESENCE,
+          actor: session.actor,
+          data: msg.data,
+          targetActor: msg.targetActor
+        });
+        break;
+      }
+      case ClientMsgCode.BROADCAST_EVENT: {
+        scheduleFanOut({
+          type: ServerMsgCode.BROADCASTED_EVENT,
+          actor: session.actor,
+          event: msg.event
+        });
+        break;
+      }
+      case ClientMsgCode.FETCH_STORAGE: {
+        if (session.version >= 8 /* V8 */) {
+          if (__privateGet(this, __allowStreaming)) {
+            const NODES_PER_CHUNK = 250;
+            for (const chunk of _itertools.chunked.call(void 0, 
+              nodeStreamToCompactNodes(this.storage.loadedDriver.iter_nodes()),
+              NODES_PER_CHUNK
+            )) {
+              replyImmediately({
+                type: ServerMsgCode.STORAGE_CHUNK,
+                nodes: chunk
+              });
+            }
+          } else {
+            replyImmediately({
+              type: ServerMsgCode.STORAGE_CHUNK,
+              nodes: Array.from(
+                nodeStreamToCompactNodes(this.storage.loadedDriver.iter_nodes())
+              )
+            });
+          }
+          replyImmediately({ type: ServerMsgCode.STORAGE_STREAM_END });
+        } else {
+          replyImmediately({
+            type: ServerMsgCode.STORAGE_STATE_V7,
+            items: Array.from(this.storage.loadedDriver.iter_nodes())
+          });
+        }
+        break;
+      }
+      case ClientMsgCode.UPDATE_STORAGE: {
+        _optionalChain([this, 'access', _110 => _110.driver, 'access', _111 => _111.bump_storage_version, 'optionalCall', _112 => _112()]);
+        const result = await this.storage.applyOps(msg.ops);
+        const opsToForward = result.flatMap(
+          (r) => r.action === "accepted" ? [r.op] : []
+        );
+        const opsToSendBack = result.flatMap((r) => {
+          switch (r.action) {
+            case "ignored":
+              return r.ignoredOpId !== void 0 ? [ackIgnoredOp(r.ignoredOpId)] : [];
+            case "accepted":
+              return r.fix !== void 0 ? [r.fix] : [];
+            default:
+              return assertNever(r, "Unhandled case");
+          }
+        });
+        if (opsToForward.length > 0) {
+          scheduleFanOut({
+            type: ServerMsgCode.UPDATE_STORAGE,
+            ops: opsToForward.map(stripOpId)
+          });
+          scheduleReply({
+            type: ServerMsgCode.UPDATE_STORAGE,
+            ops: opsToForward
+          });
+        }
+        if (opsToSendBack.length > 0) {
+          replyImmediately({
+            type: ServerMsgCode.UPDATE_STORAGE,
+            ops: opsToSendBack
+          });
+        }
+        if (opsToForward.length > 0) {
+          const p$ = _optionalChain([this, 'access', _113 => _113.hooks, 'access', _114 => _114.postClientMsgStorageDidUpdate, 'optionalCall', _115 => _115(ctx)]);
+          if (p$) defer(p$);
+        }
+        break;
+      }
+      case ClientMsgCode.FETCH_YDOC: {
+        const vector = msg.vector;
+        const guid = msg.guid;
+        const isV2 = msg.v2;
+        const [update, stateVector, snapshotHash] = await Promise.all([
+          this.yjsStorage.getYDocUpdate(this.logger, vector, guid, isV2),
+          this.yjsStorage.getYStateVector(guid),
+          this.yjsStorage.getSnapshotHash({ guid, isV2 })
+        ]);
+        if (update !== null && snapshotHash !== null) {
+          replyImmediately({
+            type: ServerMsgCode.UPDATE_YDOC,
+            update,
+            isSync: true,
+            // this is no longer used by the client, instead we use the presence of stateVector
+            stateVector,
+            guid,
+            v2: isV2,
+            remoteSnapshotHash: snapshotHash
+          });
+        }
+        break;
+      }
+      case ClientMsgCode.UPDATE_YDOC: {
+        const update = msg.update;
+        const guid = msg.guid;
+        const isV2 = msg.v2;
+        const [result, error3] = await tryCatch(
+          this.yjsStorage.addYDocUpdate(this.logger, update, guid, isV2)
+        );
+        if (error3)
+          break;
+        this.sendToAll(
+          {
+            type: ServerMsgCode.UPDATE_YDOC,
+            update,
+            guid,
+            isSync: false,
+            stateVector: null,
+            v2: isV2,
+            remoteSnapshotHash: result.snapshotHash
+          },
+          ctx,
+          defer
+        );
+        if (result.isUpdated) {
+          const p$ = _optionalChain([this, 'access', _116 => _116.hooks, 'access', _117 => _117.postClientMsgYdocDidUpdate, 'optionalCall', _118 => _118(ctx, session)]);
+          if (p$) defer(p$);
+        }
+        break;
+      }
+      default: {
+        try {
+          return assertNever(msg, "Unrecognized client msg");
+        } catch (e2) {
+        }
+      }
+    }
+  }
+};
+__debug2 = new WeakMap();
+__allowStreaming = new WeakMap();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BackendSession = BackendSession; exports.BrowserSession = BrowserSession; exports.ConsoleTarget = ConsoleTarget; exports.DefaultMap = DefaultMap2; exports.InMemoryDriver = InMemoryDriver; exports.LogLevel = LogLevel; exports.LogTarget = LogTarget; exports.Logger = Logger; exports.NestedMap = NestedMap; exports.ProtocolVersion = ProtocolVersion; exports.ROOT_YDOC_ID = ROOT_YDOC_ID; exports.Room = Room; exports.UniqueMap = UniqueMap; exports.ackIgnoredOp = ackIgnoredOp; exports.clientMsgDecoder = clientMsgDecoder; exports.concatUint8Arrays = concatUint8Arrays; exports.guidDecoder = guidDecoder; exports.jsonObjectYolo = jsonObjectYolo; exports.jsonYolo = jsonYolo; exports.makeInMemorySnapshot = makeInMemorySnapshot; exports.makeMetadataDB = makeMetadataDB; exports.plainLsonToNodeStream = plainLsonToNodeStream; exports.protocolVersionDecoder = protocolVersionDecoder; exports.quote = quote; exports.serializeServerMsg = serialize; exports.snapshotToLossyJson_eager = snapshotToLossyJson_eager; exports.snapshotToLossyJson_lazy = snapshotToLossyJson_lazy; exports.snapshotToNodeStream = snapshotToNodeStream; exports.snapshotToPlainLson_eager = snapshotToPlainLson_eager; exports.snapshotToPlainLson_lazy = snapshotToPlainLson_lazy; exports.test_only__Storage = Storage; exports.test_only__YjsStorage = YjsStorage; exports.transientClientMsgDecoder = transientClientMsgDecoder; exports.tryCatch = tryCatch;
+//# sourceMappingURL=index.cjs.map