@mml-io/3d-web-user-networking 0.26.0 → 0.27.0

package/build/index.js

@@ -1,8 +1,8 @@
 // src/UserNetworkingServer.ts
-import { encodeError, DeltaNetV01ServerErrors } from "@mml-io/delta-net-protocol";
+import { encodeError, DeltaNetServerErrors } from "@mml-io/delta-net-protocol";
 import {
   DeltaNetServer,
-  DeltaNetServerError as DeltaNetServerError2
+  DeltaNetServerError
 } from "@mml-io/delta-net-server";
 
 // src/DeltaNetComponentMapping.ts
@@ -11,13 +11,13 @@ var COMPONENT_POSITION_X = 1;
 var COMPONENT_POSITION_Y = 2;
 var COMPONENT_POSITION_Z = 3;
 var COMPONENT_ROTATION_Y = 4;
-var COMPONENT_ROTATION_W = 5;
-var COMPONENT_STATE = 6;
+var COMPONENT_STATE = 5;
 var STATE_INTERNAL_CONNECTION_ID = 0;
 var STATE_CHARACTER_DESCRIPTION = 1;
 var STATE_USERNAME = 2;
 var STATE_COLORS = 3;
-var rotationMultiplier = 360;
+var STATE_USER_ID = 4;
+var rotationMultiplier = 1e4;
 var positionMultiplier = 100;
 var textDecoder = new TextDecoder();
 var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
@@ -40,11 +40,7 @@ var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
     );
     components.set(
       COMPONENT_ROTATION_Y,
-      BigInt(Math.round(update.rotation.quaternionY * rotationMultiplier))
-    );
-    components.set(
-      COMPONENT_ROTATION_W,
-      BigInt(Math.round(update.rotation.quaternionW * rotationMultiplier))
+      BigInt(Math.round(update.rotation.eulerY * rotationMultiplier))
     );
     components.set(COMPONENT_STATE, BigInt(update.state));
     return components;
@@ -56,12 +52,11 @@ var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
     const positionX = Number(components.get(COMPONENT_POSITION_X) || BigInt(0)) / positionMultiplier;
     const positionY = Number(components.get(COMPONENT_POSITION_Y) || BigInt(0)) / positionMultiplier;
     const positionZ = Number(components.get(COMPONENT_POSITION_Z) || BigInt(0)) / positionMultiplier;
-    const rotationY = Number(components.get(COMPONENT_ROTATION_Y) || BigInt(0)) / rotationMultiplier;
-    const rotationW = Number(components.get(COMPONENT_ROTATION_W) || BigInt(0)) / rotationMultiplier;
+    const eulerY = Number(components.get(COMPONENT_ROTATION_Y) || BigInt(0)) / rotationMultiplier;
     const state = Number(components.get(COMPONENT_STATE) || BigInt(0));
     return {
       position: { x: positionX, y: positionY, z: positionZ },
-      rotation: { quaternionY: rotationY, quaternionW: rotationW },
+      rotation: { eulerY },
       state
     };
   }
@@ -71,6 +66,9 @@ var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
   static toStates(userIdentity) {
     const states = /* @__PURE__ */ new Map();
     const textEncoder = new TextEncoder();
+    if (userIdentity.userId !== void 0 && userIdentity.userId !== null) {
+      states.set(STATE_USER_ID, textEncoder.encode(userIdentity.userId));
+    }
     if (userIdentity.username) {
       states.set(STATE_USERNAME, textEncoder.encode(userIdentity.username));
     }
@@ -85,6 +83,15 @@ var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
     }
     return states;
   }
+  /**
+   * Decode persistent userId from binary state
+   */
+  static persistentUserIdFromBytes(bytes) {
+    if (bytes.length === 0) {
+      return null;
+    }
+    return textDecoder.decode(bytes);
+  }
   /**
    * Encode username to binary state
    */
@@ -136,6 +143,11 @@ var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
           states.set(stateId, _DeltaNetComponentMapping.encodeColors(value));
         }
         break;
+      case STATE_USER_ID:
+        if (typeof value === "string") {
+          states.set(stateId, textEncoder.encode(value));
+        }
+        break;
     }
     return states;
   }
