Bradley/stackbench test

.gitattributes

@@ -2,3 +2,5 @@
 **/ModuleBindings/** linguist-generated=true eol=lf
 /docs/llms/** linguist-generated=true
 /docs/llms/*-details.json linguist-generated=false
+/tools/stack-bench/** text eol=lf
+/tools/stack-bench/**/*.woff2 -text -diff

codex-plugin/plugins/spacetimedb/skills/typescript-client/SKILL.md

@@ -18,7 +18,7 @@ Generated bindings convert snake_case names to camelCase, including row fields:
 ## React: main.tsx
 
 ```typescript
-import React, { useEffect, useMemo } from 'react';
+import React, { useMemo } from 'react';
 import ReactDOM from 'react-dom/client';
 import { SpacetimeDBProvider } from 'spacetimedb/react';
 import { DbConnection } from './module_bindings';
@@ -30,6 +30,7 @@ function Root() {
     DbConnection.builder()
       .withUri(SPACETIMEDB_URI)
       .withDatabaseName(MODULE_NAME)
+      // Reuse the token issued on the previous connection.
       .withToken(localStorage.getItem('auth_token') || undefined),
     []
   );
@@ -46,14 +47,15 @@ ReactDOM.createRoot(document.getElementById('root')!).render(<Root />);
 ## React: App.tsx
 
 ```typescript
