Implement event tables (server, Rust/TS/C# codegen + client SDKs) (#4217)

## 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

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

---------

Signed-off-by: Tyler Cloutier <cloutiertyler@users.noreply.github.com>
Co-authored-by: Phoebe Goldman <phoebe@goldman-tribe.org>
Co-authored-by: Jason Larabie <jason@clockworklabs.io>
Co-authored-by: joshua-spacetime <josh@clockworklabs.io>

Author: 4 people

Cargo.lock

@@ -49,11 +49,13 @@ members = [
   "modules/sdk-test-connect-disconnect",
   "modules/sdk-test-procedure",
   "modules/sdk-test-view",
+  "modules/sdk-test-event-table",
   "sdks/rust/tests/test-client",
   "sdks/rust/tests/test-counter",
   "sdks/rust/tests/connect_disconnect_client",
   "sdks/rust/tests/procedure-client",
   "sdks/rust/tests/view-client",
+  "sdks/rust/tests/event-table-client",
   "tools/ci",
   "tools/upgrade-version",
   "tools/license-check",

Cargo.toml

@@ -12,9 +12,9 @@
 #include <memory>
 #include "../autogen_base.h"
 #include "spacetimedb/bsatn/bsatn.h"
+#include "RawViewDefV9.g.h"
 #include "RawColumnDefaultValueV9.g.h"
 #include "RawProcedureDefV9.g.h"
-#include "RawViewDefV9.g.h"
 
 namespace SpacetimeDB::Internal {
 

crates/bindings-cpp/include/spacetimedb/internal/autogen/RawMiscModuleExportV9.g.h

@@ -13,11 +13,11 @@
 #include "../autogen_base.h"
 #include "spacetimedb/bsatn/bsatn.h"
 #include "RawMiscModuleExportV9.g.h"
-#include "RawReducerDefV9.g.h"
+#include "RawTypeDefV9.g.h"
 #include "RawTableDefV9.g.h"
-#include "Typespace.g.h"
 #include "RawRowLevelSecurityDefV9.g.h"
-#include "RawTypeDefV9.g.h"
+#include "RawReducerDefV9.g.h"
+#include "Typespace.g.h"
 
 namespace SpacetimeDB::Internal {
 

crates/bindings-cpp/include/spacetimedb/internal/autogen/RawModuleDefV9.g.h

@@ -12,8 +12,8 @@
 #include <memory>
 #include "../autogen_base.h"
 #include "spacetimedb/bsatn/bsatn.h"
-#include "ProductType.g.h"
 #include "AlgebraicType.g.h"
+#include "ProductType.g.h"
 
 namespace SpacetimeDB::Internal {
 

crates/bindings-cpp/include/spacetimedb/internal/autogen/RawProcedureDefV9.g.h

@@ -12,12 +12,12 @@
 #include <memory>
 #include "../autogen_base.h"
 #include "spacetimedb/bsatn/bsatn.h"
-#include "RawScheduleDefV9.g.h"
 #include "TableAccess.g.h"
 #include "RawConstraintDefV9.g.h"
+#include "RawIndexDefV9.g.h"
 #include "TableType.g.h"
 #include "RawSequenceDefV9.g.h"
-#include "RawIndexDefV9.g.h"
+#include "RawScheduleDefV9.g.h"
 
 namespace SpacetimeDB::Internal {
 

crates/bindings-cpp/include/spacetimedb/internal/autogen/RawTableDefV9.g.h

@@ -61,6 +61,7 @@ mod sym {
     symbol!(unique);
     symbol!(update);
     symbol!(default);
+    symbol!(event);
 
     symbol!(u8);
     symbol!(i8);

crates/bindings-macro/src/lib.rs

@@ -19,6 +19,7 @@ pub(crate) struct TableArgs {
     scheduled: Option<ScheduledArg>,
     name: Ident,
     indices: Vec<IndexArg>,
+    event: Option<Span>,
 }
 
 enum TableAccess {
@@ -71,6 +72,7 @@ impl TableArgs {
         let mut scheduled = None;
         let mut name = None;
         let mut indices = Vec::new();
+        let mut event = None;
         syn::meta::parser(|meta| {
             match_meta!(match meta {
                 sym::public => {
@@ -91,6 +93,10 @@ impl TableArgs {
                     check_duplicate(&scheduled, &meta)?;
                     scheduled = Some(ScheduledArg::parse_meta(meta)?);
                 }
+                sym::event => {
+                    check_duplicate(&event, &meta)?;
+                    event = Some(meta.path.span());
+                }
             });
             Ok(())
         })
@@ -107,6 +113,7 @@ impl TableArgs {
             scheduled,
             name,
             indices,
+            event,
         })
     }
 }
@@ -852,6 +859,18 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
     );
 
     let table_access = args.access.iter().map(|acc| acc.to_value());
+    let is_event = args.event.iter().map(|_| {
+        quote!(
+            const IS_EVENT: bool = true;
+        )
+    });
+    let can_be_lookup_impl = if args.event.is_none() {
+        quote! {
+            impl spacetimedb::query_builder::CanBeLookupTable for #original_struct_ident {}
+        }
+    } else {
+        quote! {}
+    };
     let unique_col_ids = unique_columns.iter().map(|col| col.index);
     let primary_col_id = primary_key_column.clone().into_iter().map(|col| col.index);
     let sequence_col_ids = sequenced_columns.iter().map(|col| col.index);
@@ -977,6 +996,7 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
             const TABLE_NAME: &'static str = #table_name;
             // the default value if not specified is Private
             #(const TABLE_ACCESS: spacetimedb::table::TableAccess = #table_access;)*
+            #(#is_event)*
             const UNIQUE_COLUMNS: &'static [u16] = &[#(#unique_col_ids),*];
             const INDEXES: &'static [spacetimedb::table::IndexDesc<'static>] = &[#(#index_descs),*];
             #(const PRIMARY_KEY: Option<u16> = Some(#primary_col_id);)*
@@ -1088,6 +1108,8 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
             }
         }
 
+        #can_be_lookup_impl
+
     };
 
     let table_query_handle_def = quote! {

crates/bindings-macro/src/table.rs

@@ -117,6 +117,7 @@ export function tableToSchema<
       };
     }) as T['idxs'],
     tableDef,
+    ...(tableDef.isEvent ? { isEvent: true } : {}),
   };
 }
 

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

@@ -117,6 +117,7 @@ export type UntypedTableDef = {
   indexes: readonly IndexOpts<any>[];
   constraints: readonly ConstraintOpts<any>[];
   tableDef: Infer<typeof RawTableDefV10>;
+  isEvent?: boolean;
 };
 
 /**
@@ -179,6 +180,7 @@ export type TableOpts<Row extends RowObj> = {
         { [k: string]: RowBuilder<RowObj> },
         ReturnType<typeof t.unit>
       >;
+  event?: boolean;
 };
 
 /**
@@ -301,6 +303,7 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
     public: isPublic = false,
     indexes: userIndexes = [],
     scheduled,
+    event: isEvent = false,
   } = opts;
 
   // 1. column catalogue + helpers
@@ -476,7 +479,7 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
         tableType: { tag: 'User' },
         tableAccess: { tag: isPublic ? 'Public' : 'Private' },
         defaultValues,
-        isEvent: false,
+        isEvent,
       };
     },
     idxs: {} as OptsIndices<Opts>,