@@ -171,13 +183,15 @@ var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
     }
   }
   static fromUserStates(states, logger) {
+    const userIdBytes = states.get(STATE_USER_ID);
+    const userId = userIdBytes ? _DeltaNetComponentMapping.persistentUserIdFromBytes(userIdBytes) ?? "" : "";
     const usernameBytes = states.get(STATE_USERNAME);
     const username = usernameBytes ? _DeltaNetComponentMapping.usernameFromBytes(usernameBytes) : null;
     const characterDescBytes = states.get(STATE_CHARACTER_DESCRIPTION);
     const characterDescription = characterDescBytes ? _DeltaNetComponentMapping.characterDescriptionFromBytes(characterDescBytes) : null;
     const colorsBytes = states.get(STATE_COLORS);
-    const colorsArray = colorsBytes ? _DeltaNetComponentMapping.decodeColors(colorsBytes, logger) : [];
-    return { username, characterDescription, colors: colorsArray };
+    const colorsArray = colorsBytes ? _DeltaNetComponentMapping.decodeColors(colorsBytes, logger) : null;
+    return { userId, username, characterDescription, colors: colorsArray };
   }
   static userIdFromBytes(bytes) {
     if (bytes.length === 0) {
@@ -196,486 +210,24 @@ var DeltaNetComponentMapping = class _DeltaNetComponentMapping {
     if (bytes.length === 0) {
       return null;
     }
-    return JSON.parse(textDecoder.decode(bytes));
+    try {
+      return JSON.parse(textDecoder.decode(bytes));
+    } catch {
+      return null;
+    }
   }
   /**
    * Decode binary states back to username and character description
    */
   static fromStates(states, logger) {
-    const userIdBytes = states.get(STATE_INTERNAL_CONNECTION_ID);
-    let userId = null;
-    if (userIdBytes) {
-      const reader = new BufferReader(userIdBytes);
-      userId = reader.readUVarint(false);
+    const connectionIdBytes = states.get(STATE_INTERNAL_CONNECTION_ID);
+    let connectionId = null;
+    if (connectionIdBytes) {
+      const reader = new BufferReader(connectionIdBytes);
+      connectionId = reader.readUVarint(false);
     }
     const userStates = _DeltaNetComponentMapping.fromUserStates(states, logger);
-    return { userId, ...userStates };
-  }
-};
-
-// src/UserNetworkingMessages.ts
-import { DeltaNetServerError } from "@mml-io/delta-net-server";
-var UserNetworkingServerError = class extends DeltaNetServerError {
-};
-var SERVER_BROADCAST_MESSAGE_TYPE = 1;
-var FROM_CLIENT_CHAT_MESSAGE_TYPE = 2;
-var FROM_SERVER_CHAT_MESSAGE_TYPE = 3;
-function parseClientChatMessage(contents) {
-  try {
-    const parsed = JSON.parse(contents);
-    if (typeof parsed === "object" && parsed !== null && "message" in parsed && typeof parsed.message === "string") {
-      return {
-        message: parsed.message
-      };
-    } else {
-      throw new Error("Invalid chat message");
-    }
-  } catch (error) {
-    return new Error(`Invalid chat message: ${error}`);
-  }
-}
-function parseServerChatMessage(contents) {
-  try {
-    const parsed = JSON.parse(contents);
-    if (typeof parsed === "object" && parsed !== null && "fromUserId" in parsed && typeof parsed.fromUserId === "number" && "message" in parsed && typeof parsed.message === "string") {
-      return {
-        fromUserId: parsed.fromUserId,
-        message: parsed.message
-      };
-    } else {
-      throw new Error("Invalid server chat message");
-    }
-  } catch (error) {
-    return new Error(`Invalid server chat message: ${error}`);
-  }
-}
-function parseServerBroadcastMessage(contents) {
-  try {
-    const parsed = JSON.parse(contents);
-    if (typeof parsed === "object" && parsed !== null && "broadcastType" in parsed && typeof parsed.broadcastType === "string" && "payload" in parsed && typeof parsed.payload === "object") {
-      return {
-        broadcastType: parsed.broadcastType,
-        payload: parsed.payload
-      };
-    } else {
-      throw new Error("Invalid server broadcast message");
-    }
-  } catch (error) {
-    return new Error(`Invalid server broadcast message: ${error}`);
-  }
-}
-
-// src/legacy/LegacyUserNetworkingCodec.ts
-var LegacyUserNetworkingCodec = class {
-  static encodeUpdate(update) {
-    const buffer = new ArrayBuffer(19);
-    const dataView = new DataView(buffer);
-    dataView.setUint16(0, update.id);
-    dataView.setFloat32(2, update.position.x);
-    dataView.setFloat32(6, update.position.y);
-    dataView.setFloat32(10, update.position.z);
-    dataView.setInt16(14, update.rotation.quaternionY * 32767);
-    dataView.setInt16(16, update.rotation.quaternionW * 32767);
-    dataView.setUint8(18, update.state);
-    return new Uint8Array(buffer);
-  }
-  static decodeUpdate(buffer) {
-    const dataView = new DataView(buffer);
-    const id = dataView.getUint16(0);
-    const x = dataView.getFloat32(2);
-    const y = dataView.getFloat32(6);
-    const z = dataView.getFloat32(10);
-    const quaternionY = dataView.getInt16(14) / 32767;
-    const quaternionW = dataView.getInt16(16) / 32767;
-    const state = dataView.getUint8(18);
-    const position = { x, y, z };
-    const rotation = { quaternionY, quaternionW };
-    return { id, position, rotation, state };
-  }
-};
-
-// src/legacy/LegacyUserNetworkingMessages.ts
-var LEGACY_USER_NETWORKING_DISCONNECTED_MESSAGE_TYPE = "disconnected";
-var LEGACY_USER_NETWORKING_IDENTITY_MESSAGE_TYPE = "identity";
-var LEGACY_USER_NETWORKING_USER_AUTHENTICATE_MESSAGE_TYPE = "user_auth";
-var LEGACY_USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE = "user_profile";
-var LEGACY_USER_NETWORKING_USER_UPDATE_MESSAGE_TYPE = "user_update";
-var LEGACY_USER_NETWORKING_SERVER_BROADCAST_MESSAGE_TYPE = "broadcast";
-var LEGACY_USER_NETWORKING_SERVER_ERROR_MESSAGE_TYPE = "error";
-var LEGACY_USER_NETWORKING_PING_MESSAGE_TYPE = "ping";
-var LEGACY_USER_NETWORKING_PONG_MESSAGE_TYPE = "pong";
-var LEGACY_USER_NETWORKING_CONNECTION_LIMIT_REACHED_ERROR_TYPE = "CONNECTION_LIMIT_REACHED";
-var LEGACY_USER_NETWORKING_AUTHENTICATION_FAILED_ERROR_TYPE = "AUTHENTICATION_FAILED";
-var LEGACY_USER_NETWORKING_SERVER_SHUTDOWN_ERROR_TYPE = "SERVER_SHUTDOWN";
-var LEGACY_USER_NETWORKING_UNKNOWN_ERROR = "UNKNOWN_ERROR";
-
-// src/legacy/LegacyAdapter.ts
-function toArrayBuffer(buffer) {
-  const arrayBuffer = new ArrayBuffer(buffer.length);
-  const view = new Uint8Array(arrayBuffer);
-  for (let i = 0; i < buffer.length; ++i) {
-    view[i] = buffer[i];
-  }
-  return arrayBuffer;
-}
-var WebSocketOpenStatus = 1;
-var LegacyAdapter = class {
-  constructor(userNetworkingServer, deltaNetServer, logger) {
-    this.userNetworkingServer = userNetworkingServer;
-    this.deltaNetServer = deltaNetServer;
-    this.logger = logger;
-  }
-  allClientsById = /* @__PURE__ */ new Map();
-  legacyAuthenticatedClientsById = /* @__PURE__ */ new Map();
-  broadcastMessage(broadcastType, broadcastPayload) {
-    if (broadcastType !== SERVER_BROADCAST_MESSAGE_TYPE) {
-      return;
-    }
-    const parsedPayload = parseServerBroadcastMessage(broadcastPayload);
-    if (parsedPayload instanceof Error) {
-      this.logger.error("Error parsing server broadcast message", parsedPayload);
-      return;
-    }
-    const { broadcastType: broadcastTypeString, payload } = parsedPayload;
-    const message = {
-      type: "broadcast",
-      broadcastType: broadcastTypeString,
-      payload
-    };
-    const messageString = JSON.stringify(message);
-    for (const [, client] of this.legacyAuthenticatedClientsById) {
-      if (client.socket.readyState === WebSocketOpenStatus) {
-        client.socket.send(messageString);
-      }
-    }
-  }
-  addWebSocket(socket) {
-    const id = this.userNetworkingServer.getLegacyClientId();
-    const client = {
-      id,
-      lastPong: Date.now(),
-      socket,
-      authenticatedUser: null,
-      update: {
-        id,
-        position: { x: 0, y: 0, z: 0 },
-        rotation: { quaternionY: 0, quaternionW: 1 },
-        state: 0
-      }
-    };
-    this.allClientsById.set(id, client);
-    socket.addEventListener("message", (message) => {
-      try {
-        if (message.data instanceof ArrayBuffer || message.data instanceof Buffer) {
-          if (client.authenticatedUser) {
-            const arrayBuffer = message.data instanceof ArrayBuffer ? message.data : toArrayBuffer(message.data);
-            const update = LegacyUserNetworkingCodec.decodeUpdate(arrayBuffer);
-            update.id = id;
-            const index = this.deltaNetServer.dangerouslyGetConnectionsToComponentIndex().get(id);
-            client.update = update;
-            if (index !== void 0) {
-              this.deltaNetServer.setComponentValue(
-                COMPONENT_POSITION_X,
-                index,
-                BigInt(Math.round(update.position.x * positionMultiplier))
-              );
-              this.deltaNetServer.setComponentValue(
-                COMPONENT_POSITION_Y,
-                index,
-                BigInt(Math.round(update.position.y * positionMultiplier))
-              );
-              this.deltaNetServer.setComponentValue(
-                COMPONENT_POSITION_Z,
-                index,
-                BigInt(Math.round(update.position.z * positionMultiplier))
-              );
-              this.deltaNetServer.setComponentValue(
-                COMPONENT_ROTATION_Y,
-                index,
-                BigInt(Math.round(update.rotation.quaternionY * rotationMultiplier))
-              );
-              this.deltaNetServer.setComponentValue(
-                COMPONENT_ROTATION_W,
-                index,
-                BigInt(Math.round(update.rotation.quaternionW * rotationMultiplier))
-              );
-              this.deltaNetServer.setComponentValue(
-                COMPONENT_STATE,
-                index,
-                BigInt(Math.round(update.state))
-              );
-            }
-          }
-        } else {
-          let parsed;
-          try {
-            parsed = JSON.parse(message.data);
-          } catch (e) {
-            this.logger.error("Error parsing JSON message", message, e);
-            return;
-          }
-          if (!client.authenticatedUser) {
-            if (parsed.type === LEGACY_USER_NETWORKING_USER_AUTHENTICATE_MESSAGE_TYPE) {
-              this.handleUserAuth(client, parsed).then((authResult) => {
-                if (client.socket.readyState !== WebSocketOpenStatus) {
-                  return;
-                }
-                if (!authResult) {
-                  this.logger.error(`Client-id ${client.id} user_auth failed`, authResult);
-                  const serverError = JSON.stringify({
-                    type: LEGACY_USER_NETWORKING_SERVER_ERROR_MESSAGE_TYPE,
-                    errorType: LEGACY_USER_NETWORKING_AUTHENTICATION_FAILED_ERROR_TYPE,
-                    message: "Authentication failed"
-                  });
-                  socket.send(serverError);
-                  socket.close();
-                } else {
-                  if (!this.userNetworkingServer.hasCapacityForLegacyClient()) {
-                    const serverError = JSON.stringify({
-                      type: LEGACY_USER_NETWORKING_SERVER_ERROR_MESSAGE_TYPE,
-                      errorType: LEGACY_USER_NETWORKING_CONNECTION_LIMIT_REACHED_ERROR_TYPE,
-                      message: "Connection limit reached"
-                    });
-                    socket.send(serverError);
-                    socket.close();
-                    return;
-                  }
-                  const userData = authResult;
-                  this.deltaNetServer.dangerouslyAddNewJoinerCallback((index) => {
-                    if (client.socket.readyState !== WebSocketOpenStatus) {
-                      return null;
-                    }
-                    client.authenticatedUser = userData;
-                    this.deltaNetServer.setComponentValue(COMPONENT_POSITION_X, index, BigInt(0));
-                    this.deltaNetServer.setComponentValue(COMPONENT_POSITION_Y, index, BigInt(0));
-                    this.deltaNetServer.setComponentValue(COMPONENT_POSITION_Z, index, BigInt(0));
-                    this.deltaNetServer.setComponentValue(COMPONENT_ROTATION_Y, index, BigInt(0));
-                    this.deltaNetServer.setComponentValue(COMPONENT_ROTATION_W, index, BigInt(0));
-                    this.deltaNetServer.setComponentValue(COMPONENT_STATE, index, BigInt(0));
-                    const asUserData = {
-                      ...userData,
-                      colors: []
-                    };
-                    return {
-                      id: client.id,
-                      afterAddCallback: () => {
-                        this.userNetworkingServer.setAuthenticatedLegacyClientConnection(
-                          client.id,
-                          client.socket,
-                          asUserData
-                        );
-                        this.userNetworkingServer.updateUserCharacter(client.id, asUserData);
-                      }
-                    };
-                  });
-                  const userProfileMessage = JSON.stringify({
-                    id: client.id,
-                    type: LEGACY_USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE,
-                    username: userData.username,
-                    characterDescription: userData.characterDescription
-                  });
-                  client.socket.send(userProfileMessage);
-                  const identityMessage = JSON.stringify({
-                    id: client.id,
-                    type: LEGACY_USER_NETWORKING_IDENTITY_MESSAGE_TYPE
-                  });
-                  client.socket.send(identityMessage);
-                  const allUsers = this.deltaNetServer.dangerouslyGetConnectionsToComponentIndex();
-                  for (const [connectionId, componentIndex] of allUsers) {
-                    if (connectionId === client.id) {
-                      continue;
-                    }
-                    const x = this.deltaNetServer.getComponentValue(COMPONENT_POSITION_X, componentIndex) ?? 0 / positionMultiplier;
-                    const y = this.deltaNetServer.getComponentValue(COMPONENT_POSITION_Y, componentIndex) ?? 0 / positionMultiplier;
-                    const z = this.deltaNetServer.getComponentValue(COMPONENT_POSITION_Z, componentIndex) ?? 0 / positionMultiplier;
-                    const quaternionY = this.deltaNetServer.getComponentValue(COMPONENT_ROTATION_Y, componentIndex) ?? 0 / rotationMultiplier;
-                    const quaternionW = this.deltaNetServer.getComponentValue(COMPONENT_ROTATION_W, componentIndex) ?? 0 / rotationMultiplier;
-                    const state = this.deltaNetServer.getComponentValue(COMPONENT_STATE, componentIndex) ?? 0;
-                    const update = LegacyUserNetworkingCodec.encodeUpdate({
-                      id: connectionId,
-                      position: { x, y, z },
-                      rotation: { quaternionY, quaternionW },
-                      state
-                    });
-                    client.socket.send(
-                      JSON.stringify({
-                        id: connectionId,
-                        type: LEGACY_USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE,
-                        username: this.userNetworkingServer.getUsername(connectionId),
-                        characterDescription: this.userNetworkingServer.getCharacterDescription(connectionId)
-                      })
-                    );
-                    client.socket.send(update);
-                  }
-                  this.legacyAuthenticatedClientsById.set(id, client);
-                }
-              });
-            } else {
-              this.logger.error(`Unhandled message pre-auth: ${JSON.stringify(parsed)}`);
-              socket.close();
-            }
-          } else {
-            switch (parsed.type) {
-              case LEGACY_USER_NETWORKING_PONG_MESSAGE_TYPE:
-                client.lastPong = Date.now();
-                break;
-              case LEGACY_USER_NETWORKING_USER_UPDATE_MESSAGE_TYPE:
-                this.handleUserUpdate(id, parsed);
-                break;
-              default:
-                this.logger.error(`Unhandled message: ${JSON.stringify(parsed)}`);
-            }
-          }
-        }
-      } catch (e) {
-        this.logger.error("Error handling message", message, e);
-        socket.send(
-          JSON.stringify({
-            type: LEGACY_USER_NETWORKING_SERVER_ERROR_MESSAGE_TYPE,
-            errorType: LEGACY_USER_NETWORKING_UNKNOWN_ERROR,
-            message: "Error handling message"
-          })
-        );
-        socket.close();
-      }
-    });
-    socket.addEventListener("close", () => {
-      this.handleDisconnectedClient(client);
-    });
-  }
-  handleDisconnectedClient(client) {
-    if (!this.allClientsById.has(client.id)) {
-      return;
-    }
-    this.allClientsById.delete(client.id);
-    if (client.authenticatedUser !== null) {
-      this.userNetworkingServer.onLegacyClientDisconnect(client.id);
-      this.legacyAuthenticatedClientsById.delete(client.id);
-      this.deltaNetServer.clearInternalConnectionId(client.id);
-    }
-  }
-  async handleUserAuth(client, credentials) {
-    const userData = this.userNetworkingServer.onLegacyClientConnect(
-      client.id,
-      credentials.sessionToken,
-      credentials.userIdentity
-    );
-    let resolvedUserData;
-    if (userData instanceof Promise) {
-      resolvedUserData = await userData;
-    } else {
-      resolvedUserData = userData;
-    }
-    if (resolvedUserData instanceof Error) {
-      this.logger.error(`Client-id ${client.id} user_auth failed`, resolvedUserData);
-      return false;
-    } else if (resolvedUserData === true) {
-      this.logger.error(`Client-id ${client.id} user_auth failed`, resolvedUserData);
-      resolvedUserData = credentials.userIdentity;
-    } else {
-      resolvedUserData = resolvedUserData;
-    }
-    if (resolvedUserData === null) {
-      this.logger.error(`Client-id ${client.id} user_auth unauthorized and ignored`);
-      return false;
-    }
-    return resolvedUserData;
-  }
-  updateUserCharacter(clientId, userData) {
-    this.internalUpdateUser(clientId, userData);
-  }
-  internalUpdateUser(clientId, userData) {
-    const client = this.legacyAuthenticatedClientsById.get(clientId);
-    client.authenticatedUser = userData;
-    this.legacyAuthenticatedClientsById.set(clientId, client);
-    this.userNetworkingServer.updateUserCharacter(client.id, { ...userData, colors: [] });
-  }
-  async handleUserUpdate(clientId, message) {
-    const client = this.legacyAuthenticatedClientsById.get(clientId);
-    if (!client) {
-      this.logger.error(`Client-id ${clientId} user_update ignored, client not found`);
-      return;
-    }
-    const authorizedUserData = message.userIdentity;
-    let resolvedAuthorizedUserData;
-    if (authorizedUserData instanceof Promise) {
-      resolvedAuthorizedUserData = await authorizedUserData;
-    } else {
-      resolvedAuthorizedUserData = authorizedUserData;
-    }
-    if (!resolvedAuthorizedUserData) {
-      this.logger.warn(`Client-id ${clientId} user_update unauthorized and ignored`);
-      return;
-    }
-    this.internalUpdateUser(clientId, resolvedAuthorizedUserData);
-  }
-  sendUpdates(removedIds, addedIds, updateUserProfilesInTick) {
-    for (const id of removedIds) {
-      const disconnectMessage = JSON.stringify({
-        id,
-        type: LEGACY_USER_NETWORKING_DISCONNECTED_MESSAGE_TYPE
-      });
-      for (const [, otherClient] of this.legacyAuthenticatedClientsById) {
-        if (otherClient.socket.readyState === WebSocketOpenStatus) {
-          otherClient.socket.send(disconnectMessage);
-        }
-      }
-    }
-    for (const id of addedIds) {
-      const identityMessage = JSON.stringify({
-        id,
-        type: LEGACY_USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE,
-        username: this.userNetworkingServer.getUsername(id),
-        characterDescription: this.userNetworkingServer.getCharacterDescription(id)
-      });
-      for (const [, otherClient] of this.legacyAuthenticatedClientsById) {
-        if (otherClient.socket.readyState === WebSocketOpenStatus) {
-          otherClient.socket.send(identityMessage);
-        }
-      }
-    }
-    for (const id of updateUserProfilesInTick) {
-      const identityMessage = JSON.stringify({
-        id,
-        type: LEGACY_USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE,
-        username: this.userNetworkingServer.getUsername(id),
-        characterDescription: this.userNetworkingServer.getCharacterDescription(id)
-      });
-      for (const [, otherClient] of this.legacyAuthenticatedClientsById) {
-        if (otherClient.socket.readyState === WebSocketOpenStatus) {
-          otherClient.socket.send(identityMessage);
-        }
-      }
-    }
-    const allUsers = this.deltaNetServer.dangerouslyGetConnectionsToComponentIndex();
-    for (const [connectionId, componentIndex] of allUsers) {
-      const x = this.deltaNetServer.getComponentValue(COMPONENT_POSITION_X, componentIndex) ?? 0 / positionMultiplier;
-      const y = this.deltaNetServer.getComponentValue(COMPONENT_POSITION_Y, componentIndex) ?? 0 / positionMultiplier;
-      const z = this.deltaNetServer.getComponentValue(COMPONENT_POSITION_Z, componentIndex) ?? 0 / positionMultiplier;
-      const quaternionY = this.deltaNetServer.getComponentValue(COMPONENT_ROTATION_Y, componentIndex) ?? 0 / rotationMultiplier;
-      const quaternionW = this.deltaNetServer.getComponentValue(COMPONENT_ROTATION_W, componentIndex) ?? 0 / rotationMultiplier;
-      const state = this.deltaNetServer.getComponentValue(COMPONENT_STATE, componentIndex) ?? 0;
-      const encodedUpdate = LegacyUserNetworkingCodec.encodeUpdate({
-        id: connectionId,
-        position: { x, y, z },
-        rotation: { quaternionY, quaternionW },
-        state
-      });
-      for (const [otherClientId, otherClient] of this.legacyAuthenticatedClientsById) {
-        if (otherClientId !== connectionId && otherClient.socket.readyState === WebSocketOpenStatus) {
-          otherClient.socket.send(encodedUpdate);
-        }
-      }
-    }
-  }
-  dispose(clientCloseError) {
-    const stringifiedError = clientCloseError ? JSON.stringify(clientCloseError) : void 0;
-    for (const [, client] of this.legacyAuthenticatedClientsById) {
-      if (stringifiedError) {
-        client.socket.send(stringifiedError);
-      }
-      client.socket.close();
-    }
+    return { connectionId, ...userStates };
   }
 };
 
@@ -721,184 +273,114 @@ var UserNetworkingServer = class {
         this.handleCustomMessage(customMessage);
       }
     });
