spacetimedb 2.5.0 → 2.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacetimedb",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "API and ABI bindings for the SpacetimeDB TypeScript module library",
   "homepage": "https://github.com/clockworklabs/SpacetimeDB#readme",
   "bugs": {
@@ -22,6 +22,26 @@
   "sideEffects": [
     "./src/server/polyfills.ts"
   ],
+  "scripts": {
+    "build:js": "tsup",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build": "pnpm -s build:js && pnpm -s build:types",
+    "format": "prettier . --write --ignore-path ../../.prettierignore",
+    "lint": "eslint . && prettier . --check --ignore-path ../../.prettierignore",
+    "test": "vitest run",
+    "test:typecheck": "vitest typecheck --run",
+    "coverage": "vitest run --coverage",
+    "brotli-size": "brotli-size dist/index.js",
+    "size": "pnpm -s build && size-limit",
+    "generate:moduledef": "cargo run -p spacetimedb-codegen --example regen-typescript-moduledef && prettier --write src/lib/autogen",
+    "generate:client-api": "cargo run -p generate-client-api && prettier --write src/sdk/client_api",
+    "generate:test-app": "pnpm --filter @clockworklabs/test-app generate",
+    "generate:examples:chat-react-ts": "pnpm --filter @clockworklabs/chat-react-ts generate",
+    "generate:examples:react-ts": "pnpm --filter @clockworklabs/react-ts generate",
+    "generate:examples:empty": "pnpm --filter @clockworklabs/empty-client generate",
+    "generate": "pnpm generate:moduledef && pnpm generate:client-api && pnpm generate:test-app && pnpm generate:examples:chat-react-ts && pnpm generate:examples:react-ts && pnpm generate:examples:empty",
+    "prepublishOnly": "pnpm run build && pnpm run test && pnpm run size"
+  },
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -228,24 +248,5 @@
     "typescript-eslint": "^8.18.2",
     "vite": "^7.1.5",
     "vitest": "^3.2.4"
-  },
-  "scripts": {
-    "build:js": "tsup",
-    "build:types": "tsc -p tsconfig.build.json",
-    "build": "pnpm -s build:js && pnpm -s build:types",
-    "format": "prettier . --write --ignore-path ../../.prettierignore",
-    "lint": "eslint . && prettier . --check --ignore-path ../../.prettierignore",
-    "test": "vitest run",
-    "test:typecheck": "vitest typecheck --run",
-    "coverage": "vitest run --coverage",
-    "brotli-size": "brotli-size dist/index.js",
-    "size": "pnpm -s build && size-limit",
-    "generate:moduledef": "cargo run -p spacetimedb-codegen --example regen-typescript-moduledef && prettier --write src/lib/autogen",
-    "generate:client-api": "cargo run -p generate-client-api && prettier --write src/sdk/client_api",
-    "generate:test-app": "pnpm --filter @clockworklabs/test-app generate",
-    "generate:examples:chat-react-ts": "pnpm --filter @clockworklabs/chat-react-ts generate",
-    "generate:examples:react-ts": "pnpm --filter @clockworklabs/react-ts generate",
-    "generate:examples:empty": "pnpm --filter @clockworklabs/empty-client generate",
-    "generate": "pnpm generate:moduledef && pnpm generate:client-api && pnpm generate:test-app && pnpm generate:examples:chat-react-ts && pnpm generate:examples:react-ts && pnpm generate:examples:empty"
   }
-}
+}

package/src/lib/type_builders.test-d.ts

@@ -35,6 +35,8 @@ const rowOptionOptional = {
 };
 type RowOptionOptional = InferTypeOfRow<typeof rowOptionOptional>;
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _rowOptionOptionalOmitted: RowOptionOptional = {};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const _rowOptionOptionalNone: RowOptionOptional = {
   foo: undefined,
 };

package/src/lib/type_builders.ts

@@ -39,9 +39,45 @@ export type Infer<T> = T extends RowObj
 /**
  * Helper type to extract the type of a row from an object.
  */
