Put the Svelte binding on ConnectionManager; add reconnect() for token swaps

# Description of Changes

A Svelte app that lets a user start anonymous and then sign in (e.g. via Google)
has no clean way to apply the new token. The Svelte provider holds its
connection in a module-level singleton that's reused across remounts, so even a
`{#key}` swap keeps the old token, and there's no reconnect path — the only
thing that actually works is a hard `window.location.reload()`, which throws
away all client state and flickers the UI on every sign-in / sign-out. The
Svelte binding also lacks the auto-reconnect that the React and Solid bindings
already have, so a dropped socket just stays dropped.

This rebuilds `createSpacetimeDBProvider` on top of the shared
`ConnectionManager` — the same pool React and Solid already use — and surfaces a
`reconnect(builder)` method on the context value, closing both gaps at once:

- The connection is owned by `ConnectionManager`, keyed by uri + database name.
  Its reference counting and deferred release absorb rapid mount/unmount cycles
  (HMR, `{#key}`), replacing the bespoke singleton, and the binding gets the
  manager's exponential-backoff auto-reconnect on unexpected drops for free.
- `ConnectionState` gains `reconnect(builder)` (backed by the new
  `ConnectionManager.rebuild`): tears down the current connection and reconnects
  with a fresh builder carrying a new token, no page reload. `useTable` /
  `useReducer` already react to the connection store, so subscriptions re-bind
  to the new connection automatically.
- `getConnection` is now non-generic (`DbConnectionImpl<any> | null`), matching
  the React and Solid `ConnectionState`, so the bindings line up.

`useTable`, `useReducer` and `useSpacetimeDB` are unchanged.

Motivated by #5373; hangs off the reconnect tracking issue #1936.

# API and ABI breaking changes

Minor, TypeScript-only: `ConnectionState.getConnection` is no longer generic —
it returns `DbConnectionImpl<any> | null`, as the React and Solid bindings
already do. Call sites that wrote `getConnection<MyConn>()` lose the type
argument; `getConnection()` is unchanged. The provider's return type stays
`Writable<ConnectionState>`.

# Expected complexity level and risk

2. Low. The Svelte provider is now a thin adapter: it mirrors the manager's
store into a Svelte store and wires up `getConnection` / `reconnect` / `retain`
/ `release`. The connection-lifecycle logic that used to be bespoke here — the
module-level singleton, deferred cleanup, and reconnect — now lives in the
well-tested, shared `ConnectionManager` that the React and Solid bindings
already depend on.

# Testing

- [x] `tsc -p tsconfig.build.json` typechecks; `build:js` emits the Svelte
  ESM/CJS + browser bundles cleanly; eslint + prettier clean.
- [x] Full vitest suite green (225 tests), including the new `rebuild()` unit
  tests from the previous commit.
- [ ] Reviewer: this package has no Svelte component-test harness today (the
  pre-existing Svelte binding had none), so the provider wiring is covered
  indirectly through the `ConnectionManager` unit tests. Worth a manual smoke
  test of an anonymous -> signed-in `reconnect(builder)` flow, and a call on
  whether to add @testing-library/svelte coverage here.

Author: krisajenkins

crates/bindings-typescript/src/svelte/SpacetimeDBProvider.ts

@@ -3,99 +3,75 @@ import { writable, type Writable } from 'svelte/store';
 import {
   DbConnectionBuilder,
   type DbConnectionImpl,
-  type ErrorContextInterface,
-  type RemoteModuleOf,
 } from '../sdk/db_connection_impl';
 import { ConnectionId } from '../lib/connection_id';
+import {
+  ConnectionManager,
+  type ConnectionState as ManagerConnectionState,
+} from '../sdk/connection_manager';
 import {
   SPACETIMEDB_CONTEXT_KEY,
   type ConnectionState,
 } from './connection_state';
 