-    if (this.options.legacyAdapterEnabled) {
-      this.legacyAdapter = new LegacyAdapter(this, this.deltaNetServer, this.logger);
-    }
     this.tickInterval = setInterval(() => {
-      const { removedIds, addedIds } = this.deltaNetServer.tick();
-      if (this.legacyAdapter) {
-        this.legacyAdapter.sendUpdates(removedIds, addedIds, this.updatedUserProfilesInTick);
-        this.updatedUserProfilesInTick.clear();
+      const { addedIds, addedObserverIds } = this.deltaNetServer.tick();
+      if (this.options.onClientAuthenticated) {
+        for (const connectionId of addedIds) {
+          this.options.onClientAuthenticated(connectionId);
+        }
+        for (const connectionId of addedObserverIds) {
+          this.options.onClientAuthenticated(connectionId);
+        }
       }
     }, 50);
   }
   deltaNetServer;
   authenticatedClientsById = /* @__PURE__ */ new Map();
+  connectionIdByUserId = /* @__PURE__ */ new Map();
   tickInterval;
-  legacyAdapter = null;
-  updatedUserProfilesInTick = /* @__PURE__ */ new Set();
-  getCharacterDescription(connectionId) {
-    var _a;
-    const client = this.authenticatedClientsById.get(connectionId);
-    return ((_a = client == null ? void 0 : client.authenticatedUser) == null ? void 0 : _a.characterDescription) ?? { mmlCharacterUrl: "" };
-  }
-  getUsername(connectionId) {
-    var _a, _b;
-    const client = this.authenticatedClientsById.get(connectionId);
-    this.logger.info("getUsername", connectionId, (_a = client == null ? void 0 : client.authenticatedUser) == null ? void 0 : _a.username);
-    return ((_b = client == null ? void 0 : client.authenticatedUser) == null ? void 0 : _b.username) ?? "";
-  }
-  getLegacyClientId() {
-    return this.deltaNetServer.getNextConnectionId();
-  }
-  hasCapacityForLegacyClient() {
-    return true;
-  }
-  onLegacyClientConnect(id, sessionToken, userIdentity) {
-    return this.options.onClientConnect(id, sessionToken, {
-      username: (userIdentity == null ? void 0 : userIdentity.username) ?? null,
-      characterDescription: (userIdentity == null ? void 0 : userIdentity.characterDescription) ?? null,
-      colors: null
-    });
-  }
-  setAuthenticatedLegacyClientConnection(clientId, webSocket, userData) {
-    this.logger.info("setAuthenticatedLegacyClientConnection", clientId, userData);
-    const authenticatedClient = {
-      id: clientId,
-      socket: webSocket,
-      lastPong: Date.now(),
-      authenticatedUser: userData,
-      deltaNetConnection: null
-    };
-    this.authenticatedClientsById.set(clientId, authenticatedClient);
-  }
-  onLegacyClientDisconnect(id) {
-    this.options.onClientDisconnect(id);
-  }
   handleStatesUpdate(update) {
-    const deltaNetConnection = update.deltaNetV01Connection;
-    const clientId = deltaNetConnection.internalConnectionId;
+    var _a, _b, _c;
+    const deltaNetConnection = update.connection;
+    const connectionId = deltaNetConnection.internalConnectionId;
     const updatedStates = update.states;
     const updatedStatesMap = new Map(updatedStates);
-    const updatedUserData = DeltaNetComponentMapping.fromUserStates(
-      updatedStatesMap,
-      this.logger
-    );
-    const existingClient = this.authenticatedClientsById.get(clientId);
+    const decoded = DeltaNetComponentMapping.fromUserStates(updatedStatesMap, this.logger);
+    const existingClient = this.authenticatedClientsById.get(connectionId);
     if (!existingClient) {
-      return new DeltaNetServerError2(
-        DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
+      return new DeltaNetServerError(
+        DeltaNetServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
         "User not authenticated - no client found",
         false
       );
     }
-    const existingUserData = existingClient.authenticatedUser ?? {};
-    const userData = {
-      ...existingUserData,
-      ...updatedUserData
+    const identityUpdate = {
+      username: decoded.username ?? ((_a = existingClient.authenticatedUser) == null ? void 0 : _a.username) ?? null,
+      characterDescription: decoded.characterDescription ?? ((_b = existingClient.authenticatedUser) == null ? void 0 : _b.characterDescription) ?? null,
+      colors: decoded.colors ?? ((_c = existingClient.authenticatedUser) == null ? void 0 : _c.colors) ?? null
     };
-    const res = this.options.onClientUserIdentityUpdate(clientId, userData);
+    const res = this.options.onClientUserIdentityUpdate(connectionId, identityUpdate);
     if (res instanceof Promise) {
       return res.then((res2) => {
-        if (!this.authenticatedClientsById.get(clientId)) {
-          return new DeltaNetServerError2(
-            DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
-            "User not authenticated - client disconnected",
-            false
-          );
-        }
-        if (res2 instanceof DeltaNetServerError2) {
-          return res2;
-        }
-        if (res2 instanceof Error) {
-          return new DeltaNetServerError2(
-            DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
-            "User identity update failed",
-            false
-          );
-        }
-        if (res2 === null) {
-          return new DeltaNetServerError2(
-            DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
-            "User identity update failed",
-            false
-          );
-        }
-        if (res2 === false) {
-          return new DeltaNetServerError2(
-            DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
-            "User identity update failed",
-            false
-          );
-        }
-        if (!res2 || typeof res2 !== "object") {
-          return new DeltaNetServerError2(
-            DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
-            "User identity update failed",
-            false
-          );
-        }
-        this.updatedUserProfilesInTick.add(clientId);
-        existingClient.authenticatedUser = {
-          ...existingClient.authenticatedUser,
-          ...res2
-        };
-        return {
-          success: true,
-          stateOverrides: Array.from(DeltaNetComponentMapping.toStates(res2).entries())
-        };
+        return this.applyIdentityUpdateResult(existingClient, connectionId, identityUpdate, res2);
       });
     }
-    if (res instanceof DeltaNetServerError2) {
+    return this.applyIdentityUpdateResult(existingClient, connectionId, identityUpdate, res);
+  }
+  applyIdentityUpdateResult(existingClient, connectionId, identityUpdate, res) {
+    var _a, _b;
+    if (this.authenticatedClientsById.get(connectionId) !== existingClient) {
+      return new DeltaNetServerError(
+        DeltaNetServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
+        "User not authenticated - client disconnected",
+        false
+      );
+    }
+    if (res instanceof DeltaNetServerError) {
       return res;
     }
     if (res instanceof Error) {
-      return new DeltaNetServerError2(
-        DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
+      return new DeltaNetServerError(
+        DeltaNetServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
         "User identity update failed",
         false
       );
     }
-    if (res === null) {
-      return new DeltaNetServerError2(
-        DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
+    if (res === null || res === false) {
+      return new DeltaNetServerError(
+        DeltaNetServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
         "User identity update failed",
         false
       );
     }
-    if (res === false) {
-      return new DeltaNetServerError2(
-        DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
-        "User identity update failed",
-        false
-      );
+    if (res === true) {
+      existingClient.authenticatedUser = {
+        userId: ((_a = existingClient.authenticatedUser) == null ? void 0 : _a.userId) ?? "",
+        username: identityUpdate.username,
+        characterDescription: identityUpdate.characterDescription,
+        colors: identityUpdate.colors
+      };
+      return { success: true };
     }
     if (!res || typeof res !== "object") {
-      return new DeltaNetServerError2(
-        DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
+      return new DeltaNetServerError(
+        DeltaNetServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
         "User identity update failed",
         false
       );
     }
-    this.updatedUserProfilesInTick.add(clientId);
     existingClient.authenticatedUser = {
-      ...existingClient.authenticatedUser,
-      ...res
+      userId: ((_b = existingClient.authenticatedUser) == null ? void 0 : _b.userId) ?? "",
+      username: res.username,
+      characterDescription: res.characterDescription,
+      colors: res.colors
     };
     return {
       success: true,
-      stateOverrides: Array.from(DeltaNetComponentMapping.toStates(res).entries())
+      stateOverrides: Array.from(
+        DeltaNetComponentMapping.toStates(existingClient.authenticatedUser).entries()
+      )
     };
   }
   handleJoiner(joiner) {
-    const deltaNetConnection = joiner.deltaNetV01Connection;
+    const deltaNetConnection = joiner.connection;
     const webSocket = deltaNetConnection.webSocket;
     const states = joiner.states;
-    const clientId = joiner.internalConnectionId;
+    const connectionId = joiner.internalConnectionId;
     const statesMap = new Map(states);
     const userData = DeltaNetComponentMapping.fromUserStates(statesMap, this.logger);
     return this.handleDeltaNetAuthentication(
-      clientId,
+      connectionId,
       webSocket,
       deltaNetConnection,
       joiner.token,
@@ -906,9 +388,12 @@ var UserNetworkingServer = class {
     ).then((authResult) => {
       var _a;
       if (!authResult.success) {
-        this.logger.warn(`Authentication failed for client ID: ${clientId}`, authResult.error);
-        return new DeltaNetServerError2(
-          DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
+        this.logger.warn(
+          `Authentication failed for connection ID: ${connectionId}`,
+          authResult.error
+        );
+        return new DeltaNetServerError(
+          DeltaNetServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
           ((_a = authResult.error) == null ? void 0 : _a.message) || "Authentication failed",
           false
         );
@@ -919,54 +404,52 @@ var UserNetworkingServer = class {
         };
       }
     }).catch((error) => {
-      this.logger.error(`Authentication error for client ID: ${clientId}:`, error);
-      return new DeltaNetServerError2(
-        DeltaNetV01ServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
+      this.logger.error(`Authentication error for connection ID: ${connectionId}:`, error);
+      return new DeltaNetServerError(
+        DeltaNetServerErrors.USER_AUTHENTICATION_FAILED_ERROR_TYPE,
         "Authentication error",
         false
       );
     });
   }
   handleLeave(leave) {
-    const deltaNetConnection = leave.deltaNetV01Connection;
-    const clientId = deltaNetConnection.internalConnectionId;
-    if (clientId !== void 0) {
-      const client = this.authenticatedClientsById.get(clientId);
+    var _a;
+    const deltaNetConnection = leave.connection;
+    const connectionId = deltaNetConnection.internalConnectionId;
+    if (connectionId !== void 0) {
+      const client = this.authenticatedClientsById.get(connectionId);
       if (client) {
-        this.options.onClientDisconnect(clientId);
-        this.authenticatedClientsById.delete(clientId);
+        if ((_a = client.authenticatedUser) == null ? void 0 : _a.userId) {
+          this.connectionIdByUserId.delete(client.authenticatedUser.userId);
+        }
+        this.options.onClientDisconnect(connectionId);
+        this.authenticatedClientsById.delete(connectionId);
       }
     }
   }
   handleCustomMessage(customMessage) {
-    const deltaNetConnection = customMessage.deltaNetV01Connection;
-    const clientId = deltaNetConnection.internalConnectionId;
-    const client = this.authenticatedClientsById.get(clientId);
+    var _a, _b;
+    const deltaNetConnection = customMessage.connection;
+    const connectionId = deltaNetConnection.internalConnectionId;
+    const client = this.authenticatedClientsById.get(connectionId);
     if (client && client.authenticatedUser) {
-      if (customMessage.customType === FROM_CLIENT_CHAT_MESSAGE_TYPE) {
-        const chatMessage = parseClientChatMessage(customMessage.contents);
-        if (chatMessage instanceof Error) {
-          this.logger.error(`Invalid chat message from client ${clientId}:`, chatMessage);
-        } else {
-          const serverChatMessage = {
-            fromUserId: clientId,
-            message: chatMessage.message
-          };
-          this.deltaNetServer.broadcastCustomMessage(
-            FROM_SERVER_CHAT_MESSAGE_TYPE,
-            JSON.stringify(serverChatMessage)
-          );
-        }
-      }
+      (_b = (_a = this.options).onCustomMessage) == null ? void 0 : _b.call(
+        _a,
+        connectionId,
+        customMessage.customType,
+        customMessage.contents
+      );
     } else {
-      this.logger.warn(`Custom message from unauthenticated client ${clientId} - ignoring`);
+      this.logger.warn(`Custom message from unauthenticated client ${connectionId} - ignoring`);
     }
   }
-  async handleDeltaNetAuthentication(clientId, webSocket, deltaNetConnection, sessionToken, userIdentity) {
+  async handleDeltaNetAuthentication(connectionId, webSocket, deltaNetConnection, sessionToken, userIdentity) {
     try {
-      let onClientConnectReturn = deltaNetConnection.isObserver ? null : await this.options.onClientConnect(clientId, sessionToken, userIdentity);
+      let onClientConnectReturn = deltaNetConnection.isObserver ? null : await this.options.onClientConnect(connectionId, sessionToken, userIdentity);
       if (!deltaNetConnection.isObserver && !onClientConnectReturn) {
-        this.logger.warn(`Authentication failed for client ${clientId} - no user data returned`);
+        this.logger.warn(
+          `Authentication failed for connection ${connectionId} - no user data returned`
+        );
         return { success: false };
       }
       if (onClientConnectReturn instanceof Error) {
@@ -975,15 +458,31 @@ var UserNetworkingServer = class {
       if (onClientConnectReturn === true) {
         onClientConnectReturn = userIdentity;
       }
+      if (onClientConnectReturn && !onClientConnectReturn.userId) {
+        onClientConnectReturn = {
+          ...onClientConnectReturn,
+          userId: crypto.randomUUID()
+        };
+      }
+      if (onClientConnectReturn && this.connectionIdByUserId.has(onClientConnectReturn.userId)) {
+        this.options.onClientDisconnect(connectionId);
+        return {
+          success: false,
+          error: new Error(`userId "${onClientConnectReturn.userId}" is already connected`)
+        };
+      }
       const authenticatedUser = onClientConnectReturn;
       const authenticatedClient = {
-        id: clientId,
+        connectionId,
         socket: webSocket,
         lastPong: Date.now(),
         authenticatedUser,
         deltaNetConnection
       };
-      this.authenticatedClientsById.set(clientId, authenticatedClient);
+      this.authenticatedClientsById.set(connectionId, authenticatedClient);
+      if (authenticatedUser == null ? void 0 : authenticatedUser.userId) {
+        this.connectionIdByUserId.set(authenticatedUser.userId, connectionId);
+      }
       let stateOverrides = [];
       if (onClientConnectReturn) {
         const officialStates = DeltaNetComponentMapping.toStates(onClientConnectReturn);
@@ -999,128 +498,145 @@ var UserNetworkingServer = class {
     }
   }
   connectClient(socket) {
-    if (socket.protocol === "") {
-      if (this.legacyAdapter) {
-        this.legacyAdapter.addWebSocket(socket);
-        return;
-      } else {
-        socket.close(1e3, "Legacy client detected (no subprotocol) - not supported");
-        return;
-      }
+    const resolvedProtocol = this.options.resolveProtocol ? this.options.resolveProtocol(socket.protocol) : void 0;
+    if (resolvedProtocol === null) {
+      this.logger.warn(
+        `Rejecting client: unsupported WebSocket sub-protocol "${socket.protocol}". resolveProtocol returned null, indicating no matching protocol version.`
+      );
+      socket.close(1002, "Unsupported sub-protocol");
+      return;
     }
-    this.deltaNetServer.addWebSocket(socket);
+    this.deltaNetServer.addWebSocket(
+      socket,
+      resolvedProtocol ?? void 0
+    );
     socket.addEventListener("close", () => {
       this.deltaNetServer.removeWebSocket(socket);
     });
   }
   broadcastMessage(broadcastType, broadcastPayload) {
     this.deltaNetServer.broadcastCustomMessage(broadcastType, broadcastPayload);
-    if (this.legacyAdapter) {
-      this.legacyAdapter.broadcastMessage(broadcastType, broadcastPayload);
+  }
+  sendCustomMessageToClient(connectionId, customType, payload) {
+    const client = this.authenticatedClientsById.get(connectionId);
+    if (!client) {
+      return;
     }
+    this.deltaNetServer.sendCustomMessageToConnection(connectionId, customType, payload);
+  }
+  getAuthenticatedUser(connectionId) {
+    const client = this.authenticatedClientsById.get(connectionId);
+    return (client == null ? void 0 : client.authenticatedUser) ?? null;
   }
-  updateUserCharacter(clientId, userData) {
-    this.logger.info("updateUserCharacter", clientId, userData);
-    this.internalUpdateUser(clientId, userData);
+  updateUserCharacter(connectionId, userData) {
+    this.logger.info("updateUserCharacter", connectionId, userData);
+    this.internalUpdateUser(connectionId, userData);
   }
-  updateUserUsername(clientId, username) {
-    const client = this.authenticatedClientsById.get(clientId);
+  updateUserUsername(connectionId, username) {
+    const client = this.authenticatedClientsById.get(connectionId);
     if (!client || !client.authenticatedUser) return;
     client.authenticatedUser = {
       ...client.authenticatedUser,
       username
     };
-    this.updatedUserProfilesInTick.add(clientId);
     const states = DeltaNetComponentMapping.toUsernameState(username);
     const asArray = Array.from(states.entries());
-    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, clientId, asArray);
+    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, connectionId, asArray);
   }
-  updateUserCharacterDescription(clientId, characterDescription) {
-    const client = this.authenticatedClientsById.get(clientId);
+  updateUserCharacterDescription(connectionId, characterDescription) {
+    const client = this.authenticatedClientsById.get(connectionId);
     if (!client || !client.authenticatedUser) return;
     client.authenticatedUser = {
       ...client.authenticatedUser,
       characterDescription
     };
-    this.updatedUserProfilesInTick.add(clientId);
     const states = DeltaNetComponentMapping.toCharacterDescriptionState(characterDescription);
     const asArray = Array.from(states.entries());
-    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, clientId, asArray);
+    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, connectionId, asArray);
   }
-  updateUserColors(clientId, colors) {
-    const client = this.authenticatedClientsById.get(clientId);
+  updateUserColors(connectionId, colors) {
+    const client = this.authenticatedClientsById.get(connectionId);
     if (!client || !client.authenticatedUser) return;
     client.authenticatedUser = {
       ...client.authenticatedUser,
       colors
     };
-    this.updatedUserProfilesInTick.add(clientId);
     const states = DeltaNetComponentMapping.toColorsState(colors);
     const asArray = Array.from(states.entries());
-    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, clientId, asArray);
+    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, connectionId, asArray);
   }
-  updateUserStates(clientId, updates) {
-    const client = this.authenticatedClientsById.get(clientId);
+  updateUserStates(connectionId, updates) {
+    const client = this.authenticatedClientsById.get(connectionId);
     if (!client || !client.authenticatedUser) return;
     const states = /* @__PURE__ */ new Map();
     let hasUpdates = false;
     let updatedUserData = client.authenticatedUser;
-    this.updatedUserProfilesInTick.add(clientId);
-    if (updates.username !== null) {
+    if (updates.username !== void 0) {
       updatedUserData = {
         ...updatedUserData,
         username: updates.username
       };
-      const usernameStates = DeltaNetComponentMapping.toUsernameState(updates.username);
-      for (const [stateId, stateValue] of usernameStates) {
-        states.set(stateId, stateValue);
+      if (updates.username !== null) {
+        const usernameStates = DeltaNetComponentMapping.toUsernameState(updates.username);
+        for (const [stateId, stateValue] of usernameStates) {
+          states.set(stateId, stateValue);
+        }
+      } else {
+        states.set(STATE_USERNAME, new Uint8Array(0));
       }
       hasUpdates = true;
     }
-    if (updates.characterDescription !== null) {
+    if (updates.characterDescription !== void 0) {
       updatedUserData = {
         ...updatedUserData,
         characterDescription: updates.characterDescription
       };
-      const characterDescStates = DeltaNetComponentMapping.toCharacterDescriptionState(
-        updates.characterDescription
-      );
-      for (const [stateId, stateValue] of characterDescStates) {
-        states.set(stateId, stateValue);
+      if (updates.characterDescription !== null) {
+        const characterDescStates = DeltaNetComponentMapping.toCharacterDescriptionState(
+          updates.characterDescription
+        );
+        for (const [stateId, stateValue] of characterDescStates) {
+          states.set(stateId, stateValue);
+        }
+      } else {
+        states.set(STATE_CHARACTER_DESCRIPTION, new Uint8Array(0));
       }
       hasUpdates = true;
     }
-    if (updates.colors !== null) {
+    if (updates.colors !== void 0) {
       updatedUserData = {
         ...updatedUserData,
         colors: updates.colors
       };
-      const colorsStates = DeltaNetComponentMapping.toColorsState(updates.colors);
-      for (const [stateId, stateValue] of colorsStates) {
-        states.set(stateId, stateValue);
+      if (updates.colors !== null) {
+        const colorsStates = DeltaNetComponentMapping.toColorsState(updates.colors);
+        for (const [stateId, stateValue] of colorsStates) {
+          states.set(stateId, stateValue);
+        }
+      } else {
+        states.set(STATE_COLORS, new Uint8Array(0));
       }
       hasUpdates = true;
     }
     if (hasUpdates) {
       client.authenticatedUser = updatedUserData;
       const asArray = Array.from(states.entries());
-      this.deltaNetServer.overrideUserStates(client.deltaNetConnection, clientId, asArray);
+      this.deltaNetServer.overrideUserStates(client.deltaNetConnection, connectionId, asArray);
     }
   }
-  internalUpdateUser(clientId, userData) {
-    const client = this.authenticatedClientsById.get(clientId);
+  internalUpdateUser(connectionId, userData) {
+    const client = this.authenticatedClientsById.get(connectionId);
     if (!client) {
-      throw new Error(`internalUpdateUser - client not found for clientId ${clientId}`);
+      throw new Error(`internalUpdateUser - client not found for connectionId ${connectionId}`);
     }
-    this.logger.info("internalUpdateUser", clientId, userData);
-    this.updatedUserProfilesInTick.add(clientId);
+    this.logger.info("internalUpdateUser", connectionId, userData);
     client.authenticatedUser = {
       ...client.authenticatedUser,
       ...userData
     };
     const states = DeltaNetComponentMapping.toStates(userData);
     const asArray = Array.from(states.entries());
-    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, clientId, asArray);
+    this.deltaNetServer.overrideUserStates(client.deltaNetConnection, connectionId, asArray);
   }
   dispose(clientCloseError) {
     if (this.tickInterval) {
@@ -1142,6 +658,8 @@ var UserNetworkingServer = class {
       client.socket.close();
     }
     this.authenticatedClientsById.clear();
+    this.connectionIdByUserId.clear();
+    this.deltaNetServer.dispose();
   }
 };
 
@@ -1168,10 +686,11 @@ var UserNetworkingClient = class {
     this.logger = logger;
     this.pendingUpdate = initialUpdate ?? {
       position: { x: 0, y: 0, z: 0 },
-      rotation: { quaternionY: 0, quaternionW: 1 },
+      rotation: { eulerY: 0 },
       state: 0
     };
     this.userState = initialUserState ?? {
+      userId: "",
       username: null,
       characterDescription: null,
       colors: null
@@ -1191,19 +710,19 @@ var UserNetworkingClient = class {
           const networkUpdate = this.processNetworkUpdate([], addedStableIds, []);
           this.config.onUpdate(networkUpdate);
           if (this.userIndex !== null) {
-            const userIds = this.deltaNetState.getStableIds();
-            if (this.userIndex < userIds.length) {
-              const stableId = userIds[this.userIndex];
-              const userId = this.stableIdToUserId.get(stableId);
-              if (!userId) {
-                throw new Error(`No userId found for stableId ${stableId}`);
+            const stableIds = this.deltaNetState.getStableIds();
+            if (this.userIndex < stableIds.length) {
+              const stableId = stableIds[this.userIndex];
+              const connId = this.stableIdToConnectionId.get(stableId);
+              if (!connId) {
+                throw new Error(`No connectionId found for stableId ${stableId}`);
               }
-              this.userId = userId;
+              this.connectionId = connId;
               this.isAuthenticated = true;
-              this.config.assignedIdentity(this.userId);
+              this.config.assignedIdentity(this.connectionId);
             } else {
               this.logger.error(
-                `Invalid userIndex ${this.userIndex}, userIds length: ${userIds.length}`
+                `Invalid userIndex ${this.userIndex}, stableIds length: ${stableIds.length}`
               );
             }
           }
@@ -1244,7 +763,7 @@ var UserNetworkingClient = class {
         }
       },
       void 0,
-      // timeCallback is optional
+      // timeCallback
       (status) => {
         let mappedStatus;
         switch (status) {
@@ -1267,28 +786,30 @@ var UserNetworkingClient = class {
             mappedStatus = 3 /* Disconnected */;
         }
         this.config.statusUpdateCallback(mappedStatus);
-      }
+      },
+      config.resolveProtocol
     );
   }
   deltaNetClient;
   deltaNetState;
-  userId = null;
+  connectionId = null;
   userIndex = null;
   userState = {
+    userId: "",
     username: null,
     characterDescription: null,
     colors: null
   };
-  stableIdToUserId = /* @__PURE__ */ new Map();
+  stableIdToConnectionId = /* @__PURE__ */ new Map();
   userProfiles = /* @__PURE__ */ new Map();
   isAuthenticated = false;
   pendingUpdate;
   reset() {
     this.deltaNetState.reset();
     this.userProfiles.clear();
-    this.stableIdToUserId.clear();
+    this.stableIdToConnectionId.clear();
     this.isAuthenticated = false;
-    this.userId = null;
+    this.connectionId = null;
     this.userIndex = null;
   }
   sendInitialAuthentication() {
@@ -1297,16 +818,16 @@ var UserNetworkingClient = class {
     this.deltaNetClient.setUserComponents(components, states);
   }
   processNetworkUpdate(removedStableIds, addedStableIdsArray, stateUpdates) {
-    const addedUserIds = /* @__PURE__ */ new Map();
-    const removedUserIds = /* @__PURE__ */ new Set();
+    const addedConnectionIds = /* @__PURE__ */ new Map();
+    const removedConnectionIds = /* @__PURE__ */ new Set();
     for (const stableId of removedStableIds) {
-      const userId = this.stableIdToUserId.get(stableId);
-      if (userId) {
-        removedUserIds.add(userId);
-        this.userProfiles.delete(userId);
-        this.stableIdToUserId.delete(stableId);
+      const connId = this.stableIdToConnectionId.get(stableId);
+      if (connId) {
+        removedConnectionIds.add(connId);
+        this.userProfiles.delete(connId);
+        this.stableIdToConnectionId.delete(stableId);
       } else {
-        throw new Error(`No userId found for stableId ${stableId}`);
+        throw new Error(`No connectionId found for stableId ${stableId}`);
       }
     }
     for (const stableId of addedStableIdsArray) {
@@ -1314,33 +835,33 @@ var UserNetworkingClient = class {
       if (!stableUserData) {
         throw new Error(`No stableUserData found for stableId ${stableId}`);
       }
-      const userIdState = stableUserData.states.get(STATE_INTERNAL_CONNECTION_ID);
-      if (!userIdState) {
-        throw new Error(`No userIdState found for stableId ${stableId}`);
+      const connectionIdState = stableUserData.states.get(STATE_INTERNAL_CONNECTION_ID);
+      if (!connectionIdState) {
+        throw new Error(`No connectionIdState found for stableId ${stableId}`);
       }
-      const userId = DeltaNetComponentMapping.userIdFromBytes(userIdState);
-      if (!userId) {
-        throw new Error(`Failed to extract userId from bytes for stableId ${stableId}`);
+      const connId = DeltaNetComponentMapping.userIdFromBytes(connectionIdState);
+      if (!connId) {
+        throw new Error(`Failed to extract connectionId from bytes for stableId ${stableId}`);
       }
-      this.stableIdToUserId.set(stableId, userId);
+      this.stableIdToConnectionId.set(stableId, connId);
       const newProfile = DeltaNetComponentMapping.fromStates(stableUserData.states, this.logger);
-      this.userProfiles.set(userId, newProfile);
+      this.userProfiles.set(connId, newProfile);
       const clientUpdate = DeltaNetComponentMapping.fromComponents(stableUserData.components);
-      addedUserIds.set(userId, {
+      addedConnectionIds.set(connId, {
         userState: newProfile,
         components: clientUpdate
       });
     }
     const updatedUsers = /* @__PURE__ */ new Map();
     for (const [stableUserId, userInfo] of this.deltaNetState.byStableId) {
-      const userId = this.stableIdToUserId.get(stableUserId);
-      if (!userId) {
-        throw new Error(`No userId found for stableUserId ${stableUserId}`);
+      const connId = this.stableIdToConnectionId.get(stableUserId);
+      if (!connId) {
+        throw new Error(`No connectionId found for stableUserId ${stableUserId}`);
       }
-      if (!addedUserIds.has(userId)) {
+      if (!addedConnectionIds.has(connId)) {
         if (userInfo.components.size > 0) {
           const clientUpdate = DeltaNetComponentMapping.fromComponents(userInfo.components);
-          updatedUsers.set(userId, {
+          updatedUsers.set(connId, {
             components: clientUpdate
           });
         }
@@ -1348,19 +869,25 @@ var UserNetworkingClient = class {
     }
     for (const update of stateUpdates) {
       const stableUserId = update.stableId;
-      const userId = this.stableIdToUserId.get(stableUserId);
-      if (!userId) {
-        throw new Error(`No userId found for stableUserId ${stableUserId}`);
+      const connId = this.stableIdToConnectionId.get(stableUserId);
+      if (!connId) {
+        throw new Error(`No connectionId found for stableUserId ${stableUserId}`);
       }
-      if (addedUserIds.has(userId)) {
+      if (addedConnectionIds.has(connId)) {
         continue;
       }
-      const profile = this.userProfiles.get(userId);
+      const profile = this.userProfiles.get(connId);
       if (!profile) {
-        this.logger.warn(`No profile found for user ${userId}, skipping update`);
+        this.logger.warn(`No profile found for connection ${connId}, skipping update`);
         continue;
       }
-      const existingUpdate = updatedUsers.get(userId);
+      let existingUpdate = updatedUsers.get(connId);
+      if (!existingUpdate) {
+        const stableUserData = this.deltaNetState.byStableId.get(stableUserId);
+        const components = stableUserData ? DeltaNetComponentMapping.fromComponents(stableUserData.components) : { position: { x: 0, y: 0, z: 0 }, rotation: { eulerY: 0 }, state: 0 };
+        existingUpdate = { components };
+        updatedUsers.set(connId, existingUpdate);
+      }
       let existingUserStateUpdate = existingUpdate.userState;
       if (!existingUserStateUpdate) {
         existingUserStateUpdate = {};
@@ -1372,37 +899,48 @@ var UserNetworkingClient = class {
             "STATE_INTERNAL_CONNECTION_ID is not expected to change in state updates"
           );
           break;
-        case STATE_USERNAME:
+        case STATE_USER_ID: {
+          const persistentUserId = DeltaNetComponentMapping.persistentUserIdFromBytes(update.state);
+          if (persistentUserId) {
+            profile.userId = persistentUserId;
+            existingUserStateUpdate.userId = persistentUserId;
+          }
+          break;
+        }
+        case STATE_USERNAME: {
           const username = DeltaNetComponentMapping.usernameFromBytes(update.state);
           if (username) {
             profile.username = username;
             existingUserStateUpdate.username = username;
           }
           break;
-        case STATE_CHARACTER_DESCRIPTION:
+        }
+        case STATE_CHARACTER_DESCRIPTION: {
           const characterDescription = DeltaNetComponentMapping.characterDescriptionFromBytes(
             update.state
           );
           profile.characterDescription = characterDescription;
           existingUserStateUpdate.characterDescription = characterDescription;
           break;
-        case STATE_COLORS:
+        }
+        case STATE_COLORS: {
           const colors = DeltaNetComponentMapping.decodeColors(update.state, this.logger);
           profile.colors = colors;
           existingUserStateUpdate.colors = colors;
           break;
+        }
         default:
           this.logger.warn(`Unknown state ID: ${update.stateId}`);
       }
     }
     return {
-      removedUserIds,
-      addedUserIds,
+      removedConnectionIds,
+      addedConnectionIds,
       updatedUsers
     };
   }
   sendUpdate(update) {
-    if (!this.isAuthenticated || this.userId === null) {
+    if (!this.isAuthenticated || this.connectionId === null) {
       this.pendingUpdate = update;
       return;
     }
@@ -1410,14 +948,14 @@ var UserNetworkingClient = class {
     this.deltaNetClient.setUserComponents(components, /* @__PURE__ */ new Map());
   }
   sendCustomMessage(customType, contents) {
-    if (!this.isAuthenticated || this.userId === null) {
+    if (!this.isAuthenticated || this.connectionId === null) {
       this.logger.warn("Cannot send custom message before authentication");
       return;
     }
     this.deltaNetClient.sendCustomMessage(customType, contents);
   }
   updateUsername(username) {
-    if (!this.isAuthenticated || this.userId === null) {
+    if (!this.isAuthenticated || this.connectionId === null) {
       return;
     }
     this.userState.username = username;
@@ -1425,7 +963,7 @@ var UserNetworkingClient = class {
     this.deltaNetClient.setUserComponents(/* @__PURE__ */ new Map(), states);
   }
   updateCharacterDescription(characterDescription) {
-    if (!this.isAuthenticated || this.userId === null) {
+    if (!this.isAuthenticated || this.connectionId === null) {
       return;
     }
     this.userState.characterDescription = characterDescription;
@@ -1433,7 +971,7 @@ var UserNetworkingClient = class {
     this.deltaNetClient.setUserComponents(/* @__PURE__ */ new Map(), states);
   }
   updateColors(colors) {
-    if (!this.isAuthenticated || this.userId === null) {
+    if (!this.isAuthenticated || this.connectionId === null) {
       return;
     }
     this.userState.colors = colors;
@@ -1446,49 +984,31 @@ var UserNetworkingClient = class {
   }
 };
 
+// src/UserNetworkingMessages.ts
+import { DeltaNetServerError as DeltaNetServerError2 } from "@mml-io/delta-net-server";
+var UserNetworkingServerError = class extends DeltaNetServerError2 {
+};
+
 // src/index.ts
-import {
-  DeltaNetV01ServerErrors as DeltaNetV01ServerErrors2,
-  deltaNetProtocolSubProtocol_v0_1
-} from "@mml-io/delta-net-protocol";
+import { DeltaNetServerErrors as DeltaNetServerErrors2 } from "@mml-io/delta-net-protocol";
 export {
   COMPONENT_POSITION_X,
   COMPONENT_POSITION_Y,
   COMPONENT_POSITION_Z,
-  COMPONENT_ROTATION_W,
   COMPONENT_ROTATION_Y,
   COMPONENT_STATE,
   DeltaNetComponentMapping,
-  DeltaNetV01ServerErrors2 as DeltaNetV01ServerErrors,
-  FROM_CLIENT_CHAT_MESSAGE_TYPE,
-  FROM_SERVER_CHAT_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_AUTHENTICATION_FAILED_ERROR_TYPE,
-  LEGACY_USER_NETWORKING_CONNECTION_LIMIT_REACHED_ERROR_TYPE,
-  LEGACY_USER_NETWORKING_DISCONNECTED_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_IDENTITY_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_PING_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_PONG_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_SERVER_BROADCAST_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_SERVER_ERROR_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_SERVER_SHUTDOWN_ERROR_TYPE,
-  LEGACY_USER_NETWORKING_UNKNOWN_ERROR,
-  LEGACY_USER_NETWORKING_USER_AUTHENTICATE_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_USER_PROFILE_MESSAGE_TYPE,
-  LEGACY_USER_NETWORKING_USER_UPDATE_MESSAGE_TYPE,
-  SERVER_BROADCAST_MESSAGE_TYPE,
+  DeltaNetServerErrors2 as DeltaNetServerErrors,
   STATE_CHARACTER_DESCRIPTION,
   STATE_COLORS,
   STATE_INTERNAL_CONNECTION_ID,
   STATE_USERNAME,
+  STATE_USER_ID,
   UserNetworkingClient,
   UserNetworkingConsoleLogger,
   UserNetworkingServer,
   UserNetworkingServerError,
   WebsocketStatus,
-  deltaNetProtocolSubProtocol_v0_1,
-  parseClientChatMessage,
-  parseServerBroadcastMessage,
-  parseServerChatMessage,
   positionMultiplier,
   rotationMultiplier
 };