-export type InferTypeOfRow<T extends RowObj> = {
-  [K in keyof T & string]: InferTypeOfTypeBuilder<CollapseColumn<T[K]>>;
-};
+type OptionalRowKeys<T extends RowObj> = {
+  [K in keyof T & string]-?: CollapseColumn<T[K]> extends OptionBuilder<any>
+    ? K
+    : never;
+}[keyof T & string];
+
+type RequiredRowKeys<T extends RowObj> = Exclude<
+  keyof T & string,
+  OptionalRowKeys<T>
+>;
+
+export type InferTypeOfRow<T extends RowObj> = Prettify<
+  {
+    [K in RequiredRowKeys<T>]: InferTypeOfTypeBuilder<CollapseColumn<T[K]>>;
+  } & {
+    [K in OptionalRowKeys<T>]?: InferTypeOfTypeBuilder<CollapseColumn<T[K]>>;
+  }
+>;
+
+type OptionalParamKeys<T extends RowObj> = {
+  [K in keyof T & string]-?: undefined extends InferTypeOfTypeBuilder<
+    CollapseColumn<T[K]>
+  >
+    ? K
+    : never;
+}[keyof T & string];
+
+type RequiredParamKeys<T extends RowObj> = Exclude<
+  keyof T & string,
+  OptionalParamKeys<T>
+>;
+
+export type InferTypeOfParams<T extends RowObj> = Prettify<
+  {
+    [K in RequiredParamKeys<T>]: InferTypeOfTypeBuilder<CollapseColumn<T[K]>>;
+  } & {
+    [K in OptionalParamKeys<T>]?: InferTypeOfTypeBuilder<CollapseColumn<T[K]>>;
+  }
+>;
 
 /**
  * Helper type to extract the type of a row from an object.

package/src/react/useTable.ts

@@ -127,18 +127,23 @@ export function useTable<TableDef extends UntypedTableDef>(
       setSubscribeApplied(false);
       return;
     }
-    const connection = connectionState.getConnection()!;
-    if (connectionState.isActive && connection) {
-      const cancel = connection
-        .subscriptionBuilder()
-        .onApplied(() => {
-          setSubscribeApplied(true);
-        })
-        .subscribe(querySql);
-      return () => {
-        cancel.unsubscribe();
-      };
+    const connection = connectionState.getConnection();
+    if (!connectionState.isActive || !connection) {
+      // The connection dropped (or was replaced and has not reconnected
+      // yet), so any previously applied subscription no longer reflects the
+      // current cache. Report not-ready until the new subscription applies.
+      setSubscribeApplied(false);
+      return;
     }
+    const cancel = connection
+      .subscriptionBuilder()
+      .onApplied(() => {
+        setSubscribeApplied(true);
+      })
+      .subscribe(querySql);
+    return () => {
+      cancel.unsubscribe();
+    };
   }, [querySql, connectionState.isActive, connectionState, enabled]);
 
   const subscribe = useCallback(

package/src/sdk/connection_manager.ts

@@ -46,12 +46,30 @@ export type ConnectionState = {
 
 type Listener = () => void;
 
+export const CONNECTION_MANAGER_RECONNECT_BASE_DELAY_MS = 1000;
+export const CONNECTION_MANAGER_RECONNECT_MAX_DELAY_MS = 30_000;
+
+/**
+ * Computes the reconnect delay for the given attempt (0-based) using
+ * exponential backoff: the base delay doubles with each consecutive failed
+ * attempt, capped at the maximum delay.
+ */
+export function connectionManagerReconnectDelayMs(attempt: number): number {
+  return Math.min(
+    CONNECTION_MANAGER_RECONNECT_BASE_DELAY_MS * 2 ** attempt,
+    CONNECTION_MANAGER_RECONNECT_MAX_DELAY_MS
+  );
+}
+
 type ManagedConnection = {
   connection?: DbConnectionImpl<any>;
+  builder?: DbConnectionBuilder<any>;
   refCount: number;
   state: ConnectionState;
   listeners: Set<Listener>;
   pendingRelease: ReturnType<typeof setTimeout> | null;
+  reconnectTimer: ReturnType<typeof setTimeout> | null;
+  reconnectAttempt: number;
   onConnect?: (conn: DbConnectionImpl<any>) => void;
   onDisconnect?: (ctx: ErrorContextInterface<any>, error?: Error) => void;
   onConnectError?: (ctx: ErrorContextInterface<any>, error: Error) => void;
@@ -91,10 +109,13 @@ class ConnectionManagerImpl {
     }
     const managed: ManagedConnection = {
       connection: undefined,
+      builder: undefined,
       refCount: 0,
       state: defaultState(),
       listeners: new Set(),
       pendingRelease: null,
+      reconnectTimer: null,
+      reconnectAttempt: 0,
     };
     this.#connections.set(key, managed);
     return managed;
@@ -106,47 +127,25 @@ class ConnectionManagerImpl {
     }
   }
 
