spacetimedb 2.1.0 → 2.2.0

package/dist/index.browser.mjs

@@ -428,8 +428,8 @@ var BinaryReader = class {
     this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength);
     this.offset = 0;
   }
-  reset(view) {
-    this.view = view;
+  reset(input) {
+    this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength);
     this.offset = 0;
   }
   get remaining() {
@@ -621,6 +621,11 @@ var BinaryWriter = class {
     this.view.setUint8(this.offset, value);
     this.offset += 1;
   }
+  writeBytes(value) {
+    this.expandBuffer(value.length);
+    new Uint8Array(this.buffer.buffer, this.offset, value.length).set(value);
+    this.offset += value.length;
+  }
   writeI8(value) {
     this.expandBuffer(1);
     this.view.setInt8(this.offset, value);
@@ -4465,6 +4470,7 @@ var scalarCompare = (x, y) => {
   return x < y ? -1 : 1;
 };
 var TableCacheImpl = class {
+  hasPrimaryKey;
   rows;
   tableDef;
   emitter;
@@ -4478,6 +4484,9 @@ var TableCacheImpl = class {
     this.tableDef = tableDef;
     this.rows = /* @__PURE__ */ new Map();
     this.emitter = new EventEmitter();
+    this.hasPrimaryKey = Object.values(this.tableDef.columns).some(
+      (col) => col.columnMetadata.isPrimaryKey === true
+    );
     for (const idxDef of this.tableDef.resolvedIndexes) {
       const index = this.#makeReadonlyIndex(this.tableDef, idxDef);
       this[idxDef.name] = index;
@@ -4587,10 +4596,7 @@ var TableCacheImpl = class {
       }
       return pendingCallbacks;
     }
-    const hasPrimaryKey = Object.values(this.tableDef.columns).some(
-      (col) => col.columnMetadata.isPrimaryKey === true
-    );
-    if (hasPrimaryKey) {
+    if (this.hasPrimaryKey) {
       const insertMap = /* @__PURE__ */ new Map();
       const deleteMap = /* @__PURE__ */ new Map();
       for (const op of operations) {
@@ -4998,27 +5004,17 @@ async function decompress(buffer, type, chunkSize = 128 * 1024) {
   });
   const decompressionStream = new DecompressionStream(type);
   const decompressedStream = readableStream.pipeThrough(decompressionStream);
-  const reader = decompressedStream.getReader();
   const chunks = [];
-  let totalLength = 0;
-  let result;
-  while (!(result = await reader.read()).done) {
-    chunks.push(result.value);
-    totalLength += result.value.length;
-  }
-  const decompressedArray = new Uint8Array(totalLength);
-  let chunkOffset = 0;
-  for (const chunk of chunks) {
-    decompressedArray.set(chunk, chunkOffset);
-    chunkOffset += chunk.length;
-  }
-  return decompressedArray;
+  for await (const chunk of decompressedStream) {
+    chunks.push(chunk);
+  }
+  return new Blob(chunks).bytes();
 }
 
 // src/sdk/ws.ts
 async function resolveWS() {
-  if (typeof globalThis.WebSocket !== "undefined") {
-    return globalThis.WebSocket;
+  if (typeof WebSocket !== "undefined") {
+    return WebSocket;
   }
   const dynamicImport = new Function("m", "return import(m)");
   try {
@@ -5032,9 +5028,54 @@ async function resolveWS() {
     throw err;
   }
 }
+async function openWebSocket({
+  url,
+  nameOrAddress,
+  wsProtocol,
+  authToken,
+  compression,
+  lightMode,
+  confirmedReads
+}) {
+  const headers = new Headers();
+  const WS = await resolveWS();
+  let temporaryAuthToken;
+  if (authToken) {
+    headers.set("Authorization", `Bearer ${authToken}`);
+    const tokenUrl = new URL("v1/identity/websocket-token", url);
+    tokenUrl.protocol = url.protocol === "wss:" ? "https:" : "http:";
+    const response = await fetch(tokenUrl, { method: "POST", headers });
+    if (response.ok) {
+      const { token } = await response.json();
+      temporaryAuthToken = token;
+    } else {
+      throw new Error(`Failed to verify token: ${response.statusText}`);
+    }
+  }
+  const databaseUrl = new URL(`v1/database/${nameOrAddress}/subscribe`, url);
+  if (temporaryAuthToken) {
+    databaseUrl.searchParams.set("token", temporaryAuthToken);
+  }
+  databaseUrl.searchParams.set(
+    "compression",
+    { gzip: "Gzip", brotli: "Brotli", none: "None" }[compression] ?? "None"
+  );
+  if (lightMode) {
+    databaseUrl.searchParams.set("light", "true");
+  }
+  if (confirmedReads !== void 0) {
+    databaseUrl.searchParams.set("confirmed", confirmedReads.toString());
+  }
+  const ws = new WS(databaseUrl.toString(), wsProtocol);
+  ws.binaryType = "arraybuffer";
+  return ws;
+}
 
 // src/sdk/websocket_decompress_adapter.ts
 var WebsocketDecompressAdapter = class _WebsocketDecompressAdapter {
+  get protocol() {
+    return this.#ws.protocol;
+  }
   set onclose(handler) {
     this.#ws.onclose = handler;
   }
@@ -5058,9 +5099,7 @@ var WebsocketDecompressAdapter = class _WebsocketDecompressAdapter {
       case 0:
         return data;
       case 1:
-        throw new Error(
-          "Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection."
-        );
+        return await decompress(data, "brotli");
       case 2:
         return await decompress(data, "gzip");
       default:
@@ -5076,51 +5115,10 @@ var WebsocketDecompressAdapter = class _WebsocketDecompressAdapter {
     this.#ws.close();
   }
   constructor(ws) {
-    ws.binaryType = "arraybuffer";
     this.#ws = ws;
   }
-  static async createWebSocketFn({
-    url,
-    nameOrAddress,
-    wsProtocol,
-    authToken,
-    compression,
-    lightMode,
-    confirmedReads
-  }) {
-    const headers = new Headers();
-    const WS = await resolveWS();
-    let temporaryAuthToken = void 0;
-    if (authToken) {
-      headers.set("Authorization", `Bearer ${authToken}`);
-      const tokenUrl = new URL("v1/identity/websocket-token", url);
-      tokenUrl.protocol = url.protocol === "wss:" ? "https:" : "http:";
-      const response = await fetch(tokenUrl, { method: "POST", headers });
-      if (response.ok) {
-        const { token } = await response.json();
-        temporaryAuthToken = token;
-      } else {
-        return Promise.reject(
-          new Error(`Failed to verify token: ${response.statusText}`)
-        );
-      }
-    }
-    const databaseUrl = new URL(`v1/database/${nameOrAddress}/subscribe`, url);
-    if (temporaryAuthToken) {
-      databaseUrl.searchParams.set("token", temporaryAuthToken);
-    }
-    databaseUrl.searchParams.set(
-      "compression",
-      compression === "gzip" ? "Gzip" : "None"
-    );
-    if (lightMode) {
-      databaseUrl.searchParams.set("light", "true");
-    }
-    if (confirmedReads !== void 0) {
-      databaseUrl.searchParams.set("confirmed", confirmedReads.toString());
-    }
-    const ws = new WS(databaseUrl.toString(), wsProtocol);
-    return new _WebsocketDecompressAdapter(ws);
+  static async openWebSocket(args) {
+    return new _WebsocketDecompressAdapter(await openWebSocket(args));
   }
 };
 
@@ -5137,7 +5135,7 @@ var DbConnectionBuilder = class {
   constructor(remoteModule, dbConnectionCtor) {
     this.remoteModule = remoteModule;
     this.dbConnectionCtor = dbConnectionCtor;
-    this.#createWSFn = WebsocketDecompressAdapter.createWebSocketFn;
+    this.#createWSFn = WebsocketDecompressAdapter.openWebSocket;
   }
   #uri;
   #nameOrAddress;
@@ -5192,6 +5190,16 @@ var DbConnectionBuilder = class {
    * @param compression The compression algorithm to use for the connection.
    */
   withCompression(compression) {
+    if (compression === "brotli") {
+      try {
+        new DecompressionStream("brotli");
+      } catch (e) {
+        throw new TypeError(
+          `Brotli compression is not supported by the runtime. Please choose a different compression method.`,
+          { cause: e }
+        );
+      }
+    }
     this.#compression = compression;
     return this;
   }
@@ -5555,6 +5563,100 @@ var SubscriptionHandleImpl = class {
     return this.#activeState;
   }
 };
+
+// src/sdk/websocket_protocols.ts
+var V2_WS_PROTOCOL = "v2.bsatn.spacetimedb";
+var V3_WS_PROTOCOL = "v3.bsatn.spacetimedb";
+var PREFERRED_WS_PROTOCOLS = [V3_WS_PROTOCOL, V2_WS_PROTOCOL];
+function normalizeWsProtocol(protocol) {
+  if (protocol === V3_WS_PROTOCOL) {
+    return V3_WS_PROTOCOL;
+  }
+  if (protocol === "" || protocol === V2_WS_PROTOCOL) {
+    return V2_WS_PROTOCOL;
+  }
+  stdbLogger(
+    "warn",
+    `Unexpected websocket subprotocol "${protocol}", falling back to ${V2_WS_PROTOCOL}.`
+  );
+  return V2_WS_PROTOCOL;
+}
+
+// src/sdk/websocket_v3_frames.ts
+var EMPTY_V3_PAYLOAD_ERR = "v3 websocket payloads must contain at least one message";
+function ensureMessages(messages) {
+  if (messages.length === 0) {
+    throw new RangeError(EMPTY_V3_PAYLOAD_ERR);
+  }
+}
+function ensureMessageCount(messages, messageCount) {
+  ensureMessages(messages);
+  if (messageCount < 1 || messageCount > messages.length) {
+    throw new RangeError(
+      `v3 websocket payload requested ${messageCount} messages from ${messages.length}`
+    );
+  }
+}
+function concatenateMessagesV3(writer, messages, messageCount = messages.length) {
+  ensureMessageCount(messages, messageCount);
+  writer.clear();
+  for (let i = 0; i < messageCount; i++) {
+    writer.writeBytes(messages[i]);
+  }
+  return writer.getBuffer();
+}
+function countClientMessagesForV3Frame(messages, maxFrameBytes) {
+  ensureMessages(messages);
+  const firstMessage = messages[0];
+  if (firstMessage.length > maxFrameBytes) {
+    return 1;
+  }
+  let count = 1;
+  let frameSize = firstMessage.length;
+  while (count < messages.length) {
+    const nextMessage = messages[count];
+    const nextFrameSize = frameSize + nextMessage.length;
+    if (nextFrameSize > maxFrameBytes) {
+      break;
+    }
+    frameSize = nextFrameSize;
+    count += 1;
+  }
+  return count;
+}
+function encodeClientMessagesV3(writer, messages, messageCount = messages.length) {
+  return concatenateMessagesV3(writer, messages, messageCount);
+}
+function forEachServerMessageV3(reader, data, visit) {
+  reader.reset(data);
+  if (reader.remaining === 0) {
+    throw new RangeError(EMPTY_V3_PAYLOAD_ERR);
+  }
+  let count = 0;
+  while (reader.remaining > 0) {
+    visit(ServerMessage.deserialize(reader));
+    count += 1;
+  }
+  return count;
+}
+
+// src/sdk/db_connection_impl.ts
+var TEXT_ENCODER = new TextEncoder();
+function getClientMessageVariantTag(name) {
+  if (ClientMessage.algebraicType.tag !== "Sum") {
+    throw new TypeError("ClientMessage must be a sum type");
+  }
+  const tag = ClientMessage.algebraicType.value.variants.findIndex(
+    (variant) => variant.name === name
+  );
+  if (tag === -1) {
+    throw new RangeError(`Unknown ClientMessage variant: ${name}`);
+  }
+  return tag;
+}
+var CLIENT_MESSAGE_CALL_REDUCER_TAG = getClientMessageVariantTag("CallReducer");
+var CLIENT_MESSAGE_CALL_PROCEDURE_TAG = getClientMessageVariantTag("CallProcedure");
+var MAX_V3_OUTBOUND_FRAME_BYTES = 256 * 1024;
 var DbConnectionImpl = class {
   /**
    * Whether or not the connection is active.
@@ -5589,22 +5691,35 @@ var DbConnectionImpl = class {
    * The `ConnectionId` of the connection to to the database.
    */
   connectionId = ConnectionId.random();
+  #connectionIdHex = this.connectionId.toHexString();
   // These fields are meant to be strictly private.
   #queryId = 0;
   #requestId = 0;
   #eventId = 0;
   #emitter;
-  #messageQueue = Promise.resolve();
+  #inboundQueue = [];
+  #inboundQueueOffset = 0;
+  #isDrainingInboundQueue = false;
   #outboundQueue = [];
+  #isOutboundFlushScheduled = false;
+  #negotiatedWsProtocol = V2_WS_PROTOCOL;
   #subscriptionManager = new SubscriptionManager();
   #remoteModule;
   #reducerCallbacks = /* @__PURE__ */ new Map();
   #reducerCallInfo = /* @__PURE__ */ new Map();
   #procedureCallbacks = /* @__PURE__ */ new Map();
   #rowDeserializers;
+  #rowIdMetadata;
   #reducerArgsSerializers;
   #procedureSerializers;
+  #reducerNameBytes;
+  #procedureNameBytes;
   #sourceNameToTableDef;
+  #messageReader = new BinaryReader(new Uint8Array());
+  #rowListReader = new BinaryReader(new Uint8Array());
+  #clientFrameEncoder = new BinaryWriter(1024);
+  #boundSubscriptionBuilder;
+  #boundDisconnect;
   // These fields are not part of the public API, but in a pinch you
   // could use JavaScript to access them by bypassing TypeScript's
   // private fields.
@@ -5633,22 +5748,35 @@ var DbConnectionImpl = class {
     this.token = token;
     this.#remoteModule = remoteModule;
     this.#emitter = emitter;
+    this.#boundSubscriptionBuilder = this.subscriptionBuilder.bind(this);
+    this.#boundDisconnect = this.disconnect.bind(this);
     this.#rowDeserializers = /* @__PURE__ */ Object.create(null);
+    this.#rowIdMetadata = /* @__PURE__ */ Object.create(null);
     this.#sourceNameToTableDef = /* @__PURE__ */ Object.create(null);
     for (const table2 of Object.values(remoteModule.tables)) {
       this.#rowDeserializers[table2.sourceName] = ProductType.makeDeserializer(
         table2.rowType
       );
       this.#sourceNameToTableDef[table2.sourceName] = table2;
+      const primaryKeyColumn = Object.entries(table2.columns).find(
+        ([, column]) => column.columnMetadata.isPrimaryKey
+      );
+      this.#rowIdMetadata[table2.sourceName] = primaryKeyColumn ? {
+        primaryKeyColName: primaryKeyColumn[0],
+        primaryKeyColType: primaryKeyColumn[1].typeBuilder.algebraicType
+      } : {};
     }
     this.#reducerArgsSerializers = /* @__PURE__ */ Object.create(null);
+    this.#reducerNameBytes = /* @__PURE__ */ Object.create(null);
     for (const reducer of remoteModule.reducers) {
       this.#reducerArgsSerializers[reducer.name] = {
         serialize: ProductType.makeSerializer(reducer.paramsType),
         deserialize: ProductType.makeDeserializer(reducer.paramsType)
       };
+      this.#reducerNameBytes[reducer.name] = TEXT_ENCODER.encode(reducer.name);
     }
     this.#procedureSerializers = /* @__PURE__ */ Object.create(null);
+    this.#procedureNameBytes = /* @__PURE__ */ Object.create(null);
     for (const procedure of remoteModule.procedures) {
       this.#procedureSerializers[procedure.name] = {
         serializeArgs: ProductType.makeSerializer(
@@ -5658,9 +5786,11 @@ var DbConnectionImpl = class {
           procedure.returnType.algebraicType
         )
       };
+      this.#procedureNameBytes[procedure.name] = TEXT_ENCODER.encode(
+        procedure.name
+      );
     }
-    const connectionId = this.connectionId.toHexString();
-    url.searchParams.set("connection_id", connectionId);
+    url.searchParams.set("connection_id", this.#connectionIdHex);
     this.clientCache = new ClientCache();
     this.db = this.#makeDbView();
     this.reducers = this.#makeReducers(remoteModule);
@@ -5668,7 +5798,7 @@ var DbConnectionImpl = class {
     this.wsPromise = createWSFn({
       url,
       nameOrAddress,
-      wsProtocol: "v2.bsatn.spacetimedb",
+      wsProtocol: [...PREFERRED_WS_PROTOCOLS],
       authToken: token,
       compression,
       lightMode,
@@ -5712,16 +5842,22 @@ var DbConnectionImpl = class {
   }
   #makeReducers(def) {
     const out = {};
-    const writer = new BinaryWriter(1024);
     for (const reducer of def.reducers) {
       const reducerName = reducer.name;
+      const encodedReducerName = this.#reducerNameBytes[reducerName];
       const key = reducer.accessorName;
       const { serialize: serializeArgs } = this.#reducerArgsSerializers[reducerName];
       out[key] = (params) => {
+        const writer = this.#reducerArgsEncoder;
         writer.clear();
         serializeArgs(writer, params);
         const argsBuffer = writer.getBuffer();
-        return this.callReducer(reducerName, argsBuffer, params);
+        return this.#callReducerWithEncodedName(
+          reducerName,
+          encodedReducerName,
+          argsBuffer,
+          params
+        );
       };
     }
     return out;
@@ -5731,13 +5867,18 @@ var DbConnectionImpl = class {
     const writer = new BinaryWriter(1024);
     for (const procedure of def.procedures) {
       const procedureName = procedure.name;
+      const encodedProcedureName = this.#procedureNameBytes[procedureName];
       const key = procedure.accessorName;
       const { serializeArgs, deserializeReturn } = this.#procedureSerializers[procedureName];
       out[key] = (params) => {
         writer.clear();
         serializeArgs(writer, params);
         const argsBuffer = writer.getBuffer();
-        return this.callProcedure(procedureName, argsBuffer).then((returnBuf) => {
+        return this.#callProcedureWithEncodedName(
+          procedureName,
+          encodedProcedureName,
+          argsBuffer
+        ).then((returnBuf) => {
           return deserializeReturn(new BinaryReader(returnBuf));
         });
       };
@@ -5749,8 +5890,8 @@ var DbConnectionImpl = class {
       db: this.db,
       reducers: this.reducers,
       isActive: this.isActive,
-      subscriptionBuilder: this.subscriptionBuilder.bind(this),
-      disconnect: this.disconnect.bind(this),
+      subscriptionBuilder: this.#boundSubscriptionBuilder,
+      disconnect: this.#boundDisconnect,
       event
     };
   }
@@ -5795,21 +5936,16 @@ var DbConnectionImpl = class {
   }
   #parseRowList(type, tableName, rowList) {
     const buffer = rowList.rowsData;
-    const reader = new BinaryReader(buffer);
+    const reader = this.#rowListReader;
+    reader.reset(buffer);
     const rows = [];
     const deserializeRow = this.#rowDeserializers[tableName];
-    const table2 = this.#sourceNameToTableDef[tableName];
-    const columnsArray = Object.entries(table2.columns);
-    const primaryKeyColumnEntry = columnsArray.find(
-      (col) => col[1].columnMetadata.isPrimaryKey
-    );
+    const { primaryKeyColName, primaryKeyColType } = this.#rowIdMetadata[tableName];
     let previousOffset = 0;
     while (reader.remaining > 0) {
       const row = deserializeRow(reader);
       let rowId = void 0;
-      if (primaryKeyColumnEntry !== void 0) {
-        const primaryKeyColName = primaryKeyColumnEntry[0];
-        const primaryKeyColType = primaryKeyColumnEntry[1].typeBuilder.algebraicType;
+      if (primaryKeyColName !== void 0 && primaryKeyColType !== void 0) {
         rowId = AlgebraicType.intoMapKey(
           primaryKeyColType,
           row[primaryKeyColName]
@@ -5890,40 +6026,136 @@ var DbConnectionImpl = class {
     return this.#mergeTableUpdates(updates);
   }
   #flushOutboundQueue(wsResolved) {
+    if (this.#negotiatedWsProtocol === V3_WS_PROTOCOL) {
+      this.#flushOutboundQueueV3(wsResolved);
+      return;
+    }
+    this.#flushOutboundQueueV2(wsResolved);
+  }
+  #flushOutboundQueueV2(wsResolved) {
     const pending = this.#outboundQueue.splice(0);
     for (const message of pending) {
       wsResolved.send(message);
     }
   }
+  #flushOutboundQueueV3(wsResolved) {
+    if (this.#outboundQueue.length === 0) {
+      return;
+    }
+    const batchSize = countClientMessagesForV3Frame(
+      this.#outboundQueue,
+      MAX_V3_OUTBOUND_FRAME_BYTES
+    );
+    wsResolved.send(
+      encodeClientMessagesV3(
+        this.#clientFrameEncoder,
+        this.#outboundQueue,
+        batchSize
+      )
+    );
+    if (batchSize === this.#outboundQueue.length) {
+      this.#outboundQueue.length = 0;
+      return;
+    }
+    this.#outboundQueue.copyWithin(0, batchSize);
+    this.#outboundQueue.length -= batchSize;
+    if (this.#outboundQueue.length > 0) {
+      this.#scheduleDeferredOutboundFlush();
+    }
+  }
+  #scheduleOutboundFlush() {
+    this.#scheduleOutboundFlushWith("microtask");
+  }
+  #scheduleDeferredOutboundFlush() {
+    this.#scheduleOutboundFlushWith("next-task");
+  }
+  #scheduleOutboundFlushWith(schedule) {
+    if (this.#isOutboundFlushScheduled) {
+      return;
+    }
+    this.#isOutboundFlushScheduled = true;
+    const flush = () => {
+      this.#isOutboundFlushScheduled = false;
+      if (this.ws && this.isActive) {
+        this.#flushOutboundQueue(this.ws);
+      }
+    };
+    if (schedule === "next-task") {
+      setTimeout(flush, 0);
+    } else {
+      queueMicrotask(flush);
+    }
+  }
+  #reducerArgsEncoder = new BinaryWriter(1024);
   #clientMessageEncoder = new BinaryWriter(1024);
+  #sendEncodedMessage(encoded, describe) {
+    stdbLogger("trace", describe);
+    if (this.ws && this.isActive) {
+      if (this.#negotiatedWsProtocol === V2_WS_PROTOCOL) {
+        if (this.#outboundQueue.length) this.#flushOutboundQueue(this.ws);
+        this.ws.send(encoded);
+        return;
+      }
+      this.#outboundQueue.push(encoded.slice());
+      this.#scheduleOutboundFlush();
+    } else {
+      this.#outboundQueue.push(encoded.slice());
+    }
+  }
   #sendMessage(message) {
     const writer = this.#clientMessageEncoder;
     writer.clear();
     ClientMessage.serialize(writer, message);
     const encoded = writer.getBuffer();
-    if (this.ws && this.isActive) {
-      if (this.#outboundQueue.length) this.#flushOutboundQueue(this.ws);
-      stdbLogger(
-        "trace",
-        () => `Sending message to server: ${stringify(message)}`
-      );
-      this.ws.send(encoded);
-    } else {
-      stdbLogger(
-        "trace",
-        () => `Queuing message to server: ${stringify(message)}`
-      );
-      this.#outboundQueue.push(encoded.slice());
-    }
+    const isLive = !!(this.ws && this.isActive);
+    this.#sendEncodedMessage(
+      encoded,
+      () => isLive ? `Sending message to server: ${stringify(message)}` : `Queuing message to server: ${stringify(message)}`
+    );
+  }
+  #sendCallReducerMessage(requestId, reducerNameBytes, argsBuffer) {
+    const writer = this.#clientMessageEncoder;
+    writer.clear();
+    writer.writeByte(CLIENT_MESSAGE_CALL_REDUCER_TAG);
+    writer.writeU32(requestId);
+    writer.writeU8(0);
+    writer.writeUInt8Array(reducerNameBytes);
+    writer.writeUInt8Array(argsBuffer);
+    const encoded = writer.getBuffer();
+    this.#sendEncodedMessage(
+      encoded,
+      () => `Sending reducer call message to server: requestId=${requestId}`
+    );
+  }
+  #sendCallProcedureMessage(requestId, procedureNameBytes, argsBuffer) {
+    const writer = this.#clientMessageEncoder;
+    writer.clear();
+    writer.writeByte(CLIENT_MESSAGE_CALL_PROCEDURE_TAG);
+    writer.writeU32(requestId);
+    writer.writeU8(0);
+    writer.writeUInt8Array(procedureNameBytes);
+    writer.writeUInt8Array(argsBuffer);
+    const encoded = writer.getBuffer();
+    this.#sendEncodedMessage(
+      encoded,
+      () => `Sending procedure call message to server: requestId=${requestId}`
+    );
+  }
+  #setConnectionId(connectionId) {
+    this.connectionId = connectionId;
+    this.#connectionIdHex = connectionId.toHexString();
   }
   #nextEventId() {
     this.#eventId += 1;
-    return `${this.connectionId.toHexString()}:${this.#eventId}`;
+    return `${this.#connectionIdHex}:${this.#eventId}`;
   }
   /**
    * Handles WebSocket onOpen event.
    */
   #handleOnOpen() {
+    if (this.ws) {
+      this.#negotiatedWsProtocol = normalizeWsProtocol(this.ws.protocol);
+    }
     this.isActive = true;
     if (this.ws) {
       this.#flushOutboundQueue(this.ws);
@@ -5958,8 +6190,16 @@ var DbConnectionImpl = class {
       eventContext
     );
   }
-  async #processMessage(data) {
-    const serverMessage = ServerMessage.deserialize(new BinaryReader(data));
+  #dispatchPendingCallbacks(callbacks) {
+    stdbLogger(
+      "trace",
+      () => `Calling ${callbacks.length} triggered row callbacks`
+    );
+    for (const callback of callbacks) {
+      callback.cb();
+    }
+  }
+  #processServerMessage(serverMessage) {
     stdbLogger(
       "trace",
       () => `Processing server message: ${stringify(serverMessage)}`
@@ -5970,7 +6210,7 @@ var DbConnectionImpl = class {
         if (!this.token && serverMessage.value.token) {
           this.token = serverMessage.value.token;
         }
-        this.connectionId = serverMessage.value.connectionId;
+        this.#setConnectionId(serverMessage.value.connectionId);
         this.#emitter.emit("connect", this, this.identity, this.token);
         break;
       }
@@ -5996,13 +6236,7 @@ var DbConnectionImpl = class {
         const callbacks = this.#applyTableUpdates(tableUpdates, eventContext);
         const { event: _, ...subscriptionEventContext } = eventContext;
         subscription.emitter.emit("applied", subscriptionEventContext);
-        stdbLogger(
-          "trace",
-          () => `Calling ${callbacks.length} triggered row callbacks`
-        );
-        for (const callback of callbacks) {
-          callback.cb();
-        }
+        this.#dispatchPendingCallbacks(callbacks);
         break;
       }
       case "UnsubscribeApplied": {
@@ -6025,13 +6259,7 @@ var DbConnectionImpl = class {
         const { event: _, ...subscriptionEventContext } = eventContext;
         subscription.emitter.emit("end", subscriptionEventContext);
         this.#subscriptionManager.subscriptions.delete(querySetId);
-        stdbLogger(
-          "trace",
-          () => `Calling ${callbacks.length} triggered row callbacks`
-        );
-        for (const callback of callbacks) {
-          callback.cb();
-        }
+        this.#dispatchPendingCallbacks(callbacks);
         break;
       }
       case "SubscriptionError": {
@@ -6079,13 +6307,7 @@ var DbConnectionImpl = class {
           eventContext,
           serverMessage.value
         );
-        stdbLogger(
-          "trace",
-          () => `Calling ${callbacks.length} triggered row callbacks`
-        );
-        for (const callback of callbacks) {
-          callback.cb();
-        }
+        this.#dispatchPendingCallbacks(callbacks);
         break;
       }
       case "ReducerResult": {
@@ -6113,13 +6335,7 @@ var DbConnectionImpl = class {
             eventContext,
             result.value.transactionUpdate
           );
-          stdbLogger(
-            "trace",
-            () => `Calling ${callbacks.length} triggered row callbacks`
-          );
-          for (const callback of callbacks) {
-            callback.cb();
-          }
+          this.#dispatchPendingCallbacks(callbacks);
         }
         this.#reducerCallInfo.delete(requestId);
         const cb = this.#reducerCallbacks.get(requestId);
@@ -6144,14 +6360,55 @@ var DbConnectionImpl = class {
       }
     }
   }
+  #processV2Message(data) {
+    const reader = this.#messageReader;
+    reader.reset(data);
+    this.#processServerMessage(ServerMessage.deserialize(reader));
+  }
+  #processMessage(data) {
+    if (this.#negotiatedWsProtocol !== V3_WS_PROTOCOL) {
+      this.#processV2Message(data);
+      return;
+    }
+    const messageCount = forEachServerMessageV3(
+      this.#messageReader,
+      data,
+      (serverMessage) => {
+        this.#processServerMessage(serverMessage);
+      }
+    );
+    stdbLogger(
+      "trace",
+      () => `Processing server v3 payload with ${messageCount} message(s)`
+    );
+  }
   /**
    * Handles WebSocket onMessage event.
    * @param wsMessage MessageEvent object.
    */
   #handleOnMessage(wsMessage) {
-    this.#messageQueue = this.#messageQueue.then(() => {
-      return this.#processMessage(wsMessage.data);
-    });
+    this.#inboundQueue.push(wsMessage.data);
+    if (this.#isDrainingInboundQueue) {
+      return;
+    }
+    this.#isDrainingInboundQueue = true;
+    try {
+      while (this.#inboundQueueOffset < this.#inboundQueue.length) {
+        const data = this.#inboundQueue[this.#inboundQueueOffset];
+        this.#inboundQueueOffset += 1;
+        if (data) {
+          this.#processMessage(data);
+        }
+      }
+    } finally {
+      if (this.#inboundQueueOffset >= this.#inboundQueue.length) {
+        this.#inboundQueue.length = 0;
+      } else if (this.#inboundQueueOffset > 0) {
+        this.#inboundQueue = this.#inboundQueue.slice(this.#inboundQueueOffset);
+      }
+      this.#inboundQueueOffset = 0;
+      this.#isDrainingInboundQueue = false;
+    }
   }
   /**
    * Call a reducer on your SpacetimeDB module.
@@ -6160,6 +6417,45 @@ var DbConnectionImpl = class {
    * @param argsSerializer The arguments to pass to the reducer
    */
   callReducer(reducerName, argsBuffer, reducerArgs) {
+    const encodedReducerName = this.#reducerNameBytes[reducerName];
+    if (encodedReducerName) {
+      return this.#callReducerWithEncodedName(
+        reducerName,
+        encodedReducerName,
+        argsBuffer,
+        reducerArgs
+      );
+    }
+    return this.#callReducerGeneric(reducerName, argsBuffer, reducerArgs);
+  }
+  #callReducerWithEncodedName(reducerName, encodedReducerName, argsBuffer, reducerArgs) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const requestId = this.#getNextRequestId();
+    this.#sendCallReducerMessage(requestId, encodedReducerName, argsBuffer);
+    if (reducerArgs) {
+      this.#reducerCallInfo.set(requestId, {
+        name: reducerName,
+        args: reducerArgs
+      });
+    }
+    this.#reducerCallbacks.set(requestId, (result) => {
+      if (result.tag === "Ok" || result.tag === "OkEmpty") {
+        resolve();
+      } else {
+        if (result.tag === "Err") {
+          const reader = new BinaryReader(result.value);
+          const errorString = reader.readString();
+          reject(new SenderError(errorString));
+        } else if (result.tag === "InternalError") {
+          reject(new InternalError(result.value));
+        } else {
+          reject(new Error("Unexpected reducer result"));
+        }
+      }
+    });
+    return promise;
+  }
+  #callReducerGeneric(reducerName, argsBuffer, reducerArgs) {
     const { promise, resolve, reject } = Promise.withResolvers();
     const requestId = this.#getNextRequestId();
     const message = ClientMessage.CallReducer({
@@ -6199,7 +6495,8 @@ var DbConnectionImpl = class {
    * @param params The arguments to pass to the reducer
    */
   callReducerWithParams(reducerName, _paramsType, params) {
-    const writer = new BinaryWriter(1024);
+    const writer = this.#reducerArgsEncoder;
+    writer.clear();
     this.#reducerArgsSerializers[reducerName].serialize(writer, params);
     const argsBuffer = writer.getBuffer();
     return this.callReducer(reducerName, argsBuffer, params);
@@ -6211,6 +6508,30 @@ var DbConnectionImpl = class {
    * @param argsBuffer The arguments to pass to the reducer
    */
   callProcedure(procedureName, argsBuffer) {
+    const encodedProcedureName = this.#procedureNameBytes[procedureName];
+    if (encodedProcedureName) {
+      return this.#callProcedureWithEncodedName(
+        procedureName,
+        encodedProcedureName,
+        argsBuffer
+      );
+    }
+    return this.#callProcedureGeneric(procedureName, argsBuffer);
+  }
+  #callProcedureWithEncodedName(procedureName, encodedProcedureName, argsBuffer) {
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const requestId = this.#getNextRequestId();
+    this.#sendCallProcedureMessage(requestId, encodedProcedureName, argsBuffer);
+    this.#procedureCallbacks.set(requestId, (result) => {
+      if (result.tag === "Ok") {
+        resolve(result.value);
+      } else {
+        reject(result.value);
+      }
+    });
+    return promise;
+  }
+  #callProcedureGeneric(procedureName, argsBuffer) {
     const { promise, resolve, reject } = Promise.withResolvers();
     const requestId = this.#getNextRequestId();
     const message = ClientMessage.CallProcedure({
@@ -7151,7 +7472,7 @@ function table(opts, row, ..._) {
         increment: 1n
       });
     }
-    if (meta.defaultValue) {
+    if (Object.prototype.hasOwnProperty.call(meta, "defaultValue")) {
       const writer = new BinaryWriter(16);
       builder.serialize(writer, meta.defaultValue);
       defaultValues.push({