-let connRef: DbConnectionImpl<any> | null = null;
-let cleanupTimeoutId: ReturnType<typeof setTimeout> | null = null;
-
+/**
+ * Establish a SpacetimeDB connection for the current component subtree and make
+ * it available to `useSpacetimeDB`, `useTable` and `useReducer`.
+ *
+ * The connection is owned by the shared `ConnectionManager` (the same pool the
+ * React and Solid bindings use), keyed by uri + database name. The manager's
+ * reference counting and deferred cleanup absorb rapid mount/unmount cycles
+ * (HMR, `{#key}` blocks), and it reconnects automatically with exponential
+ * backoff if the socket drops unexpectedly.
+ *
+ * To swap the connection's auth token without reloading the page (e.g. after a
+ * sign-in), call `reconnect(builder)` from the context value with a builder
+ * carrying the new token.
+ */
 export function createSpacetimeDBProvider<
   DbConnection extends DbConnectionImpl<any>,
 >(
   connectionBuilder: DbConnectionBuilder<DbConnection>
 ): Writable<ConnectionState> {
-  const getConnection = () => connRef as DbConnection | null;
+  const key = ConnectionManager.getKey(
+    connectionBuilder.getUri(),
+    connectionBuilder.getModuleName()
+  );
 
-  const store = writable<ConnectionState>({
+  const fallback: ManagerConnectionState = {
     isActive: false,
     identity: undefined,
     token: undefined,
     connectionId: ConnectionId.random(),
     connectionError: undefined,
-    getConnection: getConnection as ConnectionState['getConnection'],
-  });
-
-  if (cleanupTimeoutId) {
-    clearTimeout(cleanupTimeoutId);
-    cleanupTimeoutId = null;
-  }
-
-  if (!connRef) {
-    connRef = connectionBuilder.build();
-  }
-
-  const onConnect = (conn: DbConnection) => {
-    store.update(s => ({
-      ...s,
-      isActive: conn.isActive,
-      identity: conn.identity,
-      token: conn.token,
-      connectionId: conn.connectionId,
-    }));
   };
 
-  const onDisconnect = (
-    ctx: ErrorContextInterface<RemoteModuleOf<DbConnection>>
-  ) => {
-    store.update(s => ({
-      ...s,
-      isActive: ctx.isActive,
-    }));
+  const getConnection = () =>
+    ConnectionManager.getConnection<DbConnection>(key);
+  const reconnect = (builder: DbConnectionBuilder<DbConnection>): void => {
+    ConnectionManager.rebuild(key, builder);
   };
 
-  const onConnectError = (
-    ctx: ErrorContextInterface<RemoteModuleOf<DbConnection>>,
-    err: Error
-  ) => {
-    store.update(s => ({
-      ...s,
-      isActive: ctx.isActive,
-      connectionError: err,
-    }));
-  };
-
-  connectionBuilder.onConnect(onConnect);
-  connectionBuilder.onDisconnect(onDisconnect);
-  connectionBuilder.onConnectError(onConnectError);
-
-  const conn = connRef;
-  store.update(s => ({
-    ...s,
-    isActive: conn.isActive,
-    identity: conn.identity,
-    token: conn.token,
-    connectionId: conn.connectionId,
-  }));
+  const snapshot = (): ConnectionState => ({
+    ...(ConnectionManager.getSnapshot(key) ?? fallback),
+    getConnection,
+    reconnect,
+  });
 
-  setContext(SPACETIMEDB_CONTEXT_KEY, store);
+  // Retain for this provider's lifetime, then mirror the manager's external
+  // store into a Svelte store. `getConnection` / `reconnect` are stable across
+  // updates; only the plain state fields change.
+  ConnectionManager.retain(key, connectionBuilder);
+  const store = writable<ConnectionState>(snapshot());
+  const unsubscribe = ConnectionManager.subscribe(key, () =>
+    store.set(snapshot())
+  );
 
   onDestroy(() => {
-    connRef?.removeOnConnect(onConnect as any);
-    connRef?.removeOnDisconnect(onDisconnect as any);
-    connRef?.removeOnConnectError(onConnectError as any);
-
-    cleanupTimeoutId = setTimeout(() => {
-      connRef?.disconnect();
-      connRef = null;
-      cleanupTimeoutId = null;
-    }, 0);
+    unsubscribe();
+    ConnectionManager.release(key);
   });
 
+  setContext(SPACETIMEDB_CONTEXT_KEY, store);
   return store;
 }

crates/bindings-typescript/src/svelte/connection_state.ts

@@ -1,16 +1,20 @@
-import type { ConnectionId } from '../lib/connection_id';
-import type { Identity } from '../lib/identity';
-import type { DbConnectionImpl } from '../sdk/db_connection_impl';
-
-export type ConnectionState = {
-  isActive: boolean;
-  identity?: Identity;
-  token?: string;
-  connectionId: ConnectionId;
-  connectionError?: Error;
-  getConnection<
-    DbConnection extends DbConnectionImpl<any>,
-  >(): DbConnection | null;
-};
+import type {
+  DbConnectionBuilder,
+  DbConnectionImpl,
+} from '../sdk/db_connection_impl';
+import type { ConnectionState as ManagerConnectionState } from '../sdk/connection_manager';
 
 export const SPACETIMEDB_CONTEXT_KEY = Symbol('spacetimedb');
+
+export type ConnectionState = ManagerConnectionState & {
+  /** The live connection, or `null` before it is first established. */
+  getConnection(): DbConnectionImpl<any> | null;
+  /**
+   * Tear down the current connection and reconnect using a fresh builder —
+   * typically to apply a new auth token after sign-in or sign-out. The builder
+   * should carry the new token and the same uri + database name. Table and
+   * reducer subscriptions re-bind automatically once the new connection is
+   * live, so there is no need to reload the page to swap a token.
+   */
+  reconnect(builder: DbConnectionBuilder<any>): void;
+};