spacetimedb 2.0.3 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacetimedb",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "API and ABI bindings for the SpacetimeDB TypeScript module library",
   "homepage": "https://github.com/clockworklabs/SpacetimeDB#readme",
   "bugs": {

package/src/lib/binary_writer.ts

@@ -42,6 +42,10 @@ export default class BinaryWriter {
     this.buffer = typeof init === 'number' ? new ResizableBuffer(init) : init;
   }
 
+  clear() {
+    this.offset = 0;
+  }
+
   reset(buffer: ResizableBuffer) {
     this.buffer = buffer;
     this.offset = 0;

package/src/lib/indexes.ts

@@ -9,7 +9,7 @@ import type { ColumnIsUnique } from './constraints';
  * existing column names are referenced.
  */
 export type IndexOpts<AllowedCol extends string> = {
-  accessor?: string;
+  accessor: string;
   name?: string;
 } & (
   | { algorithm: 'btree'; columns: readonly AllowedCol[] }

package/src/lib/query.ts

@@ -11,6 +11,7 @@ import type {
   TypeBuilder,
 } from './type_builders';
 import type { Values } from './type_util';
+import type { Bool as SatsBool } from './algebraic_type_variants';
 
 /**
  * Helper to get the set of table names.
@@ -65,7 +66,7 @@ type From<TableDef extends TypedTableDef> = RowTypedQuery<
   Readonly<{
     toSql(): string;
     where(
-      predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+      predicate: (row: RowExpr<TableDef>) => PredicateExpr<TableDef>
     ): From<TableDef>;
     rightSemijoin<RightTable extends TypedTableDef>(
       other: TableRef<RightTable>,
@@ -93,7 +94,7 @@ type SemijoinBuilder<TableDef extends TypedTableDef> = RowTypedQuery<
   Readonly<{
     toSql(): string;
     where(
-      predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+      predicate: (row: RowExpr<TableDef>) => PredicateExpr<TableDef>
     ): SemijoinBuilder<TableDef>;
     /** @deprecated No longer needed — builder is already a valid query. */
     build(): Query<TableDef>;
@@ -120,7 +121,7 @@ class SemijoinImpl<TableDef extends TypedTableDef>
   }
 
   where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+    predicate: (row: RowExpr<TableDef>) => PredicateExpr<TableDef>
   ): SemijoinImpl<TableDef> {
     const nextSourceQuery = this.sourceQuery.where(predicate);
     return new SemijoinImpl<TableDef>(
@@ -167,9 +168,9 @@ class FromBuilder<TableDef extends TypedTableDef>
   ) {}
 
   where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+    predicate: (row: RowExpr<TableDef>) => PredicateExpr<TableDef>
   ): FromBuilder<TableDef> {
-    const newCondition = predicate(this.table.cols);
+    const newCondition = normalizePredicateExpr(predicate(this.table.cols));
     const nextWhere = this.whereClause
       ? this.whereClause.and(newCondition)
       : newCondition;
@@ -308,7 +309,7 @@ class TableRefImpl<TableDef extends TypedTableDef>
   }
 
   where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+    predicate: (row: RowExpr<TableDef>) => PredicateExpr<TableDef>
   ): FromBuilder<TableDef> {
     return this.asFrom().where(predicate);
   }
@@ -628,6 +629,11 @@ export type ValueExpr<TableDef extends TypedTableDef, Value> =
   | LiteralExpr<Value & LiteralValue>
   | ColumnExprForValue<TableDef, Value>;
 