-  /**
-   * Retains a connection, incrementing its reference count.
-   * Creates the connection on first call; returns existing connection on subsequent calls.
-   * Cancels any pending release if the connection was about to be cleaned up.
-   *
-   * @param key - Unique identifier for the connection (use getKey to generate)
-   * @param builder - Connection builder to create the connection if needed
-   * @returns The managed connection instance
-   */
-  retain<T extends DbConnectionImpl<any>>(
-    key: string,
-    builder: DbConnectionBuilder<T>
-  ): T {
-    const managed = this.#ensureEntry(key);
-    if (managed.pendingRelease) {
-      clearTimeout(managed.pendingRelease);
-      managed.pendingRelease = null;
-    }
-    managed.refCount += 1;
-    if (managed.connection) {
-      return managed.connection as T;
-    }
-
-    const connection = builder.build();
-    managed.connection = connection;
-
-    const updateState = (updates: Partial<ConnectionState>) => {
-      managed.state = { ...managed.state, ...updates };
-      this.#notify(managed);
-    };
+  #updateState(
+    managed: ManagedConnection,
+    updates: Partial<ConnectionState>
+  ): void {
+    managed.state = { ...managed.state, ...updates };
+    this.#notify(managed);
+  }
 
-    updateState({
-      isActive: connection.isActive,
-      identity: connection.identity,
-      token: connection.token,
-      connectionId: connection.connectionId,
-      connectionError: undefined,
-    });
+  #ensureCallbacks(managed: ManagedConnection): void {
+    if (managed.onConnect) {
+      return;
+    }
 
     managed.onConnect = conn => {
-      updateState({
+      if (conn !== managed.connection) {
+        return;
+      }
+      managed.reconnectAttempt = 0;
+      this.#updateState(managed, {
         isActive: conn.isActive,
         identity: conn.identity,
         token: conn.token,
@@ -156,26 +155,145 @@ class ConnectionManagerImpl {
     };
 
     managed.onDisconnect = (ctx, error) => {
-      updateState({
-        isActive: ctx.isActive,
+      if (ctx !== managed.connection) {
+        return;
+      }
+      this.#updateState(managed, {
+        isActive: false,
         connectionError: error ?? undefined,
       });
+      this.#scheduleReconnect(managed);
     };
 
     managed.onConnectError = (ctx, error) => {
-      updateState({
-        isActive: ctx.isActive,
+      if (ctx !== managed.connection) {
+        return;
+      }
+      this.#updateState(managed, {
+        isActive: false,
         connectionError: error,
       });
+      this.#scheduleReconnect(managed);
     };
+  }
+
+  #attachCallbacks<T extends DbConnectionImpl<any>>(
+    managed: ManagedConnection,
+    builder: DbConnectionBuilder<T>
+  ): void {
+    this.#ensureCallbacks(managed);
+    builder.onConnect(managed.onConnect!);
+    builder.onDisconnect(managed.onDisconnect!);
+    builder.onConnectError(managed.onConnectError!);
+  }
+
+  #detachCallbacks(
+    managed: ManagedConnection,
+    connection: DbConnectionImpl<any>
+  ): void {
+    if (managed.onConnect) {
+      connection.removeOnConnect(managed.onConnect as any);
+    }
+    if (managed.onDisconnect) {
+      connection.removeOnDisconnect(managed.onDisconnect as any);
+    }
+    if (managed.onConnectError) {
+      connection.removeOnConnectError(managed.onConnectError as any);
+    }
+  }
 
-    builder.onConnect(managed.onConnect);
-    builder.onDisconnect(managed.onDisconnect);
-    builder.onConnectError(managed.onConnectError);
+  #buildManagedConnection<T extends DbConnectionImpl<any>>(
+    managed: ManagedConnection,
+    builder: DbConnectionBuilder<T>
+  ): T {
+    managed.builder = builder;
+    const connection = builder.build();
+    managed.connection = connection;
+    this.#attachCallbacks(managed, builder);
+
+    this.#updateState(managed, {
+      isActive: connection.isActive,
+      identity: connection.identity,
+      token: connection.token,
+      connectionId: connection.connectionId,
+      connectionError: undefined,
+    });
 
     return connection as T;
   }
 