+import { useEffect } from 'react';
 import { useTable, useSpacetimeDB } from 'spacetimedb/react';
 import { DbConnection, tables } from './module_bindings';
 
 function App() {
   const { isActive, identity: myIdentity, token, getConnection } = useSpacetimeDB();
   const conn = getConnection() as DbConnection | null;
 
-  // Save auth token
+  // Persist the issued token for the next page load.
   useEffect(() => { if (token) localStorage.setItem('auth_token', token); }, [token]);
 
   // Subscribe when connected. Prefer typed query builders over raw SQL

codex-plugin/plugins/spacetimedb/skills/typescript-server/SKILL.md

@@ -98,6 +98,10 @@ Every column is a `t` builder value:
 
 Modifiers: `.primaryKey()`, `.autoInc()`, `.unique()`, `.index('btree')`, `.default(value)`.
 
+`.primaryKey()` and `.unique()` apply to one column. For uniqueness across
+multiple columns, use a surrogate key, the multi-column index below, and a
+reducer that rejects an existing index match before inserting.
+
 Use `.default(value)` only for a newly appended migration-safe field. Do not put defaults on primary-key, unique, or auto-increment columns.
 
 Optional columns: `nickname: t.option(t.string())`
@@ -130,7 +134,9 @@ export { default } from './schema';   // re-export the schema for the module ent
 
 ## Reducers
 
-Reducers are created with `spacetimedb.reducer(...)`; the export name becomes the reducer name:
+Reducers are created with `spacetimedb.reducer(...)`. An exported `signUp`
+becomes `signUp` in generated clients and `sign_up` in `spacetime call` and
+`describe`:
 
 ```typescript
 export const createEntity = spacetimedb.reducer(
@@ -278,17 +284,30 @@ const Shape = t.enum('Shape', {
 A client subscribing to a view receives only the rows it returns. Use a per-user view
 (keyed on `ctx.sender`) for per-viewer access control: deleting a row it depends on
 (e.g. a membership row) automatically drops the rows it was exposing from that client.
+Use index accessors in views. Do not scan a whole table with `.iter()` when an
+indexed lookup can select the required rows.
 
 `t.row(...)` and `t.object(...)` return schema builders, not TypeScript runtime row types. Let a view callback infer its result, or annotate a separately declared structural type such as `Array<{ sku: bigint; label: string }>`. A named output type must not reuse the generated PascalCase name of its view accessor (for example, reserve `DiscountedProduct` for a `discounted_product` view).
 
+A view context is `ViewCtx<S>` (and `AnonymousViewCtx<S>`), both exported from
+`spacetimedb/server`. It carries `sender`, a read-only `db`, and `from`; it is
+not a `ReducerCtx`, so a helper shared between a reducer and a view must accept
+either:
+
+```typescript
+import type { ReducerCtx, ViewCtx, InferSchema } from 'spacetimedb/server';
+type S = InferSchema<typeof spacetimedb>;
+function stockOf(ctx: ReducerCtx<S> | ViewCtx<S>, itemId: bigint) { ... }
+```
+
 Both `spacetimedb.view(...)` and `spacetimedb.anonymousView(...)` take three arguments: view options, the declared return schema, and the callback.
 
 ```typescript
 // Anonymous view (same for all clients):
 export const activeUsers = spacetimedb.anonymousView(
   { name: 'active_users', public: true },
   t.array(entity.rowType),
-  (ctx) => [...ctx.db.entity.iter()].filter(e => e.active)
+  (ctx) => [...ctx.db.entity.active.filter(true)]        // active: t.bool().index('btree')
 );
 
 // Per-user view (varies by ctx.sender):

crates/bindings-typescript/src/lib/query.ts

@@ -248,19 +248,21 @@ export type NamespacedQueryBuilder<SchemaDef extends UntypedSchemaDef> =
  * A runtime reference to a table. This materializes the RowExpr for us.
  * TODO: Maybe add the full SchemaDef to the type signature depending on how joins will work.
  */
-export type TableRef<TableDef extends TypedTableDef> = Readonly<{
-  type: 'table';
-  sourceName: TableDef['sourceName'];
-  accessorName: string;
-  cols: RowExpr<TableDef>;
-  indexedCols: IndexedRowExpr<TableDef>;
-  tableDef: TableDef;
+// Keep this named so TypeScript diagnostics show `TableRef` instead of its
+// expanded structure.
+export interface TableRef<TableDef extends TypedTableDef> {
+  readonly type: 'table';
+  readonly sourceName: TableDef['sourceName'];
+  readonly accessorName: string;
+  readonly cols: RowExpr<TableDef>;
+  readonly indexedCols: IndexedRowExpr<TableDef>;
+  readonly tableDef: TableDef;
   // Delegated UntypedTableDef properties for compatibility.
-  columns: TableDef['columns'];
-  indexes: TableDef['indexes'];
-  rowType: TableDef['rowType'];
-  constraints: any;
-}>;
+  readonly columns: TableDef['columns'];
+  readonly indexes: TableDef['indexes'];
+  readonly rowType: TableDef['rowType'];
+  readonly constraints: any;
+}
 
 class TableRefImpl<TableDef extends TypedTableDef>
   implements TableRef<TableDef>, From<TableDef>

crates/bindings-typescript/src/sdk/connection_manager.ts

@@ -145,9 +145,7 @@ class ConnectionManagerImpl {
         clearTimeout(managed.reconnectTimer);
         managed.reconnectTimer = null;
         managed.reconnectAttempt = 0;
-        if (managed.builder) {
-          this.#buildManagedConnection(managed, managed.builder);
-        }
+        this.#reconnectManagedConnection(managed);
         continue;
       }
 
@@ -179,9 +177,7 @@ class ConnectionManagerImpl {
     connection.disconnect();
     this.#updateState(managed, { isActive: false });
     managed.reconnectAttempt = 0;
-    if (managed.builder) {
-      this.#buildManagedConnection(managed, managed.builder);
-    }
+    this.#reconnectManagedConnection(managed);
   }
 
   /** Generates a unique key for a connection based on URI and module name. */
@@ -294,6 +290,14 @@ class ConnectionManagerImpl {
     }
   }
 
+  /** Reconnect with the issued token. Explicit rebuilds use the caller's token. */
+  #reconnectManagedConnection(managed: ManagedConnection): void {
+    if (!managed.builder) return;
+    const token = managed.state.token;
+    if (token) managed.builder.withToken(token);
+    this.#buildManagedConnection(managed, managed.builder);
+  }
+
   #buildManagedConnection<T extends DbConnectionImpl<any>>(
     managed: ManagedConnection,
     builder: DbConnectionBuilder<T>