+type PredicateExpr<TableDef extends TypedTableDef> =
+  | BooleanExpr<TableDef>
+  | ColumnExprForValue<TableDef, SatsBool>
+  | boolean;
+
 type LiteralExpr<Value> = {
   type: 'literal';
   value: Value;
@@ -654,6 +660,24 @@ function normalizeValue(val: ValueInput<any>): ValueExpr<any, any> {
   return literal(val as LiteralValue);
 }
 
+function normalizePredicateExpr<TableDef extends TypedTableDef>(
+  value: PredicateExpr<TableDef>
+): BooleanExpr<TableDef> {
+  if (value instanceof BooleanExpr) return value;
+  if (typeof value === 'boolean') {
+    return new BooleanExpr({
+      type: 'eq',
+      left: literal(value),
+      right: literal(true),
+    });
+  }
+  return new BooleanExpr({
+    type: 'eq',
+    left: value as ValueExpr<TableDef, any>,
+    right: literal(true),
+  });
+}
+
 type EqExpr<Table extends TypedTableDef = any> = BooleanExpr<Table>;
 
 type BooleanExprData<Table extends TypedTableDef> = (

package/src/lib/schema.ts

@@ -61,20 +61,35 @@ export interface TableToSchema<
   accessorName: AccName;
   columns: T['rowType']['row'];
   rowType: T['rowSpacetimeType'];
+  // Declarative user-provided table-level indexes.
   indexes: T['idxs'];
+  // Resolved runtime index metadata used by runtime consumers (e.g. TableCache).
+  resolvedIndexes: readonly UntypedIndex<keyof T['rowType']['row'] & string>[];
   constraints: T['constraints'];
 }
 
 export function tablesToSchema<
   const T extends Record<string, UntypedTableSchema>,
 >(ctx: ModuleContext, tables: T): TablesToSchema<T> {
+  // `TablesToSchema<T>['tables']` is intentionally readonly in the public type,
+  // but we need a mutable builder while materializing it from entries.
+  type MutableTableDefs = {
+    -readonly [AccName in keyof TablesToSchema<T>['tables']]: TablesToSchema<T>['tables'][AccName];
+  };
+  const tableDefs = Object.create(null) as MutableTableDefs;
+  for (const [accName, schema] of Object.entries(tables) as [
+    keyof T & string,
+    T[keyof T & string],
+  ][]) {
+    tableDefs[accName] = tableToSchema(
+      accName,
+      schema,
+      schema.tableDef(ctx, accName)
+    ) as TablesToSchema<T>['tables'][typeof accName];
+  }
+
   return {
-    tables: Object.fromEntries(
-      Object.entries(tables).map(([accName, schema]) => [
-        accName,
-        tableToSchema(accName, schema, schema.tableDef(ctx, accName)),
-      ])
-    ) as TablesToSchema<T>['tables'],
+    tables: tableDefs as TablesToSchema<T>['tables'],
   };
 }
 
@@ -90,6 +105,46 @@ export function tableToSchema<
     schema.rowType.algebraicType.value.elements[i].name;
 
   type AllowedCol = keyof T['rowType']['row'] & string;
+  // Build fully-resolved runtime index metadata from the host-facing RawTableDef.
+  // This is intentionally separate from `schema.idxs`, which keeps the original
+  // user-declared `IndexOpts` shape for type-level inference.
+  const resolvedIndexes: UntypedIndex<AllowedCol>[] = tableDef.indexes.map(
+    idx => {
+      const accessorName = idx.accessorName;
+      if (typeof accessorName !== 'string' || accessorName.length === 0) {
+        throw new TypeError(
+          `Index '${idx.sourceName ?? '<unknown>'}' on table '${tableDef.sourceName}' is missing accessor name`
+        );
+      }
+
+      const columnIds =
+        idx.algorithm.tag === 'Direct'
+          ? [idx.algorithm.value]
+          : idx.algorithm.value;
+
+      const unique = tableDef.constraints.some(
+        c =>
+          c.data.tag === 'Unique' &&
+          c.data.value.columns.every(col => columnIds.includes(col))
+      );
+
+      const algorithm = (
+        {
+          BTree: 'btree',
+          Hash: 'hash',
+          Direct: 'direct',
+        } as const
+      )[idx.algorithm.tag];
+
+      return {
+        name: accessorName,
+        unique,
+        algorithm,
+        columns: columnIds.map(getColName) as AllowedCol[],
+      };
+    }
+  );
+
   return {
     // For client,`schama.tableName` will always be there as canonical name.
     // For module, if explicit name is not provided via `name`, accessor name will
@@ -98,29 +153,16 @@ export function tableToSchema<
     accessorName: accName,
     columns: schema.rowType.row, // typed as T[i]['rowType']['row'] under TablesToSchema<T>
     rowType: schema.rowSpacetimeType,
+    // Keep declarative indexes in their original shape for type-level consumers.
+    indexes: schema.idxs,
     constraints: tableDef.constraints.map(c => ({
       name: c.sourceName,
       constraint: 'unique',
       columns: c.data.value.columns.map(getColName) as [string],
     })),
-    // TODO: horrible horrible horrible. we smuggle this `Array<UntypedIndex>`
-    // by casting it to an `Array<IndexOpts>` as `TableToSchema` expects.
-    // This is then used in `TableCacheImpl.constructor` and who knows where else.
-    // We should stop lying about our types.
-    indexes: tableDef.indexes.map((idx): UntypedIndex<AllowedCol> => {
-      const columnIds =
-        idx.algorithm.tag === 'Direct'
-          ? [idx.algorithm.value]
-          : idx.algorithm.value;
-      return {
-        name: idx.accessorName!,
-        unique: tableDef.constraints.some(c =>
-          c.data.value.columns.every(col => columnIds.includes(col))
-        ),
-        algorithm: idx.algorithm.tag.toLowerCase() as 'btree',
-        columns: columnIds.map(getColName),
-      };
-    }) as T['idxs'],
+    // Expose resolved runtime indexes separately so runtime users don't have to
+    // reinterpret `indexes` with unsafe casts.
+    resolvedIndexes,
     tableDef,
     ...(tableDef.isEvent ? { isEvent: true } : {}),
   };

package/src/lib/table.ts

@@ -17,6 +17,7 @@ import type {
   Indexes,
   IndexOpts,
   ReadonlyIndexes,
+  UntypedIndex,
 } from './indexes';
 import ScheduleAt from './schedule_at';
 import type { TableSchema } from './table_schema';
@@ -116,7 +117,25 @@ export type UntypedTableDef = {
   columns: Record<string, ColumnBuilder<any, any, ColumnMetadata<any>>>;
   // This is really just a ProductType where all the elements have names.
   rowType: RowBuilder<RowObj>['algebraicType']['value'];
+  /**
+   * Declarative multi-column indexes supplied by user code in `table({ indexes: [...] }, ...)`.
+   *
+   * This is intentionally the *declarative* shape (`IndexOpts`) because a lot of
+   * type-level behavior is derived from these entries (for example query-builder
+   * inference over composite indexes).
+   */
   indexes: readonly IndexOpts<any>[];
+  /**
+   * Fully-resolved runtime indexes materialized from `RawTableDefV10`.
+   *
+   * This contains both:
+   * 1) field-level indexes inferred from column metadata, and
+   * 2) explicit table-level indexes.
+   *
+   * Runtime consumers like `TableCacheImpl` should use this field instead of
+   * reinterpreting `indexes` as runtime index metadata.
+   */
+  resolvedIndexes: readonly UntypedIndex<any>[];
   constraints: readonly ConstraintOpts<any>[];
   tableDef: RawTableDefV10;
   isEvent?: boolean;
@@ -400,6 +419,14 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
 
   // convert explicit multi‑column indexes coming from options.indexes
   for (const indexOpts of userIndexes ?? []) {
+    const accessor = indexOpts.accessor;
+    if (typeof accessor !== 'string' || accessor.length === 0) {
+      const tableLabel = name ?? '<unnamed>';
+      const indexLabel = indexOpts.name ?? '<unnamed>';
+      throw new TypeError(
+        `Index '${indexLabel}' on table '${tableLabel}' must define a non-empty 'accessor'`
+      );
+    }
     let algorithm: RawIndexAlgorithm;
     switch (indexOpts.algorithm) {
       case 'btree':
@@ -418,16 +445,19 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
         algorithm = { tag: 'Direct', value: colIds.get(indexOpts.column)! };
         break;
     }
-    // unnamed indexes will be assigned a globally unique name
-    // The name users supply is actually the accessor name which will be used
-    // in TypeScript to access the index. This will be used verbatim.
-    // This is confusing because it is not the index name and there is
-    // no actual way for the user to set the actual index name.
-    // I think we should standardize: name and accessorName as the way to set
-    // the name and accessor name of an index across all SDKs.
+
+    // Unnamed indexes are assigned a globally unique source name.
+    // `accessor` controls the TypeScript property used to access the index.
+    // `name` (if present) is preserved as the canonical schema name.
+    //
+    // IMPORTANT: we intentionally do not reject duplicate accessor names here.
+    // This preserves existing behavior for raw table definitions. Downstream
+    // runtime consumers decide how duplicates are resolved:
+    // - server runtime merges duplicate accessors onto one accessor object
+    // - client cache assignment is last-write-wins for duplicate accessors
     indexes.push({
       sourceName: undefined,
-      accessorName: indexOpts.accessor,
+      accessorName: accessor,
       algorithm,
       canonicalName: indexOpts.name,
     });
@@ -496,7 +526,9 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
         isEvent,
       };
     },
-    idxs: {} as OptsIndices<Opts>,
+    // Preserve the declared index options as runtime data so `tableToSchema`
+    // can expose them without type-smuggling.
+    idxs: userIndexes as OptsIndices<Opts>,
     constraints: constraints as OptsConstraints<Opts>,
     schedule,
   };

