@mml-io/delta-net-server 0.26.1 → 0.27.1

package/build/index.js

@@ -1,10 +1,15 @@
 // src/DeltaNetServer.ts
 import {
   BufferWriter,
+  DeltaNetServerErrors as DeltaNetServerErrors3,
+  deltaNetSupportedSubProtocols as deltaNetSupportedSubProtocols2,
+  deltaNetProtocolSubProtocol_v0_1 as deltaNetProtocolSubProtocol_v0_14,
+  deltaNetProtocolSubProtocol_v0_2 as deltaNetProtocolSubProtocol_v0_24,
   encodeInitialCheckout,
-  encodePing,
+  encodeInitialCheckoutV02,
+  encodeServerCustom,
   encodeTick,
-  encodeServerMessage as encodeServerMessage2
+  encodeTickV02
 } from "@mml-io/delta-net-protocol";
 
 // src/ComponentCollection.ts
@@ -136,17 +141,26 @@ var ComponentCollection = class _ComponentCollection {
 
 // src/createDeltaNetServerConnectionForWebsocket.ts
 import {
-  deltaNetProtocolSubProtocol_v0_1
+  deltaNetSupportedSubProtocols,
+  DeltaNetServerErrors as DeltaNetServerErrors2,
+  deltaNetProtocolSubProtocol_v0_1 as deltaNetProtocolSubProtocol_v0_13,
+  deltaNetProtocolSubProtocol_v0_2 as deltaNetProtocolSubProtocol_v0_23,
+  encodeError
 } from "@mml-io/delta-net-protocol";
 
 // src/DeltaNetV01Connection.ts
 import {
-  DeltaNetV01ServerErrors,
+  deltaNetProtocolSubProtocol_v0_1 as deltaNetProtocolSubProtocol_v0_12,
+  encodeServerMessage
+} from "@mml-io/delta-net-protocol";
+
+// src/DeltaNetConnection.ts
+import {
   BufferReader,
   decodeClientMessages,
-  encodeServerMessage
+  DeltaNetServerErrors
 } from "@mml-io/delta-net-protocol";
-var DeltaNetV01Connection = class {
+var DeltaNetConnection = class {
   constructor(webSocket, deltaNetServer) {
     this.webSocket = webSocket;
     this.deltaNetServer = deltaNetServer;
@@ -159,7 +173,7 @@ var DeltaNetV01Connection = class {
           new Error(
             `Message size ${buffer.length} bytes exceeds maximum allowed size of ${maxMessageSize} bytes`
           ),
-          DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+          DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
           false
         );
         return;
@@ -174,14 +188,13 @@ var DeltaNetV01Connection = class {
           new Error(
             `Failed to decode client messages: ${error instanceof Error ? error.message : error}`
           ),
-          DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+          DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
           false
         );
         return;
       }
     };
     webSocket.addEventListener("message", this.websocketListener);
-    this.deltaNetServer = deltaNetServer;
   }
   websocketListener;
   internalConnectionId;
@@ -194,19 +207,19 @@ var DeltaNetV01Connection = class {
   pendingStateValidations = /* @__PURE__ */ new Map();
   nextValidationId = 1;
   // Track authentication state
-  isAuthenticated = false;
-  isAuthenticating = false;
+  authState = "pending";
   authenticationAbortController = null;
-  sendMessage(message) {
-    this.sendEncodedBytes(encodeServerMessage(message).getBuffer());
-  }
   sendEncodedBytes(bytes) {
+    if (this.webSocket.readyState !== 1) {
+      return false;
+    }
     this.webSocket.send(bytes);
+    return true;
   }
   dispose() {
     this.webSocket.removeEventListener("message", this.websocketListener);
-    for (const [, validation] of this.pendingStateValidations) {
-      validation.abortController.abort();
+    for (const { abortController } of this.pendingStateValidations.values()) {
+      abortController.abort();
     }
     this.pendingStateValidations.clear();
     if (this.authenticationAbortController) {
@@ -215,7 +228,7 @@ var DeltaNetV01Connection = class {
     }
   }
   setAuthenticated() {
-    this.isAuthenticated = true;
+    this.authState = "authenticated";
   }
   disconnectWithError(error, errorType, retryable = true) {
     try {
@@ -229,34 +242,53 @@ var DeltaNetV01Connection = class {
       console.warn("Failed to send error message to client:", sendError);
     }
     try {
-      this.webSocket.close(1008, error.message);
+      const encoder = new TextEncoder();
+      const buf = new Uint8Array(123);
+      const { written } = encoder.encodeInto(error.message, buf);
+      const reason = new TextDecoder().decode(buf.subarray(0, written));
+      this.webSocket.close(1008, reason);
     } catch (closeError) {
       console.warn("Failed to close websocket connection:", closeError);
     }
+    this.deltaNetServer.removeWebSocket(this.webSocket);
   }
   async handleConnectUser(token, observer, components, states) {
     var _a, _b;
-    if (this.isAuthenticated) {
+    if (this.authState === "authenticated") {
       this.disconnectWithError(
         new Error("User is already authenticated"),
-        DeltaNetV01ServerErrors.USER_ALREADY_AUTHENTICATED_ERROR_TYPE,
+        DeltaNetServerErrors.USER_ALREADY_AUTHENTICATED_ERROR_TYPE,
         false
       );
       return;
     }
-    if (this.isAuthenticating) {
+    if (this.authState === "authenticating") {
       this.disconnectWithError(
         new Error("Authentication already in progress"),
-        DeltaNetV01ServerErrors.AUTHENTICATION_IN_PROGRESS_ERROR_TYPE,
+        DeltaNetServerErrors.AUTHENTICATION_IN_PROGRESS_ERROR_TYPE,
         false
       );
       return;
     }
-    this.isAuthenticating = true;
+    if (this.authState === "failed") {
+      this.disconnectWithError(
+        new Error("Authentication has already failed for this connection"),
+        DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+        false
+      );
+      return;
+    }
+    this.authState = "authenticating";
     this.authenticationAbortController = new AbortController();
     this.isObserver = observer;
-    this.components = new Map(components);
-    this.states = new Map(states);
+    this.components.clear();
+    for (const [id, value] of components) {
+      this.components.set(id, value);
+    }
+    this.states.clear();
+    for (const [id, value] of states) {
+      this.states.set(id, value);
+    }
     let result;
     try {
       const rawResult = this.deltaNetServer.validateJoiner(this, token, components, states);
@@ -275,21 +307,24 @@ var DeltaNetV01Connection = class {
       if ((_b = this.authenticationAbortController) == null ? void 0 : _b.signal.aborted) {
         return;
       }
-      result = error;
+      result = error instanceof Error ? error : new Error(String(error));
     }
     this.authenticationAbortController = null;
     if (result instanceof DeltaNetServerError) {
+      this.authState = "failed";
       this.disconnectWithError(result, result.errorType, result.retryable);
     } else if (result instanceof Error) {
+      this.authState = "failed";
       this.disconnectWithError(
         result,
-        DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+        DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
         false
       );
     } else if (typeof result !== "object") {
+      this.authState = "failed";
       this.disconnectWithError(
         new Error("Invalid authentication result"),
-        DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+        DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
         false
       );
     } else {
@@ -301,17 +336,17 @@ var DeltaNetV01Connection = class {
         }
         this.deltaNetServer.addAuthenticatedConnection(this);
       } else {
+        this.authState = "failed";
         this.disconnectWithError(
           new Error(result.error || "Authentication failed"),
-          DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+          DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
           false
         );
       }
     }
-    this.isAuthenticating = false;
   }
   async handleStateUpdate(stateId, stateValue) {
-    if (!this.isAuthenticated) {
+    if (this.authState !== "authenticated") {
       console.error("State update received before authentication completed");
       return;
     }
@@ -320,15 +355,16 @@ var DeltaNetV01Connection = class {
       existingValidation.abortController.abort();
       this.pendingStateValidations.delete(stateId);
     }
+    const abortController = new AbortController();
     const result = this.deltaNetServer.validateAndApplyStateUpdate(
       this,
       this.internalConnectionId,
       stateId,
-      stateValue
+      stateValue,
+      abortController.signal
     );
     if (result instanceof Promise) {
       const validationId = this.nextValidationId++;
-      const abortController = new AbortController();
       this.pendingStateValidations.set(stateId, { validationId, abortController });
       try {
         const asyncResult = await result;
@@ -344,7 +380,7 @@ var DeltaNetV01Connection = class {
         if (asyncResult instanceof Error) {
           this.disconnectWithError(
             asyncResult,
-            DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+            DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
             false
           );
           return;
@@ -359,13 +395,13 @@ var DeltaNetV01Connection = class {
           } else if (error instanceof Error) {
             this.disconnectWithError(
               error,
-              DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+              DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
               false
             );
           } else {
             this.disconnectWithError(
               new Error("State validation failed"),
-              DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+              DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
               false
             );
           }
@@ -380,7 +416,7 @@ var DeltaNetV01Connection = class {
       if (result instanceof Error) {
         this.disconnectWithError(
           result,
-          DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+          DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
           false
         );
         return;
@@ -391,25 +427,29 @@ var DeltaNetV01Connection = class {
   handleClientMessage(parsed) {
     switch (parsed.type) {
       case "connectUser": {
-        if (this.deltaNetServer !== null) {
-          this.handleConnectUser(parsed.token, parsed.observer, parsed.components, parsed.states);
-        }
+        this.handleConnectUser(
+          parsed.token,
+          parsed.observer,
+          parsed.components,
+          parsed.states
+        ).catch((error) => {
+          console.error("Unhandled error in handleConnectUser:", error);
+        });
         return;
       }
       case "pong":
         return;
       case "setUserComponents": {
-        if (!this.deltaNetServer) {
-          console.error("DeltaNetServer not set on connection that received event", this);
-          return;
-        }
-        if (!this.isAuthenticated) {
-          this.sendMessage({
-            type: "error",
-            errorType: "USER_NOT_AUTHENTICATED",
-            message: `Event sent, but user has not been authenticated yet.`,
-            retryable: false
-          });
+        if (this.authState !== "authenticated") {
+          try {
+            this.sendMessage({
+              type: "error",
+              errorType: DeltaNetServerErrors.USER_NOT_AUTHENTICATED_ERROR_TYPE,
+              message: `Event sent, but user has not been authenticated yet.`,
+              retryable: false
+            });
+          } catch {
+          }
           console.error("Event sent, but user has not been authenticated yet.");
           this.webSocket.close(1e3, "User has not been authenticated yet");
           return;
@@ -422,28 +462,29 @@ var DeltaNetV01Connection = class {
         if (!result.success) {
           this.disconnectWithError(
             new Error(result.error),
-            DeltaNetV01ServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
+            DeltaNetServerErrors.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
             true
           );
           return;
         }
         for (const [stateId, stateValue] of parsed.states) {
-          this.handleStateUpdate(stateId, stateValue);
+          this.handleStateUpdate(stateId, stateValue).catch((error) => {
+            console.error("Unhandled error in handleStateUpdate:", error);
+          });
         }
         return;
       }
       case "clientCustom": {
-        if (!this.deltaNetServer) {
-          console.error("DeltaNetServer not set on connection that received custom message", this);
-          return;
-        }
-        if (!this.isAuthenticated) {
-          this.sendMessage({
-            type: "error",
-            errorType: "USER_NOT_AUTHENTICATED",
-            message: `Custom message sent, but user has not been authenticated yet.`,
-            retryable: false
-          });
+        if (this.authState !== "authenticated") {
+          try {
+            this.sendMessage({
+              type: "error",
+              errorType: DeltaNetServerErrors.USER_NOT_AUTHENTICATED_ERROR_TYPE,
+              message: `Custom message sent, but user has not been authenticated yet.`,
+              retryable: false
+            });
+          } catch {
+          }
           console.error("Custom message sent, but user has not been authenticated yet.");
           this.webSocket.close(1e3, "User has not been authenticated yet");
           return;
@@ -462,29 +503,55 @@ var DeltaNetV01Connection = class {
   }
 };
 
+// src/DeltaNetV01Connection.ts
+var DeltaNetV01Connection = class extends DeltaNetConnection {
+  protocolVersion = deltaNetProtocolSubProtocol_v0_12;
+  sendMessage(message) {
+    return this.sendEncodedBytes(encodeServerMessage(message).getBuffer());
+  }
+};
+
+// src/DeltaNetV02Connection.ts
+import {
+  deltaNetProtocolSubProtocol_v0_2 as deltaNetProtocolSubProtocol_v0_22,
+  encodeServerMessageV02
+} from "@mml-io/delta-net-protocol";
+var DeltaNetV02Connection = class extends DeltaNetConnection {
+  protocolVersion = deltaNetProtocolSubProtocol_v0_22;
+  sendMessage(message) {
+    return this.sendEncodedBytes(encodeServerMessageV02(message).getBuffer());
+  }
+};
+
 // src/createDeltaNetServerConnectionForWebsocket.ts
-var SupportedWebsocketSubProtocolsPreferenceOrder = [
-  deltaNetProtocolSubProtocol_v0_1
-];
-function IsRecognizedWebsocketSubProtocol(protocol) {
-  return SupportedWebsocketSubProtocolsPreferenceOrder.includes(protocol);
+function isRecognizedDeltaNetSubProtocol(protocol) {
+  return deltaNetSupportedSubProtocols.includes(protocol);
 }
-function createDeltaNetServerConnectionForWebsocket(webSocket, deltaNetServer) {
-  if (!webSocket.protocol || !IsRecognizedWebsocketSubProtocol(webSocket.protocol)) {
-    const errorMessageString = `Unsupported websocket subprotocol: ${webSocket.protocol}`;
-    const errorMessage = [
-      {
-        type: "error",
-        errorType: "UNSUPPORTED_WEBSOCKET_SUBPROTOCOL",
-        message: errorMessageString,
-        retryable: false
-      }
-    ];
-    webSocket.send(JSON.stringify(errorMessage));
+function createDeltaNetServerConnectionForWebsocket(webSocket, deltaNetServer, deltaNetSubProtocol) {
+  const protocol = deltaNetSubProtocol ?? webSocket.protocol;
+  if (!protocol || !isRecognizedDeltaNetSubProtocol(protocol)) {
+    const errorMessageString = `Unsupported websocket subprotocol: ${protocol ?? "none"}. Supported: ${deltaNetSupportedSubProtocols.join(", ")}`;
+    console.warn(errorMessageString);
+    const encoded = encodeError({
+      type: "error",
+      errorType: DeltaNetServerErrors2.UNSUPPORTED_WEBSOCKET_SUBPROTOCOL_ERROR_TYPE,
+      message: errorMessageString,
+      retryable: false
+    });
+    webSocket.send(encoded.getBuffer());
     webSocket.close();
     return null;
   }
-  return new DeltaNetV01Connection(webSocket, deltaNetServer);
+  switch (protocol) {
+    case deltaNetProtocolSubProtocol_v0_23:
+      return new DeltaNetV02Connection(webSocket, deltaNetServer);
+    case deltaNetProtocolSubProtocol_v0_13:
+      return new DeltaNetV01Connection(webSocket, deltaNetServer);
+    default: {
+      const _exhaustive = protocol;
+      throw new Error(`Unhandled protocol version: ${_exhaustive}`);
+    }
+  }
 }
 
 // src/StateCollection.ts
@@ -572,53 +639,62 @@ var DeltaNetServer2 = class {
   };
   connectionIdToComponentIndex = /* @__PURE__ */ new Map();
   componentIndexToConnectionId = /* @__PURE__ */ new Map();
-  connectionIdToDeltaNetServerConnection = /* @__PURE__ */ new Map();
-  allDeltaNetV01Connections = /* @__PURE__ */ new Set();
-  authenticatedDeltaNetV01Connections = /* @__PURE__ */ new Set();
+  connectionIdToConnection = /* @__PURE__ */ new Map();
+  allConnections = /* @__PURE__ */ new Set();
+  authenticatedConnections = /* @__PURE__ */ new Set();
+  authenticatedV01Connections = /* @__PURE__ */ new Set();
+  authenticatedV02Connections = /* @__PURE__ */ new Set();
   observerConnections = /* @__PURE__ */ new Set();
   // Track observer connections separately
-  webSocketToDeltaNetServerConnection = /* @__PURE__ */ new Map();
+  webSocketToConnection = /* @__PURE__ */ new Map();
   components = /* @__PURE__ */ new Map();
   states = /* @__PURE__ */ new Map();
   documentEffectiveStartTime = Date.now();
-  pingCounter = 1;
   disposed = false;
   maxStateValueSize;
   maxMessageSize;
   static handleWebsocketSubprotocol(protocols) {
     const protocolsSet = new Set(protocols);
-    for (const protocol of SupportedWebsocketSubProtocolsPreferenceOrder) {
+    for (const protocol of deltaNetSupportedSubProtocols2) {
       if (protocolsSet.has(protocol)) {
         return protocol;
       }
     }
     return false;
   }
-  addWebSocket(webSocket) {
+  /**
+   * @param webSocket  The upgraded WebSocket.
+   * @param deltaNetSubProtocol  Optional explicit delta-net sub-protocol
+   *   version. When provided, `webSocket.protocol` is ignored for version
+   *   selection. This allows a higher-level protocol to be negotiated at the
+   *   WebSocket level while the delta-net version is supplied by the caller.
+   */
+  addWebSocket(webSocket, deltaNetSubProtocol) {
     if (this.disposed) {
       throw new Error("This DeltaNetServer has been disposed");
     }
-    const deltaNetV01Connection = createDeltaNetServerConnectionForWebsocket(webSocket, this);
-    if (deltaNetV01Connection === null) {
+    const connection = createDeltaNetServerConnectionForWebsocket(
+      webSocket,
+      this,
+      deltaNetSubProtocol
+    );
+    if (connection === null) {
       return;
     }
-    this.allDeltaNetV01Connections.add(deltaNetV01Connection);
-    this.webSocketToDeltaNetServerConnection.set(
-      deltaNetV01Connection.webSocket,
-      deltaNetV01Connection
-    );
+    this.allConnections.add(connection);
+    this.webSocketToConnection.set(connection.webSocket, connection);
   }
   removeWebSocket(webSocket) {
-    const deltaNetV01Connection = this.webSocketToDeltaNetServerConnection.get(webSocket);
-    if (deltaNetV01Connection === void 0) {
+    const connection = this.webSocketToConnection.get(webSocket);
+    if (connection === void 0) {
       return;
     }
-    if (!this.allDeltaNetV01Connections.has(deltaNetV01Connection)) {
+    if (!this.allConnections.has(connection)) {
       return;
     }
-    deltaNetV01Connection.dispose();
+    connection.dispose();
     if (!this.disposed && this.opts.onLeave) {
-      const internalConnectionId2 = deltaNetV01Connection.internalConnectionId;
+      const internalConnectionId2 = connection.internalConnectionId;
       const index = this.connectionIdToComponentIndex.get(internalConnectionId2);
       if (index !== void 0) {
         const components = [];
@@ -637,7 +713,7 @@ var DeltaNetServer2 = class {
         }
         try {
           this.opts.onLeave({
-            deltaNetV01Connection,
+            connection,
             internalConnectionId: internalConnectionId2,
             components,
             states
@@ -645,25 +721,66 @@ var DeltaNetServer2 = class {
         } catch (error) {
           console.warn("Error in onLeave callback:", error);
         }
+      } else if (connection.isObserver) {
+        try {
+          this.opts.onLeave({
+            connection,
+            internalConnectionId: internalConnectionId2,
+            components: [],
+            states: []
+          });
+        } catch (error) {
+          console.warn("Error in onLeave callback for observer:", error);
+        }
       }
     }
-    const internalConnectionId = deltaNetV01Connection.internalConnectionId;
-    this.connectionIdToDeltaNetServerConnection.delete(internalConnectionId);
-    if (this.preTickData.newJoinerConnections.has(deltaNetV01Connection)) {
-      this.preTickData.newJoinerConnections.delete(deltaNetV01Connection);
+    const internalConnectionId = connection.internalConnectionId;
+    this.connectionIdToConnection.delete(internalConnectionId);
+    if (this.preTickData.newJoinerConnections.has(connection)) {
+      this.preTickData.newJoinerConnections.delete(connection);
     } else {
       const index = this.connectionIdToComponentIndex.get(internalConnectionId);
       if (index !== void 0) {
         this.clearInternalConnectionId(internalConnectionId);
       }
     }
-    this.authenticatedDeltaNetV01Connections.delete(deltaNetV01Connection);
-    this.observerConnections.delete(deltaNetV01Connection);
-    this.allDeltaNetV01Connections.delete(deltaNetV01Connection);
-    this.webSocketToDeltaNetServerConnection.delete(deltaNetV01Connection.webSocket);
+    this.removeFromAuthenticatedSets(connection);
+    this.observerConnections.delete(connection);
+    this.allConnections.delete(connection);
+    this.webSocketToConnection.delete(connection.webSocket);
   }
   hasWebSocket(webSocket) {
-    return this.webSocketToDeltaNetServerConnection.has(webSocket);
+    return this.webSocketToConnection.has(webSocket);
+  }
+  addToAuthenticatedSets(connection) {
+    this.authenticatedConnections.add(connection);
+    switch (connection.protocolVersion) {
+      case deltaNetProtocolSubProtocol_v0_14:
+        this.authenticatedV01Connections.add(connection);
+        break;
+      case deltaNetProtocolSubProtocol_v0_24:
+        this.authenticatedV02Connections.add(connection);
+        break;
+      default: {
+        const _exhaustive = connection.protocolVersion;
+        throw new Error(`Unknown protocol version: ${_exhaustive}`);
+      }
+    }
+  }
+  removeFromAuthenticatedSets(connection) {
+    this.authenticatedConnections.delete(connection);
+    switch (connection.protocolVersion) {
+      case deltaNetProtocolSubProtocol_v0_14:
+        this.authenticatedV01Connections.delete(connection);
+        break;
+      case deltaNetProtocolSubProtocol_v0_24:
+        this.authenticatedV02Connections.delete(connection);
+        break;
+      default: {
+        const _exhaustive = connection.protocolVersion;
+        throw new Error(`Unknown protocol version: ${_exhaustive}`);
+      }
+    }
   }
   dangerouslyGetConnectionsToComponentIndex() {
     return this.connectionIdToComponentIndex;
@@ -671,28 +788,6 @@ var DeltaNetServer2 = class {
   dangerouslyAddNewJoinerCallback(callback) {
     this.preTickData.newJoinerCallbacks.add(callback);
   }
-  disconnectWithError(deltaNetV01Connection, error, errorType, retryable = true) {
-    try {
-      deltaNetV01Connection.sendMessage({
-        type: "error",
-        errorType,
-        message: error.message,
-        retryable
-      });
-    } catch (sendError) {
-      console.warn("Failed to send error message to client:", sendError);
-    }
-    try {
-      deltaNetV01Connection.webSocket.close(1008, error.message);
-    } catch (closeError) {
-      console.warn("Failed to close websocket connection:", closeError);
-    }
-    try {
-      this.removeWebSocket(deltaNetV01Connection.webSocket);
-    } catch (cleanupError) {
-      console.warn("Failed to clean up connection state:", cleanupError);
-    }
-  }
   getComponentValue(componentId, componentIndex) {
     const componentCollection = this.components.get(componentId);
     if (componentCollection === void 0) {
@@ -706,7 +801,7 @@ var DeltaNetServer2 = class {
   getMaxMessageSize() {
     return this.maxMessageSize;
   }
-  validateJoiner(deltaNetV01Connection, token, components, states) {
+  validateJoiner(connection, token, components, states) {
     if (this.disposed) {
       return { success: false, error: "This DeltaNetServer has been disposed" };
     }
@@ -735,16 +830,18 @@ var DeltaNetServer2 = class {
     }
     if (this.opts.onJoiner) {
       const rawResult = this.opts.onJoiner({
-        deltaNetV01Connection,
+        connection,
         components,
         states,
         token,
-        internalConnectionId: deltaNetV01Connection.internalConnectionId
+        internalConnectionId: connection.internalConnectionId
       });
       if (rawResult instanceof Promise) {
-        return rawResult.then((resolvedResult) => {
-          return resultToReturn(resolvedResult);
-        }).catch((error) => {
+        return rawResult.then(
+          (resolvedResult) => {
+            return resultToReturn(resolvedResult);
+          }
+        ).catch((error) => {
           console.warn("Error in async onJoiner callback:", error);
           return resultToReturn(error);
         });
@@ -754,35 +851,29 @@ var DeltaNetServer2 = class {
     }
     return { success: true };
   }
-  addAuthenticatedConnection(deltaNetV01Connection) {
-    if (deltaNetV01Connection.internalConnectionId === null) {
-      throw new Error("Connection ID must be set before adding to authenticated connections");
-    }
-    this.connectionIdToDeltaNetServerConnection.set(
-      deltaNetV01Connection.internalConnectionId,
-      deltaNetV01Connection
-    );
-    if (deltaNetV01Connection.isObserver) {
-      this.observerConnections.add(deltaNetV01Connection);
-      this.preTickData.newJoinerConnections.add(deltaNetV01Connection);
+  addAuthenticatedConnection(connection) {
+    this.connectionIdToConnection.set(connection.internalConnectionId, connection);
+    if (connection.isObserver) {
+      this.observerConnections.add(connection);
+      this.preTickData.newJoinerConnections.add(connection);
     } else {
-      this.preTickData.newJoinerConnections.add(deltaNetV01Connection);
+      this.preTickData.newJoinerConnections.add(connection);
     }
   }
-  validateAndApplyStateUpdate(deltaNetV01Connection, internalConnectionId, stateId, stateValue) {
+  validateAndApplyStateUpdate(connection, internalConnectionId, stateId, stateValue, abortSignal) {
     if (this.disposed) {
       return new Error("This DeltaNetServer has been disposed");
     }
     if (stateValue.length > this.maxStateValueSize) {
       return new DeltaNetServerError(
-        "USER_NETWORKING_UNKNOWN_ERROR",
+        DeltaNetServerErrors3.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
         `State value for state ${stateId} has size ${stateValue.length} bytes which exceeds maximum allowed size of ${this.maxStateValueSize} bytes`,
         false
       );
     }
-    if (deltaNetV01Connection.isObserver) {
+    if (connection.isObserver) {
       return new DeltaNetServerError(
-        "OBSERVER_CANNOT_SEND_STATE_UPDATES",
+        DeltaNetServerErrors3.OBSERVER_CANNOT_SEND_STATE_UPDATES_ERROR_TYPE,
         "Observers cannot send state updates",
         false
       );
@@ -790,28 +881,27 @@ var DeltaNetServer2 = class {
     if (this.opts.onStatesUpdate) {
       try {
         const result = this.opts.onStatesUpdate({
-          deltaNetV01Connection,
+          connection,
           internalConnectionId,
-          states: [[stateId, stateValue]]
+          states: [[stateId, stateValue]],
+          abortSignal
         });
         if (result instanceof Promise) {
           return result.then((asyncResult) => {
-            if (!this.connectionIdToDeltaNetServerConnection.has(internalConnectionId)) {
+            if (!this.connectionIdToConnection.has(internalConnectionId)) {
               return;
             }
             if (asyncResult instanceof DeltaNetServerError || asyncResult instanceof Error) {
               return asyncResult;
             }
             if (asyncResult === true || asyncResult === void 0) {
-              this.applyStateUpdates(deltaNetV01Connection, internalConnectionId, [
-                [stateId, stateValue]
-              ]);
+              this.applyStateUpdates(connection, internalConnectionId, [[stateId, stateValue]]);
               return true;
             }
             if (asyncResult.success) {
               if (asyncResult.stateOverrides) {
                 this.applyStateUpdates(
-                  deltaNetV01Connection,
+                  connection,
                   internalConnectionId,
                   asyncResult.stateOverrides
                 );
@@ -819,7 +909,7 @@ var DeltaNetServer2 = class {
               return true;
             } else {
               return new DeltaNetServerError(
-                "USER_NETWORKING_UNKNOWN_ERROR",
+                DeltaNetServerErrors3.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
                 "State validation failed",
                 false
               );
@@ -839,23 +929,17 @@ var DeltaNetServer2 = class {
             return result;
           }
           if (result === true || result === void 0) {
-            this.applyStateUpdates(deltaNetV01Connection, internalConnectionId, [
-              [stateId, stateValue]
-            ]);
+            this.applyStateUpdates(connection, internalConnectionId, [[stateId, stateValue]]);
             return true;
           }
           if (result.success) {
             if (result.stateOverrides) {
-              this.applyStateUpdates(
-                deltaNetV01Connection,
-                internalConnectionId,
-                result.stateOverrides
-              );
+              this.applyStateUpdates(connection, internalConnectionId, result.stateOverrides);
             }
             return true;
           } else {
             return new DeltaNetServerError(
-              "USER_NETWORKING_UNKNOWN_ERROR",
+              DeltaNetServerErrors3.USER_NETWORKING_UNKNOWN_ERROR_TYPE,
               "State validation failed",
               false
             );
@@ -872,7 +956,7 @@ var DeltaNetServer2 = class {
         return new Error("State validation failed");
       }
     } else {
-      this.applyStateUpdates(deltaNetV01Connection, internalConnectionId, [[stateId, stateValue]]);
+      this.applyStateUpdates(connection, internalConnectionId, [[stateId, stateValue]]);
       return true;
     }
   }
@@ -889,29 +973,14 @@ var DeltaNetServer2 = class {
     }
     this.preTickData.unoccupyingIndices.add(index);
   }
-  sendPings() {
-    const ping = this.pingCounter++;
-    if (this.pingCounter > 1e3) {
-      this.pingCounter = 1;
-    }
-    const v01PingMessage = {
-      type: "ping",
-      ping
-    };
-    const writer = new BufferWriter(8);
-    encodePing(v01PingMessage, writer);
-    const v01Encoded = writer.getBuffer();
-    this.allDeltaNetV01Connections.forEach((deltaNetV01Connection) => {
-      deltaNetV01Connection.sendEncodedBytes(v01Encoded);
-    });
-  }
   tick() {
     if (this.disposed) {
-      return { removedIds: /* @__PURE__ */ new Set(), addedIds: /* @__PURE__ */ new Set() };
+      return { removedIds: /* @__PURE__ */ new Set(), addedIds: /* @__PURE__ */ new Set(), addedObserverIds: /* @__PURE__ */ new Set() };
     }
     this.preTickData.componentsUpdated = 0;
     const removedIds = /* @__PURE__ */ new Set();
     const addedIds = /* @__PURE__ */ new Set();
+    const addedObserverIds = /* @__PURE__ */ new Set();
     const sortedUnoccupyingIndices = Array.from(this.preTickData.unoccupyingIndices);
     sortedUnoccupyingIndices.sort((a, b) => a - b);
     for (const componentCollection of this.components.values()) {
@@ -946,27 +1015,32 @@ var DeltaNetServer2 = class {
       }
       writeIndex++;
     }
+    for (let i = writeIndex; i < this.nextIndex; i++) {
+      this.componentIndexToConnectionId.delete(i);
+    }
     this.nextIndex -= sortedUnoccupyingIndices.length;
-    for (const deltaNetV01Connection of this.preTickData.newJoinerConnections) {
-      const internalConnectionId = deltaNetV01Connection.internalConnectionId;
-      if (deltaNetV01Connection.isObserver) {
+    const failedConnections = /* @__PURE__ */ new Set();
+    for (const connection of this.preTickData.newJoinerConnections) {
+      const internalConnectionId = connection.internalConnectionId;
+      if (connection.isObserver) {
+        addedObserverIds.add(internalConnectionId);
       } else {
         const index = this.nextIndex++;
         this.connectionIdToComponentIndex.set(internalConnectionId, index);
         this.componentIndexToConnectionId.set(index, internalConnectionId);
         addedIds.add(internalConnectionId);
-        for (const [componentId] of deltaNetV01Connection.components) {
+        for (const [componentId] of connection.components) {
           if (!this.components.has(componentId)) {
             this.components.set(componentId, new ComponentCollection());
           }
         }
-        for (const [stateId] of deltaNetV01Connection.states) {
+        for (const [stateId] of connection.states) {
           if (!this.states.has(stateId)) {
             this.states.set(stateId, new StateCollection());
           }
         }
         for (const [componentId, collection] of this.components) {
-          const value = deltaNetV01Connection.components.get(componentId);
+          const value = connection.components.get(componentId);
           if (value === void 0) {
             collection.setValue(index, 0n);
           } else {
@@ -974,11 +1048,11 @@ var DeltaNetServer2 = class {
           }
         }
         for (const [stateId, collection] of this.states) {
-          const value = deltaNetV01Connection.states.get(stateId);
+          const value = connection.states.get(stateId);
           if (this.opts.serverConnectionIdStateId !== void 0 && stateId === this.opts.serverConnectionIdStateId) {
-            const writer2 = new BufferWriter(8);
-            writer2.writeUVarint(internalConnectionId);
-            const buffer = writer2.getBuffer();
+            const writer = new BufferWriter(8);
+            writer.writeUVarint(internalConnectionId);
+            const buffer = writer.getBuffer();
             collection.setValue(index, buffer);
           } else {
             if (value === void 0) {
@@ -988,10 +1062,9 @@ var DeltaNetServer2 = class {
             }
           }
         }
-        deltaNetV01Connection.sendMessage({
-          type: "userIndex",
-          index
-        });
+        if (!connection.sendMessage({ type: "userIndex", index })) {
+          failedConnections.add(connection);
+        }
       }
     }
     for (const callback of this.preTickData.newJoinerCallbacks) {
@@ -1005,9 +1078,9 @@ var DeltaNetServer2 = class {
         this.componentIndexToConnectionId.set(index, id);
         addedIds.add(id);
         if (this.opts.serverConnectionIdStateId !== void 0) {
-          const writer2 = new BufferWriter(8);
-          writer2.writeUVarint(id);
-          const buffer = writer2.getBuffer();
+          const writer = new BufferWriter(8);
+          writer.writeUVarint(id);
+          const buffer = writer.getBuffer();
           this.setUserState(index, this.opts.serverConnectionIdStateId, buffer);
         }
         if (afterAddCallback) {
@@ -1039,12 +1112,26 @@ var DeltaNetServer2 = class {
       componentDeltaDeltas: componentDeltas,
       states: stateDeltas
     };
-    const writer = new BufferWriter(this.nextIndex * this.components.size + 128);
-    encodeTick(tickMessage, writer);
-    const v01EncodedComponentsChanged = writer.getBuffer();
-    this.authenticatedDeltaNetV01Connections.forEach((deltaNetV01Connection) => {
-      deltaNetV01Connection.sendEncodedBytes(v01EncodedComponentsChanged);
-    });
+    if (this.authenticatedV01Connections.size > 0) {
+      const v01Writer = new BufferWriter(this.nextIndex * this.components.size + 128);
+      encodeTick(tickMessage, v01Writer);
+      const v01EncodedTick = v01Writer.getBuffer();
+      this.authenticatedV01Connections.forEach((connection) => {
+        if (!connection.sendEncodedBytes(v01EncodedTick)) {
+          failedConnections.add(connection);
+        }
+      });
+    }
+    if (this.authenticatedV02Connections.size > 0) {
+      const v02Writer = new BufferWriter(this.nextIndex * this.components.size + 128);
+      encodeTickV02(tickMessage, v02Writer);
+      const v02EncodedTick = v02Writer.getBuffer();
+      this.authenticatedV02Connections.forEach((connection) => {
+        if (!connection.sendEncodedBytes(v02EncodedTick)) {
+          failedConnections.add(connection);
+        }
+      });
+    }
     if (this.preTickData.newJoinerConnections.size > 0) {
       const components = [];
       for (const [componentId, collection] of this.components) {
@@ -1068,40 +1155,81 @@ var DeltaNetServer2 = class {
         indicesCount: this.nextIndex,
         serverTime: this.getServerTime()
       };
-      const writer2 = new BufferWriter(this.nextIndex * this.components.size + 128);
-      encodeInitialCheckout(initialCheckout, writer2);
-      const v01EncodedInitialCheckout = writer2.getBuffer();
-      for (const deltaNetV01Connection of this.preTickData.newJoinerConnections) {
-        deltaNetV01Connection.sendEncodedBytes(v01EncodedInitialCheckout);
+      const v01NewJoiners = [];
+      const v02NewJoiners = [];
+      for (const connection of this.preTickData.newJoinerConnections) {
+        switch (connection.protocolVersion) {
+          case deltaNetProtocolSubProtocol_v0_14:
+            v01NewJoiners.push(connection);
+            break;
+          case deltaNetProtocolSubProtocol_v0_24:
+            v02NewJoiners.push(connection);
+            break;
+          default: {
+            const _exhaustive = connection.protocolVersion;
+            throw new Error(`Unknown protocol version: ${_exhaustive}`);
+          }
+        }
+      }
+      if (v01NewJoiners.length > 0) {
+        const v01Writer = new BufferWriter(this.nextIndex * this.components.size + 128);
+        encodeInitialCheckout(initialCheckout, v01Writer);
+        const v01EncodedInitialCheckout = v01Writer.getBuffer();
+        for (const connection of v01NewJoiners) {
+          if (!connection.sendEncodedBytes(v01EncodedInitialCheckout)) {
+            failedConnections.add(connection);
+          }
+        }
+      }
+      if (v02NewJoiners.length > 0) {
+        const v02Writer = new BufferWriter(this.nextIndex * this.components.size + 128);
+        encodeInitialCheckoutV02(initialCheckout, v02Writer);
+        const v02EncodedInitialCheckout = v02Writer.getBuffer();
+        for (const connection of v02NewJoiners) {
+          if (!connection.sendEncodedBytes(v02EncodedInitialCheckout)) {
+            failedConnections.add(connection);
+          }
+        }
       }
     }
-    for (const deltaNetV01Connection of this.preTickData.newJoinerConnections) {
-      this.authenticatedDeltaNetV01Connections.add(deltaNetV01Connection);
-      deltaNetV01Connection.setAuthenticated();
+    for (const connection of this.preTickData.newJoinerConnections) {
+      if (failedConnections.has(connection)) {
+        continue;
+      }
+      this.addToAuthenticatedSets(connection);
+      connection.setAuthenticated();
     }
     this.preTickData.unoccupyingIndices.clear();
     this.preTickData.newJoinerConnections.clear();
     this.preTickData.newJoinerCallbacks.clear();
+    for (const connection of failedConnections) {
+      try {
+        this.removeWebSocket(connection.webSocket);
+      } catch (cleanupError) {
+        console.warn("Failed to clean up connection after send failure:", cleanupError);
+      }
+    }
     return {
       removedIds,
-      addedIds
+      addedIds,
+      addedObserverIds
     };
   }
   getServerTime() {
     return Date.now() - this.documentEffectiveStartTime;
   }
-  setUserComponents(deltaNetV01Connection, internalConnectionId, components) {
+  setUserComponents(connection, internalConnectionId, components) {
     if (this.disposed) {
       console.error("Cannot dispatch remote event after dispose");
       return { success: false, error: "This DeltaNetServer has been disposed" };
     }
-    if (deltaNetV01Connection.isObserver) {
+    if (connection.isObserver) {
       return { success: false, error: "Observers cannot send component updates" };
     }
     if (this.opts.onComponentsUpdate) {
       try {
         const result = this.opts.onComponentsUpdate({
-          deltaNetV01Connection,
+          connection,
           internalConnectionId,
           components
         });
@@ -1122,7 +1250,7 @@ var DeltaNetServer2 = class {
         return { success: false, error: "Component update failed" };
       }
     }
-    this.applyComponentUpdates(deltaNetV01Connection, internalConnectionId, components);
+    this.applyComponentUpdates(connection, internalConnectionId, components);
     return { success: true };
   }
   setComponentValue(componentId, index, value) {
@@ -1134,10 +1262,10 @@ var DeltaNetServer2 = class {
     }
     collection.setValue(index, value);
   }
-  applyComponentUpdates(deltaNetV01Connection, internalConnectionId, components) {
-    if (this.preTickData.newJoinerConnections.has(deltaNetV01Connection)) {
+  applyComponentUpdates(connection, internalConnectionId, components) {
+    if (this.preTickData.newJoinerConnections.has(connection)) {
       for (const [componentId, componentValue] of components) {
-        deltaNetV01Connection.components.set(componentId, componentValue);
+        connection.components.set(componentId, componentValue);
       }
       return;
     }
@@ -1149,8 +1277,8 @@ var DeltaNetServer2 = class {
       this.setComponentValue(componentId, index, componentValue);
     }
   }
-  overrideUserStates(deltaNetV01Connection, internalConnectionId, states) {
-    this.applyStateUpdates(deltaNetV01Connection, internalConnectionId, states);
+  overrideUserStates(connection, internalConnectionId, states) {
+    this.applyStateUpdates(connection, internalConnectionId, states);
   }
   setUserState(index, stateId, stateValue) {
     let collection = this.states.get(stateId);
@@ -1160,10 +1288,10 @@ var DeltaNetServer2 = class {
     }
     collection.setValue(index, stateValue);
   }
-  applyStateUpdates(deltaNetV01Connection, internalConnectionId, states) {
-    if (deltaNetV01Connection !== null && this.preTickData.newJoinerConnections.has(deltaNetV01Connection)) {
+  applyStateUpdates(connection, internalConnectionId, states) {
+    if (connection !== null && this.preTickData.newJoinerConnections.has(connection)) {
       for (const [stateId, stateValue] of states) {
-        deltaNetV01Connection.states.set(stateId, stateValue);
+        connection.states.set(stateId, stateValue);
       }
       return;
     }
@@ -1175,14 +1303,14 @@ var DeltaNetServer2 = class {
       this.setUserState(index, stateId, stateValue);
     }
   }
-  handleCustomMessage(deltaNetV01Connection, internalConnectionId, customType, contents) {
+  handleCustomMessage(connection, internalConnectionId, customType, contents) {
     if (this.disposed) {
       return;
     }
     if (this.opts.onCustomMessage) {
       try {
         this.opts.onCustomMessage({
-          deltaNetV01Connection,
+          connection,
           internalConnectionId,
           customType,
           contents
@@ -1192,41 +1320,48 @@ var DeltaNetServer2 = class {
       }
     }
   }
+  sendCustomMessageToConnection(connectionId, customType, contents) {
+    if (this.disposed) {
+      return;
+    }
+    const connection = this.connectionIdToConnection.get(connectionId);
+    if (!connection) {
+      return;
+    }
+    const writer = new BufferWriter(contents.length + 16);
+    encodeServerCustom({ type: "serverCustom", customType, contents }, writer);
+    const messageBytes = writer.getBuffer();
+    connection.sendEncodedBytes(messageBytes);
+  }
   broadcastCustomMessage(customType, contents) {
     if (this.disposed) {
       return;
     }
     const writer = new BufferWriter(contents.length + 16);
-    const message = {
-      type: "serverCustom",
-      customType,
-      contents
-    };
-    const encodedMessage = encodeServerMessage2(message, writer);
-    const messageBytes = encodedMessage.getBuffer();
-    this.authenticatedDeltaNetV01Connections.forEach((connection) => {
-      try {
-        connection.sendEncodedBytes(messageBytes);
-      } catch (error) {
-        console.warn("Failed to send custom message to connection:", error);
-      }
-    });
+    encodeServerCustom({ type: "serverCustom", customType, contents }, writer);
+    const messageBytes = writer.getBuffer();
+    for (const connection of this.authenticatedConnections) {
+      connection.sendEncodedBytes(messageBytes);
+    }
   }
   dispose() {
     this.disposed = true;
-    const connectionsToClose = Array.from(this.allDeltaNetV01Connections);
+    const connectionsToClose = Array.from(this.allConnections);
     for (const connection of connectionsToClose) {
       try {
+        connection.dispose();
         connection.webSocket.close(1001, "Server shutting down");
       } catch (error) {
         console.warn("Failed to close connection during disposal:", error);
       }
     }
-    this.allDeltaNetV01Connections.clear();
-    this.authenticatedDeltaNetV01Connections.clear();
+    this.allConnections.clear();
+    this.authenticatedConnections.clear();
+    this.authenticatedV01Connections.clear();
+    this.authenticatedV02Connections.clear();
     this.observerConnections.clear();
-    this.webSocketToDeltaNetServerConnection.clear();
-    this.connectionIdToDeltaNetServerConnection.clear();
+    this.webSocketToConnection.clear();
+    this.connectionIdToConnection.clear();
     this.connectionIdToComponentIndex.clear();
     this.componentIndexToConnectionId.clear();
     this.components.clear();
@@ -1236,8 +1371,11 @@ var DeltaNetServer2 = class {
   }
 };
 export {
+  DeltaNetConnection,
   DeltaNetServer2 as DeltaNetServer,
   DeltaNetServerError,
-  DeltaNetV01Connection
+  DeltaNetV01Connection,
+  DeltaNetV02Connection,
+  createDeltaNetServerConnectionForWebsocket
 };
 //# sourceMappingURL=index.js.map