@liveblocks/server 1.0.1 → 1.0.3

package/dist/index.js

@@ -8,751 +8,9 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 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(() => unsub?.());
-  }
-  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 = 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);
-    }
-    trackedReads?.add(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 = 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 && event.data?.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
+import { ClientMsgCode } from "@liveblocks/core";
 import {
   array,
   boolean,
@@ -773,6 +31,7 @@ var jsonObjectYolo = jsonYolo.refine(
 );
 
 // src/decoders/Op.ts
+import { OpCode } from "@liveblocks/core";
 import { constant, object, optional, string, taggedUnion } from "decoders";
 var updateObjectOp = object({
   type: constant(OpCode.UPDATE_OBJECT),
@@ -900,6 +159,7 @@ var transientClientMsgDecoder = taggedUnion2("type", {
 }).describe("Must be a valid transient client message");
 
 // src/formats/LossyJson.ts
+import { CrdtType } from "@liveblocks/core";
 function snapshotToLossyJson_eager(snapshot2) {
   try {
     return buildObject(snapshot2, "root", snapshot2.get_root().data);
@@ -1004,6 +264,12 @@ function* snapshotToNodeStream(snapshot2) {
 }
 
 // src/formats/PlainLson.ts
+import {
+  assertNever,
+  CrdtType as CrdtType2,
+  isJsonObject,
+  makePosition
+} from "@liveblocks/core";
 var SERVER_INIT_OP_PREFIX = "si";
 function generateId(state) {
   return `${SERVER_INIT_OP_PREFIX}:${state.clock++}`;
@@ -1030,7 +296,7 @@ function* iterJson(key, data, parent, state) {
     yield [
       generateId(state),
       {
-        type: CrdtType.REGISTER,
+        type: CrdtType2.REGISTER,
         data,
         parentId: parent[0],
         parentKey: key
@@ -1041,7 +307,7 @@ function* iterJson(key, data, parent, state) {
 function* iterMap(key, map, parent, state) {
   const mapTuple = [
     generateId(state),
-    { type: CrdtType.MAP, parentId: parent[0], parentKey: key }
+    { type: CrdtType2.MAP, parentId: parent[0], parentKey: key }
   ];
   yield mapTuple;
   for (const [subKey, subValue] of Object.entries(map)) {
@@ -1051,7 +317,7 @@ function* iterMap(key, map, parent, state) {
 function* iterList(key, list, parent, state) {
   const id = generateId(state);
   const crdt = {
-    type: CrdtType.LIST,
+    type: CrdtType2.LIST,
     parentId: parent[0],
     parentKey: key
   };
@@ -1076,12 +342,12 @@ function* iterObjectInner(key, value, parent, state) {
   const objectTuple = parent !== null ? [
     generateId(state),
     {
-      type: CrdtType.OBJECT,
+      type: CrdtType2.OBJECT,
       data,
       parentId: parent[0],
       parentKey: key
     }
-  ] : ["root", { type: CrdtType.OBJECT, data }];
+  ] : ["root", { type: CrdtType2.OBJECT, data }];
   yield objectTuple;
   for (const [subKey, subValue] of specialChildren) {
     yield* iterJson(subKey, subValue, objectTuple, state);
@@ -1100,11 +366,11 @@ function snapshotToPlainLson_eager(snapshot2) {
 }
 function buildNode2(snapshot2, id) {
   const node = snapshot2.get_node(id);
-  if (node.type === CrdtType.OBJECT) {
+  if (node.type === CrdtType2.OBJECT) {
     return buildObject2(snapshot2, id, node.data);
-  } else if (node.type === CrdtType.LIST) {
+  } else if (node.type === CrdtType2.LIST) {
     return buildList2(snapshot2, id);
-  } else if (node.type === CrdtType.MAP) {
+  } else if (node.type === CrdtType2.MAP) {
     return buildMap2(snapshot2, id);
   } else {
     return node.data;
@@ -1144,13 +410,13 @@ function* snapshotToPlainLson_lazy(snapshot2) {
 }
 function* emit2(snapshot2, id) {
   const node = snapshot2.get_node(id);
-  if (node.type === CrdtType.OBJECT) {
+  if (node.type === CrdtType2.OBJECT) {
     yield* emitObject2(snapshot2, id, JSON.stringify(node.data).slice(1, -1));
-  } else if (node.type === CrdtType.LIST) {
+  } else if (node.type === CrdtType2.LIST) {
     yield* emitList2(snapshot2, id);
-  } else if (node.type === CrdtType.MAP) {
+  } else if (node.type === CrdtType2.MAP) {
     yield* emitMap2(snapshot2, id);
-  } else if (node.type === CrdtType.REGISTER) {
+  } else if (node.type === CrdtType2.REGISTER) {
     yield JSON.stringify(node.data);
   }
 }
@@ -1188,17 +454,21 @@ function* emitMap2(snapshot2, id) {
   yield "}}";
 }
 
+// src/makeInMemorySnapshot.ts
+import { CrdtType as CrdtType3, isRootStorageNode, nn } from "@liveblocks/core";
+
 // src/lib/DefaultMap.ts
-var _defaultFn2;
-var DefaultMap2 = class extends Map {
+import { raise } from "@liveblocks/core";
+var _defaultFn;
+var DefaultMap = 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);
+    __privateAdd(this, _defaultFn);
+    __privateSet(this, _defaultFn, defaultFn);
   }
   /**
    * Gets the value at the given key, or creates it.
@@ -1211,14 +481,14 @@ var DefaultMap2 = class extends Map {
     if (super.has(key)) {
       return super.get(key);
     } else {
-      const fn = defaultFn ?? __privateGet(this, _defaultFn2) ?? raise("DefaultMap used without a factory function");
+      const fn = defaultFn ?? __privateGet(this, _defaultFn) ?? raise("DefaultMap used without a factory function");
       const value = fn(key);
       this.set(key, value);
       return value;
     }
   }
 };
-_defaultFn2 = new WeakMap();
+_defaultFn = new WeakMap();
 
 // src/lib/NestedMap.ts
 function emptyIterator() {
@@ -1228,7 +498,7 @@ var _map;
 var NestedMap = class {
   constructor() {
     __privateAdd(this, _map);
-    __privateSet(this, _map, new DefaultMap2(() => /* @__PURE__ */ new Map()));
+    __privateSet(this, _map, new DefaultMap(() => /* @__PURE__ */ new Map()));
   }
   get size() {
     let total = 0;
@@ -1308,7 +578,7 @@ _map = new WeakMap();
 function makeInMemorySnapshot(values) {
   const map = new Map(values);
   if (!map.has("root")) {
-    map.set("root", { type: CrdtType.OBJECT, data: {} });
+    map.set("root", { type: CrdtType3.OBJECT, data: {} });
   }
   const entries = [];
   const nodeStream = map;
@@ -1370,12 +640,23 @@ var protocolVersionDecoder = enum_(ProtocolVersion).describe(
 );
 
 // src/Room.ts
+import {
+  assertNever as assertNever3,
+  ClientMsgCode as ClientMsgCode2,
+  nodeStreamToCompactNodes,
+  OpCode as OpCode3,
+  raise as raise3,
+  ServerMsgCode as ServerMsgCode2,
+  tryParseJson,
+  WebsocketCloseCodes as CloseCode
+} from "@liveblocks/core";
 import { Mutex } from "async-mutex";
 import { array as array2, formatInline } from "decoders";
 import { chunked } from "itertools";
 import { nanoid as nanoid2 } from "nanoid";
 
 // src/lib/Logger.ts
+import { raise as raise2 } from "@liveblocks/core";
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
   LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
   LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
@@ -1407,7 +688,7 @@ var LogTarget = class {
       case 3 /* ERROR */:
         return "error";
       default:
-        return raise("Invalid log level");
+        return raise2("Invalid log level");
     }
   }
   /** Helper for formatting an Arg */
@@ -1508,6 +789,7 @@ var Logger = class _Logger {
 };
 
 // src/plugins/InMemoryDriver.ts
+import { asPos, CrdtType as CrdtType4, isRootStorageNode as isRootStorageNode2, nn as nn2 } from "@liveblocks/core";
 import { ifilter, imap } from "itertools";
 
 // src/lib/text.ts
@@ -1519,7 +801,7 @@ function quote(value) {
 function buildRevNodes(nodeStream) {
   const result = new NestedMap();
   for (const node of nodeStream) {
-    if (isRootStorageNode(node)) continue;
+    if (isRootStorageNode2(node)) continue;
     const [id, crdt] = node;
     const existing = result.get(crdt.parentId, crdt.parentKey);
     if (existing === void 0 || id > existing) {
@@ -1534,17 +816,17 @@ function buildReverseLookup(nodes) {
   const reachableNodes = /* @__PURE__ */ new Set();
   while (queue.length > 0) {
     const nodeId = queue.pop();
-    const node = nn(nodes.get(nodeId));
-    if (node.type === CrdtType.OBJECT) {
+    const node = nn2(nodes.get(nodeId));
+    if (node.type === CrdtType4.OBJECT) {
       for (const key of revNodes.keysAt(nodeId)) {
         delete node.data[key];
       }
     }
-    if (node.type !== CrdtType.REGISTER) {
+    if (node.type !== CrdtType4.REGISTER) {
       queue.push(...revNodes.valuesAt(nodeId));
     } else {
       const parent = nodes.get(node.parentId);
-      if (parent?.type === CrdtType.OBJECT) {
+      if (parent?.type === CrdtType4.OBJECT) {
         continue;
       }
     }
@@ -1560,7 +842,7 @@ function buildReverseLookup(nodes) {
   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;
+  return node.type === CrdtType4.OBJECT && Object.prototype.hasOwnProperty.call(node.data, key) && node.data[key] !== void 0;
 }
 var InMemoryDriver = class {
   constructor(options) {
@@ -1621,7 +903,7 @@ var InMemoryDriver = class {
   load_nodes_api() {
     const nodes = this._nodes;
     if (!nodes.has("root")) {
-      nodes.set("root", { type: CrdtType.OBJECT, data: {} });
+      nodes.set("root", { type: CrdtType4.OBJECT, data: {} });
     }
     const revNodes = buildReverseLookup(nodes);
     function get_next_sibling(parentId, pos) {
@@ -1639,7 +921,7 @@ var InMemoryDriver = class {
       if (parentNode === void 0) {
         throw new Error(`No such parent ${quote(node.parentId)}`);
       }
-      if (node.type === CrdtType.REGISTER && parentNode.type === CrdtType.OBJECT) {
+      if (node.type === CrdtType4.REGISTER && parentNode.type === CrdtType4.OBJECT) {
         throw new Error("Cannot add register under object");
       }
       const conflictingSiblingId = revNodes.get(node.parentId, node.parentKey);
@@ -1671,7 +953,7 @@ var InMemoryDriver = class {
     }
     async function set_object_data(id, data, allowOverwrite = false) {
       const node = nodes.get(id);
-      if (node?.type !== CrdtType.OBJECT) {
+      if (node?.type !== CrdtType4.OBJECT) {
         return;
       }
       for (const key of Object.keys(data)) {
@@ -1799,6 +1081,13 @@ function makeNewInMemoryDriver(options) {
 }
 
 // src/Storage.ts
+import {
+  asPos as asPos2,
+  assertNever as assertNever2,
+  CrdtType as CrdtType5,
+  makePosition as makePosition2,
+  OpCode as OpCode2
+} from "@liveblocks/core";
 function accept(op2, fix) {
   return { action: "accepted", op: op2, fix };
 }
@@ -1807,34 +1096,34 @@ function ignore(ignoredOp) {
 }
 function nodeFromCreateChildOp(op2) {
   switch (op2.type) {
-    case OpCode.CREATE_LIST:
+    case OpCode2.CREATE_LIST:
       return {
-        type: CrdtType.LIST,
+        type: CrdtType5.LIST,
         parentId: op2.parentId,
         parentKey: op2.parentKey
       };
-    case OpCode.CREATE_MAP:
+    case OpCode2.CREATE_MAP:
       return {
-        type: CrdtType.MAP,
+        type: CrdtType5.MAP,
         parentId: op2.parentId,
         parentKey: op2.parentKey
       };
-    case OpCode.CREATE_OBJECT:
+    case OpCode2.CREATE_OBJECT:
       return {
-        type: CrdtType.OBJECT,
+        type: CrdtType5.OBJECT,
         parentId: op2.parentId,
         parentKey: op2.parentKey,
         data: op2.data
       };
-    case OpCode.CREATE_REGISTER:
+    case OpCode2.CREATE_REGISTER:
       return {
-        type: CrdtType.REGISTER,
+        type: CrdtType5.REGISTER,
         parentId: op2.parentId,
         parentKey: op2.parentKey,
         data: op2.data
       };
     default:
-      return assertNever(op2, "Unknown op code");
+      return assertNever2(op2, "Unknown op code");
   }
 }
 var Storage = class {
@@ -1888,24 +1177,24 @@ var Storage = class {
    */
   async applyOp(op2) {
     switch (op2.type) {
-      case OpCode.CREATE_LIST:
-      case OpCode.CREATE_MAP:
-      case OpCode.CREATE_REGISTER:
-      case OpCode.CREATE_OBJECT:
+      case OpCode2.CREATE_LIST:
+      case OpCode2.CREATE_MAP:
+      case OpCode2.CREATE_REGISTER:
+      case OpCode2.CREATE_OBJECT:
         return await this.applyCreateOp(op2);
-      case OpCode.UPDATE_OBJECT:
+      case OpCode2.UPDATE_OBJECT:
         return await this.applyUpdateObjectOp(op2);
-      case OpCode.SET_PARENT_KEY:
+      case OpCode2.SET_PARENT_KEY:
         return await this.applySetParentKeyOp(op2);
-      case OpCode.DELETE_OBJECT_KEY:
+      case OpCode2.DELETE_OBJECT_KEY:
         return await this.applyDeleteObjectKeyOp(op2);
-      case OpCode.DELETE_CRDT:
+      case OpCode2.DELETE_CRDT:
         return await this.applyDeleteCrdtOp(op2);
       default:
         if (process.env.NODE_ENV === "production") {
           return ignore(op2);
         } else {
-          return assertNever(op2, "Invalid op");
+          return assertNever2(op2, "Invalid op");
         }
     }
   }
@@ -1919,19 +1208,19 @@ var Storage = class {
       return ignore(op2);
     }
     switch (parent.type) {
-      case CrdtType.OBJECT:
-        if (op2.type === OpCode.CREATE_REGISTER) {
+      case CrdtType5.OBJECT:
+        if (op2.type === OpCode2.CREATE_REGISTER) {
           return ignore(op2);
         }
-      case CrdtType.MAP:
+      case CrdtType5.MAP:
         await this.loadedDriver.set_child(op2.id, node, true);
         return accept(op2);
-      case CrdtType.LIST:
+      case CrdtType5.LIST:
         return this.createChildAsListItem(op2, node);
-      case CrdtType.REGISTER:
+      case CrdtType5.REGISTER:
         return ignore(op2);
       default:
-        return assertNever(parent, "Unhandled CRDT type");
+        return assertNever2(parent, "Unhandled CRDT type");
     }
   }
   async createChildAsListItem(op2, node) {
@@ -1942,7 +1231,7 @@ var Storage = class {
       if (insertedParentKey !== node.parentKey) {
         op2 = { ...op2, parentKey: insertedParentKey };
         fix = {
-          type: OpCode.SET_PARENT_KEY,
+          type: OpCode2.SET_PARENT_KEY,
           id: op2.id,
           parentKey: insertedParentKey
         };
@@ -1960,14 +1249,14 @@ var Storage = class {
       );
       if (prevItemId !== void 0 && prevItemId !== deletedId) {
         fix = {
-          type: OpCode.DELETE_CRDT,
+          type: OpCode2.DELETE_CRDT,
           id: prevItemId
         };
       }
       await this.loadedDriver.set_child(op2.id, node, true);
       return accept(op2, fix);
     } else {
-      return assertNever(intent, "Invalid intent");
+      return assertNever2(intent, "Invalid intent");
     }
   }
   async applyDeleteObjectKeyOp(op2) {
@@ -1990,7 +1279,7 @@ var Storage = class {
     if (newPosition !== op2.parentKey) {
       const modifiedOp = { ...op2, parentKey: newPosition };
       const fix = {
-        type: OpCode.SET_PARENT_KEY,
+        type: OpCode2.SET_PARENT_KEY,
         id: op2.id,
         parentKey: newPosition
       };
@@ -2008,7 +1297,7 @@ var Storage = class {
    * Returns the key that was used for the insertion.
    */
   async insertIntoList(id, node) {
-    const key = this.findFreeListPosition(node.parentId, asPos(node.parentKey));
+    const key = this.findFreeListPosition(node.parentId, asPos2(node.parentKey));
     if (key !== node.parentKey) {
       node = { ...node, parentKey: key };
     }
@@ -2032,13 +1321,13 @@ var Storage = class {
     if (node?.parentId === void 0) {
       return;
     }
-    if (this.loadedDriver.get_node(node.parentId)?.type !== CrdtType.LIST) {
+    if (this.loadedDriver.get_node(node.parentId)?.type !== CrdtType5.LIST) {
       return;
     }
     if (node.parentKey === targetKey) {
       return targetKey;
     }
-    const key = this.findFreeListPosition(node.parentId, asPos(targetKey));
+    const key = this.findFreeListPosition(node.parentId, asPos2(targetKey));
     if (key !== node.parentKey) {
       await this.loadedDriver.move_sibling(id, key);
     }
@@ -2058,14 +1347,15 @@ var Storage = class {
     const currPos = parentPos;
     const nextPos = this.loadedDriver.get_next_sibling(parentId, currPos);
     if (nextPos !== void 0) {
-      return makePosition(currPos, nextPos);
+      return makePosition2(currPos, nextPos);
     } else {
-      return makePosition(currPos);
+      return makePosition2(currPos);
     }
   }
 };
 
 // src/YjsStorage.ts
+import { DefaultMap as DefaultMap2 } from "@liveblocks/core";
 import { Base64 } from "js-base64";
 import { nanoid } from "nanoid";
 import * as Y from "yjs";
@@ -2078,7 +1368,7 @@ var YjsStorage = class {
     __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(
+    __publicField(this, "keysById", new DefaultMap2(
       () => /* @__PURE__ */ new Set()
     ));
     __publicField(this, "initPromisesById", /* @__PURE__ */ new Map());
@@ -2324,8 +1614,8 @@ async function tryCatch(promise) {
   try {
     const data = await (typeof promise === "function" ? promise() : promise);
     return [data, void 0];
-  } catch (error3) {
-    return [void 0, error3];
+  } catch (error) {
+    return [void 0, error];
   }
 }
 
@@ -2370,6 +1660,7 @@ __revMap = new WeakMap();
 __keyFn = new WeakMap();
 
 // src/utils.ts
+import { ServerMsgCode } from "@liveblocks/core";
 function concatUint8Arrays(arrays) {
   const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
   const result = new Uint8Array(totalLength);
@@ -2399,7 +1690,7 @@ var HIGHEST_PROTOCOL_VERSION = Math.max(
   )
 );
 var SERVER_MSG_CODE_NAMES = Object.fromEntries(
-  Object.entries(ServerMsgCode).map(([k, v]) => [v, k])
+  Object.entries(ServerMsgCode2).map(([k, v]) => [v, k])
 );
 var BLACK_HOLE = new Logger([
   /* No targets, i.e. black hole logger */
@@ -2415,7 +1706,7 @@ function serialize(msgs) {
   return JSON.stringify(msgs);
 }
 function ackIgnoredOp(opId) {
-  return { type: OpCode.DELETE_CRDT, id: "ACK", opId };
+  return { type: OpCode3.DELETE_CRDT, id: "ACK", opId };
 }
 function stripOpId(op2) {
   const { opId: _, ...rest } = op2;
@@ -2600,7 +1891,7 @@ var Room = class {
   }
   // prettier-ignore
   get data() {
-    return this._data ?? raise("Cannot use room before it's loaded");
+    return this._data ?? raise3("Cannot use room before it's loaded");
   }
   // prettier-ignore
   // ------------------------------------------------------------------------------------
@@ -2719,7 +2010,7 @@ var Room = class {
     while ((existing = this.sessions.lookupPrimaryKey(ticket.actor)) !== void 0) {
       this.endBrowserSession(
         existing,
-        WebsocketCloseCodes.KICKED,
+        CloseCode.KICKED,
         "Closed stale connection",
         ctx,
         defer
@@ -2751,7 +2042,7 @@ var Room = class {
     this.sendToOthers(
       ticket.sessionKey,
       {
-        type: ServerMsgCode.USER_JOINED,
+        type: ServerMsgCode2.USER_JOINED,
         actor: newSession.actor,
         id: newSession.user.id,
         info: newSession.user.info,
@@ -2782,7 +2073,7 @@ var Room = class {
     const deleted = sessions.delete(key);
     if (deleted) {
       for (const other of this.otherSessions(key)) {
-        other.send({ type: ServerMsgCode.USER_LEFT, actor: session.actor });
+        other.send({ type: ServerMsgCode2.USER_LEFT, actor: session.actor });
       }
       const p$ = this.hooks.onSessionDidEnd?.(session, ctx);
       if (p$) defer(p$);
@@ -2814,7 +2105,7 @@ var Room = class {
       "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");
+    const text = typeof data === "string" ? data : raise3("Unsupported message format");
     if (text === "ping") {
       await this.handlePing(key, ctx);
     } else {
@@ -2824,7 +2115,7 @@ var Room = class {
         const reason = process.env.NODE_ENV !== "production" ? formatInline(messages.error) : "Invalid message format";
         this.endBrowserSession(
           key,
-          WebsocketCloseCodes.INVALID_MESSAGE_FORMAT,
+          CloseCode.INVALID_MESSAGE_FORMAT,
           reason,
           ctx,
           defer
@@ -2914,7 +2205,7 @@ var Room = class {
       if (success === 0) {
         this.endBrowserSession(
           key,
-          WebsocketCloseCodes.KICKED,
+          CloseCode.KICKED,
           "Closed broken connection",
           ctx,
           defer
@@ -2936,7 +2227,7 @@ var Room = class {
       if (success === 0) {
         this.endBrowserSession(
           key,
-          WebsocketCloseCodes.KICKED,
+          CloseCode.KICKED,
           "Closed broken connection",
           ctx,
           defer
@@ -3037,8 +2328,8 @@ var Room = class {
       } else {
         if (!session.hasNotifiedClientStorageUpdateError) {
           toReply.push({
-            type: ServerMsgCode.REJECT_STORAGE_OP,
-            opIds: msg.type === ClientMsgCode.UPDATE_STORAGE ? msg.ops.map((op2) => op2.opId) : [],
+            type: ServerMsgCode2.REJECT_STORAGE_OP,
+            opIds: msg.type === ClientMsgCode2.UPDATE_STORAGE ? msg.ops.map((op2) => op2.opId) : [],
             reason: isMsgAllowed.reason
           });
           session.setHasNotifiedClientStorageUpdateError();
@@ -3099,24 +2390,24 @@ var Room = class {
       throw new Error("Handling messages requires exclusive access");
     }
     switch (msg.type) {
-      case ClientMsgCode.UPDATE_PRESENCE: {
+      case ClientMsgCode2.UPDATE_PRESENCE: {
         scheduleFanOut({
-          type: ServerMsgCode.UPDATE_PRESENCE,
+          type: ServerMsgCode2.UPDATE_PRESENCE,
           actor: session.actor,
           data: msg.data,
           targetActor: msg.targetActor
         });
         break;
       }
-      case ClientMsgCode.BROADCAST_EVENT: {
+      case ClientMsgCode2.BROADCAST_EVENT: {
         scheduleFanOut({
-          type: ServerMsgCode.BROADCASTED_EVENT,
+          type: ServerMsgCode2.BROADCASTED_EVENT,
           actor: session.actor,
           event: msg.event
         });
         break;
       }
-      case ClientMsgCode.FETCH_STORAGE: {
+      case ClientMsgCode2.FETCH_STORAGE: {
         if (session.version >= 8 /* V8 */) {
           if (__privateGet(this, __allowStreaming)) {
             const NODES_PER_CHUNK = 250;
@@ -3125,28 +2416,28 @@ var Room = class {
               NODES_PER_CHUNK
             )) {
               replyImmediately({
-                type: ServerMsgCode.STORAGE_CHUNK,
+                type: ServerMsgCode2.STORAGE_CHUNK,
                 nodes: chunk
               });
             }
           } else {
             replyImmediately({
-              type: ServerMsgCode.STORAGE_CHUNK,
+              type: ServerMsgCode2.STORAGE_CHUNK,
               nodes: Array.from(
                 nodeStreamToCompactNodes(this.storage.loadedDriver.iter_nodes())
               )
             });
           }
-          replyImmediately({ type: ServerMsgCode.STORAGE_STREAM_END });
+          replyImmediately({ type: ServerMsgCode2.STORAGE_STREAM_END });
         } else {
           replyImmediately({
-            type: ServerMsgCode.STORAGE_STATE_V7,
+            type: ServerMsgCode2.STORAGE_STATE_V7,
             items: Array.from(this.storage.loadedDriver.iter_nodes())
           });
         }
         break;
       }
-      case ClientMsgCode.UPDATE_STORAGE: {
+      case ClientMsgCode2.UPDATE_STORAGE: {
         this.driver.bump_storage_version?.();
         const result = await this.storage.applyOps(msg.ops);
         const opsToForward = result.flatMap(
@@ -3159,22 +2450,22 @@ var Room = class {
             case "accepted":
               return r.fix !== void 0 ? [r.fix] : [];
             default:
-              return assertNever(r, "Unhandled case");
+              return assertNever3(r, "Unhandled case");
           }
         });
         if (opsToForward.length > 0) {
           scheduleFanOut({
-            type: ServerMsgCode.UPDATE_STORAGE,
+            type: ServerMsgCode2.UPDATE_STORAGE,
             ops: opsToForward.map(stripOpId)
           });
           scheduleReply({
-            type: ServerMsgCode.UPDATE_STORAGE,
+            type: ServerMsgCode2.UPDATE_STORAGE,
             ops: opsToForward
           });
         }
         if (opsToSendBack.length > 0) {
           replyImmediately({
-            type: ServerMsgCode.UPDATE_STORAGE,
+            type: ServerMsgCode2.UPDATE_STORAGE,
             ops: opsToSendBack
           });
         }
@@ -3184,7 +2475,7 @@ var Room = class {
         }
         break;
       }
-      case ClientMsgCode.FETCH_YDOC: {
+      case ClientMsgCode2.FETCH_YDOC: {
         const vector = msg.vector;
         const guid = msg.guid;
         const isV2 = msg.v2;
@@ -3195,7 +2486,7 @@ var Room = class {
         ]);
         if (update !== null && snapshotHash !== null) {
           replyImmediately({
-            type: ServerMsgCode.UPDATE_YDOC,
+            type: ServerMsgCode2.UPDATE_YDOC,
             update,
             isSync: true,
             // this is no longer used by the client, instead we use the presence of stateVector
@@ -3207,18 +2498,18 @@ var Room = class {
         }
         break;
       }
-      case ClientMsgCode.UPDATE_YDOC: {
+      case ClientMsgCode2.UPDATE_YDOC: {
         const update = msg.update;
         const guid = msg.guid;
         const isV2 = msg.v2;
-        const [result, error3] = await tryCatch(
+        const [result, error] = await tryCatch(
           this.yjsStorage.addYDocUpdate(this.logger, update, guid, isV2)
         );
-        if (error3)
+        if (error)
           break;
         this.sendToAll(
           {
-            type: ServerMsgCode.UPDATE_YDOC,
+            type: ServerMsgCode2.UPDATE_YDOC,
             update,
             guid,
             isSync: false,
@@ -3237,7 +2528,7 @@ var Room = class {
       }
       default: {
         try {
-          return assertNever(msg, "Unrecognized client msg");
+          return assertNever3(msg, "Unrecognized client msg");
         } catch {
         }
       }
@@ -3250,7 +2541,7 @@ export {
   BackendSession,
   BrowserSession,
   ConsoleTarget,
-  DefaultMap2 as DefaultMap,
+  DefaultMap,
   InMemoryDriver,
   LogLevel,
   LogTarget,