@@ -349,7 +353,7 @@ class ConnectionManagerImpl {
         return;
       }
 
-      this.#buildManagedConnection(managed, managed.builder);
+      this.#reconnectManagedConnection(managed);
     }, delay);
   }
 

crates/bindings-typescript/tests/connection_manager_liveness.test.ts

@@ -12,7 +12,7 @@ type ErrorContextInterface = { isActive: boolean };
 class MockConnection {
   isActive = false;
   identity = undefined;
-  token = undefined;
+  token: string | undefined;
   connectionId = ConnectionId.random();
   isDisconnectRequested = false;
   disconnected = false;
@@ -28,6 +28,10 @@ class MockConnection {
     (ctx: ErrorContextInterface, error: Error) => void
   >();
 
+  constructor(private readonly issuedToken?: string) {
+    this.token = undefined;
+  }
+
   get isSocketClosed(): boolean {
     return this.socketClosed;
   }
@@ -63,6 +67,7 @@ class MockConnection {
 
   simulateConnect(): void {
     this.isActive = true;
+    this.token = this.issuedToken;
     for (const cb of this.#onConnect) cb(this);
   }
   simulateDisconnect(error?: Error): void {
@@ -74,7 +79,9 @@ class MockConnection {
 
 class MockBuilder {
   buildCount = 0;
+  presentedTokens: Array<string | undefined> = [];
   connections: MockConnection[] = [];
+  #token: string | undefined;
 
   #onConnect = new Set<(conn: MockConnection) => void>();
   #onDisconnect = new Set<
@@ -84,9 +91,17 @@ class MockBuilder {
     (ctx: ErrorContextInterface, error: Error) => void
   >();
 
+  constructor(private readonly issuedToken?: string) {}
+
+  withToken(token?: string): MockBuilder {
+    this.#token = token;
+    return this;
+  }
+
   build(): MockConnection {
-    const connection = new MockConnection();
+    const connection = new MockConnection(this.issuedToken);
     this.buildCount += 1;
+    this.presentedTokens.push(this.#token);
     this.connections.push(connection);
     for (const cb of this.#onConnect) connection.register('connect', cb);
     for (const cb of this.#onDisconnect) connection.register('disconnect', cb);
@@ -201,6 +216,32 @@ describe('ConnectionManager liveness recovery', () => {
     ConnectionManager.release(key);
   });
 
+  test('reuses the issued token when reviving a dead socket', () => {
+    const key = nextKey();
+    const builder = new MockBuilder('issued-token');
+    const first = retain(key, builder);
+    expect(builder.presentedTokens).toEqual([undefined]);
+
+    first.simulateConnect();
+    first.socketClosed = true;
+    fire('win:online');
+
+    expect(builder.presentedTokens).toEqual([undefined, 'issued-token']);
+    ConnectionManager.release(key);
+  });
+
+  test('an explicit rebuild uses the caller token', () => {
+    const key = nextKey();
+    const firstBuilder = new MockBuilder('issued-token');
+    retain(key, firstBuilder).simulateConnect();
+
+    const replacement = new MockBuilder().withToken('caller-token');
+    ConnectionManager.rebuild(key, replacement as any);
+
+    expect(replacement.presentedTokens).toEqual(['caller-token']);
+    ConnectionManager.release(key);
+  });
+
   test('does not rebuild a healthy connection on resume', () => {
     const key = nextKey();
     const builder = new MockBuilder();

crates/bindings-typescript/tests/table_ref_error_message.test.ts

@@ -0,0 +1,79 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+
+const bindingsRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..'
+);
+
+function runTypecheck(source: string) {
+  const tmpDir = mkdtempSync(path.join(tmpdir(), 'stdb-tableref-diag-'));
+  const reproPath = path.join(tmpDir, 'repro.ts');
+  writeFileSync(reproPath, source);
+
+  try {
+    const options: ts.CompilerOptions = {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      strict: true,
+      noEmit: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      allowImportingTsExtensions: true,
+      noImplicitAny: true,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      useDefineForClassFields: true,
+      verbatimModuleSyntax: true,
+      isolatedModules: true,
+    };
+
+    const host = ts.createCompilerHost(options);
+    const program = ts.createProgram(
+      [reproPath, path.join(bindingsRoot, 'src/server/sys.d.ts')],
+      options,
+      host
+    );
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+    return diagnostics.map(d =>
+      ts.flattenDiagnosticMessageText(d.messageText, '\n')
+    );
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+describe('TableRef diagnostics', () => {
+  const source = `
+import { t } from ${JSON.stringify(path.join(bindingsRoot, 'src/server/index.ts'))};
+import { table } from ${JSON.stringify(path.join(bindingsRoot, 'src/lib/table.ts'))};
+import { createTableRefFromDef } from ${JSON.stringify(path.join(bindingsRoot, 'src/lib/query.ts'))};
+import type { AllUnique } from ${JSON.stringify(path.join(bindingsRoot, 'src/lib/constraints.ts'))};
+
+const cartItem = table(
+  { name: 'cart_item' },
+  { id: t.u64().primaryKey().autoInc(), accountId: t.u64(), quantity: t.u32() }
+);
+
+const ref = createTableRefFromDef(cartItem as any, 'cartItem');
+type Boom = AllUnique<typeof ref, ['accountId']>;
+declare const b: Boom;
+`;
+
+  it('names the type instead of dumping its structure', () => {
+    const messages = runTypecheck(source);
+    const constraintError = messages.find(m =>
+      m.includes("does not satisfy the constraint 'UntypedTableDef'")
+    );
+
+    expect(constraintError).toBeDefined();
+    // The name, not the shape.
+    expect(constraintError).toContain('TableRef<');
+    expect(constraintError).not.toContain('type: "table"');
+    expect(constraintError).not.toContain('accessorName');
+    expect(constraintError.length).toBeLessThan(250);
+  }, 15000);
+});

crates/cli/build.rs

@@ -110,6 +110,7 @@ fn generate_template_files() {
 
     // Embed skill files from skills/*/SKILL.md
     let skills_dir = repo_root.join("skills");
+    println!("cargo:rerun-if-changed={}", skills_dir.display());
     let skill_names = discover_skill_names(&skills_dir);
 
     generated_code.push_str("pub fn get_skill(name: &str) -> Option<&'static str> {\n");

crates/cli/src/subcommands/dev.rs

@@ -738,7 +738,7 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), anyhow::E
     let loaded_config_dir = loaded_config.as_ref().map(|lc| lc.config_dir.clone());
 
     generate_build_and_publish(
-        &config,
+        &mut config,
         &project_dir,
         loaded_config_dir.as_deref(),
         &spacetimedb_dir,
@@ -853,7 +853,7 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), anyhow::E
 
                 println!("\n{}", "File change detected, rebuilding...".yellow());
                 match generate_build_and_publish(
-                    &config,
+                    &mut config,
                     &project_dir,
                     loaded_config_dir.as_deref(),
                     &spacetimedb_dir,
@@ -1000,7 +1000,7 @@ fn upsert_env_db_names_and_hosts(env_path: &Path, server_host_url: &str, databas
 
 #[allow(clippy::too_many_arguments)]
 async fn generate_build_and_publish(
-    config: &Config,
+    config: &mut Config,
     project_dir: &Path,
     config_dir: Option<&Path>,
     spacetimedb_dir: &Path,
@@ -1146,7 +1146,8 @@ async fn generate_build_and_publish(
             publish_entry.insert("break-clients".to_string(), json!(true));
         }
 
-        publish::exec_from_entry(config.clone(), publish_entry, config_dir, clear_database, yes).await?;
+        // Preserve a token created during publish for logs and later rebuilds.
+        publish::exec_from_entry(config, publish_entry, config_dir, clear_database, yes).await?;
     }
 
     println!("{}", "Published successfully!".green().bold());