Summary

Implements event tables end-to-end: server datastore, module bindings (Rust/TypeScript/C#), client codegen (Rust/TypeScript/C#), client SDKs (Rust/TypeScript/C#), and integration tests.

Event tables are tables whose rows are ephemeral — they persist to the commitlog and are delivered to V2 subscribers, but are NOT merged into committed state. Rows are only visible within the transaction that inserted them. This is the mechanism that replaces reducer event callbacks in 2.0.

What's included

Server

• is_event flag on RawTableDefV10, TableDef, TableSchema
• Event table rows recorded in TxData but skipped during committed state merge
• Commitlog replay treats event table inserts as no-ops
• Migration validation rejects changing is_event between module versions
• SELECT * FROM * excludes event tables
• V1 WebSocket subscriptions to event tables rejected with upgrade message
• V2 subscription path delivers event table rows correctly
• CanBeLookupTable trait — event tables cannot be lookup tables in semijoins
• Runtime view validation rejects event tables

Module bindings

• Rust: #[spacetimedb::table(name = my_events, public, event)]
• TypeScript: table({ event: true }, ...)
• C#: [Table(Event = true)]

Client codegen (crates/codegen/)

• Rust: Generates EventTable impl (insert-only) for event tables, Table impl for normal tables. CanBeLookupTable emitted for non-event tables.
• TypeScript: Emits event: true in generated table schemas. ClientTableCore type excludes onDelete/onUpdate for event tables via conditional types.
• C#: Generates classes inheriting from RemoteEventTableHandle (which hides OnDelete/OnBeforeDelete/OnUpdate) for event tables.

Client SDKs

• Rust: EventTable trait with insert-only callbacks, client cache bypass, count() returns 0, iter() returns empty
• TypeScript: Event table cache bypass in table_cache.ts — fires onInsert callbacks but doesn't store rows. Type-level narrowing excludes delete/update methods.
• C#: RemoteEventTableHandle base class hides delete/update events. Parse/Apply/PostApply handle EventTableRows wire format, skip cache storage, fire only OnInsert.

Tests

• 9 datastore unit tests (insert/delete/update semantics, replay, constraints, indexes, auto-inc, cross-tx reset)
• 3 Rust SDK integration tests (basic events, multiple events per reducer, no persistence across transactions)
• Codegen snapshot tests (Rust, TypeScript, C#)
• Trybuild compile tests (event tables rejected as semijoin lookup tables)

Deferred

• on_delete codegen for event tables (server only sends inserts; client synthesis deferred)
• Event tables in subscription joins / views (well-defined but restricted for now)
• C++ SDK support
• RLS integration test

API and ABI breaking changes

• is_event: bool added to RawTableDefV10 (appended, defaults to false — existing modules unaffected)
• CanBeLookupTable trait bound on semijoin methods in query builder (all non-event tables implement it, so existing code compiles unchanged)
• RemoteEventTableHandle added to C# SDK (new base class for generated event table handles)

Expected complexity level and risk

3 — Changes touch the schema pipeline end-to-end and all three client SDKs, but each individual change is straightforward. The core risk area is the committed state merge skip in committed_state.rs. Client SDK changes are additive (new code paths for event tables, existing paths unchanged).

Testing

• cargo clippy --workspace --tests --benches passes
• cargo test -p spacetimedb-codegen (snapshot tests)
• cargo test -p spacetimedb-datastore --features spacetimedb-schema/test -- event_table (9 unit tests)
• pnpm format passes
• Rust SDK integration tests pass (event_table_tests module)