package/src/sdk/db_connection_impl.ts

@@ -37,8 +37,10 @@ import {
   type PendingCallback,
   type TableUpdate as CacheTableUpdate,
 } from './table_cache.ts';
-import { WebsocketDecompressAdapter } from './websocket_decompress_adapter.ts';
-import type { WebsocketTestAdapter } from './websocket_test_adapter.ts';
+import {
+  WebsocketDecompressAdapter,
+  type WebsocketAdapter,
+} from './websocket_decompress_adapter.ts';
 import {
   SubscriptionBuilderImpl,
   SubscriptionHandleImpl,
@@ -146,7 +148,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
   #eventId = 0;
   #emitter: EventEmitter<ConnectionEvent>;
   #messageQueue = Promise.resolve();
-  #outboundQueue: ClientMessage[] = [];
+  #outboundQueue: Uint8Array[] = [];
   #subscriptionManager = new SubscriptionManager<RemoteModule>();
   #remoteModule: RemoteModule;
   #reducerCallbacks = new Map<
@@ -171,10 +173,8 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
   // private fields.
   // We use them in testing.
   private clientCache: ClientCache<RemoteModule>;
-  private ws?: WebsocketDecompressAdapter | WebsocketTestAdapter;
-  private wsPromise: Promise<
-    WebsocketDecompressAdapter | WebsocketTestAdapter | undefined
-  >;
+  private ws?: WebsocketAdapter;
+  private wsPromise: Promise<WebsocketAdapter | undefined>;
 
   constructor({
     uri,
@@ -302,6 +302,8 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
   #makeReducers(def: RemoteModule): ReducersView<RemoteModule> {
     const out: Record<string, unknown> = {};
 
+    const writer = new BinaryWriter(1024);
+
     for (const reducer of def.reducers) {
       const reducerName = reducer.name;
       const key = reducer.accessorName;
@@ -310,7 +312,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
         this.#reducerArgsSerializers[reducerName];
 
       (out as any)[key] = (params: InferTypeOfRow<typeof reducer.params>) => {
-        const writer = new BinaryWriter(1024);
+        writer.clear();
         serializeArgs(writer, params);
         const argsBuffer = writer.getBuffer();
         return this.callReducer(reducerName, argsBuffer, params);
@@ -323,6 +325,8 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
   #makeProcedures(def: RemoteModule): ProceduresView<RemoteModule> {
     const out: Record<string, unknown> = {};
 
+    const writer = new BinaryWriter(1024);
+
     for (const procedure of def.procedures) {
       const procedureName = procedure.name;
       const key = procedure.accessorName;
@@ -333,7 +337,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
       (out as any)[key] = (
         params: InferTypeOfRow<typeof procedure.params>
       ): Promise<any> => {
-        const writer = new BinaryWriter(1024);
+        writer.clear();
         serializeArgs(writer, params);
         const argsBuffer = writer.getBuffer();
         return this.callProcedure(procedureName, argsBuffer).then(returnBuf => {
@@ -537,41 +541,36 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
     return this.#mergeTableUpdates(updates);
   }
 
-  #sendEncoded(
-    wsResolved: WebsocketDecompressAdapter | WebsocketTestAdapter,
-    message: ClientMessage
-  ): void {
-    stdbLogger(
-      'trace',
-      () => `Sending message to server: ${stringify(message)}`
-    );
-    const writer = new BinaryWriter(1024);
-    ClientMessage.serialize(writer, message);
-    const encoded = writer.getBuffer();
-    wsResolved.send(encoded);
-  }
-
-  #flushOutboundQueue(
-    wsResolved: WebsocketDecompressAdapter | WebsocketTestAdapter
-  ): void {
-    if (!this.isActive || this.#outboundQueue.length === 0) {
-      return;
-    }
+  #flushOutboundQueue(wsResolved: WebsocketAdapter): void {
     const pending = this.#outboundQueue.splice(0);
     for (const message of pending) {
-      this.#sendEncoded(wsResolved, message);
+      wsResolved.send(message);
     }
   }
 
+  #clientMessageEncoder = new BinaryWriter(1024);
   #sendMessage(message: ClientMessage): void {
-    this.wsPromise.then(wsResolved => {
-      if (!wsResolved || !this.isActive) {
-        this.#outboundQueue.push(message);
-        return;
-      }
-      this.#flushOutboundQueue(wsResolved);
-      this.#sendEncoded(wsResolved, 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)}`
+      );
+      // use slice() to copy, in case the clientMessageEncoder's buffer gets used
+      this.#outboundQueue.push(encoded.slice());
+    }
   }
 
   #nextEventId(): string {
@@ -978,11 +977,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
    * ```
    */
   disconnect(): void {
-    this.wsPromise.then(wsResolved => {
-      if (wsResolved) {
-        wsResolved.close();
-      }
-    });
+    this.wsPromise.then(ws => ws?.close());
   }
 
   private on(

package/src/sdk/table_cache.ts

@@ -12,7 +12,6 @@ import type {
   ReadonlyIndexes,
   ReadonlyRangedIndex,
   ReadonlyUniqueIndex,
-  UntypedIndex,
 } from '../lib/indexes.ts';
 import type { Bound } from '../server/range.ts';
 import type { Prettify } from '../lib/type_util.ts';
@@ -84,23 +83,27 @@ export class TableCacheImpl<
     this.tableDef = tableDef;
     this.rows = new Map();
     this.emitter = new EventEmitter();
-    // Build indexes
-    const indexesDef = this.tableDef.indexes || [];
-    for (const idx of indexesDef) {
-      // TODO: don't do this. See comment in `tableToSchema` in `schema.ts`
-      const idxDef = idx as UntypedIndex<
-        keyof TableDefForTableName<RemoteModule, TableName>['columns'] & string
-      >;
+    // Build index views from the resolved runtime index metadata.
+    //
+    // We intentionally use `resolvedIndexes` rather than `indexes`:
+    // - `indexes` is declarative table-level config (`IndexOpts`) used mainly for typing.
+    // - `resolvedIndexes` is the runtime shape (`UntypedIndex`) that includes both
+    //   field-level and explicit table-level indexes.
+    for (const idxDef of this.tableDef.resolvedIndexes) {
       const index = this.#makeReadonlyIndex(this.tableDef, idxDef);
+      // IMPORTANT: for duplicate accessor names, client cache uses assignment
+      // semantics and later entries overwrite earlier ones. This matches prior
+      // behavior and is intentionally different from server runtime merge logic.
       (this as any)[idxDef.name] = index;
     }
   }
 
   // TODO: this just scans the whole table; we should build proper index structures
   #makeReadonlyIndex<
-    I extends UntypedIndex<
-      keyof TableDefForTableName<RemoteModule, TableName>['columns'] & string
-    >,
+    I extends TableDefForTableName<
+      RemoteModule,
+      TableName
+    >['resolvedIndexes'][number],
   >(
     tableDef: TableDefForTableName<RemoteModule, TableName>,
     idx: I

package/src/sdk/websocket_decompress_adapter.ts

@@ -1,48 +1,55 @@
 import { decompress } from './decompress';
 import { resolveWS } from './ws';
 
-export class WebsocketDecompressAdapter {
-  onclose?: (...ev: any[]) => void;
-  onopen?: (...ev: any[]) => void;
-  onmessage?: (msg: { data: Uint8Array }) => void;
-  onerror?: (msg: ErrorEvent) => void;
-
-  #ws: WebSocket;
-
-  async #handleOnMessage(msg: MessageEvent) {
-    const buffer = new Uint8Array(msg.data);
-    let decompressed: Uint8Array;
-
-    if (buffer[0] === 0) {
-      decompressed = buffer.slice(1);
-    } else if (buffer[0] === 1) {
-      throw new Error(
-        'Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection.'
-      );
-    } else if (buffer[0] === 2) {
-      decompressed = await decompress(buffer.slice(1), 'gzip');
-    } else {
-      throw new Error(
-        'Unexpected Compression Algorithm. Please use `gzip` or `none`'
-      );
-    }
+export interface WebsocketAdapter {
+  send(msg: Uint8Array): void;
+  close(): void;
+
+  set onclose(handler: (ev: CloseEvent) => void);
+  set onopen(handler: () => void);
+  set onmessage(handler: (msg: { data: Uint8Array }) => void);
+  set onerror(handler: (msg: ErrorEvent) => void);
+}
 
-    this.onmessage?.({ data: decompressed });
+export class WebsocketDecompressAdapter implements WebsocketAdapter {
+  set onclose(handler: (ev: CloseEvent) => void) {
+    this.#ws.onclose = handler;
   }
-
-  #handleOnOpen(msg: any) {
-    this.onopen?.(msg);
+  set onopen(handler: () => void) {
+    this.#ws.onopen = handler;
   }
-
-  #handleOnError(msg: any) {
-    this.onerror?.(msg);
+  set onmessage(handler: (msg: { data: Uint8Array }) => void) {
+    this.#ws.onmessage = async (msg: MessageEvent<ArrayBuffer>) => {
+      const data = await this.#decompress(new Uint8Array(msg.data));
+      handler({ data });
+    };
+  }
+  set onerror(handler: (msg: ErrorEvent) => void) {
+    this.#ws.onerror = handler as (msg: Event) => void;
   }
 
-  #handleOnClose(msg: any) {
-    this.onclose?.(msg);
+  #ws: WebSocket;
+
+  async #decompress(buffer: Uint8Array): Promise<Uint8Array> {
+    const tag = buffer[0];
+    const data = buffer.subarray(1);
+    switch (tag) {
+      case 0:
+        return data;
+      case 1:
+        throw new Error(
+          'Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection.'
+        );
+      case 2:
+        return await decompress(data, 'gzip');
+      default:
+        throw new Error(
+          'Unexpected Compression Algorithm. Please use `gzip` or `none`'
+        );
+    }
   }
 
-  send(msg: any): void {
+  send(msg: Uint8Array): void {
     this.#ws.send(msg);
   }
 
@@ -51,16 +58,6 @@ export class WebsocketDecompressAdapter {
   }
 
   constructor(ws: WebSocket) {
-    this.onmessage = undefined;
-    this.onopen = undefined;
-    this.onmessage = undefined;
-    this.onerror = undefined;
-
-    ws.onmessage = this.#handleOnMessage.bind(this);
-    ws.onerror = this.#handleOnError.bind(this);
-    ws.onclose = this.#handleOnClose.bind(this);
-    ws.onopen = this.#handleOnOpen.bind(this);
-
     ws.binaryType = 'arraybuffer';
 
     this.#ws = ws;

package/src/sdk/websocket_test_adapter.ts

@@ -1,10 +1,11 @@
 import { BinaryReader, BinaryWriter } from '../';
 import { ClientMessage, ServerMessage } from './client_api/types';
+import type { WebsocketAdapter } from './websocket_decompress_adapter';
 
-class WebsocketTestAdapter {
+class WebsocketTestAdapter implements WebsocketAdapter {
   onclose: any;
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-  onopen!: Function;
+  onopen!: () => void;
   onmessage: any;
   onerror: any;
 

package/src/server/runtime.ts

@@ -516,6 +516,7 @@ function makeTableView(
   ) as Table<any>;
 
   for (const indexDef of table.indexes) {
+    const accessorName = indexDef.accessorName!;
     const index_id = sys.index_id_from_name(indexDef.sourceName!);
 
     let column_ids: number[];
@@ -795,10 +796,13 @@ function makeTableView(
       } as RangedIndex<any, any>;
     }
 
-    if (Object.hasOwn(tableView, indexDef.accessorName!)) {
-      freeze(Object.assign(tableView[indexDef.accessorName!], index));
+    // IMPORTANT: duplicate accessor handling.
+    // When multiple raw indexes share the same accessor name, we merge index
+    // methods onto a single accessor object instead of throwing.
+    if (Object.hasOwn(tableView, accessorName)) {
+      freeze(Object.assign((tableView as any)[accessorName], index));
     } else {
-      tableView[indexDef.accessorName!] = freeze(index) as any;
+      (tableView as any)[accessorName] = freeze(index);
     }
   }