+  #scheduleReconnect(managed: ManagedConnection): void {
+    if (
+      managed.refCount <= 0 ||
+      managed.pendingRelease ||
+      managed.reconnectTimer ||
+      !managed.builder
+    ) {
+      return;
+    }
+
+    const connection = managed.connection;
+    if (connection) {
+      this.#detachCallbacks(managed, connection);
+    }
+    managed.connection = undefined;
+
+    // The application asked this connection to close; don't fight it. A
+    // subsequent retain() will still build a fresh connection.
+    if (connection?.isDisconnectRequested) {
+      return;
+    }
+
+    const delay = connectionManagerReconnectDelayMs(managed.reconnectAttempt);
+    managed.reconnectAttempt += 1;
+    managed.reconnectTimer = setTimeout(() => {
+      managed.reconnectTimer = null;
+      if (
+        managed.refCount <= 0 ||
+        managed.pendingRelease ||
+        managed.connection ||
+        !managed.builder
+      ) {
+        return;
+      }
+
+      this.#buildManagedConnection(managed, managed.builder);
+    }, delay);
+  }
+
+  /**
+   * Retains a connection, incrementing its reference count.
+   * Creates the connection on first call; returns existing connection on subsequent calls.
+   * Cancels any pending release if the connection was about to be cleaned up.
+   *
+   * @param key - Unique identifier for the connection (use getKey to generate)
+   * @param builder - Connection builder to create the connection if needed
+   * @returns The managed connection instance
+   */
+  retain<T extends DbConnectionImpl<any>>(
+    key: string,
+    builder: DbConnectionBuilder<T>
+  ): T {
+    const managed = this.#ensureEntry(key);
+    if (managed.pendingRelease) {
+      clearTimeout(managed.pendingRelease);
+      managed.pendingRelease = null;
+    }
+    if (managed.reconnectTimer) {
+      clearTimeout(managed.reconnectTimer);
+      managed.reconnectTimer = null;
+    }
+
+    managed.refCount += 1;
+    managed.builder = builder;
+
+    if (managed.connection) {
+      return managed.connection as T;
+    }
+
+    return this.#buildManagedConnection(managed, builder);
+  }
+
   release(key: string): void {
     const managed = this.#connections.get(key);
     if (!managed) {
@@ -187,24 +305,21 @@ class ConnectionManagerImpl {
       return;
     }
 
+    if (managed.reconnectTimer) {
+      clearTimeout(managed.reconnectTimer);
+      managed.reconnectTimer = null;
+    }
+
     managed.pendingRelease = setTimeout(() => {
       managed.pendingRelease = null;
       if (managed.refCount > 0) {
         return;
       }
-      if (managed.connection) {
-        if (managed.onConnect) {
-          managed.connection.removeOnConnect(managed.onConnect as any);
-        }
-        if (managed.onDisconnect) {
-          managed.connection.removeOnDisconnect(managed.onDisconnect as any);
-        }
-        if (managed.onConnectError) {
-          managed.connection.removeOnConnectError(
-            managed.onConnectError as any
-          );
-        }
-        managed.connection.disconnect();
+      const connection = managed.connection;
+      managed.connection = undefined;
+      if (connection) {
+        this.#detachCallbacks(managed, connection);
+        connection.disconnect();
       }
       this.#connections.delete(key);
     }, 0);

package/src/sdk/db_connection_impl.ts

@@ -23,7 +23,12 @@ import {
   type SubscriptionEventContextInterface,
 } from './event_context.ts';
 import { EventEmitter } from './event_emitter.ts';
-import type { Deserializer, Identity, InferTypeOfRow, Serializer } from '../';
+import type {
+  Deserializer,
+  Identity,
+  InferTypeOfParams,
+  Serializer,
+} from '../';
 import type {
   ProcedureResultMessage,
   ReducerResultMessage,
@@ -138,6 +143,14 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
    */
   isActive = false;
 
+  /**
+   * Whether `disconnect()` has been called on this connection.
+   * Once requested, the connection will not be reused: managed environments
+   * (such as the React `SpacetimeDBProvider`) use this to avoid reconnecting
+   * after an intentional disconnect.
+   */
+  isDisconnectRequested = false;
+
   /**
    * This connection's public identity.
    */
@@ -321,12 +334,12 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
         this.ws = v;
 
         this.ws.onclose = () => {
-          this.#emitter.emit('disconnect', this);
           this.isActive = false;
+          this.#emitter.emit('disconnect', this);
         };
         this.ws.onerror = (e: ErrorEvent) => {
-          this.#emitter.emit('connectError', this, e);
           this.isActive = false;
+          this.#emitter.emit('connectError', this, e);
         };
         this.ws.onopen = this.#handleOnOpen.bind(this);
         this.ws.onmessage = this.#handleOnMessage.bind(this);
@@ -375,7 +388,9 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
       const { serialize: serializeArgs } =
         this.#reducerArgsSerializers[reducerName];
 
-      (out as any)[key] = (params: InferTypeOfRow<typeof reducer.params>) => {
+      (out as any)[key] = (
+        params: InferTypeOfParams<typeof reducer.params>
+      ) => {
         const writer = this.#reducerArgsEncoder;
         writer.clear();
         serializeArgs(writer, params);
@@ -406,7 +421,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
         this.#procedureSerializers[procedureName];
 
       (out as any)[key] = (
-        params: InferTypeOfRow<typeof procedure.params>
+        params: InferTypeOfParams<typeof procedure.params>
       ): Promise<any> => {
         writer.clear();
         serializeArgs(writer, params);
@@ -428,7 +443,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
     event: Event<
       ReducerEventInfo<
         RemoteModule['reducers'][number]['name'],
-        InferTypeOfRow<RemoteModule['reducers'][number]['params']>
+        InferTypeOfParams<RemoteModule['reducers'][number]['params']>
       >
     >
   ): EventContextInterface<RemoteModule> {
@@ -1292,6 +1307,7 @@ export class DbConnectionImpl<RemoteModule extends UntypedRemoteModule>
    * ```
    */
   disconnect(): void {
+    this.isDisconnectRequested = true;
     this.wsPromise.then(ws => ws?.close());
   }
 

package/src/sdk/event_context.ts

@@ -1,4 +1,4 @@
-import type { InferTypeOfRow } from '../lib/type_builders.ts';
+import type { InferTypeOfParams } from '../lib/type_builders.ts';
 import type { DbContext } from './db_context';
 import type { Event } from './event.ts';
 import type { ReducerEvent } from './reducer_event.ts';
@@ -13,7 +13,7 @@ export interface EventContextInterface<RemoteModule extends UntypedRemoteModule>
   event: Event<
     ReducerEventInfo<
       RemoteModule['reducers'][number]['name'],
-      InferTypeOfRow<RemoteModule['reducers'][number]['params']>
+      InferTypeOfParams<RemoteModule['reducers'][number]['params']>
     >
   >;
 }
@@ -25,7 +25,7 @@ export interface ReducerEventContextInterface<
   event: ReducerEvent<
     ReducerEventInfo<
       RemoteModule['reducers'][number]['name'],
-      InferTypeOfRow<RemoteModule['reducers'][number]['params']>
+      InferTypeOfParams<RemoteModule['reducers'][number]['params']>
     >
   >;
 }

package/src/sdk/procedures.ts

@@ -1,5 +1,9 @@
 import type { ParamsObj } from '../lib/reducers';
-import type { Infer, InferTypeOfRow, TypeBuilder } from '../lib/type_builders';
+import type {
+  Infer,
+  InferTypeOfParams,
+  TypeBuilder,
+} from '../lib/type_builders';
 import type { CamelCase } from '../lib/type_util';
 import { coerceParams, toCamelCase, type CoerceParams } from '../lib/util';
 import type { UntypedRemoteModule } from './spacetime_module';
@@ -20,7 +24,7 @@ export type ProceduresView<RemoteModule> = IfAny<
     ? // x: camelCase(name)
       {
         [K in RemoteModule['procedures'][number] as K['accessorName']]: (
-          params: InferTypeOfRow<K['params']>
+          params: InferTypeOfParams<K['params']>
         ) => Promise<Infer<K['returnType']>>;
       }
     : never

package/src/sdk/reducers.ts

@@ -1,8 +1,7 @@
 import type { ProductType } from '../lib/algebraic_type';
 import type { ReducerSchema } from '../lib/reducer_schema';
 import type { ParamsObj } from '../lib/reducers';
-import type { CoerceRow } from '../lib/table';
-import { RowBuilder, type InferTypeOfRow } from '../lib/type_builders';
+import { RowBuilder, type InferTypeOfParams } from '../lib/type_builders';
 import { toCamelCase } from '../lib/util';
 import type { SubscriptionEventContextInterface } from './event_context';
 import type { UntypedRemoteModule } from './spacetime_module';
@@ -26,7 +25,7 @@ export type ReducersView<RemoteModule> = IfAny<
   RemoteModule extends UntypedRemoteModule
     ? {
         [K in RemoteModule['reducers'][number] as K['accessorName']]: (
-          params: InferTypeOfRow<K['params']>
+          params: InferTypeOfParams<K['params']>
         ) => Promise<void>;
       }
     : never
@@ -43,7 +42,7 @@ export type ReducerEventInfo<
 export type UntypedReducerDef = {
   name: string;
   accessorName: string;
-  params: CoerceRow<ParamsObj>;
+  params: ParamsObj;
   paramsType: ProductType;
 };
 

package/src/sdk/table_cache.ts

@@ -123,7 +123,8 @@ export class TableCacheImpl<
     const columns = idx.columns;
 
     // Extract the tuple key for this btree index (column order preserved)
-    const getKey = (row: Row): readonly unknown[] => columns.map(c => row[c]);
+    const getKey = (row: Row): readonly unknown[] =>
+      columns.map(c => (row as Record<string, unknown>)[c]);
 
     // The server’s ranged scan fixes all prefix cols to equality and applies
     // the bound only to the *last* term. We mirror that.

package/src/sdk/type_utils.ts

@@ -1,4 +1,4 @@
-import type { Infer, InferTypeOfRow } from '.';
+import type { Infer, InferTypeOfParams } from '.';
 import type { Prettify } from '../lib/type_util';
 import type { UntypedProcedureDef } from './procedures';
 import type { UntypedReducerDef } from './reducers';
@@ -7,11 +7,11 @@ export type IsEmptyObject<T> = [keyof T] extends [never] ? true : false;
 export type MaybeParams<T> = IsEmptyObject<T> extends true ? [] : [params: T];
 
 export type ParamsType<R extends UntypedReducerDef> = MaybeParams<
-  Prettify<InferTypeOfRow<R['params']>>
+  Prettify<InferTypeOfParams<R['params']>>
 >;
 
 export type ProcedureParamsType<P extends UntypedProcedureDef> = MaybeParams<
-  Prettify<InferTypeOfRow<P['params']>>
+  Prettify<InferTypeOfParams<P['params']>>
 >;
 
 export type ProcedureReturnType<P extends UntypedProcedureDef> = Infer<

package/src/sdk/websocket_test_adapter.ts

@@ -19,6 +19,7 @@ class WebsocketTestAdapter implements WebSocketAdapter {
   #onclose: (ev: CloseEvent) => void = () => {};
   #onopen: () => void = () => {};
   #onmessage: (msg: { data: Uint8Array }) => void = () => {};
+  #onerror: (msg: ErrorEvent) => void = () => {};
 
   constructor() {
     this.messageQueue = [];
@@ -39,7 +40,13 @@ class WebsocketTestAdapter implements WebSocketAdapter {
     this.#onmessage = handler;
   }
 
-  set onerror(_handler: (msg: ErrorEvent) => void) {}
+  set onerror(handler: (msg: ErrorEvent) => void) {
+    this.#onerror = handler;
+  }
+
+  error(error: Error): void {
+    this.#onerror(error as unknown as ErrorEvent);
+  }
 
   send(message: Uint8Array<ArrayBuffer>): void {
     const rawMessage = message.slice();

package/src/server/views.ts

@@ -327,8 +327,11 @@ type ViewInfo<F> = {
   returnTypeBaseSize: number;
 };
 
-export type Views = ViewInfo<ViewFn<any, any, any>>[];
-export type AnonViews = ViewInfo<AnonymousViewFn<any, any, any>>[];
+type AnyViewFn = (ctx: ViewCtx<any>, params: any) => any;
+type AnyAnonymousViewFn = (ctx: AnonymousViewCtx<any>, params: any) => any;
+
+export type Views = ViewInfo<AnyViewFn>[];
+export type AnonViews = ViewInfo<AnyAnonymousViewFn>[];
 
 // A helper to get the product type out of a type builder.
 // This is only non-never if the type builder is an array.