diff --git a/.gitignore b/.gitignore
index 32bf1df4385..2c3b68ea18b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -224,5 +224,9 @@ new.json
 # Temporary templates dir for CLI's init command
 /crates/cli/.templates
 
+# C++ build data
+modules/benchmarks-cpp/build/
+modules/module-test-cpp/build/
+
 # Symlinked output from `nix build`
 result
diff --git a/crates/bindings-cpp/.gitignore b/crates/bindings-cpp/.gitignore
new file mode 100644
index 00000000000..a5309e6b906
--- /dev/null
+++ b/crates/bindings-cpp/.gitignore
@@ -0,0 +1 @@
+build*/
diff --git a/crates/bindings-cpp/ARCHITECTURE.md b/crates/bindings-cpp/ARCHITECTURE.md
new file mode 100644
index 00000000000..bbc84d0b7c3
--- /dev/null
+++ b/crates/bindings-cpp/ARCHITECTURE.md
@@ -0,0 +1,483 @@
+# SpacetimeDB C++ SDK Architecture
+
+## Overview
+
+The SpacetimeDB C++ SDK provides a sophisticated compile-time/runtime hybrid system for building database modules in C++ that compile to WebAssembly (WASM) and run inside the SpacetimeDB database. This document describes the architectural components, type registration flow, and key differences from other language SDKs.
+
+## Core Architecture Principles
+
+### 1. Hybrid Compile-Time/Runtime System
+- **Compile-time validation**: C++20 concepts and static assertions catch constraint violations before compilation
+- **Runtime registration**: __preinit__ functions execute during WASM module load to register types and metadata
+- **Nominal type system**: Types identified by their declared names, not structural analysis
+- **Error detection**: Multi-layer validation system from compile-time through module publishing
+
+### 2. Priority-Ordered Initialization System
+The SDK uses a numbered __preinit__ function system to ensure correct initialization order:
+
+```
+__preinit__01_ - Clear global state (first)
+__preinit__10_ - Field registration
+__preinit__19_ - Auto-increment integration registration  
+__preinit__20_ - Table and lifecycle reducer registration
+__preinit__21_ - Field constraints
+__preinit__25_ - Row level security filters
+__preinit__30_ - User reducers
+__preinit__99_ - Type validation and error detection (last)
+```
+
+## Detailed Type Registration Flow
+
+### Phase 1: Compile-Time Validation
+
+**Location**: Template instantiation during compilation
+
+**Components**:
+- **C++20 Concepts** (`filterable_value_concept.h`, `table_with_constraints.h`):
+  ```cpp
+  template<typename T>
+  concept FilterableValue = 
+      std::integral<T> ||
+      std::same_as<T, std::string> ||
+      std::same_as<T, Identity> ||
+      // ... other filterable types
+  
+  template<typename T>
+  concept AutoIncrementable = 
+      std::same_as<T, int8_t> ||
+      std::same_as<T, uint32_t> ||
+      // ... integer types only
+  ```
+
+- **Static Assertions** in FIELD_ macros:
+  ```cpp
+  #define FIELD_Unique(table_name, field_name) \
+      static_assert([]() constexpr { \
+          using FieldType = decltype(std::declval<TableType>().field_name); \
+          static_assert(FilterableValue<FieldType>, \
+              "Field cannot have Unique constraint - type is not filterable."); \
+          return true; \
+      }(), "Constraint validation for " #table_name "." #field_name);
+  ```
+
+**Validation Coverage**:
+- ✅ AutoIncrement constraints (only integer types)
+- ✅ Index/Unique/PrimaryKey constraints (only filterable types)
+- ✅ Type compatibility with BSATN serialization
+- ✅ Template parameter validation
+
+**Error Output**: Clear compile-time error messages with specific guidance
+
+### Phase 2: Runtime Registration (__preinit__ functions)
+
+**Location**: WASM module load, before any user code executes
+
+#### 2.1 Global State Initialization (__preinit__01_)
+```cpp
+extern "C" __attribute__((export_name("__preinit__01_clear_global_state")))
+void __preinit__01_clear_global_state() {
+    ClearV9Module();  // Reset module definition
+    getV9TypeRegistration().clear();  // Reset type registry
+}
+```
+
+#### 2.2 Component Registration (__preinit__10-30_)
+Generated by macros during preprocessing:
+
+**Table Registration** (__preinit__20_):
+```cpp
+SPACETIMEDB_TABLE(User, users, Public)
+// Generates:
+extern "C" __attribute__((export_name("__preinit__20_register_table_User_line_42")))
+void __preinit__20_register_table_User_line_42() {
+    SpacetimeDb::Module::RegisterTable<User>("users", true);
+}
+```
+
+**Field Constraints** (__preinit__21_):
+```cpp
+FIELD_PrimaryKey(users, id);
+// Generates:
+extern "C" __attribute__((export_name("__preinit__21_field_constraint_users_id_line_43")))
+void __preinit__21_field_constraint_users_id_line_43() {
+    getV9Builder().AddFieldConstraint<User>("users", "id", FieldConstraint::PrimaryKey);
+}
+```
+
+**Auto-Increment Integration Registration** (__preinit__19_):
+Auto-increment fields require special handling during `insert()` operations. When SpacetimeDB processes an auto-increment insert, it returns only the generated column values (not the full row) in BSATN format. The C++ SDK uses a registry-based integration system to properly handle these generated values and update the user's row object.
+
+```cpp
+FIELD_PrimaryKeyAutoInc(users, id);
+// Generates both constraint registration AND auto-increment integration:
+
+// 1. Auto-increment integration function (unique per field via __LINE__)
+namespace SpacetimeDb { namespace detail {
+    static void autoinc_integrate_47(User& row, SpacetimeDb::bsatn::Reader& reader) {
+        using FieldType = decltype(std::declval<User>().id);
+        FieldType generated_value = SpacetimeDb::bsatn::deserialize<FieldType>(reader);
+        row.id = generated_value;  // Update field with generated ID
+    }
+}}
+
+// 2. Registration function to register the integrator
+extern "C" __attribute__((export_name("__preinit__19_autoinc_register_47")))
+void __preinit__19_autoinc_register_47() {
+    SpacetimeDb::detail::get_autoinc_integrator<User>() = 
+        &SpacetimeDb::detail::autoinc_integrate_47;
+}
+```
+
+**Runtime Integration Process**:
+When `insert()` is called on a table with auto-increment fields:
+1. SDK serializes and sends the row to SpacetimeDB
+2. SpacetimeDB processes the insert and generates the auto-increment value(s)
+3. SpacetimeDB returns a buffer containing only the generated column values in BSATN format
+4. SDK calls the registered integrator function to update the original row with generated values
+5. `insert()` returns the updated row with the correct generated ID
+
+This system enables users to immediately access generated IDs:
+```cpp
+SPACETIMEDB_REDUCER(create_user, ReducerContext ctx, std::string name) {
+    User user{0, name, true};  // id=0 will be auto-generated
+    User inserted_user = ctx.db[users].insert(user);  // Returns user with generated ID
+    LOG_INFO("Created user with ID: " + std::to_string(inserted_user.id));
+}
+```
+
+**Reducer Registration** (__preinit__30_):
+```cpp
+SPACETIMEDB_REDUCER(add_user, ReducerContext ctx, std::string name)
+// Generates registration function that captures parameter types and creates dispatch handler
+```
+
+#### 2.3 Multiple Primary Key Detection
+During constraint registration, track primary keys per table:
+```cpp
+// In V9Builder::AddFieldConstraint
+if (constraint == FieldConstraint::PrimaryKey) {
+    if (table_has_primary_key[table_name]) {
+        SetMultiplePrimaryKeyError(table_name);  // Set global error flag
+    }
+    table_has_primary_key[table_name] = true;
+}
+```
+
+### Phase 3: Type System Registration
+
+**Component**: V9TypeRegistration system (`v9_type_registration.h`)
+
+**Core Principle**: Only user-defined structs and enums get registered in the typespace. Primitives, arrays, Options, and special types are always inlined.
+
+**Registration Flow**:
+```cpp
+class V9TypeRegistration {
+    AlgebraicType registerType(const bsatn::AlgebraicType& bsatn_type,
+                              const std::string& explicit_name = "",
+                              const std::type_info* cpp_type = nullptr) {
+        // 1. Check if primitive → return inline
+        if (isPrimitive(bsatn_type)) return convertPrimitive(bsatn_type);
+        
+        // 2. Check if array → return inline Array with recursive element processing
+        if (bsatn_type.tag() == bsatn::AlgebraicTypeTag::Array) 
+            return convertArray(bsatn_type);
+        
+        // 3. Check if Option → return inline Sum structure
+        if (isOptionType(bsatn_type)) return convertOption(bsatn_type);
+        
+        // 4. Check if special type → return inline Product structure
+        if (isSpecialType(bsatn_type)) return convertSpecialType(bsatn_type);
+        
+        // 5. User-defined type → register in typespace, return Ref
+        return registerUserDefinedType(bsatn_type, explicit_name, cpp_type);
+    }
+};
+```
+
+**Circular Reference Detection**:
+```cpp
+// Track types currently being registered
+std::unordered_set<std::string> types_being_registered_;
+
+AlgebraicType registerUserDefinedType(...) {
+    if (types_being_registered_.contains(type_name)) {
+        setError("Circular reference detected in type: " + type_name);
+        return createErrorType();
+    }
+    types_being_registered_.insert(type_name);
+    // ... process type ...
+    types_being_registered_.erase(type_name);
+}
+```
+
+### Phase 4: Validation and Error Detection (__preinit__99_)
+
+**Location**: Final preinit function - runs after all registration is complete
+
+**Error Detection**:
+```cpp
+extern "C" __attribute__((export_name("__preinit__99_validate_types")))
+void __preinit__99_validate_types() {
+    // 1. Check for circular reference errors
+    if (g_circular_ref_error) {
+        createErrorModule("ERROR_CIRCULAR_REFERENCE_" + g_circular_ref_type_name);
+        return;
+    }
+    
+    // 2. Check for multiple primary key errors
+    if (g_multiple_primary_key_error) {
+        createErrorModule("ERROR_MULTIPLE_PRIMARY_KEYS_" + g_multiple_primary_key_table_name);
+        return;
+    }
+    
+    // 3. Check for type registration errors
+    if (getV9TypeRegistration().hasError()) {
+        createErrorModule("ERROR_TYPE_REGISTRATION_" + sanitize(error_message));
+        return;
+    }
+}
+```
+
+**Error Module Creation**: When errors are detected, the normal module is replaced with a special error module containing an invalid type reference. When SpacetimeDB tries to resolve the type, it fails with an error message that includes the descriptive error type name.
+
+### Phase 5: Module Description Export
+
+**Function**: `__describe_module__()` - Called by SpacetimeDB after preinit functions complete
+
+**Process**:
+1. Serialize the completed V9 module definition
+2. Include typespace (all registered types)
+3. Include tables with constraints
+4. Include reducers with parameter types
+5. Include named type exports
+6. Return binary module description
+
+## Namespace Qualification System
+
+### Overview
+The C++ SDK provides a unique compile-time namespace qualification system for enum types, allowing better organization in generated client code without affecting server-side C++ usage.
+
+### Architecture Components
+
+#### 1. Compile-Time Namespace Storage
+**Location**: `enum_macro.h` - namespace_info template specialization
+
+```cpp
+namespace SpacetimeDb::detail {
+    // Primary template - no namespace by default
+    template<typename T>
+    struct namespace_info {
+        static constexpr const char* value = nullptr;
+    };
+}
+
+// SPACETIMEDB_NAMESPACE macro creates specialization
+#define SPACETIMEDB_NAMESPACE(EnumType, NamespacePrefix) \
+    namespace SpacetimeDb::detail { \
+        template<> \
+        struct namespace_info<EnumType> { \
+            static constexpr const char* value = NamespacePrefix; \
+        }; \
+    }
+```
+
+#### 2. LazyTypeRegistrar Integration
+**Location**: `v9_type_registration.h` - Compile-time namespace detection
+
+```cpp
+template<typename T>
+class LazyTypeRegistrar {
+    static bsatn::AlgebraicType getOrRegister(...) {
+        std::string qualified_name = type_name;
+        
+        // Compile-time check for namespace information
+        if constexpr (requires { SpacetimeDb::detail::namespace_info<T>::value; }) {
+            constexpr const char* namespace_prefix = 
+                SpacetimeDb::detail::namespace_info<T>::value;
+            if (namespace_prefix != nullptr) {
+                qualified_name = std::string(namespace_prefix) + "." + type_name;
+            }
+        }
+        
+        // Register with qualified name
+        type_index_ = getV9TypeRegistration().registerAndGetIndex(
+            algebraic_type, qualified_name, &typeid(T));
+    }
+};
+```
+
+#### 3. Type Registration with Namespaces
+When an enum with namespace qualification is registered:
+1. SPACETIMEDB_ENUM defines the enum and its BSATN traits
+2. SPACETIMEDB_NAMESPACE adds compile-time metadata
+3. LazyTypeRegistrar detects namespace at compile-time
+4. Type is registered with qualified name (e.g., "Auth.UserRole")
+5. Client generators recognize the namespace structure
+
+### Design Rationale
+
+**Why Separate Macros?**
+- Clean separation of concerns: enum definition vs. namespace qualification
+- Optional feature - enums work without namespaces
+- Non-intrusive - doesn't modify the enum type itself
+- Compile-time only - zero runtime overhead
+
+**Why Template Specialization?**
+- Type-safe association between enum and namespace
+- Compile-time resolution - no runtime lookups
+- Works with C++20 concepts and if constexpr
+- No memory overhead - constexpr strings
+
+### Comparison with Other Approaches
+
+**Alternative 1: Preinit Runtime Modification** (Rejected)
+- Would require modifying types after registration
+- Complex synchronization with type registry
+- Runtime overhead for namespace lookup
+
+**Alternative 2: Embedded in SPACETIMEDB_ENUM** (Rejected)
+- Would complicate the macro syntax
+- Makes namespace mandatory rather than optional
+- Harder to add namespaces to existing code
+
+**Current Approach Benefits**:
+- Clean, modular design
+- Zero runtime cost
+- Optional and backwards-compatible
+- Easy to understand and maintain
+
+## Key Differences from Rust and C# SDKs
+
+### 1. Type Registration Approach
+
+**Rust SDK**:
+- Derive macros automatically generate type registration code
+- Compile-time code generation using procedural macros
+- Direct integration with Rust's type system
+- Option types automatically inlined by macro system
+
+**C# SDK**:
+- Reflection-based runtime type discovery
+- Attribute-based configuration
+- Dynamic type registration during module initialization
+- .NET type system integration
+
+**C++ SDK**:
+- Template-based compile-time validation with runtime registration
+- Macro-generated __preinit__ functions for ordered initialization
+- Manual type registration via SPACETIMEDB_STRUCT macros
+- Hybrid approach combining compile-time safety with runtime flexibility
+
+### 2. Constraint Validation
+
+**Rust SDK**:
+- Procedural macros generate compile-time validation
+- Type system automatically enforces valid constraints
+- No runtime constraint checking needed
+
+**C# SDK**:
+- Runtime validation using reflection
+- Attributes specify constraints, validated during registration
+- Dynamic error reporting
+
+**C++ SDK**:
+- **Three-layer validation system**:
+  1. **Compile-time**: C++20 concepts and static assertions
+  2. **Registration-time**: Multiple primary key detection
+  3. **Module load**: preinit_99_ comprehensive validation
+- Most sophisticated error detection of all SDKs
+
+### 3. Error Handling Strategy
+
+**Rust SDK**:
+- Compile-time errors prevent building invalid modules
+- Type system prevents most runtime errors
+- Standard Rust error messages
+
+**C# SDK**:
+- Runtime exceptions with detailed error messages
+- Graceful error handling with exception propagation
+- .NET debugging tools integration
+
+**C++ SDK**:
+- **Error module replacement strategy**:
+  - Invalid modules replaced with special error modules
+  - Error type names embed descriptive information
+  - SpacetimeDB server provides clear error messages
+  - Comprehensive error categorization and reporting
+
+### 4. Type System Philosophy
+
+**Rust SDK**: 
+- "If it compiles, it works" - maximum compile-time validation
+- Leverages Rust's ownership and type system
+- Minimal runtime overhead
+
+**C# SDK**:
+- "Flexibility with safety" - runtime validation with rich error messages
+- Leverages .NET reflection and attributes
+- Dynamic type discovery
+
+**C++ SDK**:
+- **"Validate early, validate often"** - multi-layer validation system
+- Combines C++20 compile-time features with runtime checks
+- Nominal type system with explicit registration
+- Optimized for catching errors at the earliest possible phase
+
+## Memory Management and Performance
+
+### Compile-Time Optimizations
+- Template specialization eliminates runtime overhead
+- Constexpr evaluations reduce WASM binary size
+- Zero-cost abstractions for type-safe database access
+
+### Runtime Efficiency
+- Minimal allocation during type registration
+- Efficient binary serialization with BSATN
+- Optimized field accessors with index caching
+
+### WASM Constraints
+- 16MB initial memory limit (configurable)
+- No dynamic memory growth during module registration
+- Careful memory management in preinit functions
+
+## Development Workflow Integration
+
+### Error Detection Timeline
+```
+Developer writes code
+    ↓
+C++ compilation → Compile-time validation (concepts, static_assert)
+    ↓
+Emscripten WASM build → Template instantiation validation
+    ↓
+Module publishing → Runtime validation (__preinit__99_)
+    ↓
+SpacetimeDB loading → Server-side validation and error reporting
+```
+
+### Debugging Support
+- **Compile-time**: Clear error messages with field/constraint guidance
+- **Build-time**: Template instantiation error reporting
+- **Runtime**: Comprehensive logging with error categorization
+- **Server-side**: Descriptive error module names for easy diagnosis
+
+## Future Architecture Considerations
+
+### Potential Improvements
+1. **Unified Validation**: Move more validation to compile-time using concepts
+2. **Better Error Recovery**: Partial module loading with isolated error handling
+3. **Performance Optimization**: Reduce template instantiation overhead
+4. **Enhanced Debugging**: Source location tracking for runtime errors
+
+### Scalability
+- Type registration system scales linearly with module complexity
+- Preinit function count grows with table/reducer count but remains manageable
+- Memory usage is predictable and bounded
+
+## Related Documentation
+
+- [Type System Details](README.md#features)
+- [Constraint Validation Tests](tests/type-isolation-test/)
+- [API Reference](REFERENCE.md)
+- [Quick Start Guide](QUICKSTART.md)
\ No newline at end of file
diff --git a/crates/bindings-cpp/CMakeLists.txt b/crates/bindings-cpp/CMakeLists.txt
new file mode 100644
index 00000000000..782a351a525
--- /dev/null
+++ b/crates/bindings-cpp/CMakeLists.txt
@@ -0,0 +1,82 @@
+# SpacetimeDB C++ Module Library CMake Configuration
+
+cmake_minimum_required(VERSION 3.15)
+project(SpacetimeDBCppModuleLibrary CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Module Library source files
+set(LIBRARY_SOURCES
+    src/abi/module_exports.cpp
+    src/abi/wasi_shims.cpp
+    src/internal/Module.cpp
+    src/internal/AlgebraicType.cpp  # Required for V9 autogen types
+    src/internal/v9_builder.cpp  # V9 incremental module builder
+    src/internal/v9_type_registration.cpp  # Unified type registration system
+    # src/library/index_management.cpp  # Disabled due to conflicts with index_ops.h
+    # src/type_registry.cpp  # REMOVED - TypeRegistry system eliminated
+)
+
+# Create the Module Library
+add_library(spacetimedb_cpp_library STATIC ${LIBRARY_SOURCES})
+
+# Set include directories
+target_include_directories(spacetimedb_cpp_library
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+# Create an alias target for better namespacing
+add_library(spacetimedb::spacetimedb_cpp_library ALIAS spacetimedb_cpp_library)
+
+# Set compile options if building for WASM
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    target_compile_options(spacetimedb_cpp_library PRIVATE 
+        -O2                    # Optimize for performance
+        -fno-exceptions        # Disable exceptions for WASM compatibility
+        -ffunction-sections    # Place each function in its own section
+        -fdata-sections        # Place each data item in its own section
+        -Wall -Wextra          # Enable warnings
+    )
+    # Note: -g0 should be set in the final executable's linker flags, not here
+    # This allows debugging the library during development if needed
+endif()
+
+# Export compile commands for better IDE support
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Testing configuration
+option(BUILD_TESTS "Build the test suite" ON)
+
+if(BUILD_TESTS AND NOT CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    enable_testing()
+    
+    # Add test executable
+    add_executable(test_bsatn tests/main.cpp tests/module_library_unit_tests.cpp)
+    
+    # Link against the module library
+    target_link_libraries(test_bsatn PRIVATE spacetimedb_cpp_library)
+    
+    # Set C++20 standard for tests
+    target_compile_features(test_bsatn PRIVATE cxx_std_20)
+    
+    # Add test to CTest
+    add_test(NAME bsatn_tests COMMAND test_bsatn)
+    
+    # Add verbose test variant
+    add_test(NAME bsatn_tests_verbose COMMAND test_bsatn -v)
+    
+    # Set test properties
+    set_tests_properties(bsatn_tests PROPERTIES 
+        TIMEOUT 30
+        LABELS "unit"
+    )
+    
+    set_tests_properties(bsatn_tests_verbose PROPERTIES 
+        TIMEOUT 30
+        LABELS "unit;verbose"
+    )
+endif()
\ No newline at end of file
diff --git a/crates/bindings-cpp/DEVELOP.md b/crates/bindings-cpp/DEVELOP.md
new file mode 100644
index 00000000000..0d4a761d00d
--- /dev/null
+++ b/crates/bindings-cpp/DEVELOP.md
@@ -0,0 +1,597 @@
+# C++ SDK Development Roadmap: Leveraging Modern C++ Standards
+
+This document explores how upgrading to C++23 and C++26 could fundamentally transform the SpacetimeDB C++ SDK, moving from runtime registration to compile-time type system integration and eliminating most macro usage.
+
+## Current Architecture: Why So Many Macros?
+
+### The Fundamental Problem: No Compile-Time Reflection in C++20
+
+Without reflection, the compiler cannot:
+- Enumerate struct fields automatically
+- Determine field types and names
+- Discover which types should be tables
+- Generate serialization code
+- Build type relationships
+
+This forces us into a multi-layer macro system with runtime registration:
+
+### Layer 1: SPACETIMEDB_STRUCT - Manual Field Enumeration
+
+```cpp
+struct User {
+    uint32_t id;
+    std::string name;
+    std::string email;
+};
+SPACETIMEDB_STRUCT(User, id, name, email)
+```
+
+**Why we need it:**
+- C++ has no way to iterate over struct fields at compile-time
+- We must manually list every field for serialization
+- The macro generates a `bsatn_traits<User>` specialization that knows how to serialize/deserialize
+
+**What it generates:**
+```cpp
+template<> struct bsatn_traits<User> {
+    static AlgebraicType algebraic_type() {
+        // Builds Product type with fields [id, name, email]
+    }
+    static void serialize(Writer& w, const User& val) {
+        w.write(val.id); w.write(val.name); w.write(val.email);
+    }
+};
+```
+
+**Why it can't be compile-time:** We can't discover the fields without listing them explicitly.
+
+### Layer 2: SPACETIMEDB_TABLE - Runtime Table Registration
+
+```cpp
+SPACETIMEDB_TABLE(User, users, Public)
+```
+
+**Why we need it separately from STRUCT:**
+- A struct might be used as a table, a reducer parameter, or a nested type
+- Not all structs are tables - some are just data types
+- Table registration needs additional metadata (name, access level)
+
+**What it generates:**
+```cpp
+extern "C" __attribute__((export_name("__preinit__20_register_table_User")))
+void __preinit__20_register_table_User() {
+    Module::RegisterTable<User>("users", true);
+}
+// Plus a tag type for clean syntax: ctx.db[users]
+```
+
+**Why it must be runtime:** The module schema must be built dynamically when the WASM module loads, as we can't generate a complete module description at compile-time.
+
+### Layer 3: FIELD_ Macros - Constraint Registration
+
+```cpp
+FIELD_PrimaryKey(users, id);
+FIELD_Unique(users, email);
+FIELD_Index(users, name);
+```
+
+**Why we need separate macros per constraint:**
+- Each field can have multiple constraints
+- Constraints must be registered AFTER the table (priority ordering)
+- Some constraints need compile-time validation (C++20 concepts)
+- Can't be part of SPACETIMEDB_TABLE because we need the table to exist first
+
+**What they generate:**
+```cpp
+// Compile-time validation
+static_assert(FilterableValue<decltype(User::id)>, "Primary keys must be filterable");
+
+// Runtime registration
+extern "C" __attribute__((export_name("__preinit__21_field_constraint_users_id")))
+void __preinit__21_field_constraint_users_id() {
+    AddFieldConstraint<User>("users", "id", FieldConstraint::PrimaryKey);
+}
+```
+
+**Why the split:** Compile-time validation via concepts, but runtime registration for module schema.
+
+### Layer 4: __preinit__ Priority System - Ordered Initialization
+
+```cpp
+__preinit__01_ - Clear global state
+__preinit__10_ - Field registration  
+__preinit__20_ - Table registration
+__preinit__21_ - Constraints (must come after tables)
+__preinit__30_ - Reducers
+__preinit__99_ - Validation
+```
+
+**Why we need priority ordering:**
+- Tables must exist before constraints can be added
+- Types must be registered before they're referenced
+- Validation must happen after everything else
+- WebAssembly's linear memory model requires deterministic initialization
+
+**Why it's runtime:** WASM modules are initialized linearly, and we need to build the module schema during this initialization phase.
+
+### Layer 5: Namespace Qualification - Compile-Time Metadata
+
+```cpp
+SPACETIMEDB_ENUM(UserRole, Admin, Moderator, Member)
+SPACETIMEDB_NAMESPACE(UserRole, "Auth")  // Separate macro for namespace
+```
+
+**Why we need a separate macro:**
+- Namespace is optional metadata, not core to the enum definition
+- Must work with existing enum definitions without modification
+- Needs to associate compile-time string with type
+
+**What it generates:**
+```cpp
+namespace SpacetimeDb::detail {
+    template<> struct namespace_info<UserRole> {
+        static constexpr const char* value = "Auth";
+    };
+}
+```
+
+**Why it's compile-time but still needs a macro:**
+- C++20 has no way to attach metadata to types without explicit specialization
+- Template specialization requires knowing the type name
+- LazyTypeRegistrar uses `if constexpr` to detect namespace at compile-time
+
+### Layer 6: __describe_module__ - Final Runtime Assembly
+
+```cpp
+extern "C" const uint8_t* __describe_module__() {
+    // Serialize the complete module built by __preinit__ functions
+    return Module::serialize();
+}
+```
+
+**Why it's needed:**
+- SpacetimeDB server calls this to get the module schema
+- Must return a binary description of all tables, types, reducers
+- Can only be built after all __preinit__ functions have run
+
+**The fundamental limitation:** Without compile-time reflection, we cannot know at compile-time:
+- Which types are tables
+- What fields each struct has
+- What constraints apply to each field
+- The complete type dependency graph
+- What namespace qualifications are applied
+
+### The Cascade Effect
+
+This creates a cascade of limitations:
+
+1. **No automatic serialization** → Need SPACETIMEDB_STRUCT macro
+2. **No type discovery** → Need explicit SPACETIMEDB_TABLE macro  
+3. **No field introspection** → Need separate FIELD_ macros
+4. **No compile-time module generation** → Need runtime __preinit__ system
+5. **No static validation** → Need runtime validation in __preinit__99
+
+Each macro exists because C++20 lacks the reflection capabilities to do this work automatically. The runtime registration exists because we can't build a complete module description at compile-time without knowing what types exist and their relationships.
+
+## Current Architecture Limitations (Summary)
+
+The current C++20 SDK relies on:
+- **Runtime registration** via `__preinit__` functions (because no compile-time type discovery)
+- **Heavy macro usage** for type and table registration (because no reflection)
+- **Runtime error detection** in `__preinit__99_validate_types` (because incomplete compile-time info)
+- **Manual serialization** through SPACETIMEDB_STRUCT macros (because no field enumeration)
+- **String-based type identification** requiring explicit registration (because no compile-time type identity)
+
+## C++23 Improvements
+
+### 1. Deducing `this` for Zero-Cost Field Accessors
+
+**Current approach:**
+```cpp
+template<typename TableType, typename FieldType>
+class TypedFieldAccessor : public TableAccessor<TableType> {
+    FieldType TableType::*member_ptr_;
+    // Complex inheritance hierarchy
+};
+```
+
+**C++23 approach:**
+```cpp
+struct TableAccessor {
+    template<typename Self>
+    auto filter(this Self&& self, auto&& predicate) {
+        // Deduce table type from self, no inheritance needed
+        return self.table_.filter(std::forward<decltype(predicate)>(predicate));
+    }
+};
+```
+
+**Benefits:**
+- Eliminate accessor class hierarchy
+- Perfect forwarding throughout
+- Reduced template instantiation overhead
+
+### 2. `if consteval` for Hybrid Compile/Runtime Validation
+
+**Current approach:**
+```cpp
+// Static assertions in macros
+static_assert(FilterableValue<FieldType>, "Error message");
+// Plus runtime validation in __preinit__99
+```
+
+**C++23 approach:**
+```cpp
+template<typename T>
+constexpr auto validate_constraint() {
+    if consteval {
+        // Compile-time path: full validation
+        static_assert(FilterableValue<T>);
+        return compile_time_type_id<T>();
+    } else {
+        // Runtime fallback for dynamic types
+        return runtime_type_registry::get<T>();
+    }
+}
+```
+
+**Benefits:**
+- Single validation function works at compile-time or runtime
+- Better error messages with source locations
+- Gradual migration path from runtime to compile-time
+
+### 3. `std::expected` for Error Propagation
+
+**Current approach:**
+```cpp
+// Global error flags
+static bool g_multiple_primary_key_error = false;
+static std::string g_multiple_primary_key_table_name = "";
+```
+
+**C++23 approach:**
+```cpp
+template<typename T>
+using RegistrationResult = std::expected<TypeId, RegistrationError>;
+
+constexpr RegistrationResult register_table() {
+    if (/* multiple primary keys detected */)
+        return std::unexpected(RegistrationError::MultiplePrimaryKeys);
+    return TypeId{...};
+}
+```
+
+**Benefits:**
+- Type-safe error handling
+- Composable error propagation
+- No global state needed
+
+### 4. `constexpr std::unique_ptr` for Compile-Time Type Trees
+
+**Current approach:**
+```cpp
+// Runtime type tree building
+std::vector<AlgebraicType> types;
+types.push_back(...);
+```
+
+**C++23 approach:**
+```cpp
+constexpr auto build_type_tree() {
+    std::unique_ptr<TypeNode> root = std::make_unique<TypeNode>();
+    // Build entire type hierarchy at compile time
+    return root;
+}
+
+constexpr auto type_tree = build_type_tree();
+```
+
+**Benefits:**
+- Complete type system known at compile-time
+- Zero runtime allocation
+- Enables compile-time validation of entire module
+
+### 5. `std::ranges` for Cleaner Type Processing
+
+**Current approach:**
+```cpp
+// Manual iteration and filtering
+std::vector<AlgebraicType> types;
+for (const auto& type : all_types) {
+    if (isPrimitive(type)) continue;
+    if (isOptionType(type)) continue;
+    types.push_back(processType(type));
+}
+```
+
+**C++23 approach:**
+```cpp
+// Declarative pipeline with ranges
+auto process_types() {
+    return all_types 
+        | std::views::filter(not_primitive)
+        | std::views::filter(not_option)
+        | std::views::transform(processType)
+        | std::ranges::to<std::vector>();
+}
+
+// Better: lazy evaluation for type checking
+auto valid_types = registered_types
+    | std::views::filter([](auto& t) { return validate_type(t).has_value(); });
+```
+
+**Benefits:**
+- More declarative and readable type processing
+- Lazy evaluation reduces memory usage
+- Composable validation pipelines
+- Better separation of filtering logic from processing
+
+### 6. `std::mdspan` for Table Data Access
+
+**Current approach:**
+```cpp
+// Custom iterators and accessors
+for (const auto& row : table) { }
+```
+
+**C++23 approach:**
+```cpp
+template<typename T>
+using TableView = std::mdspan<T, std::extents<size_t, std::dynamic_extent, field_count<T>()>>;
+
+// Direct columnar access
+auto names = table_view[std::full_extent, name_column];
+```
+
+**Benefits:**
+- Standard library support for multi-dimensional access
+- Optimized for columnar operations
+- Compatible with parallel algorithms
+
+## C++26 Transformative Features
+
+### 1. Static Reflection (P2996) - Complete Macro Elimination
+
+**Current approach:**
+```cpp
+SPACETIMEDB_STRUCT(User, id, name, email)
+SPACETIMEDB_TABLE(User, users, Public)
+FIELD_PrimaryKey(users, id);
+SPACETIMEDB_ENUM(UserRole, Admin, Moderator, Member)
+SPACETIMEDB_NAMESPACE(UserRole, "Auth")  // Separate macro for namespace
+```
+
+**C++26 approach:**
+```cpp
+struct [[spacetimedb::table("users", public)]] User {
+    [[spacetimedb::primary_key]] uint32_t id;
+    [[spacetimedb::unique]] std::string email;
+    std::string name;
+};
+
+enum class [[spacetimedb::namespace("Auth")]] UserRole {
+    Admin, Moderator, Member
+};
+
+// Automatic registration via reflection
+template<typename T> requires has_spacetimedb_table_attr<T>
+consteval void register_table() {
+    constexpr auto members = ^T::members();
+    for (constexpr auto member : members) {
+        if constexpr (has_attribute<member, spacetimedb::primary_key>) {
+            register_primary_key<T>(member.name(), member.type());
+        }
+    }
+}
+
+// Automatic namespace detection via reflection
+template<typename T>
+consteval std::string get_qualified_name() {
+    if constexpr (has_attribute<^T, spacetimedb::namespace>) {
+        return get_attribute<^T, spacetimedb::namespace>() + "." + name_of(^T);
+    }
+    return name_of(^T);
+}
+```
+
+**Benefits:**
+- **Zero macros needed**
+- Natural C++ syntax with attributes
+- Complete type information at compile-time
+- Automatic serialization without SPACETIMEDB_STRUCT
+
+### 2. Contracts for Constraint Validation
+
+**Current approach:**
+```cpp
+static_assert(FilterableValue<FieldType>, "Field cannot have Index constraint");
+```
+
+**C++26 approach:**
+```cpp
+template<typename T>
+void add_index_constraint(T TableType::*field)
+    [[pre: FilterableValue<T>]]
+    [[pre: !has_existing_index(field)]]
+{
+    // Contract violations become compile-time or runtime errors
+    // depending on evaluation context
+}
+```
+
+**Benefits:**
+- Declarative constraint specification
+- Automatic error messages from contract violations
+- Works for both compile-time and runtime validation
+
+### 3. Pattern Matching for Type Dispatch
+
+**Current approach:**
+```cpp
+switch(type.tag()) {
+    case AlgebraicTypeTag::Product: ...
+    case AlgebraicTypeTag::Sum: ...
+    // Manual casting and handling
+}
+```
+
+**C++26 approach:**
+```cpp
+inspect(type) {
+    <Product> p => serialize_product(p),
+    <Sum> s => serialize_sum(s),
+    <Array> [auto elem_type] => serialize_array(elem_type),
+    <Option> opt => serialize_option(opt),
+    _ => throw InvalidType{}
+}
+```
+
+**Benefits:**
+- Type-safe pattern matching
+- Exhaustiveness checking
+- Cleaner type handling code
+
+### 4. Compile-Time Type Registration via Reflection
+
+**Current approach:**
+```cpp
+extern "C" __attribute__((export_name("__preinit__20_register_table_User")))
+void __preinit__20_register_table_User() {
+    Module::RegisterTable<User>("users", true);
+}
+```
+
+**C++26 approach:**
+```cpp
+// Automatic discovery and registration at compile time
+template<typename... Tables>
+consteval auto generate_module_descriptor() {
+    ModuleDescriptor desc;
+    (reflect_and_register<Tables>(desc), ...);
+    return desc;
+}
+
+// Single compile-time constant contains entire module
+constexpr auto module = generate_module_descriptor<
+    discover_tables_via_reflection()...  // Find all types with [[spacetimedb::table]]
+>();
+
+// Single runtime export
+extern "C" const uint8_t* __describe_module__() {
+    return module.serialize();  // Already computed at compile-time
+}
+```
+
+**Benefits:**
+- **No __preinit__ functions needed**
+- Entire module structure known at compile-time
+- Single binary blob computed during compilation
+- Zero runtime registration overhead
+
+### 5. Improved `constexpr` Allocation
+
+**Current approach:**
+```cpp
+// Runtime type vector building
+std::vector<AlgebraicType> types;
+```
+
+**C++26 approach:**
+```cpp
+constexpr auto build_typespace() {
+    std::vector<AlgebraicType> types;
+    // Fully constexpr vector operations
+    for (auto type : reflect_all_types()) {
+        types.push_back(analyze_type(type));
+    }
+    return types;
+}
+
+constexpr auto typespace = build_typespace();
+```
+
+**Benefits:**
+- Complete typespace computed at compile-time
+- No runtime allocation or registration
+- Enables full compile-time validation
+
+### 6. Reflection-Based Serialization
+
+**Current approach:**
+```cpp
+// Manual field listing in SPACETIMEDB_STRUCT macro
+SPACETIMEDB_STRUCT(MyType, field1, field2, field3)
+```
+
+**C++26 approach:**
+```cpp
+template<typename T>
+constexpr void serialize(Writer& w, const T& obj) {
+    [:expand(^T::members()):] >> [&]<auto member> {
+        w.write(obj.[:member:]);
+    };
+}
+
+// Automatic serialization for any struct, no macros needed
+```
+
+**Benefits:**
+- Automatic serialization for all types
+- No manual field enumeration
+- Works with any struct/class
+
+## Migration Strategy
+
+### Phase 1: C++23 Adoption
+1. Replace class hierarchies with deducing `this`
+2. Introduce `std::expected` for error handling
+3. Use `if consteval` for hybrid validation
+4. Implement `constexpr` type tree building
+5. Gradually reduce macro usage
+
+### Phase 2: C++26 Revolution
+1. Replace all macros with reflection
+2. Eliminate __preinit__ system entirely
+3. Move to compile-time module generation
+4. Implement pattern matching for type dispatch
+5. Use contracts for all constraint validation
+
+## Expected Outcomes
+
+### With C++23:
+- **30-50% reduction** in macro usage
+- **Faster compilation** through reduced template instantiation
+- **Better error messages** with `std::expected`
+- **Cleaner API** with deducing `this`
+
+### With C++26:
+- **100% macro elimination**
+- **Zero runtime registration overhead**
+- **Compile-time module validation**
+- **Natural C++ syntax** without SDK-specific constructs
+- **Full IDE support** (no macro magic hiding semantics)
+
+## Performance Implications
+
+### Compile-Time Performance
+- **C++23**: Slightly increased due to more `constexpr` evaluation
+- **C++26**: Significantly increased initially, but:
+  - Module structure computed once and cached
+  - No runtime registration overhead
+  - Smaller WASM binaries (no registration code)
+
+### Runtime Performance
+- **C++23**: ~10% improvement from reduced indirection
+- **C++26**: ~50% improvement from eliminating registration entirely
+
+### WASM Binary Size
+- **C++23**: ~5-10% reduction (less template instantiation)
+- **C++26**: ~20-30% reduction (no registration code, no macros)
+
+## Conclusion
+
+C++26's static reflection will enable a complete paradigm shift from runtime registration to compile-time module generation. The SpacetimeDB C++ SDK could become the first database SDK to offer **zero-overhead abstractions** with no macros and no runtime registration - just pure, standard C++.
+
+The journey through C++23 provides valuable incremental improvements, but C++26's reflection capabilities will allow us to achieve what no other database SDK has: **complete compile-time type safety and module generation with natural C++ syntax**.
+
+This would position the C++ SDK as the most advanced and performant SpacetimeDB SDK, surpassing even Rust in terms of compile-time guarantees and zero-overhead abstractions.
\ No newline at end of file
diff --git a/crates/bindings-cpp/QUICKSTART.md b/crates/bindings-cpp/QUICKSTART.md
new file mode 100644
index 00000000000..9d3533c91d2
--- /dev/null
+++ b/crates/bindings-cpp/QUICKSTART.md
@@ -0,0 +1,293 @@
+# SpacetimeDB C++ Module Quickstart
+
+This guide will walk you through creating your first SpacetimeDB module in C++. We'll build a simple chat server to demonstrate the core concepts.
+
+## What is a SpacetimeDB Module?
+
+A SpacetimeDB module is C++ code that gets compiled to WebAssembly and runs inside the database. Instead of the traditional architecture (database → app server → clients), SpacetimeDB lets you write your entire backend logic that runs **inside** the database itself, giving you microsecond latency and automatic real-time sync to clients.
+
+Modules consist of two main components:
+
+- **Tables**: Database tables defined as C++ structs
+- **Reducers**: Functions that modify data and can be called by clients
+
+## Prerequisites
+
+Before we begin, make sure you have:
+
+- [SpacetimeDB CLI](https://spacetimedb.com/install) installed
+- [Emscripten SDK (emsdk)](https://emscripten.org/docs/getting_started/downloads.html) for WebAssembly compilation
+- CMake 3.16+ 
+- A C++20 compatible compiler
+
+## Creating Your First Module
+
+### Step 1: Initialize the Project
+
+Create a new C++ module using the SpacetimeDB CLI:
+
+```bash
+spacetime init --lang cpp my-chat-module
+cd my-chat-module
+```
+
+This creates a project with the following structure:
+```
+my-chat-module/
+├── CMakeLists.txt
+├── lib.cpp
+└── .gitignore
+```
+
+### Step 2: Define Your Data Structures
+
+Open `lib.cpp` and replace the generated code with our chat server implementation:
+
+```cpp
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Define a User table to store connected users
+struct User {
+    Identity identity;      // SpacetimeDB's built-in user identity type
+    std::optional<std::string> name;  // User's display name (optional)
+    bool online;           // Whether the user is currently connected
+};
+
+// Register the struct for BSATN serialization
+SPACETIMEDB_STRUCT(User, identity, name, online)
+
+// Register as a public table with identity as primary key
+SPACETIMEDB_TABLE(User, user, Public)
+FIELD_PrimaryKey(user, identity);
+
+// Define a Message table to store chat messages
+struct Message {
+    Identity sender;       // Who sent the message
+    Timestamp sent;        // When the message was sent
+    std::string text;      // Message content
+};
+
+SPACETIMEDB_STRUCT(Message, sender, sent, text)
+SPACETIMEDB_TABLE(Message, message, Public)
+```
+
+### Step 3: Add Helper Functions and Reducers
+
+First, add validation helper functions:
+
+```cpp
+// Validate that a name is not empty
+std::string validate_name(const std::string& name) {
+    if (name.empty()) {
+        throw std::runtime_error("Names must not be empty");
+    }
+    return name;
+}
+
+// Validate that a message is not empty
+std::string validate_message(const std::string& text) {
+    if (text.empty()) {
+        throw std::runtime_error("Messages must not be empty");
+    }
+    return text;
+}
+```
+
+Now add the reducers (functions that clients can call to modify the database):
+
+```cpp
+// Called when a user sets their name
+SPACETIMEDB_REDUCER(set_name, ReducerContext ctx, std::string name) {
+    name = validate_name(name);
+    
+    // Try to find existing user using primary key field accessor
+    for (auto& user_row : ctx.db[user_identity].filter(ctx.sender)) {
+        // Update existing user's name
+        user_row.name = name;
+        auto success = ctx.db[user_identity].update(user_row);
+        return;
+    }
+}
+
+// Called when a user sends a message
+SPACETIMEDB_REDUCER(send_message, ReducerContext ctx, std::string text) {
+    text = validate_message(text);
+    LOG_INFO(text);
+    
+    // Create and insert new message
+    Message new_message{ctx.sender, ctx.timestamp, text};
+    ctx.db[message].insert(new_message);
+}
+```
+
+### Step 4: Add Lifecycle Reducers
+
+Lifecycle reducers are special functions called automatically by SpacetimeDB:
+
+```cpp
+// Called when a client connects
+SPACETIMEDB_CLIENT_CONNECTED(client_connected) {
+    LOG_INFO("Connect " + ctx.sender.to_hex_string());
+    
+    // Try to find existing user
+    bool found = false;
+    for (auto& user_row : ctx.db[user_identity].filter(ctx.sender)) {
+        // Update existing user to online
+        user_row.online = true;
+        auto success = ctx.db[user_identity].update(user_row);
+        found = true;
+        break;
+    }
+    
+    if (!found) {
+        // Create new user
+        User new_user{ctx.sender, std::nullopt, true};
+        ctx.db[user].insert(new_user);
+    }
+}
+
+// Called when a client disconnects  
+SPACETIMEDB_CLIENT_DISCONNECTED(client_disconnected) {
+    // Try to find user and mark as offline
+    bool found = false;
+    for (auto& user_row : ctx.db[user_identity].filter(ctx.sender)) {
+        user_row.online = false;
+        auto success = ctx.db[user_identity].update(user_row);
+        found = true;
+        break;
+    }
+    
+    if (!found) {
+        LOG_WARN("Warning: No user found for disconnected client.");
+    }
+}
+```
+
+### Step 5: Build Your Module
+
+Build the module using the provided CMake configuration:
+
+```bash
+emcmake cmake -B build .
+cmake --build build
+```
+
+This compiles your C++ code to WebAssembly, producing `build/lib.wasm`.
+
+### Step 6: Publish to SpacetimeDB
+
+Start your local SpacetimeDB instance:
+
+```bash
+nohup spacetime start > /tmp/spacetime.log 2>&1 &
+```
+
+Publish your module:
+
+```bash
+spacetime publish . my-chat-db
+```
+
+### Step 7: Test Your Module
+
+You can test your reducers using the CLI:
+
+```bash
+# Set a user's name
+spacetime call my-chat-db set_name "Alice"
+
+# Send a message
+spacetime call my-chat-db send_message "Hello, world!"
+
+# View all users
+spacetime sql my-chat-db "SELECT * FROM user"
+
+# View all messages
+spacetime sql my-chat-db "SELECT * FROM message"
+```
+
+## Key Concepts Explained
+
+### Tables vs. Structs
+
+- **Structs** are just data types - they need `SPACETIMEDB_STRUCT` for serialization
+- **Tables** are database tables created with `SPACETIMEDB_TABLE` and store data persistently
+- The same struct can be used for multiple tables or just as a data type
+
+### Database Access Pattern
+
+SpacetimeDB C++ uses a unique accessor pattern:
+- `ctx.db[table_name]` - Access table for iteration and basic operations
+- `ctx.db[table_field]` - Access indexed fields for optimized operations
+
+```cpp
+// Table access
+ctx.db[user].insert(new_user);
+
+// Field accessor (for indexed fields)
+ctx.db[user_identity].delete_by_key(identity);
+```
+
+### Constraints and Indexes
+
+Constraints are applied **after** table registration using `FIELD_` macros:
+
+```cpp
+SPACETIMEDB_TABLE(User, user, Public)
+FIELD_PrimaryKey(user, identity);       // Primary key
+FIELD_Unique(user, email);              // Unique constraint
+FIELD_Index(user, age);                 // Index for fast queries
+```
+
+### Public vs. Private Tables
+
+- **Public tables**: Automatically synced to subscribed clients
+- **Private tables**: Only accessible by reducers, not synced to clients
+
+## Next Steps
+
+Now that you have a basic chat server:
+
+1. **Add more features**: User roles, message editing, channels
+2. **Add constraints**: Unique usernames, message length limits
+3. **Explore indexing**: For fast queries on large datasets
+4. **Try scheduled reducers**: For periodic cleanup or notifications
+5. **Generate client code**: Use `spacetime generate` to create TypeScript, C#, or Rust clients
+
+## Advanced Example: Adding Indexes
+
+You can add an index to make querying messages by sender more efficient:
+
+```cpp
+SPACETIMEDB_TABLE(Message, message, Public)
+FIELD_Index(message, sender);  // Add index on sender for faster queries
+
+// Now you can efficiently query by sender using the field accessor:
+SPACETIMEDB_REDUCER(get_user_messages, ReducerContext ctx, Identity user_identity) {
+    for (const auto& msg : ctx.db[message_sender].filter(user_identity)) {
+        LOG_INFO("Message: " + msg.text);
+    }
+}
+```
+
+## Troubleshooting
+
+**Build errors**: Ensure you have the latest Emscripten SDK and are using `emcmake cmake`
+
+**Module not found**: Check that SpacetimeDB is running with `spacetime server status`
+
+**Type errors**: Remember that C++ types need exact matches - use `uint32_t`, not `int`
+
+**Constraint violations**: Constraints are enforced by the database - duplicate primary keys will cause reducers to fail
+
+## Example Projects
+
+For more complex examples, see:
+- [`modules/sdk-test-cpp/src/lib.cpp`](../../modules/sdk-test-cpp/src/lib.cpp) - Comprehensive type and operation testing
+- [`modules/module-test-cpp/src/lib.cpp`](../../modules/module-test-cpp/src/lib.cpp) - Advanced indexing and enum examples
+
+---
+
+Ready to learn more? Check out the [C++ Reference Documentation](REFERENCE.md) for detailed API information.
\ No newline at end of file
diff --git a/crates/bindings-cpp/README.md b/crates/bindings-cpp/README.md
new file mode 100644
index 00000000000..c885d9a3869
--- /dev/null
+++ b/crates/bindings-cpp/README.md
@@ -0,0 +1,244 @@
+# SpacetimeDB C++ Module Library
+
+The SpacetimeDB C++ Module Library provides a modern C++20 API for building SpacetimeDB modules that run inside the database as WebAssembly.
+
+## Current State
+
+This library provides a production-ready C++ SDK for SpacetimeDB with complete type system support:
+
+### ✅ Features
+- Module compilation and publishing to SpacetimeDB
+- All lifecycle reducers (init, client_connected, client_disconnected)
+- User-defined reducers with unlimited parameters
+- Table registration with constraints (PrimaryKey, Unique, AutoInc)
+- Insert and delete operations
+- All primitive types (u8-u256, i8-i256, bool, f32, f64, string)
+- All special types (Identity, ConnectionId, Timestamp, TimeDuration)
+- Vector types for all primitives and special types
+- Optional types (std::optional<T>)
+- Custom struct serialization via BSATN
+- Complex enum support with proper variant names
+- Enhanced logging system with file/line info
+- Mixed type combinations - handle any complexity level
+
+### 🏗️ Architecture
+- **Hybrid Compile-Time/Runtime System**: C++20 concepts for compile-time validation with __preinit__ runtime registration
+- **V9 Type Registration System**: Unified type registration with comprehensive error detection and circular reference prevention
+- **Nominal Type System**: Types identified by their declared names with explicit registration via SPACETIMEDB_STRUCT macros
+- **Multi-Layer Validation**: Static assertions, runtime constraint checking, and error module replacement strategy
+
+See [ARCHITECTURE.md](ARCHITECTURE.md) for detailed technical documentation.
+
+### ✅ Advanced Features Available
+- **Btree indexes**: Full support with `FIELD_Index` macros and optimized queries
+- **Range queries**: Complete range query system with `range_from()`, `range_to()`, `range_inclusive()`, etc.
+- **Client visibility filters**: Row-level security with `SPACETIMEDB_CLIENT_VISIBILITY_FILTER` macro
+- **Scheduled reducers**: `SPACETIMEDB_SCHEDULE` macro for time-based execution
+- **Field accessor patterns**: Efficient indexed operations with `ctx.db[table_field]`
+
+### ❌ Not Yet Implemented  
+- Direct SQL query execution within modules (SQL available via CLI: `spacetime sql`)
+- Automatic migrations (limited - only adding tables supported)
+- Complex table schema changes
+- Transactions (individual reducers are transactional)
+
+See the working examples in `modules/sdk-test-cpp/src/lib.cpp` for comprehensive feature usage.
+
+## Features
+
+- **Modern C++20 API**: Uses concepts, structured bindings, and other C++20 features
+- **BSATN Serialization**: Binary Serialization And Type Notation for efficient data transfer
+- **Automatic Field Registration**: Tables register their fields using SPACETIMEDB_STRUCT macro
+- **Unified Reducer System**: Single macro for all reducer types with automatic lifecycle detection
+- **Type-Safe Database Access**: Template-based table accessors with compile-time type checking
+- **Memory Safety**: WASI shims for safe memory operations in WebAssembly environment
+- **Enhanced Logging**: Multiple log levels with file/line information
+- **Namespace Support**: Clean namespace qualification for enums with just 2 lines of code
+
+## Quick Start
+
+### Option 1: Using spacetime init (Recommended)
+
+```bash
+# Create a new C++ project
+spacetime init --lang cpp my-project
+cd my-project
+
+# Build and publish
+emcmake cmake -B build .
+cmake --build build
+spacetime publish . my-database
+```
+
+### Option 2: Manual Setup
+
+For existing projects, add the following to your C++ module:
+
+```cpp
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Define a table structure
+struct User {
+    uint32_t id;
+    std::string name;
+    std::string email;
+};
+
+// Register BSATN serialization
+SPACETIMEDB_STRUCT(User, id, name, email)
+
+// Register as a table
+SPACETIMEDB_TABLE(User, users, Public)
+
+// Add constraints using FIELD_ macros
+FIELD_PrimaryKeyAutoInc(users, id);
+FIELD_Unique(users, email);
+
+// Define an enum with namespace qualification
+SPACETIMEDB_ENUM(UserRole, Admin, Moderator, Member)
+SPACETIMEDB_NAMESPACE(UserRole, "Auth")  // Will be "Auth.UserRole" in client code
+
+// User-defined reducer
+SPACETIMEDB_REDUCER(add_user, ReducerContext ctx, std::string name, std::string email) {
+    User user{0, name, email}; // id will be auto-generated
+    ctx.db[users].insert(user);
+    LOG_INFO("Added user: " + name);
+}
+
+// Delete user by id (using primary key)
+SPACETIMEDB_REDUCER(delete_user, ReducerContext ctx, uint32_t id) {
+    ctx.db[users_id].delete_by_key(id);
+}
+```
+
+**Note:** Lifecycle reducers (`SPACETIMEDB_INIT`, `SPACETIMEDB_CLIENT_CONNECTED`, `SPACETIMEDB_CLIENT_DISCONNECTED`) are available but not shown in working examples. See `reducer_macros.h` for details.
+
+## Building Modules
+
+### Prerequisites
+- Emscripten SDK (emsdk)
+- CMake 3.16+
+- C++20 compatible compiler
+
+### Build Steps
+
+```bash
+# Navigate to your module directory
+cd modules/your-module
+
+# Configure with CMake (uses src/lib.cpp by default)
+emcmake cmake -B build .
+
+# Build the module
+cmake --build build
+
+# Publish to SpacetimeDB
+spacetime publish --bin-path build/lib.wasm your-database-name
+# Or use the directory (auto-detects build/lib.wasm)
+spacetime publish . your-database-name
+```
+
+#### Custom Module Source
+
+To build a different source file:
+
+```bash
+# Build a specific test module
+emcmake cmake -B build -DMODULE_SOURCE=src/test_module.cpp -DOUTPUT_NAME=test_module .
+cmake --build build
+# This creates build/test_module.wasm
+```
+
+## API Reference
+
+### Macros
+
+#### Table Definition
+- `SPACETIMEDB_TABLE(Type, table_name, Public/Private)` - Register a table
+- `SPACETIMEDB_STRUCT(Type, field1, field2, ...)` - Register type for BSATN serialization
+
+#### Enum Definition
+- `SPACETIMEDB_ENUM(EnumName, Value1, Value2, ...)` - Define a simple enum
+- `SPACETIMEDB_ENUM(EnumName, (Variant1, Type1), (Variant2, Type2), ...)` - Define an enum with payloads
+- `SPACETIMEDB_NAMESPACE(EnumName, "Namespace")` - Add namespace qualification to an enum
+
+#### Reducers
+- `SPACETIMEDB_REDUCER(name, ReducerContext ctx, ...)` - User-defined reducer
+- `SPACETIMEDB_INIT(name)` - Module initialization reducer
+- `SPACETIMEDB_CLIENT_CONNECTED(name)` - Client connection reducer
+- `SPACETIMEDB_CLIENT_DISCONNECTED(name)` - Client disconnection reducer
+
+#### Field Constraints (applied after table registration)
+- `FIELD_PrimaryKey(table_name, field)` - Primary key constraint
+- `FIELD_PrimaryKeyAutoInc(table_name, field)` - Auto-incrementing primary key
+- `FIELD_Unique(table_name, field)` - Unique constraint
+- `FIELD_UniqueAutoInc(table_name, field)` - Auto-incrementing unique field
+- `FIELD_Index(table_name, field)` - Index for faster queries
+- `FIELD_IndexAutoInc(table_name, field)` - Auto-incrementing indexed field
+- `FIELD_AutoInc(table_name, field)` - Auto-increment without other constraints
+
+### Logging
+
+```cpp
+LOG_DEBUG("Debug message");
+LOG_INFO("Info message");
+LOG_WARN("Warning message");
+LOG_ERROR("Error message");
+LOG_PANIC("Fatal error message");
+
+// With timing
+{
+    LogStopwatch timer("Operation name");
+    // ... code to time ...
+} // Automatically logs duration
+```
+
+## Architecture
+
+The library uses a sophisticated hybrid compile-time/runtime architecture:
+
+- **Compile-Time Validation** (`filterable_value_concept.h`, `table_with_constraints.h`): C++20 concepts and static assertions for constraint validation
+- **V9 Type Registration System** (`internal/v9_type_registration.h`): Unified type registration with error detection and circular reference prevention
+- **Priority-Ordered Initialization** (`internal/Module.cpp`): __preinit__ functions with numbered priorities ensure correct registration order
+- **Error Detection System** (`internal/Module.cpp`): Multi-layer validation with error module replacement for clear diagnostics
+- **BSATN Serialization** (`bsatn/`): Binary serialization system with algebraic type support for all data types
+- **Database Interface** (`database.h`, `table_with_constraints.h`): Type-safe table access with optimized field accessors
+- **Reducer System** (`reducer_macros.h`): Unified macro system for all reducer types with parameter type capture
+- **Logging** (`logger.h`): Comprehensive logging with source location tracking
+
+For detailed technical documentation, see [ARCHITECTURE.md](ARCHITECTURE.md).
+
+## Limitations
+
+1. **Type System**
+   - Very large type combinations may exceed WASM memory limits
+   - Complex recursive type references require careful ordering
+
+2. **Database Operations**
+   - Index-based operations use field accessors: `ctx.db[table_field].delete_by_key(value)`
+   - Table constraints are declared and enforced by server
+   - Supports insert, delete, and update operations through field accessors
+
+3. **Advanced Features**  
+   - **Btree indexes**: `FIELD_Index` creates btree indexes for efficient range queries
+   - **Range queries**: Full support for `range_from()`, `range_to()`, `range_inclusive()`, etc.
+   - **Client visibility filters**: Row-level security via `SPACETIMEDB_CLIENT_VISIBILITY_FILTER`
+   - **Limited migrations**: Only adding tables supported automatically
+   - **SQL execution**: Available via CLI (`spacetime sql`) but not within modules
+
+## Examples
+
+See the `modules/sdk-test-cpp/src/` directory for example modules:
+- `lib.cpp` - Comprehensive working module with all primitive types, tables, and reducers
+- Full equivalence with Rust and C# SDK test modules
+- Examples of all constraint types and database operations
+
+## Contributing
+
+This library is part of the SpacetimeDB project. Please see the main repository for contribution guidelines.
+
+## License
+
+Apache License 2.0 - See LICENSE file in the root directory.
\ No newline at end of file
diff --git a/crates/bindings-cpp/REFERENCE.md b/crates/bindings-cpp/REFERENCE.md
new file mode 100644
index 00000000000..51922e6b262
--- /dev/null
+++ b/crates/bindings-cpp/REFERENCE.md
@@ -0,0 +1,1167 @@
+# SpacetimeDB C++ Module Reference
+
+Complete API reference for building SpacetimeDB modules in C++.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Setup](#setup)
+- [Core Concepts](#core-concepts)
+- [Tables](#tables)
+- [Reducers](#reducers)
+- [Database Operations](#database-operations)
+- [Types and Serialization](#types-and-serialization)
+- [Constraints and Indexing](#constraints-and-indexing)
+- [Special Types](#special-types)
+- [Logging](#logging)
+- [Build System](#build-system)
+- [Examples](#examples)
+
+## Overview
+
+SpacetimeDB allows writing server-side applications in C++ that compile to WebAssembly and run inside the database. This eliminates the traditional application server layer, providing microsecond latency and automatic real-time synchronization to clients.
+
+### Module Structure
+
+A SpacetimeDB C++ module consists of:
+
+```cpp
+#include <spacetimedb.h>
+using namespace SpacetimeDb;
+
+// 1. Data structures (structs/enums)
+struct MyData { /* fields */ };
+SPACETIMEDB_STRUCT(MyData, /* field names */);
+
+// 2. Tables (persistent storage)
+SPACETIMEDB_TABLE(MyData, my_table, Public);
+
+// 3. Constraints (applied after table registration)
+FIELD_PrimaryKey(my_table, id);
+
+// 4. Reducers (functions clients can call)
+SPACETIMEDB_REDUCER(my_function, ReducerContext ctx, /* parameters */) {
+    // Your logic here
+}
+```
+
+## Setup
+
+### Project Initialization
+
+```bash
+# Create new project
+spacetime init --lang cpp my-module
+cd my-module
+
+# Build and publish
+emcmake cmake -B build .
+cmake --build build
+spacetime publish . my-database
+```
+
+### Manual Setup
+
+For existing projects, ensure your `CMakeLists.txt` includes:
+
+```cmake
+cmake_minimum_required(VERSION 3.16)
+project(my-module)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Set path to SpacetimeDB C++ library
+set(SPACETIMEDB_CPP_LIBRARY_PATH "path/to/crates/bindings-cpp")
+
+add_executable(lib src/lib.cpp)
+target_include_directories(lib PRIVATE ${SPACETIMEDB_CPP_LIBRARY_PATH}/include)
+
+add_subdirectory(${SPACETIMEDB_CPP_LIBRARY_PATH} spacetimedb_cpp_library)
+target_link_libraries(lib PRIVATE spacetimedb_cpp_library)
+
+# Emscripten settings for WASM
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    set_target_properties(lib PROPERTIES
+        SUFFIX ".wasm"
+        LINK_FLAGS "-s STANDALONE_WASM=1 ..."
+    )
+endif()
+```
+
+## Core Concepts
+
+### Tables
+
+Tables are persistent data storage defined as C++ structs:
+
+```cpp
+struct User {
+    uint32_t id;
+    std::string name;
+    bool active;
+};
+```
+
+### Reducers
+
+Reducers are functions that modify data and can be called by clients:
+
+```cpp
+SPACETIMEDB_REDUCER(create_user, ReducerContext ctx, std::string name) {
+    User user{0, name, true};
+    ctx.db[users].insert(user);
+}
+```
+
+### Transactions
+
+All reducer calls run in transactions. If a reducer fails, all changes are rolled back.
+
+## Tables
+
+### Defining Tables
+
+Tables require two steps: struct registration and table registration.
+
+```cpp
+// Step 1: Register struct for serialization
+struct Product {
+    uint32_t id;
+    std::string name;
+    double price;
+    std::optional<std::string> description;
+};
+SPACETIMEDB_STRUCT(Product, id, name, price, description);
+
+// Step 2: Register as table
+SPACETIMEDB_TABLE(Product, products, Public);
+```
+
+### Table Visibility
+
+- **Public**: `SPACETIMEDB_TABLE(Type, name, Public)` - Synced to subscribed clients
+- **Private**: `SPACETIMEDB_TABLE(Type, name, Private)` - Only accessible by reducers
+
+### Multiple Tables per Type
+
+The same struct can be used for multiple tables:
+
+```cpp
+SPACETIMEDB_STRUCT(LogEntry, timestamp, message, level);
+SPACETIMEDB_TABLE(LogEntry, error_logs, Private);
+SPACETIMEDB_TABLE(LogEntry, debug_logs, Private);
+SPACETIMEDB_TABLE(LogEntry, audit_logs, Public);
+```
+
+## Reducers
+
+### Basic Reducers
+
+```cpp
+SPACETIMEDB_REDUCER(function_name, ReducerContext ctx, /* parameters */) {
+    // Reducer logic
+}
+```
+
+**Parameters:**
+- First parameter must always be `ReducerContext ctx`
+- Additional parameters are passed by clients
+- All parameter types must be registered with `SPACETIMEDB_STRUCT`
+
+### Lifecycle Reducers
+
+Special reducers called automatically by SpacetimeDB:
+
+```cpp
+// Called when module is first published
+SPACETIMEDB_INIT(init) {
+    // Initialize data, create default records
+    LOG_INFO("Module initialized");
+}
+
+// Called when a client connects
+SPACETIMEDB_CLIENT_CONNECTED(on_connect) {
+    LOG_INFO("Client connected");
+    // ctx.sender contains the client's Identity
+}
+
+// Called when a client disconnects
+SPACETIMEDB_CLIENT_DISCONNECTED(on_disconnect) {
+    LOG_INFO("Client disconnected");
+    // Update user status, cleanup resources
+}
+```
+
+### Reducer Context
+
+The `ReducerContext` provides access to:
+
+```cpp
+SPACETIMEDB_REDUCER(example, ReducerContext ctx, /* params */) {
+    // Database access
+    ctx.db[table_name].insert(record);
+    
+    // Client identity
+    Identity client = ctx.sender;
+    
+    // Current timestamp
+    Timestamp now = ctx.timestamp;
+    
+    // Random number generation
+    uint64_t random = ctx.rng().next_u64();
+    int dice_roll = ctx.random<int>();
+}
+```
+
+## Database Operations
+
+### Table Access Patterns
+
+SpacetimeDB C++ uses two access patterns:
+
+#### 1. Table Access (`ctx.db[table_name]`)
+
+For basic operations and iteration:
+
+```cpp
+// Insert (basic)
+User user{0, "Alice", true};
+ctx.db[users].insert(user);
+
+// Insert with auto-increment callback
+// If users table has FIELD_PrimaryKeyAutoInc(users, id)
+User user_with_autoinc{0, "Bob", true};  // id=0 will be auto-generated
+User inserted_user = ctx.db[users].insert(user_with_autoinc);
+LOG_INFO("Created user with auto-generated ID: " + std::to_string(inserted_user.id));
+
+// Iterate all rows
+for (const auto& user : ctx.db[users]) {
+    LOG_INFO("User: " + user.name);
+}
+
+// Update (requires full row replacement)
+for (auto& user : ctx.db[users]) {
+    if (user.name == "Alice") {
+        user.active = false;
+        ctx.db[users].update(user);
+        break;
+    }
+}
+```
+
+#### 2. Field Access (`ctx.db[table_field]`)
+
+For indexed operations (requires constraints):
+
+```cpp
+// Table with primary key
+SPACETIMEDB_TABLE(User, users, Public);
+FIELD_PrimaryKey(users, id);
+
+// Efficient operations using primary key
+SPACETIMEDB_REDUCER(delete_user, ReducerContext ctx, uint32_t user_id) {
+    ctx.db[users_id].delete_by_key(user_id);
+}
+
+SPACETIMEDB_REDUCER(update_user, ReducerContext ctx, uint32_t user_id, std::string new_name) {
+    User updated_user{user_id, new_name, true};
+    ctx.db[users_id].update(updated_user);
+}
+```
+
+### Supported Operations
+
+| Operation | Table Access | Field Access (Indexed) |
+|-----------|--------------|------------------------|
+| Insert | `insert(row)` | - |
+| Delete | Manual iteration | `delete_by_key(key)` |
+| Update | `update(row)` | `update(row)` |
+| Query | Iteration | `filter(value)` |
+
+## Random Number Generation
+
+The C++ SDK provides deterministic random number generation through the `ReducerContext`. The RNG is seeded with the reducer's timestamp, ensuring reproducible behavior across SpacetimeDB instances.
+
+### Basic Usage
+
+```cpp
+SPACETIMEDB_REDUCER(dice_game, ReducerContext ctx, std::string player, uint32_t sides) {
+    // Get the RNG instance (lazily initialized)
+    auto& rng = ctx.rng();
+    
+    // Generate random numbers
+    uint32_t dice_roll = rng.gen_range(1u, sides);
+    uint64_t large_number = rng.next_u64();
+    float probability = rng.gen_float();  // [0, 1)
+    bool coin_flip = rng.gen_bool();
+    
+    // Convenience method for single values
+    int random_int = ctx.random<int>();
+    double random_double = ctx.random<double>();
+}
+```
+
+### Core Methods
+
+#### `ctx.rng()`
+Returns the random number generator instance for this reducer call.
+
+#### `ctx.random<T>()`
+Convenience method to generate a single random value of type T.
+
+### RNG Methods
+
+#### Basic Generation
+```cpp
+auto& rng = ctx.rng();
+
+// Generate raw random bits
+uint32_t bits32 = rng.next_u32();
+uint64_t bits64 = rng.next_u64();
+
+// Generate typed values
+int value = rng.gen<int>();
+float value = rng.gen<float>();    // [0, 1)
+double value = rng.gen<double>();  // [0, 1)
+bool value = rng.gen<bool>();
+```
+
+#### Range Generation
+```cpp
+// Integer ranges [min, max] (inclusive)
+int dice = rng.gen_range(1, 6);
+uint64_t large = rng.gen_range(1000000u, 9999999u);
+
+// Floating point ranges [min, max)
+float speed = rng.gen_range(0.5f, 2.0f);
+double precision = rng.gen_range(0.0, 100.0);
+```
+
+#### Utility Methods
+```cpp
+// Fill buffer with random bytes
+std::vector<uint8_t> buffer(32);
+rng.fill_bytes(buffer);
+
+uint8_t raw_buffer[16];
+rng.fill_bytes(raw_buffer, 16);
+
+// Shuffle containers
+std::vector<std::string> deck = {"Ace", "King", "Queen", "Jack"};
+rng.shuffle(deck.begin(), deck.end());
+
+// Sample random element
+std::vector<int> options = {10, 20, 30, 40};
+int choice = rng.sample(options);  // Returns one of the elements
+```
+
+### Deterministic Behavior
+
+The RNG is seeded with the reducer's timestamp in microseconds:
+- **Same timestamp = Same sequence**: Reducers called at the exact same microsecond will generate identical random sequences
+- **Different timestamps = Different sequences**: Even microsecond differences produce completely different random sequences
+- **Reproducible across instances**: The same reducer call will generate the same random values on any SpacetimeDB instance
+
+### Example: Casino Game
+
+```cpp
+SPACETIMEDB_TABLE(GameResult, game_results, Public)
+SPACETIMEDB_STRUCT(GameResult, player, game_type, result, payout, timestamp)
+struct GameResult {
+    uint32_t id;
+    std::string player;
+    std::string game_type;
+    std::string result;
+    uint32_t payout;
+    Timestamp timestamp;
+};
+
+SPACETIMEDB_REDUCER(play_slots, ReducerContext ctx, std::string player_name) {
+    auto& rng = ctx.rng();
+    
+    // Generate three slot symbols
+    std::vector<std::string> symbols = {"🍒", "🍋", "🔔", "⭐", "💎"};
+    std::string slot1 = rng.sample(symbols);
+    std::string slot2 = rng.sample(symbols);
+    std::string slot3 = rng.sample(symbols);
+    
+    // Check for wins
+    uint32_t payout = 0;
+    std::string result = slot1 + " " + slot2 + " " + slot3;
+    
+    if (slot1 == slot2 && slot2 == slot3) {
+        if (slot1 == "💎") payout = 1000;      // Jackpot!
+        else if (slot1 == "⭐") payout = 500;   // Stars
+        else payout = 100;                      // Three of a kind
+    } else if (slot1 == slot2 || slot2 == slot3 || slot1 == slot3) {
+        payout = 10;  // Pair
+    }
+    
+    // Record the result
+    GameResult game{0, player_name, "slots", result, payout, ctx.timestamp};
+    ctx.db[game_results].insert(game);
+}
+```
+
+### Technical Details
+
+- **Algorithm**: Uses C++20's `std::mt19937_64` (64-bit Mersenne Twister)
+- **Seeding**: Timestamp microseconds since Unix epoch
+- **Thread Safety**: Each reducer call gets its own RNG instance
+- **Performance**: Lazy initialization - RNG is only created when first accessed
+- **Memory**: Uses `std::shared_ptr` to maintain copyability of `ReducerContext`
+
+## Types and Serialization
+
+### Primitive Types
+
+All standard C++ numeric types are supported:
+
+```cpp
+struct AllTypes {
+    // Integers
+    uint8_t u8_field;
+    uint16_t u16_field;
+    uint32_t u32_field;
+    uint64_t u64_field;
+    int8_t i8_field;
+    int16_t i16_field;
+    int32_t i32_field;
+    int64_t i64_field;
+    
+    // Large integers (SpacetimeDB types)
+    SpacetimeDb::u128 u128_field;
+    SpacetimeDb::u256 u256_field;
+    SpacetimeDb::i128 i128_field;
+    SpacetimeDb::i256 i256_field;
+    
+    // Floating point
+    float f32_field;
+    double f64_field;
+    
+    // Other
+    bool bool_field;
+    std::string string_field;
+};
+SPACETIMEDB_STRUCT(AllTypes, u8_field, u16_field, /* ... all fields ... */);
+```
+
+### Container Types
+
+```cpp
+struct WithContainers {
+    std::vector<uint32_t> numbers;
+    std::vector<std::string> names;
+    std::optional<std::string> description;
+    std::optional<std::vector<uint32_t>> optional_numbers;
+};
+SPACETIMEDB_STRUCT(WithContainers, numbers, names, description, optional_numbers);
+```
+
+### Custom Enums
+
+#### Simple Enums (Unit Variants)
+
+```cpp
+// Using SPACETIMEDB_ENUM macro (recommended)
+SPACETIMEDB_ENUM(Status, Pending, Active, Inactive)
+
+// Manual implementation for complex cases
+enum class Priority : uint8_t { Low = 0, Medium = 1, High = 2 };
+
+namespace SpacetimeDb::bsatn {
+template<>
+struct bsatn_traits<Priority> {
+    static AlgebraicType algebraic_type() {
+        return LazyTypeRegistrar<Priority>::getOrRegister([]() {
+            SumTypeBuilder builder;
+            builder.with_unit_variant("Low");
+            builder.with_unit_variant("Medium");
+            builder.with_unit_variant("High");
+            return AlgebraicType::make_sum(builder.build());
+        }, "Priority");
+    }
+    
+    static void serialize(Writer& writer, const Priority& value) {
+        writer.write_u8(static_cast<uint8_t>(value));
+    }
+    
+    static Priority deserialize(Reader& reader) {
+        return static_cast<Priority>(reader.read_u8());
+    }
+};
+}
+```
+
+#### Variant Enums (With Payloads)
+
+```cpp
+struct ErrorInfo { std::string message; };
+SPACETIMEDB_STRUCT(ErrorInfo, message);
+
+// Enum with different payload types
+SPACETIMEDB_ENUM(Result,
+    (Success, uint32_t),
+    (Error, ErrorInfo),
+    (Pending, std::monostate)  // Unit variant
+)
+```
+
+### Namespace Qualification for Enums
+
+Add namespace qualification to enums for better organization in generated client code:
+
+```cpp
+// Define the enum normally
+SPACETIMEDB_ENUM(UserRole, Admin, Moderator, Member)
+
+// Add namespace qualification (separate macro)
+SPACETIMEDB_NAMESPACE(UserRole, "Auth")  // Will be "Auth.UserRole" in client code
+
+// Multiple enums can share the same namespace
+SPACETIMEDB_ENUM(Permission, Read, Write, Execute, Delete)
+SPACETIMEDB_NAMESPACE(Permission, "Auth")  // Will be "Auth.Permission"
+
+// Works with variant enums too
+SPACETIMEDB_ENUM(NetworkEvent,
+    (Connected, ConnectionInfo),
+    (Disconnected, std::string),
+    (Error, ErrorDetails)
+)
+SPACETIMEDB_NAMESPACE(NetworkEvent, "Network")  // Will be "Network.NetworkEvent"
+```
+
+**How It Works**:
+- The `SPACETIMEDB_NAMESPACE` macro adds compile-time metadata to qualify the type name
+- Client code generators recognize the namespace and organize types accordingly
+- The namespace prefix appears in generated TypeScript, C#, and Rust client code
+- Server-side C++ code continues to use the unqualified name
+
+**Benefits**:
+- Better organization of related types in client code
+- Avoids naming conflicts in large projects
+- Clearer API structure for client developers
+- No runtime overhead - purely compile-time feature
+
+### Custom Structs
+
+```cpp
+struct Address {
+    std::string street;
+    std::string city;
+    std::string country;
+};
+SPACETIMEDB_STRUCT(Address, street, city, country);
+
+struct Person {
+    uint32_t id;
+    std::string name;
+    Address address;  // Nested struct
+    std::vector<std::string> hobbies;
+};
+SPACETIMEDB_STRUCT(Person, id, name, address, hobbies);
+```
+
+## Constraints and Indexing
+
+### Constraint Types
+
+Constraints are applied **after** table registration using `FIELD_` macros:
+
+```cpp
+SPACETIMEDB_TABLE(User, users, Public);
+
+// Primary key (unique + clustered btree index)
+FIELD_PrimaryKey(users, id);
+
+// Auto-incrementing primary key  
+FIELD_PrimaryKeyAutoInc(users, id);
+
+// Unique constraint (creates btree index)
+FIELD_Unique(users, email);
+
+// Auto-incrementing unique field
+FIELD_UniqueAutoInc(users, sequence_num);
+
+// Btree index for fast queries and range operations
+FIELD_Index(users, age);
+
+// Auto-incrementing indexed field
+FIELD_IndexAutoInc(users, order_id);
+
+// Multi-column btree index
+FIELD_NamedMultiColumnIndex(users, age_city_idx, age, city);
+```
+
+### Constraint Requirements
+
+| Constraint Type | Allowed Types |
+|-----------------|---------------|
+| PrimaryKey | Integers, bool, string, Identity, ConnectionId, Timestamp, enums |
+| Unique | Same as PrimaryKey |
+| Index | Same as PrimaryKey |
+| AutoInc | Integer types only |
+
+### Auto-Increment Callbacks
+
+When using auto-increment fields, the `insert()` method automatically returns the row with the generated ID populated. This enables immediate access to generated values without requiring additional lookups.
+
+```cpp
+// Table with auto-increment ID
+SPACETIMEDB_TABLE(User, users, Public);
+FIELD_PrimaryKeyAutoInc(users, id);
+
+SPACETIMEDB_REDUCER(create_user, ReducerContext ctx, std::string name) {
+    User user{0, name, true};  // id=0 is placeholder - will be auto-generated
+    
+    // insert() returns the user with the generated ID
+    User created_user = ctx.db[users].insert(user);
+    
+    // Generated ID is immediately available
+    LOG_INFO("Created user " + name + " with ID: " + std::to_string(created_user.id));
+    
+    // Can use the ID for related operations
+    if (created_user.id > 1000) {
+        LOG_INFO("High-value user created");
+    }
+}
+
+// Works with all auto-increment constraint types
+FIELD_UniqueAutoInc(orders, order_number);
+FIELD_IndexAutoInc(events, sequence);
+FIELD_AutoInc(logs, entry_id);
+```
+
+**How It Works**:
+1. SpacetimeDB generates the auto-increment value server-side
+2. Only the generated column values are returned (not the full row)
+3. The SDK automatically integrates the generated values back into your row object
+4. The `insert()` method returns the complete row with generated fields populated
+
+**Multiple Auto-Increment Fields**:
+If a table has multiple auto-increment fields, all generated values are integrated:
+
+```cpp
+struct LogEntry {
+    uint32_t id;          // Auto-increment primary key
+    uint64_t sequence;    // Auto-increment sequence number
+    std::string message;
+};
+
+SPACETIMEDB_TABLE(LogEntry, logs, Private);
+FIELD_PrimaryKeyAutoInc(logs, id);
+FIELD_UniqueAutoInc(logs, sequence);
+
+SPACETIMEDB_REDUCER(log_message, ReducerContext ctx, std::string msg) {
+    LogEntry entry{0, 0, msg};  // Both id and sequence will be generated
+    LogEntry created = ctx.db[logs].insert(entry);
+    
+    LOG_INFO("Log entry " + std::to_string(created.id) + 
+             " with sequence " + std::to_string(created.sequence));
+}
+```
+
+### Using Indexed Fields
+
+```cpp
+// Primary key access
+SPACETIMEDB_REDUCER(get_user, ReducerContext ctx, uint32_t user_id) {
+    // Efficient O(log n) lookup
+    auto user_opt = ctx.db[users_id].find(user_id);
+    if (user_opt.has_value()) {
+        LOG_INFO("Found user: " + user_opt->name);
+    }
+}
+
+// Unique field access
+SPACETIMEDB_REDUCER(find_by_email, ReducerContext ctx, std::string email) {
+    for (const auto& user : ctx.db[users_email].filter(email)) {
+        LOG_INFO("User with email " + email + ": " + user.name);
+        break; // Unique, so only one result
+    }
+}
+
+// Non-unique index
+SPACETIMEDB_REDUCER(users_by_age, ReducerContext ctx, uint32_t age) {
+    for (const auto& user : ctx.db[users_age].filter(age)) {
+        LOG_INFO("User age " + std::to_string(age) + ": " + user.name);
+    }
+}
+```
+
+### Range Queries
+
+Btree indexes support efficient range queries using the C++ range query system:
+
+```cpp
+#include <spacetimedb/range_queries.h>
+
+SPACETIMEDB_TABLE(Product, products, Public);
+FIELD_Index(products, price);
+FIELD_Index(products, category);
+
+SPACETIMEDB_REDUCER(products_in_price_range, ReducerContext ctx, double min_price, double max_price) {
+    // Create range objects
+    auto price_range = range_inclusive(min_price, max_price);  // min_price..=max_price
+    auto expensive_items = range_from(100.0);                 // >= 100.0
+    auto cheap_items = range_to(50.0);                        // < 50.0
+    
+    // Use indexed field accessor for efficient queries
+    for (const auto& product : ctx.db[products_price].filter(price_range)) {
+        LOG_INFO("Product in range: " + product.name + " - $" + std::to_string(product.price));
+    }
+}
+
+// All range construction patterns
+SPACETIMEDB_REDUCER(demonstrate_ranges, ReducerContext ctx) {
+    auto range1 = range_from(25);                    // 25..  (>= 25)
+    auto range2 = range_to(30);                      // ..30  (< 30)
+    auto range3 = range(20, 35);                     // 20..35 (>= 20, < 35)
+    auto range4 = range_inclusive(20, 35);           // 20..=35 (>= 20, <= 35)
+    auto range5 = range_to_inclusive(30);            // ..=30 (>= 30)
+    auto range6 = range_full<int>();                 // .. (all values)
+    
+    // Check if value is in range
+    bool in_range = range4.contains(25);  // true
+    
+    // Range queries work with any indexed type
+    auto name_range = range(std::string("A"), std::string("M")); // Names A-L
+    for (const auto& user : ctx.db[users_name].filter(name_range)) {
+        LOG_INFO("User: " + user.name);
+    }
+}
+```
+
+## Client Visibility Filters
+
+Control what data clients can see using row-level security:
+
+```cpp
+#include <spacetimedb/client_visibility_filter.h>
+
+// Only show users their own data
+SPACETIMEDB_CLIENT_VISIBILITY_FILTER(user_data_filter, 
+    "SELECT * FROM user_data WHERE owner_identity = current_user_identity()"
+);
+
+// Show public posts and user's own private posts
+SPACETIMEDB_CLIENT_VISIBILITY_FILTER(posts_filter,
+    "SELECT * FROM posts WHERE is_public = true OR author_identity = current_user_identity()"
+);
+
+// Time-based visibility (only show recent messages)
+SPACETIMEDB_CLIENT_VISIBILITY_FILTER(recent_messages,
+    "SELECT * FROM messages WHERE timestamp > (current_timestamp() - INTERVAL '1 day')"
+);
+
+struct UserData {
+    uint32_t id;
+    Identity owner_identity;
+    std::string private_info;
+    bool is_sensitive;
+};
+SPACETIMEDB_STRUCT(UserData, id, owner_identity, private_info, is_sensitive);
+SPACETIMEDB_TABLE(UserData, user_data, Public);  // Public table with RLS
+
+struct Post {
+    uint32_t id;
+    Identity author_identity;
+    std::string content;
+    bool is_public;
+    Timestamp created_at;
+};
+SPACETIMEDB_STRUCT(Post, id, author_identity, content, is_public, created_at);
+SPACETIMEDB_TABLE(Post, posts, Public);  // Filtered by posts_filter
+```
+
+**Available SQL functions for filters:**
+- `current_user_identity()` - Get the calling client's Identity
+- `current_timestamp()` - Get current server timestamp
+- Standard SQL operators and functions
+- Table and column references
+
+## Special Types
+
+SpacetimeDB provides built-in types for common use cases:
+
+### Identity
+
+Represents a unique user/client identity:
+
+```cpp
+struct User {
+    Identity id;        // Unique across all users
+    std::string name;
+};
+
+SPACETIMEDB_REDUCER(create_user, ReducerContext ctx, std::string name) {
+    User user{ctx.sender, name};  // ctx.sender is the calling client's identity
+    ctx.db[users].insert(user);
+}
+```
+
+### ConnectionId
+
+Represents a specific client connection:
+
+```cpp
+struct Session {
+    ConnectionId connection;
+    Identity user;
+    Timestamp login_time;
+};
+```
+
+### Timestamp
+
+Represents a point in time:
+
+```cpp
+struct Event {
+    std::string name;
+    Timestamp when;
+};
+
+SPACETIMEDB_REDUCER(log_event, ReducerContext ctx, std::string event_name) {
+    Event event{event_name, ctx.timestamp};  // Current time
+    ctx.db[events].insert(event);
+}
+```
+
+### TimeDuration
+
+Represents a duration of time:
+
+```cpp
+struct Task {
+    std::string name;
+    TimeDuration estimated_duration;
+};
+
+// Create durations
+auto one_hour = TimeDuration::from_hours(1);
+auto five_minutes = TimeDuration::from_millis(5 * 60 * 1000);
+```
+
+### Scheduled Reducers
+
+Schedule reducers to run automatically at specified times:
+
+```cpp
+#include <spacetimedb/schedule_reducer.h>
+
+// Define a table to store scheduled tasks
+struct ScheduledTask {
+    uint32_t id;
+    ScheduleAt run_at;         // When to execute
+    std::string task_data;
+    Timestamp created_at;
+};
+SPACETIMEDB_STRUCT(ScheduledTask, id, run_at, task_data, created_at);
+SPACETIMEDB_TABLE(ScheduledTask, scheduled_tasks, Private);
+FIELD_PrimaryKeyAutoInc(scheduled_tasks, id);
+
+// Register the table for scheduling (column 1 = run_at field, index 0-based)
+SPACETIMEDB_SCHEDULE(scheduled_tasks, 1, process_scheduled_task);
+
+// The scheduled reducer - called automatically when tasks are due
+SPACETIMEDB_REDUCER(process_scheduled_task, ReducerContext ctx, ScheduledTask task) {
+    LOG_INFO("Processing scheduled task: " + task.task_data);
+    
+    // Process the task...
+    
+    // Optionally schedule another task
+    auto next_run = ScheduleAt(TimeDuration::from_hours(24)); // Run in 24 hours
+    ScheduledTask next_task{0, next_run, "Daily cleanup", ctx.timestamp};
+    ctx.db[scheduled_tasks].insert(next_task);
+}
+
+// Create scheduled tasks from other reducers
+SPACETIMEDB_REDUCER(schedule_reminder, ReducerContext ctx, std::string message, uint64_t delay_seconds) {
+    auto run_time = ScheduleAt(TimeDuration::from_secs(delay_seconds));
+    ScheduledTask reminder{0, run_time, message, ctx.timestamp};
+    ctx.db[scheduled_tasks].insert(reminder);
+    
+    LOG_INFO("Reminder scheduled for " + std::to_string(delay_seconds) + " seconds");
+}
+
+// ScheduleAt can be created with TimeDuration (relative) or Timestamp (absolute)
+SPACETIMEDB_REDUCER(schedule_examples, ReducerContext ctx) {
+    // Relative scheduling (from now)
+    auto in_one_hour = ScheduleAt(TimeDuration::from_hours(1));
+    auto in_five_minutes = ScheduleAt(TimeDuration::from_millis(5 * 60 * 1000));
+    
+    // Absolute scheduling (specific time)
+    auto specific_time = ScheduleAt(Timestamp::from_millis(1640995200000)); // Specific Unix timestamp
+    
+    // Schedule tasks
+    ctx.db[scheduled_tasks].insert(ScheduledTask{0, in_one_hour, "Hourly task", ctx.timestamp});
+    ctx.db[scheduled_tasks].insert(ScheduledTask{0, in_five_minutes, "Quick task", ctx.timestamp});
+}
+```
+
+**Key points about scheduled reducers:**
+- Must have a table with a `ScheduleAt` field
+- Use `SPACETIMEDB_SCHEDULE(table_name, column_index, reducer_name)` to register
+- The scheduled reducer receives the entire row as parameter
+- Column index is 0-based (0 = first field, 1 = second field, etc.)
+- Scheduled reducers run with module identity, not client identity
+
+## Logging
+
+SpacetimeDB provides structured logging:
+
+```cpp
+SPACETIMEDB_REDUCER(example, ReducerContext ctx) {
+    LOG_DEBUG("Debug information");
+    LOG_INFO("General information");
+    LOG_WARN("Warning message");
+    LOG_ERROR("Error occurred");
+    LOG_PANIC("Fatal error");  // Terminates reducer
+    
+    // With timing
+    {
+        LogStopwatch timer("Database operation");
+        // ... time-consuming operation ...
+    } // Automatically logs duration
+}
+```
+
+## Build System
+
+### CMake Configuration
+
+The C++ SDK uses CMake with Emscripten for WebAssembly compilation:
+
+```cmake
+# Basic configuration
+cmake_minimum_required(VERSION 3.16)
+project(my-module)
+set(CMAKE_CXX_STANDARD 20)
+
+# Module source (defaults to src/lib.cpp)
+if(NOT DEFINED MODULE_SOURCE)
+    set(MODULE_SOURCE "src/lib.cpp")
+endif()
+
+# Output name (defaults to "lib")
+if(NOT DEFINED OUTPUT_NAME)
+    set(OUTPUT_NAME "lib")
+endif()
+
+# Link SpacetimeDB library
+set(SPACETIMEDB_CPP_LIBRARY_PATH "path/to/bindings-cpp")
+add_executable(${OUTPUT_NAME} ${MODULE_SOURCE})
+target_include_directories(${OUTPUT_NAME} PRIVATE ${SPACETIMEDB_CPP_LIBRARY_PATH}/include)
+add_subdirectory(${SPACETIMEDB_CPP_LIBRARY_PATH} spacetimedb_cpp_library)
+target_link_libraries(${OUTPUT_NAME} PRIVATE spacetimedb_cpp_library)
+```
+
+### Build Commands
+
+```bash
+# Standard build
+emcmake cmake -B build .
+cmake --build build
+
+# Custom module source
+emcmake cmake -B build -DMODULE_SOURCE=src/test.cpp -DOUTPUT_NAME=test .
+cmake --build build
+# Creates build/test.wasm
+
+# Publishing
+spacetime publish --bin-path build/lib.wasm my-database
+# Or auto-detect
+spacetime publish . my-database
+```
+
+### Emscripten Settings
+
+The build system automatically configures:
+- WebAssembly output format
+- Required exports for SpacetimeDB
+- Memory settings optimized for database operations
+- Exception handling disabled for WASM compatibility
+
+## Examples
+
+### Complete User Management System
+
+```cpp
+#include <spacetimedb.h>
+using namespace SpacetimeDb;
+
+// User data structure
+struct User {
+    uint32_t id;
+    Identity identity;
+    std::string username;
+    std::string email;
+    Timestamp created_at;
+    bool active;
+};
+SPACETIMEDB_STRUCT(User, id, identity, username, email, created_at, active);
+
+// User table with constraints
+SPACETIMEDB_TABLE(User, users, Public);
+FIELD_PrimaryKeyAutoInc(users, id);
+FIELD_Unique(users, identity);
+FIELD_Unique(users, username);
+FIELD_Unique(users, email);
+FIELD_Index(users, active);
+
+// Register new user
+SPACETIMEDB_REDUCER(register_user, ReducerContext ctx, std::string username, std::string email) {
+    // Check if user already exists
+    for (const auto& user : ctx.db[users_identity].filter(ctx.sender)) {
+        if (user.active) {
+            LOG_ERROR("User already registered");
+            return;
+        }
+    }
+    
+    User new_user{0, ctx.sender, username, email, ctx.timestamp, true};
+    ctx.db[users].insert(new_user);
+    LOG_INFO("User registered: " + username);
+}
+
+// Update user profile
+SPACETIMEDB_REDUCER(update_profile, ReducerContext ctx, std::string new_username) {
+    for (auto& user : ctx.db[users]) {
+        if (user.identity == ctx.sender && user.active) {
+            user.username = new_username;
+            ctx.db[users].update(user);
+            LOG_INFO("Profile updated");
+            return;
+        }
+    }
+    LOG_ERROR("User not found or inactive");
+}
+
+// Deactivate user
+SPACETIMEDB_REDUCER(deactivate_user, ReducerContext ctx) {
+    for (auto& user : ctx.db[users]) {
+        if (user.identity == ctx.sender) {
+            user.active = false;
+            ctx.db[users].update(user);
+            LOG_INFO("User deactivated");
+            return;
+        }
+    }
+}
+
+// Admin: List all active users
+SPACETIMEDB_REDUCER(list_active_users, ReducerContext ctx) {
+    for (const auto& user : ctx.db[users_active].filter(true)) {
+        LOG_INFO("Active user: " + user.username + " (" + user.email + ")");
+    }
+}
+
+// Lifecycle: Track connections
+SPACETIMEDB_CLIENT_CONNECTED(on_connect) {
+    LOG_INFO("Client connected");
+}
+
+SPACETIMEDB_CLIENT_DISCONNECTED(on_disconnect) {
+    LOG_INFO("Client disconnected");
+}
+```
+
+### Advanced: Chat System with Channels
+
+```cpp
+// Channel structure
+struct Channel {
+    uint32_t id;
+    std::string name;
+    std::string description;
+    Identity owner;
+    bool public_channel;
+};
+SPACETIMEDB_STRUCT(Channel, id, name, description, owner, public_channel);
+SPACETIMEDB_TABLE(Channel, channels, Public);
+FIELD_PrimaryKeyAutoInc(channels, id);
+FIELD_Unique(channels, name);
+
+// Message structure
+struct Message {
+    uint32_t id;
+    uint32_t channel_id;
+    Identity sender;
+    std::string content;
+    Timestamp timestamp;
+};
+SPACETIMEDB_STRUCT(Message, id, channel_id, sender, content, timestamp);
+SPACETIMEDB_TABLE(Message, messages, Public);
+FIELD_PrimaryKeyAutoInc(messages, id);
+FIELD_Index(messages, channel_id);
+FIELD_Index(messages, sender);
+
+// Create channel
+SPACETIMEDB_REDUCER(create_channel, ReducerContext ctx, std::string name, std::string description, bool is_public) {
+    Channel channel{0, name, description, ctx.sender, is_public};
+    ctx.db[channels].insert(channel);
+    LOG_INFO("Channel created: " + name);
+}
+
+// Send message to channel
+SPACETIMEDB_REDUCER(send_message, ReducerContext ctx, uint32_t channel_id, std::string content) {
+    // Verify channel exists
+    bool channel_exists = false;
+    for (const auto& channel : ctx.db[channels]) {
+        if (channel.id == channel_id) {
+            channel_exists = true;
+            break;
+        }
+    }
+    
+    if (!channel_exists) {
+        LOG_ERROR("Channel not found");
+        return;
+    }
+    
+    Message message{0, channel_id, ctx.sender, content, ctx.timestamp};
+    ctx.db[messages].insert(message);
+}
+
+// Get channel history
+SPACETIMEDB_REDUCER(get_channel_history, ReducerContext ctx, uint32_t channel_id) {
+    for (const auto& message : ctx.db[messages_channel_id].filter(channel_id)) {
+        LOG_INFO("Message: " + message.content);
+    }
+}
+```
+
+## Error Handling
+
+### Constraint Violations
+
+```cpp
+SPACETIMEDB_REDUCER(create_user, ReducerContext ctx, std::string username) {
+    User user{0, ctx.sender, username, ctx.timestamp};
+    
+    // If username is not unique, this will fail the entire transaction
+    ctx.db[users].insert(user);
+    
+    // This line won't execute if the insert fails
+    LOG_INFO("User created successfully");
+}
+```
+
+### Validation Patterns
+
+```cpp
+SPACETIMEDB_REDUCER(update_age, ReducerContext ctx, uint32_t new_age) {
+    if (new_age > 150) {
+        LOG_ERROR("Invalid age: " + std::to_string(new_age));
+        return; // Early return prevents any database changes
+    }
+    
+    // Find and update user...
+}
+```
+
+---
+
+This completes the C++ reference documentation. For more examples and advanced patterns, see the working modules in [`modules/sdk-test-cpp`](../../modules/sdk-test-cpp) and [`modules/module-test-cpp`](../../modules/module-test-cpp).
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb.h b/crates/bindings-cpp/include/spacetimedb.h
new file mode 100644
index 00000000000..6cb10d5b91d
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb.h
@@ -0,0 +1,203 @@
+#pragma once
+
+/**
+ * SpacetimeDB C++20 Module API - Single Include Header
+ * 
+ * Complete, optimized API for building SpacetimeDB modules with support for:
+ * - Tables with field constraints
+ * - BSATN serialization
+ * - Reducers (user-defined and lifecycle)
+ * - Database operations
+ * - Logging and debugging
+ * 
+ * =============================================================================
+ * USAGE EXAMPLES
+ * =============================================================================
+ * 
+ * Table Definition:
+ *    struct User {
+ *        uint32_t id;
+ *        std::string username;
+ *        std::string email;
+ *    };
+ *    SPACETIMEDB_STRUCT(User, id, username, email)
+ *    SPACETIMEDB_TABLE(User, "users", Public,
+ *        PrimaryKeyAutoInc(id),
+ *        Unique(email)
+ *    )
+ * 
+ * Lifecycle Reducers:
+ *    SPACETIMEDB_INIT(init_module) {
+ *        LOG_INFO("Module initialized!");
+ *    }
+ * 
+ * User Reducers:
+ *    void add_user(ReducerContext ctx, std::string username, std::string email) {
+ *        User user{0, username, email}; // id auto-generated
+ *        ctx.db.table<User>("users").insert(user);
+ *    }
+ *    REGISTER_REDUCER(add_user, add_user)
+ */
+
+// =============================================================================
+// STANDARD LIBRARY DEPENDENCIES
+// =============================================================================
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <array>
+#include <string_view>
+#include <concepts>
+#include <functional>
+#include <type_traits>
+#include <span>
+
+// =============================================================================
+// CORE SPACETIMEDB TYPE SYSTEM
+// =============================================================================
+
+// Core types and BSATN support
+#include "spacetimedb/bsatn/types.h"
+#include "spacetimedb/bsatn/timestamp.h"
+#include "spacetimedb/bsatn/time_duration.h"
+#include "spacetimedb/bsatn/writer.h"
+#include "spacetimedb/bsatn/reader.h"
+#include "spacetimedb/bsatn/algebraic_type.h"
+#include "spacetimedb/bsatn/traits.h"
+#include "spacetimedb/bsatn/sum_type.h"
+#include "spacetimedb/bsatn/schedule_at.h"
+
+// Autogenerated types for module definition
+#include "spacetimedb/internal/autogen/SumType.g.h"  // Complete SumType definition first
+#include "spacetimedb/internal/autogen/RawModuleDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawTableDefV9.g.h"
+#include "spacetimedb/internal/autogen/Typespace.g.h"
+#include "spacetimedb/internal/autogen/ProductType.g.h"
+#include "spacetimedb/internal/autogen/ProductTypeElement.g.h"
+#include "spacetimedb/internal/autogen/TableAccess.g.h"
+#include "spacetimedb/internal/autogen/TableType.g.h"
+
+// =============================================================================
+// MODULE SYSTEM INFRASTRUCTURE
+// =============================================================================
+
+// Core module infrastructure
+#include "spacetimedb/internal/Module.h"
+#include "spacetimedb/internal/field_registration.h"
+
+// Logging system
+#include "spacetimedb/logger.h"
+
+// =============================================================================
+// TABLE AND CONSTRAINT SYSTEM
+// =============================================================================
+
+// Type extensions for special types
+#include "spacetimedb/bsatn/type_extensions.h"
+
+// Table operations and constraint support
+#include "spacetimedb/table.h"
+#include "spacetimedb/database.h"
+#include "spacetimedb/table_with_constraints.h"
+
+// =============================================================================
+// REDUCER SYSTEM
+// =============================================================================
+
+// Reducer context and macros
+#include "spacetimedb/reducer_context.h"
+#include "spacetimedb/reducer_macros.h"
+#include "spacetimedb/reducer_error.h"
+
+// Client visibility filters
+#include "spacetimedb/client_visibility_filter.h"
+#include "spacetimedb/rls.h"
+
+// =============================================================================
+// CONVENIENCE ALIASES AND COMPATIBILITY
+// =============================================================================
+
+// Convenience aliases for table access levels
+namespace SpacetimeDb {
+    // Re-export table access constants for convenience
+    constexpr auto Public = Internal::TableAccess::Public;
+    constexpr auto Private = Internal::TableAccess::Private;
+}
+
+// =============================================================================
+// UNIFIED MACRO SYSTEM
+// =============================================================================
+
+// Use unified macro system
+#include "spacetimedb/macros.h"
+
+
+// =============================================================================
+// MODULE DEFINITION UTILITIES
+// =============================================================================
+
+// Forward declarations for module system compatibility
+namespace spacetimedb {
+    // Template specialization support
+    template<typename T> struct table_metadata;
+    
+    namespace internal {
+        /**
+         * @brief Serialize the current module definition to BSATN
+         * @return Serialized module definition
+         */
+        inline std::vector<uint8_t> serialize_module_def() {
+            auto& module_def = SpacetimeDb::Internal::Module::GetModuleDef();
+            return module_def.serialize();
+        }
+    }
+
+    // =============================================================================
+    // CONVENIENCE TYPE ALIASES
+    // =============================================================================
+    
+    // Vector type aliases for SpacetimeDB types
+    using VecTimeDuration = std::vector<::SpacetimeDb::TimeDuration>;
+}
+
+// =============================================================================
+// DOCUMENTATION AND USAGE NOTES
+// =============================================================================
+
+/**
+ * CONSTRAINT TYPES REFERENCE:
+ * 
+ * Basic Constraints:
+ * - PrimaryKey(field) - Primary key constraint (unique, non-null)
+ * - Unique(field) - Unique constraint (allows null)
+ * - Index(field) - Index for fast lookups
+ * - AutoInc(field) - Auto-incrementing field
+ * 
+ * Combination Constraints:
+ * - PrimaryKeyAutoInc(field) - Primary key with auto-increment
+ * - UniqueAutoInc(field) - Unique field with auto-increment  
+ * - IndexAutoInc(field) - Indexed field with auto-increment
+ * 
+ * LIFECYCLE REDUCERS:
+ * - SPACETIMEDB_INIT(name) - Called when module is initialized
+ * - SPACETIMEDB_CLIENT_CONNECTED(name) - Called when client connects
+ * - SPACETIMEDB_CLIENT_DISCONNECTED(name) - Called when client disconnects
+ * 
+ * LOGGING LEVELS:
+ * - LOG_DEBUG(msg) - Debug information
+ * - LOG_INFO(msg) - General information
+ * - LOG_WARN(msg) - Warning messages
+ * - LOG_ERROR(msg) - Error messages
+ * - LOG_PANIC(msg) - Critical errors (may terminate)
+ */
+
+// =============================================================================
+// BSATN IMPLEMENTATION INCLUDES
+// =============================================================================
+
+// Include BSATN implementation files after all headers are defined
+#include "spacetimedb/bsatn/types_impl.h"
+#include "spacetimedb/bsatn/schedule_at_impl.h"
+#include "spacetimedb/enum_macro.h"
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/abi/FFI.h b/crates/bindings-cpp/include/spacetimedb/abi/FFI.h
new file mode 100644
index 00000000000..e8663f579fd
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/abi/FFI.h
@@ -0,0 +1,125 @@
+#ifndef SPACETIMEDB_FFI_H
+#define SPACETIMEDB_FFI_H
+
+#include <cstdint>
+#include <cstddef>
+#include "spacetimedb/abi/opaque_types.h"
+#include "spacetimedb/abi/abi.h"
+
+/**
+ * @file FFI.h
+ * @brief SpacetimeDB Foreign Function Interface (FFI) layer for C++ modules
+ * 
+ * This file re-exports the raw ABI functions with additional type aliases
+ * and convenience functions. Since we now use C# style opaque types that
+ * are ABI-compatible, no conversion is needed.
+ * 
+ * Organization:
+ * - Raw C ABI with opaque types is in abi.h
+ * - This file provides type aliases and convenience functions
+ * 
+ * Key Features:
+ * - Type-safe opaque types prevent mixing TableId with IndexId etc.
+ * - Full BSATN integration for all data operations
+ * - Modern iterator API with proper resource management
+ * - Comprehensive error handling with Status codes
+ * 
+ * Note: WASI shims for C++ standard library support are provided separately
+ * in the module library implementation.
+ */
+
+// ========================================================================
+// C++ TYPE ALIASES AND CONVENIENCE FUNCTIONS
+// ========================================================================
+
+namespace SpacetimeDb {
+namespace FFI {
+
+using LogLevel = ::SpacetimeDb::LogLevel;
+using IndexType = ::SpacetimeDb::IndexType;
+
+// Re-export all functions from the raw ABI
+// Since we now use ABI-compatible opaque types, no conversion is needed
+using ::table_id_from_name;
+using ::index_id_from_name;
+using ::datastore_table_row_count;
+using ::datastore_table_scan_bsatn;
+using ::datastore_index_scan_range_bsatn;
+using ::datastore_btree_scan_bsatn;
+using ::row_iter_bsatn_advance;
+using ::row_iter_bsatn_close;
+using ::datastore_insert_bsatn;
+using ::datastore_update_bsatn;
+using ::datastore_delete_by_index_scan_range_bsatn;
+using ::datastore_delete_by_btree_scan_bsatn;
+using ::datastore_delete_all_by_eq_bsatn;
+using ::bytes_source_read;
+using ::bytes_sink_write;
+using ::console_log;
+using ::console_timer_start;
+using ::console_timer_end;
+
+// ===== Scheduling =====
+#ifdef SPACETIMEDB_UNSTABLE_FEATURES
+using ::volatile_nonatomic_schedule_immediate;
+#endif
+
+// ===== Identity =====
+using ::identity;
+
+// ===== Module Export Helpers =====
+
+// Helper for __describe_module__ implementation
+inline void describe_module(BytesSink description) {
+    ::__describe_module__(description);
+}
+
+// Helper for __call_reducer__ implementation
+inline int16_t call_reducer(
+    uint32_t id,
+    uint64_t sender_0, uint64_t sender_1, uint64_t sender_2, uint64_t sender_3,
+    uint64_t conn_id_0, uint64_t conn_id_1,
+    uint64_t timestamp, 
+    BytesSource args, 
+    BytesSink error) {
+    return ::__call_reducer__(id, sender_0, sender_1, sender_2, sender_3,
+                             conn_id_0, conn_id_1, timestamp, 
+                             args, error);
+}
+
+// Utility functions for common operations
+namespace Utils {
+
+// Helper to write data to a BytesSink
+inline void write_bytes_to_sink(BytesSink sink_handle, const uint8_t* data, size_t len) {
+    size_t buffer_len = len;
+    Status status = bytes_sink_write(sink_handle, data, &buffer_len);
+    if (is_error(status)) {
+        // In a real implementation, this would use the SDK's exception system
+        // For now, we just ignore errors in this utility function
+    }
+}
+
+// Helper to read all data from a BytesSource
+inline bool read_all_from_source(BytesSource source_handle, uint8_t* buffer, size_t* buffer_len) {
+    int16_t result = bytes_source_read(source_handle, buffer, buffer_len);
+    return result >= 0;
+}
+
+} // namespace Utils
+
+// Additional status codes
+namespace StatusCode {
+    using namespace ::SpacetimeDb::StatusCode;
+    constexpr Status EXHAUSTED{16};
+}
+
+// Custom wrapper for simplified logging
+inline void console_log(const uint8_t* message, size_t message_len, LogLevel level) {
+    ::console_log(level, nullptr, 0, nullptr, 0, 0, message, message_len);
+}
+
+} // namespace FFI
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_FFI_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/abi/abi.h b/crates/bindings-cpp/include/spacetimedb/abi/abi.h
new file mode 100644
index 00000000000..09a4ee01c86
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/abi/abi.h
@@ -0,0 +1,173 @@
+#ifndef SPACETIMEDB_ABI_H
+#define SPACETIMEDB_ABI_H
+
+#include <cstdint>
+#include <cstddef>
+#include "opaque_types.h"
+
+/**
+ * @file abi.h
+ * @brief Raw C ABI interface for SpacetimeDB modules
+ * 
+ * This file contains the raw C-compatible ABI declarations.
+ * These functions use only C-compatible types and are suitable
+ * for extern "C" linkage.
+ */
+
+// ========================================================================
+// SECTION 1: IMPORT DECLARATIONS - Functions provided by SpacetimeDB host
+// ========================================================================
+
+// Macro for declaring imported functions from the SpacetimeDB host
+#define STDB_IMPORT(name) \
+    __attribute__((import_module("spacetime_10.0"), import_name(#name))) extern
+
+// Import opaque types into global namespace for C compatibility
+using SpacetimeDb::Status;
+using SpacetimeDb::TableId;
+using SpacetimeDb::IndexId;
+using SpacetimeDb::ColId;
+using SpacetimeDb::IndexType;
+using SpacetimeDb::LogLevel;
+using SpacetimeDb::BytesSink;
+using SpacetimeDb::BytesSource;
+using SpacetimeDb::RowIter;
+using SpacetimeDb::ConsoleTimerId;
+
+// Disable warnings about C-linkage with user-defined types
+// This is safe because our opaque types are single-field structs
+// which have the same ABI as their underlying type
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+
+extern "C" {
+
+// ===== Table and Index Management =====
+STDB_IMPORT(table_id_from_name)
+Status table_id_from_name(const uint8_t* name_ptr, size_t name_len, TableId* out);
+
+STDB_IMPORT(index_id_from_name)
+Status index_id_from_name(const uint8_t* name_ptr, size_t name_len, IndexId* out);
+
+// ===== Table Operations =====
+STDB_IMPORT(datastore_table_row_count)
+Status datastore_table_row_count(TableId table_id, uint64_t* out);
+
+STDB_IMPORT(datastore_table_scan_bsatn)
+Status datastore_table_scan_bsatn(TableId table_id, RowIter* out);
+
+// ===== Index Scanning =====
+STDB_IMPORT(datastore_index_scan_range_bsatn)
+Status datastore_index_scan_range_bsatn(
+    IndexId index_id, const uint8_t* prefix_ptr, size_t prefix_len, ColId prefix_elems,
+    const uint8_t* rstart_ptr, size_t rstart_len, const uint8_t* rend_ptr, size_t rend_len, 
+    RowIter* out);
+
+STDB_IMPORT(datastore_btree_scan_bsatn)
+Status datastore_btree_scan_bsatn(
+    IndexId index_id, const uint8_t* prefix_ptr, size_t prefix_len, ColId prefix_elems,
+    const uint8_t* rstart_ptr, size_t rstart_len, const uint8_t* rend_ptr, size_t rend_len, 
+    RowIter* out);
+
+// ===== Row Iterator Operations =====
+STDB_IMPORT(row_iter_bsatn_advance)
+int16_t row_iter_bsatn_advance(RowIter iter, uint8_t* buffer_ptr, size_t* buffer_len_ptr);
+
+STDB_IMPORT(row_iter_bsatn_close)
+Status row_iter_bsatn_close(RowIter iter);
+
+// ===== Data Manipulation =====
+STDB_IMPORT(datastore_insert_bsatn)
+Status datastore_insert_bsatn(TableId table_id, uint8_t* row_ptr, size_t* row_len_ptr);
+
+STDB_IMPORT(datastore_update_bsatn)
+Status datastore_update_bsatn(TableId table_id, IndexId index_id, uint8_t* row_ptr, size_t* row_len_ptr);
+
+// ===== Delete Operations =====
+STDB_IMPORT(datastore_delete_by_index_scan_range_bsatn)
+Status datastore_delete_by_index_scan_range_bsatn(
+    IndexId index_id, const uint8_t* prefix_ptr, size_t prefix_len, ColId prefix_elems,
+    const uint8_t* rstart_ptr, size_t rstart_len, const uint8_t* rend_ptr, size_t rend_len, 
+    uint32_t* out);
+
+STDB_IMPORT(datastore_delete_by_btree_scan_bsatn)
+Status datastore_delete_by_btree_scan_bsatn(
+    IndexId index_id, const uint8_t* prefix_ptr, size_t prefix_len, ColId prefix_elems,
+    const uint8_t* rstart_ptr, size_t rstart_len, const uint8_t* rend_ptr, size_t rend_len, 
+    uint32_t* out);
+
+STDB_IMPORT(datastore_delete_all_by_eq_bsatn)
+Status datastore_delete_all_by_eq_bsatn(
+    TableId table_id, const uint8_t* rel_ptr, size_t rel_len,
+    uint32_t* out);
+
+// ===== Bytes Source/Sink Operations =====
+STDB_IMPORT(bytes_source_read)
+int16_t bytes_source_read(BytesSource source, uint8_t* buffer_ptr, size_t* buffer_len_ptr);
+
+STDB_IMPORT(bytes_sink_write)
+Status bytes_sink_write(BytesSink sink, const uint8_t* buffer_ptr, size_t* buffer_len_ptr);
+
+// ===== Console/Logging Operations =====
+STDB_IMPORT(console_log)
+void console_log(
+    LogLevel level, const uint8_t* target_ptr, size_t target_len,
+    const uint8_t* filename_ptr, size_t filename_len, uint32_t line_number,
+    const uint8_t* message_ptr, size_t message_len);
+
+STDB_IMPORT(console_timer_start)
+ConsoleTimerId console_timer_start(const uint8_t* name_ptr, size_t name_len);
+
+STDB_IMPORT(console_timer_end)
+Status console_timer_end(ConsoleTimerId timer_id);
+
+// ===== Scheduling =====
+#ifdef SPACETIMEDB_UNSTABLE_FEATURES
+STDB_IMPORT(volatile_nonatomic_schedule_immediate)
+void volatile_nonatomic_schedule_immediate(
+    const uint8_t* name_ptr, size_t name_len, const uint8_t* args_ptr, size_t args_len);
+#endif
+
+// ===== Identity =====
+STDB_IMPORT(identity)
+void identity(uint8_t* id_ptr);
+
+} // extern "C"
+
+// ========================================================================
+// SECTION 2: EXPORT DECLARATIONS - Functions modules provide to SpacetimeDB
+// ========================================================================
+
+// Macro for declaring exported functions that the module provides
+#define STDB_EXPORT(name) __attribute__((export_name(#name)))
+
+extern "C" {
+
+// ===== Required Module Exports =====
+STDB_EXPORT(__describe_module__)
+void __describe_module__(BytesSink description);
+
+STDB_EXPORT(__call_reducer__)
+int16_t __call_reducer__(
+    uint32_t id,
+    uint64_t sender_0, uint64_t sender_1, uint64_t sender_2, uint64_t sender_3,
+    uint64_t conn_id_0, uint64_t conn_id_1,
+    uint64_t timestamp, 
+    BytesSource args, 
+    BytesSink error);
+
+// ========================================================================
+// WASI SHIMS
+// ========================================================================
+
+// This indicates that WASI shims are provided by the SpacetimeDB C++ Module Library
+// When this is defined, modules can safely use the C++ standard library
+// The actual WASI function declarations come from system headers (wasi/api.h)
+// Our implementations are in wasi_shims.cpp
+#define SPACETIMEDB_HAS_WASI_SHIMS 1
+
+} // extern "C"
+
+#pragma clang diagnostic pop
+
+#endif // SPACETIMEDB_ABI_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/abi/opaque_types.h b/crates/bindings-cpp/include/spacetimedb/abi/opaque_types.h
new file mode 100644
index 00000000000..ae6f0f9bcce
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/abi/opaque_types.h
@@ -0,0 +1,195 @@
+#ifndef SPACETIMEDB_OPAQUE_TYPES_H
+#define SPACETIMEDB_OPAQUE_TYPES_H
+
+#include <cstdint>
+#include <functional>
+#include <unordered_map>
+#include <string>
+
+/**
+ * @file opaque_types.h
+ * @brief Type-safe opaque wrappers for SpacetimeDB handle types
+ * 
+ * This file provides opaque type wrappers matching the C# implementation
+ * to prevent accidental mixing of different handle types and improve type safety.
+ * 
+ * These types use C# style single-field structs for direct ABI compatibility,
+ * allowing them to be passed directly to C imports without conversion.
+ * 
+ * Benefits:
+ * - Prevents mixing TableId with IndexId, etc.
+ * - Makes APIs more self-documenting
+ * - Catches type errors at compile time
+ * - Zero runtime overhead (optimized away)
+ * - Direct ABI compatibility with C imports
+ */
+
+namespace SpacetimeDb {
+
+// Macro to define opaque typedef with C# style single-field struct
+// This ensures ABI compatibility - struct with single field has same
+// memory layout and calling convention as the field itself
+#define SPACETIMEDB_OPAQUE_TYPEDEF(Name, UnderlyingType)                      \
+    struct Name {                                                              \
+        UnderlyingType inner;                                                  \
+                                                                              \
+        /* Constructors */                                                     \
+        constexpr Name() : inner(0) {}                                        \
+        constexpr explicit Name(UnderlyingType v) : inner(v) {}               \
+                                                                              \
+        /* Conversion operators for backward compatibility */                  \
+        constexpr explicit operator UnderlyingType() const { return inner; }   \
+        constexpr UnderlyingType get() const { return inner; }                \
+ \
+                                                                              \
+        /* Comparison operators */                                             \
+        constexpr bool operator==(const Name& other) const {                  \
+            return inner == other.inner;                                       \
+        }                                                                      \
+        constexpr bool operator!=(const Name& other) const {                  \
+            return inner != other.inner;                                       \
+        }                                                                      \
+        constexpr bool operator<(const Name& other) const {                   \
+            return inner < other.inner;                                        \
+        }                                                                      \
+        constexpr bool operator<=(const Name& other) const {                  \
+            return inner <= other.inner;                                       \
+        }                                                                      \
+        constexpr bool operator>(const Name& other) const {                   \
+            return inner > other.inner;                                        \
+        }                                                                      \
+        constexpr bool operator>=(const Name& other) const {                  \
+            return inner >= other.inner;                                       \
+        }                                                                      \
+                                                                              \
+        /* Check if valid (non-zero) */                                        \
+        constexpr bool is_valid() const { return inner != 0; }                \
+        constexpr explicit operator bool() const { return is_valid(); }        \
+    };                                                                         \
+                                                                              \
+    /* Hash support for unordered containers */                               \
+    inline std::size_t hash_value(const Name& id) {                          \
+        return std::hash<UnderlyingType>{}(id.inner);                        \
+    }
+
+// Define opaque types matching C# bindings
+SPACETIMEDB_OPAQUE_TYPEDEF(Status, uint16_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(TableId, uint32_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(IndexId, uint32_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(ColId, uint16_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(IndexType, uint8_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(LogLevel, uint8_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(BytesSink, uint32_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(BytesSource, uint32_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(RowIter, uint32_t)
+SPACETIMEDB_OPAQUE_TYPEDEF(ConsoleTimerId, uint32_t)
+
+// Common invalid/sentinel values
+namespace Invalid {
+    constexpr TableId TABLE_ID{0};
+    constexpr IndexId INDEX_ID{0};
+    constexpr RowIter ROW_ITER{0xFFFFFFFF};
+    constexpr BytesSource BYTES_SOURCE{0xFFFFFFFF};
+    constexpr BytesSink BYTES_SINK{0xFFFFFFFF};
+    constexpr ConsoleTimerId CONSOLE_TIMER{0};
+}
+
+// Define all status codes in one place using X-macro pattern
+#define SPACETIMEDB_STATUS_CODES(X) \
+    X(OK, 0) \
+    X(HOST_CALL_FAILURE, 1) \
+    X(NOT_IN_TRANSACTION, 2) \
+    X(BSATN_DECODE_ERROR, 3) \
+    X(NO_SUCH_TABLE, 4) \
+    X(NO_SUCH_INDEX, 5) \
+    X(NO_SUCH_ITER, 6) \
+    X(NO_SUCH_CONSOLE_TIMER, 7) \
+    X(NO_SUCH_BYTES, 8) \
+    X(NO_SPACE, 9) \
+    X(BUFFER_TOO_SMALL, 11) \
+    X(UNIQUE_ALREADY_EXISTS, 12) \
+    X(SCHEDULE_AT_DELAY_TOO_LONG, 13) \
+    X(INDEX_NOT_UNIQUE, 14) \
+    X(NO_SUCH_ROW, 15) \
+    X(AUTO_INC_OVERFLOW, 16) \
+    X(NO_SUCH_REDUCER, 999) \
+    X(UNKNOWN, 0xFFFF)
+
+// Status code constants generated from the X-macro
+namespace StatusCode {
+    // Generate constants
+    #define X(name, value) constexpr Status name{value};
+    SPACETIMEDB_STATUS_CODES(X)
+    #undef X
+    
+    // Generate string lookup function
+    inline const char* to_string(Status status) {
+        switch (status.inner) {
+            #define X(name, value) case value: return #name;
+            SPACETIMEDB_STATUS_CODES(X)
+            #undef X
+            default: return "UNKNOWN_ERROR";
+        }
+    }
+}
+
+// Log level constants
+namespace LogLevelValue {
+    constexpr LogLevel ERROR{0};
+    constexpr LogLevel WARN{1};
+    constexpr LogLevel INFO{2};
+    constexpr LogLevel DEBUG{3};
+    constexpr LogLevel TRACE{4};
+}
+
+// Index type constants
+namespace IndexTypeValue {
+    constexpr IndexType BTREE{0};
+    constexpr IndexType HASH{1};
+}
+
+// Helper functions
+inline bool is_ok(Status status) { 
+    return status == StatusCode::OK; 
+}
+
+inline bool is_error(Status status) { 
+    return status != StatusCode::OK; 
+}
+
+// Format status with both name and numeric code
+inline std::string format_status(Status status) {
+    return std::string(StatusCode::to_string(status)) + " (" + std::to_string(status.inner) + ")";
+}
+
+// Enable std::hash for opaque types
+} // namespace SpacetimeDb
+
+// Specializations for std::hash
+namespace std {
+    template<> struct hash<SpacetimeDb::TableId> {
+        size_t operator()(const SpacetimeDb::TableId& id) const {
+            return hash<uint32_t>{}(id.inner);
+        }
+    };
+    
+    template<> struct hash<SpacetimeDb::IndexId> {
+        size_t operator()(const SpacetimeDb::IndexId& id) const {
+            return hash<uint32_t>{}(id.inner);
+        }
+    };
+    
+    template<> struct hash<SpacetimeDb::RowIter> {
+        size_t operator()(const SpacetimeDb::RowIter& iter) const {
+            return hash<uint32_t>{}(iter.inner);
+        }
+    };
+    
+    template<> struct hash<SpacetimeDb::ConsoleTimerId> {
+        size_t operator()(const SpacetimeDb::ConsoleTimerId& id) const {
+            return hash<uint32_t>{}(id.inner);
+        }
+    };
+}
+
+#endif // SPACETIMEDB_OPAQUE_TYPES_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/DEVELOP.md b/crates/bindings-cpp/include/spacetimedb/bsatn/DEVELOP.md
new file mode 100644
index 00000000000..940393c574f
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/DEVELOP.md
@@ -0,0 +1,7 @@
+# Core bsatn library
+
+These files here are being used by both the Unreal C++ Client SDK and the Module Library.
+These files are the main files. The SDK do not use these files directly becouse a user might move the SDK plugin to the unreal engine plugin direcory or the unreal project directory.
+All changed made in one of the files should copied over to the SDK.
+
+SDK bsatn path: "crates\sdk-unreal\SpacetimeDbSdk\Source\SpacetimeDbSdk\Public\BSATN"
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/README.md b/crates/bindings-cpp/include/spacetimedb/bsatn/README.md
new file mode 100644
index 00000000000..8cf27f5389b
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/README.md
@@ -0,0 +1,58 @@
+# BSATN C++ Library
+
+This directory contains a self-contained C++ implementation of BSATN (Binary SpacetimeDB Algebraic Type Notation) serialization.
+
+## For C++ Client Usage
+
+The BSATN library can be used independently for serialization/deserialization without any SpacetimeDB module dependencies. 
+
+### What you need:
+- All headers in this directory
+- Standard C++ library (C++20)
+- No external dependencies
+
+### What you DON'T need:
+- `ITypeRegistrar.h` - This is only for modules, not clients
+- Type registration functionality
+- Any files from outside this directory
+
+### Basic usage:
+
+```cpp
+#include "bsatn/bsatn.h"
+
+// Define your struct
+struct MyData {
+    uint32_t id;
+    std::string name;
+};
+
+// Define serialization traits
+SPACETIMEDB_STRUCT(MyData, id, name)
+
+// Serialize
+MyData data{42, "example"};
+std::vector<uint8_t> buffer;
+SpacetimeDb::bsatn::Writer writer(buffer);
+SpacetimeDb::bsatn::serialize(writer, data);
+
+// Deserialize
+SpacetimeDb::bsatn::Reader reader(buffer);
+auto result = SpacetimeDb::bsatn::deserialize<MyData>(reader);
+```
+
+## Architecture Notes
+
+- **ITypeRegistrar.h**: Interface for optional type registration. Clients can ignore this - it's only used by SpacetimeDB modules. The interface is kept here to avoid circular dependencies while maintaining clean architecture.
+
+- **No external dependencies**: All files only include other BSATN headers or standard C++ library headers.
+
+- **Special types**: The library includes SpacetimeDB special types (Identity, ConnectionId, Timestamp, TimeDuration) that serialize with specific tags for compatibility.
+
+## File Structure
+
+- Core: `reader.h`, `writer.h`, `serialization.h`
+- Type system: `algebraic_type.h`, `traits.h`, `primitive_traits.h`
+- Special types: `types.h`, `timestamp.h`, `time_duration.h`, `special_types.h`
+- Utilities: `size_calculator.h`, `sum_type.h`
+- Module-only: `ITypeRegistrar.h` (can be ignored by clients)
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/algebraic_type.h b/crates/bindings-cpp/include/spacetimedb/bsatn/algebraic_type.h
new file mode 100644
index 00000000000..7cf8db1545a
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/algebraic_type.h
@@ -0,0 +1,508 @@
+#ifndef SPACETIMEDB_BSATN_ALGEBRAIC_TYPE_H
+#define SPACETIMEDB_BSATN_ALGEBRAIC_TYPE_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+#include <variant>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+
+namespace SpacetimeDb::bsatn {
+
+// Forward declarations
+class AlgebraicType;
+struct SumTypeSchema;
+struct ProductType;
+struct ProductTypeElement;
+struct SumTypeVariant;
+struct ArrayType;
+
+/**
+ * Represents the tag for different algebraic types in SpacetimeDB's type system.
+ * This mirrors the Rust/C# implementation for compatibility.
+ */
+enum class AlgebraicTypeTag : uint8_t {
+    Ref = 0,      // Reference to another type
+    Sum = 1,      // Sum type (tagged union/enum)
+    Product = 2,  // Product type (struct/tuple)
+    Array = 3,    // Array type
+    String = 4,   // UTF-8 string
+    Bool = 5,     // Boolean
+    I8 = 6,       // Signed 8-bit integer
+    U8 = 7,       // Unsigned 8-bit integer
+    I16 = 8,      // Signed 16-bit integer
+    U16 = 9,      // Unsigned 16-bit integer
+    I32 = 10,     // Signed 32-bit integer
+    U32 = 11,     // Unsigned 32-bit integer
+    I64 = 12,     // Signed 64-bit integer
+    U64 = 13,     // Unsigned 64-bit integer
+    I128 = 14,    // Signed 128-bit integer
+    U128 = 15,    // Unsigned 128-bit integer
+    I256 = 16,    // Signed 256-bit integer
+    U256 = 17,    // Unsigned 256-bit integer
+    F32 = 18,     // 32-bit floating point
+    F64 = 19      // 64-bit floating point
+};
+
+// ============================================================================
+// HELPER TEMPLATE FOR DEEP COPYING UNIQUE_PTR MEMBERS
+// ============================================================================
+
+/**
+ * RAII helper for deep copying unique_ptr members.
+ * Eliminates duplicate copy constructor patterns.
+ */
+template<typename T>
+std::unique_ptr<T> deep_copy_ptr(const std::unique_ptr<T>& ptr) {
+    return ptr ? ptr->copy() : nullptr;
+}
+
+// ============================================================================
+// TYPE ELEMENT STRUCTURES
+// ============================================================================
+
+/**
+ * Represents an element in a ProductType.
+ * Stores a complete AlgebraicType object to eliminate ambiguity.
+ */
+struct ProductTypeElement {
+    std::optional<std::string> name;
+    std::unique_ptr<AlgebraicType> algebraic_type;
+    
+    ProductTypeElement(std::optional<std::string> n, AlgebraicType type);
+    ProductTypeElement(const ProductTypeElement& other);
+    ProductTypeElement(ProductTypeElement&& other) = default;
+    ProductTypeElement& operator=(const ProductTypeElement& other);
+    ProductTypeElement& operator=(ProductTypeElement&& other) = default;
+};
+
+/**
+ * Represents a variant in a SumType.
+ * Stores a complete AlgebraicType object to eliminate ambiguity.
+ */
+struct SumTypeVariant {
+    std::string name;
+    std::unique_ptr<AlgebraicType> algebraic_type;
+    
+    SumTypeVariant(std::string n, AlgebraicType type);
+    SumTypeVariant(const SumTypeVariant& other);
+    SumTypeVariant(SumTypeVariant&& other) = default;
+    SumTypeVariant& operator=(const SumTypeVariant& other);
+    SumTypeVariant& operator=(SumTypeVariant&& other) = default;
+};
+
+/**
+ * Represents a sum type (tagged union/enum).
+ * Each variant has a name and can contain data.
+ */
+struct SumTypeSchema {
+    std::vector<SumTypeVariant> variants;
+    
+    explicit SumTypeSchema(std::vector<SumTypeVariant> v) : variants(std::move(v)) {}
+};
+
+/**
+ * Represents a product type (struct/tuple).
+ * Contains ordered elements (fields).
+ */
+struct ProductType {
+    std::vector<ProductTypeElement> elements;
+    
+    explicit ProductType(std::vector<ProductTypeElement> elems) 
+        : elements(std::move(elems)) {}
+    
+    // Helper to create a product type for a C++ struct
+    template<typename T>
+    static ProductType make();
+};
+
+/**
+ * Represents an array type.
+ * Contains the complete type of elements in the array.
+ */
+struct ArrayType {
+    std::unique_ptr<AlgebraicType> element_type;
+    
+    explicit ArrayType(AlgebraicType elem_type);
+    ArrayType(const ArrayType& other);
+    ArrayType(ArrayType&& other) = default;
+    ArrayType& operator=(const ArrayType& other);
+    ArrayType& operator=(ArrayType&& other) = default;
+};
+
+// ============================================================================
+// MAIN ALGEBRAIC TYPE CLASS
+// ============================================================================
+
+/**
+ * @brief The main algebraic type representation for SpacetimeDB's type system.
+ * 
+ * AlgebraicType is a tagged union that represents all possible types in SpacetimeDB.
+ * It supports both primitive types (integers, floats, strings, etc.) and composite
+ * types (products/structs, sums/enums, arrays, and references).
+ * 
+ * This type system is designed to be:
+ * - Compatible with multiple languages (Rust, C#, C++)
+ * - Serializable via BSATN (Binary Sparse Algebraic Type Notation)
+ * - Type-safe with compile-time verification
+ * 
+ * @example Creating primitive types:
+ * @code
+ * auto int_type = AlgebraicType::primitive<AlgebraicTypeTag::I32>();
+ * auto string_type = AlgebraicType::primitive<AlgebraicTypeTag::String>();
+ * @endcode
+ * 
+ * @example Creating composite types:
+ * @code
+ * // Create an array type
+ * auto array_type = AlgebraicType::Array(AlgebraicType::primitive<AlgebraicTypeTag::I32>());
+ * @endcode
+ */
+class AlgebraicType {
+public:
+    /**
+     * Internal data storage for type-specific information.
+     */
+    using DataType = std::variant<
+        uint32_t,                          // Ref - type reference
+        std::unique_ptr<SumTypeSchema>,    // Sum type
+        std::unique_ptr<ProductType>,      // Product type
+        std::unique_ptr<ArrayType>,        // Array type
+        std::monostate                     // Primitive types (no additional data)
+    >;
+
+private:
+    AlgebraicTypeTag tag_;
+    DataType data_;
+
+public:
+    // Constructor accessible for copy operations and internal use
+    AlgebraicType(AlgebraicTypeTag tag, DataType data) : tag_(tag), data_(std::move(data)) {}
+    // -------------------------------------------------------------------------
+    // PRIMITIVE TYPE FACTORY (TEMPLATED - REPLACES 16 INDIVIDUAL METHODS)
+    // -------------------------------------------------------------------------
+    
+    /**
+     * Template factory for primitive types.
+     * Replaces all individual primitive factory methods (Bool(), I8(), etc.)
+     * 
+     * @tparam Tag The AlgebraicTypeTag for the primitive type
+     * @return AlgebraicType instance for the specified primitive
+     * 
+     * @example
+     * auto bool_type = AlgebraicType::primitive<AlgebraicTypeTag::Bool>();
+     * auto int_type = AlgebraicType::primitive<AlgebraicTypeTag::I32>();
+     */
+    template<AlgebraicTypeTag Tag>
+    static AlgebraicType primitive() {
+        static_assert(
+            static_cast<uint8_t>(Tag) >= static_cast<uint8_t>(AlgebraicTypeTag::String),
+            "primitive<Tag>() can only be used for primitive types"
+        );
+        return AlgebraicType(Tag, std::monostate{});
+    }
+    
+    // Convenience aliases for ALL primitives (required by other files)
+    static AlgebraicType Bool() { return primitive<AlgebraicTypeTag::Bool>(); }
+    static AlgebraicType I8() { return primitive<AlgebraicTypeTag::I8>(); }
+    static AlgebraicType U8() { return primitive<AlgebraicTypeTag::U8>(); }
+    static AlgebraicType I16() { return primitive<AlgebraicTypeTag::I16>(); }
+    static AlgebraicType U16() { return primitive<AlgebraicTypeTag::U16>(); }
+    static AlgebraicType I32() { return primitive<AlgebraicTypeTag::I32>(); }
+    static AlgebraicType U32() { return primitive<AlgebraicTypeTag::U32>(); }
+    static AlgebraicType I64() { return primitive<AlgebraicTypeTag::I64>(); }
+    static AlgebraicType U64() { return primitive<AlgebraicTypeTag::U64>(); }
+    static AlgebraicType I128() { return primitive<AlgebraicTypeTag::I128>(); }
+    static AlgebraicType U128() { return primitive<AlgebraicTypeTag::U128>(); }
+    static AlgebraicType I256() { return primitive<AlgebraicTypeTag::I256>(); }
+    static AlgebraicType U256() { return primitive<AlgebraicTypeTag::U256>(); }
+    static AlgebraicType F32() { return primitive<AlgebraicTypeTag::F32>(); }
+    static AlgebraicType F64() { return primitive<AlgebraicTypeTag::F64>(); }
+    static AlgebraicType String() { return primitive<AlgebraicTypeTag::String>(); }
+    
+    // -------------------------------------------------------------------------
+    // COMPOSITE TYPE FACTORIES
+    // -------------------------------------------------------------------------
+    
+    static AlgebraicType Ref(uint32_t type_id) {
+        return AlgebraicType(AlgebraicTypeTag::Ref, type_id);
+    }
+    
+    static AlgebraicType make_ref(uint32_t type_id) {
+        return Ref(type_id);
+    }
+    
+    static AlgebraicType make_product(std::unique_ptr<ProductType> product_type) {
+        return AlgebraicType(AlgebraicTypeTag::Product, std::move(product_type));
+    }
+    
+    static AlgebraicType make_sum(std::unique_ptr<SumTypeSchema> sum_type) {
+        return AlgebraicType(AlgebraicTypeTag::Sum, std::move(sum_type));
+    }
+    
+    static AlgebraicType Array(AlgebraicType elem_type) {
+        return AlgebraicType(AlgebraicTypeTag::Array, 
+                           std::make_unique<ArrayType>(std::move(elem_type)));
+    }
+    
+    /**
+     * Creates a unit type (empty product).
+     * This represents std::monostate or Rust's () unit type.
+     */
+    static AlgebraicType Unit() {
+        return make_product(std::make_unique<ProductType>(std::vector<ProductTypeElement>{}));
+    }
+    
+    /**
+     * Creates an Option type with simplified logic.
+     * Represents a sum type with "some" and "none" variants.
+     */
+    static AlgebraicType Option(uint32_t some_type_ref) {
+        if (some_type_ref == 0xFFFFFFFF) {
+            return create_unit_option();
+        }
+        return create_typed_option(some_type_ref);
+    }
+    
+    static AlgebraicType Product(std::vector<std::pair<std::string, uint32_t>> fields) {
+        std::vector<ProductTypeElement> elements;
+        elements.reserve(fields.size());
+        for (auto& [name, type_ref] : fields) {
+            elements.emplace_back(std::move(name), Ref(type_ref));
+        }
+        return make_product(std::make_unique<ProductType>(std::move(elements)));
+    }
+    
+    // -------------------------------------------------------------------------
+    // ACCESSORS AND TYPE CHECKING
+    // -------------------------------------------------------------------------
+    
+    AlgebraicTypeTag tag() const { return tag_; }
+    const DataType& data() const { return data_; }
+    
+    /**
+     * Template-based type checking.
+     * Replaces all individual is_*() methods with a single template.
+     * 
+     * @tparam Tag The AlgebraicTypeTag to check against
+     * @return true if this type has the specified tag
+     * 
+     * @example
+     * if (type.is<AlgebraicTypeTag::I32>()) { ... }
+     * if (type.is<AlgebraicTypeTag::Array>()) { ... }
+     */
+    template<AlgebraicTypeTag Tag>
+    bool is() const { return tag_ == Tag; }
+    
+    // Convenience methods for most common checks
+    bool is_ref() const { return is<AlgebraicTypeTag::Ref>(); }
+    bool is_sum() const { return is<AlgebraicTypeTag::Sum>(); }
+    bool is_product() const { return is<AlgebraicTypeTag::Product>(); }
+    bool is_array() const { return is<AlgebraicTypeTag::Array>(); }
+    bool is_primitive() const { 
+        return static_cast<uint8_t>(tag_) >= static_cast<uint8_t>(AlgebraicTypeTag::String);
+    }
+    
+    // -------------------------------------------------------------------------
+    // DATA ACCESSOR METHODS
+    // -------------------------------------------------------------------------
+    
+    uint32_t as_ref() const {
+        if (!is_ref()) std::abort(); // Type is not a Ref
+        return std::get<uint32_t>(data_);
+    }
+    
+    const SumTypeSchema& as_sum() const {
+        if (!is_sum()) std::abort(); // Type is not a Sum
+        return *std::get<std::unique_ptr<SumTypeSchema>>(data_);
+    }
+    
+    const ProductType& as_product() const {
+        if (!is_product()) std::abort(); // Type is not a Product
+        return *std::get<std::unique_ptr<ProductType>>(data_);
+    }
+    
+    const ArrayType& as_array() const {
+        if (!is_array()) std::abort(); // Type is not an Array
+        return *std::get<std::unique_ptr<ArrayType>>(data_);
+    }
+    
+    // -------------------------------------------------------------------------
+    // COPY METHOD (SIMPLIFIED WITH VISITOR PATTERN)
+    // -------------------------------------------------------------------------
+    
+    std::unique_ptr<AlgebraicType> copy() const {
+        return std::visit([this](const auto& data) -> std::unique_ptr<AlgebraicType> {
+            using DataT = std::decay_t<decltype(data)>;
+            
+            if constexpr (std::is_same_v<DataT, std::monostate>) {
+                // Primitive types
+                return std::make_unique<AlgebraicType>(tag_, std::monostate{});
+            } else if constexpr (std::is_same_v<DataT, uint32_t>) {
+                // Ref types
+                return std::make_unique<AlgebraicType>(Ref(data));
+            } else if constexpr (std::is_same_v<DataT, std::unique_ptr<SumTypeSchema>>) {
+                // Sum types
+                std::vector<SumTypeVariant> new_variants;
+                new_variants.reserve(data->variants.size());
+                for (const auto& variant : data->variants) {
+                    new_variants.push_back(variant);  // Uses copy constructor
+                }
+                return std::make_unique<AlgebraicType>(AlgebraicType(
+                    AlgebraicTypeTag::Sum,
+                    std::make_unique<SumTypeSchema>(std::move(new_variants))
+                ));
+            } else if constexpr (std::is_same_v<DataT, std::unique_ptr<ProductType>>) {
+                // Product types
+                std::vector<ProductTypeElement> new_elements;
+                new_elements.reserve(data->elements.size());
+                for (const auto& elem : data->elements) {
+                    new_elements.push_back(elem);  // Uses copy constructor
+                }
+                return std::make_unique<AlgebraicType>(AlgebraicType(
+                    AlgebraicTypeTag::Product,
+                    std::make_unique<ProductType>(std::move(new_elements))
+                ));
+            } else if constexpr (std::is_same_v<DataT, std::unique_ptr<ArrayType>>) {
+                // Array types
+                return std::make_unique<AlgebraicType>(AlgebraicType(
+                    AlgebraicTypeTag::Array,
+                    std::make_unique<ArrayType>(*data)  // Uses copy constructor
+                ));
+            }
+        }, data_);
+    }
+
+private:
+    // Helper methods for Option factory
+    static AlgebraicType create_unit_option() {
+        std::vector<SumTypeVariant> variants;
+        variants.emplace_back("some", Unit());
+        variants.emplace_back("none", Unit());
+        return make_sum(std::make_unique<SumTypeSchema>(std::move(variants)));
+    }
+    
+    static AlgebraicType create_typed_option(uint32_t some_type_ref) {
+        std::vector<SumTypeVariant> variants;
+        variants.emplace_back("some", Ref(some_type_ref));
+        variants.emplace_back("none", Unit());
+        return make_sum(std::make_unique<SumTypeSchema>(std::move(variants)));
+    }
+};
+
+// ============================================================================
+// ALGEBRAIC TYPE TRAITS
+// ============================================================================
+
+/**
+ * Trait for getting the AlgebraicType of a C++ type.
+ * Specialized for primitive and container types.
+ * 
+ * @example
+ * auto type = algebraic_type_of<int32_t>::get();
+ * auto array_type = algebraic_type_of<std::vector<int32_t>>::get();
+ */
+template<typename T>
+struct algebraic_type_of {
+    static AlgebraicType get();
+};
+
+// Helper macro to reduce repetitive primitive type specializations
+#define SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(cpp_type, tag_value) \
+    template<> struct algebraic_type_of<cpp_type> { \
+        static AlgebraicType get() { return AlgebraicType::primitive<AlgebraicTypeTag::tag_value>(); } \
+    }
+
+// Primitive type specializations
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(bool, Bool);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(char, U8);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int8_t, I8);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int16_t, I16);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int32_t, I32);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int64_t, I64);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint8_t, U8);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint16_t, U16);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint32_t, U32);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint64_t, U64);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(float, F32);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(double, F64);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(std::string, String);
+
+#undef SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE
+
+// Container type specializations (properly implemented, no TODOs)
+template<typename T> 
+struct algebraic_type_of<std::vector<T>> {
+    static AlgebraicType get() {
+        return AlgebraicType::Array(algebraic_type_of<T>::get());
+    }
+};
+
+template<typename T> 
+struct algebraic_type_of<std::optional<T>> {
+    static AlgebraicType get() {
+        // Create proper Option type with the inner type
+        AlgebraicType inner_type = algebraic_type_of<T>::get();
+        
+        std::vector<SumTypeVariant> variants;
+        variants.emplace_back("some", std::move(inner_type));
+        variants.emplace_back("none", AlgebraicType::Unit());
+        
+        return AlgebraicType::make_sum(std::make_unique<SumTypeSchema>(std::move(variants)));
+    }
+};
+
+// ============================================================================
+// INLINE IMPLEMENTATIONS
+// ============================================================================
+
+// ProductTypeElement implementations
+inline ProductTypeElement::ProductTypeElement(std::optional<std::string> n, AlgebraicType type)
+    : name(std::move(n)), algebraic_type(std::make_unique<AlgebraicType>(std::move(type))) {}
+
+inline ProductTypeElement::ProductTypeElement(const ProductTypeElement& other)
+    : name(other.name), algebraic_type(deep_copy_ptr(other.algebraic_type)) {}
+
+inline ProductTypeElement& ProductTypeElement::operator=(const ProductTypeElement& other) {
+    if (this != &other) {
+        name = other.name;
+        algebraic_type = deep_copy_ptr(other.algebraic_type);
+    }
+    return *this;
+}
+
+// SumTypeVariant implementations
+inline SumTypeVariant::SumTypeVariant(std::string n, AlgebraicType type)
+    : name(std::move(n)), algebraic_type(std::make_unique<AlgebraicType>(std::move(type))) {}
+
+inline SumTypeVariant::SumTypeVariant(const SumTypeVariant& other)
+    : name(other.name), algebraic_type(deep_copy_ptr(other.algebraic_type)) {}
+
+inline SumTypeVariant& SumTypeVariant::operator=(const SumTypeVariant& other) {
+    if (this != &other) {
+        name = other.name;
+        algebraic_type = deep_copy_ptr(other.algebraic_type);
+    }
+    return *this;
+}
+
+// ArrayType implementations
+inline ArrayType::ArrayType(AlgebraicType elem_type)
+    : element_type(std::make_unique<AlgebraicType>(std::move(elem_type))) {}
+
+inline ArrayType::ArrayType(const ArrayType& other)
+    : element_type(deep_copy_ptr(other.element_type)) {}
+
+inline ArrayType& ArrayType::operator=(const ArrayType& other) {
+    if (this != &other) {
+        element_type = deep_copy_ptr(other.element_type);
+    }
+    return *this;
+}
+
+} // namespace SpacetimeDb::bsatn
+
+#endif // SPACETIMEDB_BSATN_ALGEBRAIC_TYPE_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/algebraic_type.h.backup b/crates/bindings-cpp/include/spacetimedb/bsatn/algebraic_type.h.backup
new file mode 100644
index 00000000000..ca8d2e5b645
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/algebraic_type.h.backup
@@ -0,0 +1,657 @@
+#ifndef SPACETIMEDB_BSATN_ALGEBRAIC_TYPE_H
+#define SPACETIMEDB_BSATN_ALGEBRAIC_TYPE_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <memory>
+#include <variant>
+#include <optional>
+#include <stdexcept>
+
+namespace SpacetimeDb::bsatn {
+
+// Forward declarations
+class AlgebraicType;
+struct SumTypeSchema;
+struct ProductType;
+struct ProductTypeElement;
+struct SumTypeVariant;
+struct ArrayType;
+
+/**
+ * Represents the tag for different algebraic types in SpacetimeDB's type system.
+ * This mirrors the Rust/C# implementation for compatibility.
+ */
+enum class AlgebraicTypeTag : uint8_t {
+    Ref = 0,      // Reference to another type
+    Sum = 1,      // Sum type (tagged union/enum)
+    Product = 2,  // Product type (struct/tuple)
+    Array = 3,    // Array type
+    String = 4,   // UTF-8 string
+    Bool = 5,     // Boolean
+    I8 = 6,       // Signed 8-bit integer
+    U8 = 7,       // Unsigned 8-bit integer
+    I16 = 8,      // Signed 16-bit integer
+    U16 = 9,      // Unsigned 16-bit integer
+    I32 = 10,     // Signed 32-bit integer
+    U32 = 11,     // Unsigned 32-bit integer
+    I64 = 12,     // Signed 64-bit integer
+    U64 = 13,     // Unsigned 64-bit integer
+    I128 = 14,    // Signed 128-bit integer
+    U128 = 15,    // Unsigned 128-bit integer
+    I256 = 16,    // Signed 256-bit integer
+    U256 = 17,    // Unsigned 256-bit integer
+    F32 = 18,     // 32-bit floating point
+    F64 = 19      // 64-bit floating point
+};
+
+/**
+ * Represents an element in a ProductType.
+ * Renamed from AggregateElement to match Rust/C# conventions.
+ * 
+ * Stores a complete AlgebraicType object to eliminate ambiguity between
+ * primitive tags and registry indices.
+ */
+struct ProductTypeElement {
+    std::optional<std::string> name;
+    std::unique_ptr<AlgebraicType> algebraic_type;  // Complete type information
+    
+    // Constructor taking AlgebraicType by value and moving to unique_ptr
+    ProductTypeElement(std::optional<std::string> n, AlgebraicType type);
+    
+    // Copy constructor (deep copy of AlgebraicType)
+    ProductTypeElement(const ProductTypeElement& other);
+    
+    // Move constructor
+    ProductTypeElement(ProductTypeElement&& other) = default;
+    
+    // Assignment operators
+    ProductTypeElement& operator=(const ProductTypeElement& other);
+    ProductTypeElement& operator=(ProductTypeElement&& other) = default;
+};
+
+/**
+ * Represents a variant in a SumType.
+ * Renamed for consistency with Rust/C# naming.
+ * 
+ * Stores a complete AlgebraicType object to eliminate ambiguity.
+ */
+struct SumTypeVariant {
+    std::string name;
+    std::unique_ptr<AlgebraicType> algebraic_type;  // Complete type information
+    
+    // Constructor taking AlgebraicType by value and moving to unique_ptr
+    SumTypeVariant(std::string n, AlgebraicType type);
+    
+    // Copy constructor (deep copy of AlgebraicType)
+    SumTypeVariant(const SumTypeVariant& other);
+    
+    // Move constructor
+    SumTypeVariant(SumTypeVariant&& other) = default;
+    
+    // Assignment operators
+    SumTypeVariant& operator=(const SumTypeVariant& other);
+    SumTypeVariant& operator=(SumTypeVariant&& other) = default;
+};
+
+/**
+ * Represents a sum type (tagged union/enum).
+ * Each variant has a name and can contain data.
+ * Aligned with Rust/C# naming conventions.
+ */
+struct SumTypeSchema {
+    std::vector<SumTypeVariant> variants;
+    
+    explicit SumTypeSchema(std::vector<SumTypeVariant> v) : variants(std::move(v)) {}
+};
+
+/**
+ * Represents a product type (struct/tuple).
+ * Contains ordered elements (fields).
+ * Aligned with Rust/C# naming conventions.
+ */
+struct ProductType {
+    std::vector<ProductTypeElement> elements;
+    
+    explicit ProductType(std::vector<ProductTypeElement> elems) 
+        : elements(std::move(elems)) {}
+    
+    // Helper to create a product type for a C++ struct
+    template<typename T>
+    static ProductType make();
+};
+
+/**
+ * Represents an array type.
+ * Contains the complete type of elements in the array.
+ */
+struct ArrayType {
+    std::unique_ptr<AlgebraicType> element_type;  // Complete element type information
+    
+    // Constructor taking AlgebraicType by value
+    explicit ArrayType(AlgebraicType elem_type);
+    
+    // Copy constructor (deep copy)
+    ArrayType(const ArrayType& other);
+    
+    // Move constructor
+    ArrayType(ArrayType&& other) = default;
+    
+    // Assignment operators
+    ArrayType& operator=(const ArrayType& other);
+    ArrayType& operator=(ArrayType&& other) = default;
+};
+
+/**
+ * @brief The main algebraic type representation for SpacetimeDB's type system.
+ * 
+ * AlgebraicType is a tagged union that represents all possible types in SpacetimeDB.
+ * It supports both primitive types (integers, floats, strings, etc.) and composite
+ * types (products/structs, sums/enums, arrays, and references).
+ * 
+ * This type system is designed to be:
+ * - Compatible with multiple languages (Rust, C#, C++)
+ * - Serializable via BSATN (Binary Sparse Algebraic Type Notation)
+ * - Type-safe with compile-time verification
+ * 
+ * @example Creating primitive types:
+ * @code
+ * auto int_type = AlgebraicType::I32();
+ * auto string_type = AlgebraicType::String();
+ * @endcode
+ * 
+ * @example Creating composite types:
+ * @code
+ * // Create a struct type with name and age fields
+ * auto person_type = AlgebraicType::Product({
+ *     {"name", string_type_id},
+ *     {"age", int_type_id}
+ * });
+ * 
+ * // Create an enum type (Result<T, E>)
+ * auto result_type = AlgebraicType::Sum({
+ *     {"Ok", ok_type_id},
+ *     {"Err", err_type_id}
+ * });
+ * @endcode
+ */
+class AlgebraicType {
+public:
+    /**
+     * @brief Internal data storage for type-specific information.
+     * 
+     * The variant holds different data depending on the AlgebraicTypeTag:
+     * - Ref: uint32_t (type ID in the registry)
+     * - Sum: SumTypeSchema (enum/union definition)
+     * - Product: ProductType (struct definition)
+     * - Array: ArrayType (element type information)
+     * - Primitives: std::monostate (no additional data needed)
+     */
+    using DataType = std::variant<
+        uint32_t,                          // Ref - type reference
+        std::unique_ptr<SumTypeSchema>,    // Sum type
+        std::unique_ptr<ProductType>,      // Product type
+        std::unique_ptr<ArrayType>,        // Array type
+        std::monostate                     // Primitive types (no additional data)
+    >;
+
+private:
+    AlgebraicTypeTag tag_;
+    DataType data_;
+
+public:
+    // Template factory for primitive types (reduces repetition)
+    template<AlgebraicTypeTag Tag>
+    static AlgebraicType make_primitive() {
+        static_assert(
+            static_cast<uint8_t>(Tag) >= static_cast<uint8_t>(AlgebraicTypeTag::String),
+            "make_primitive can only be used for primitive types"
+        );
+        return AlgebraicType(Tag, std::monostate{});
+    }
+    
+    // Constructors for complex types
+    static AlgebraicType make_ref(uint32_t type_id) {
+        return AlgebraicType(AlgebraicTypeTag::Ref, type_id);
+    }
+    
+    static AlgebraicType make_sum(std::unique_ptr<SumTypeSchema> sum) {
+        return AlgebraicType(AlgebraicTypeTag::Sum, std::move(sum));
+    }
+    
+    static AlgebraicType make_product(std::unique_ptr<ProductType> product) {
+        return AlgebraicType(AlgebraicTypeTag::Product, std::move(product));
+    }
+    
+    static AlgebraicType make_array(std::unique_ptr<ArrayType> array) {
+        return AlgebraicType(AlgebraicTypeTag::Array, std::move(array));
+    }
+    
+    
+    // Accessors
+    AlgebraicTypeTag tag() const { return tag_; }
+    const DataType& data() const { return data_; }
+    
+    // -------------------------------------------------------------------------
+    // Type Checking Methods
+    // -------------------------------------------------------------------------
+    /**
+     * @brief Check if this type is a reference to another type.
+     * @return true if this is a Ref type
+     */
+    bool is_ref() const { return tag_ == AlgebraicTypeTag::Ref; }
+    
+    /**
+     * @brief Check if this type is a sum type (enum/tagged union).
+     * @return true if this is a Sum type
+     */
+    bool is_sum() const { return tag_ == AlgebraicTypeTag::Sum; }
+    
+    /**
+     * @brief Check if this type is a product type (struct/tuple).
+     * @return true if this is a Product type
+     */
+    bool is_product() const { return tag_ == AlgebraicTypeTag::Product; }
+    
+    /**
+     * @brief Check if this type is an array type.
+     * @return true if this is an Array type
+     */
+    bool is_array() const { return tag_ == AlgebraicTypeTag::Array; }
+    
+    /**
+     * @brief Check if this type is a primitive type.
+     * Primitive types include all numeric types, booleans, and strings.
+     * @return true if this is a primitive type
+     */
+    bool is_primitive() const { 
+        return static_cast<uint8_t>(tag_) >= static_cast<uint8_t>(AlgebraicTypeTag::String);
+    }
+    
+    // Specific primitive type checks for convenience
+    bool is_bool() const { return tag_ == AlgebraicTypeTag::Bool; }
+    bool is_i8() const { return tag_ == AlgebraicTypeTag::I8; }
+    bool is_u8() const { return tag_ == AlgebraicTypeTag::U8; }
+    bool is_i16() const { return tag_ == AlgebraicTypeTag::I16; }
+    bool is_u16() const { return tag_ == AlgebraicTypeTag::U16; }
+    bool is_i32() const { return tag_ == AlgebraicTypeTag::I32; }
+    bool is_u32() const { return tag_ == AlgebraicTypeTag::U32; }
+    bool is_i64() const { return tag_ == AlgebraicTypeTag::I64; }
+    bool is_u64() const { return tag_ == AlgebraicTypeTag::U64; }
+    bool is_i128() const { return tag_ == AlgebraicTypeTag::I128; }
+    bool is_u128() const { return tag_ == AlgebraicTypeTag::U128; }
+    bool is_i256() const { return tag_ == AlgebraicTypeTag::I256; }
+    bool is_u256() const { return tag_ == AlgebraicTypeTag::U256; }
+    bool is_f32() const { return tag_ == AlgebraicTypeTag::F32; }
+    bool is_f64() const { return tag_ == AlgebraicTypeTag::F64; }
+    bool is_string() const { return tag_ == AlgebraicTypeTag::String; }
+    
+    // -------------------------------------------------------------------------
+    // Data Accessor Methods
+    // -------------------------------------------------------------------------
+    /**
+     * @brief Get the referenced type ID for a Ref type.
+     * @return The type ID this reference points to
+     * @throws std::runtime_error if this is not a Ref type
+     */
+    uint32_t as_ref() const {
+        if (!is_ref()) throw std::runtime_error("Type is not a Ref");
+        return std::get<uint32_t>(data_);
+    }
+    
+    /**
+     * @brief Get the sum type schema for a Sum type.
+     * @return Reference to the SumTypeSchema containing variant definitions
+     * @throws std::runtime_error if this is not a Sum type
+     */
+    const SumTypeSchema& as_sum() const {
+        if (!is_sum()) throw std::runtime_error("Type is not a Sum");
+        return *std::get<std::unique_ptr<SumTypeSchema>>(data_);
+    }
+    
+    /**
+     * @brief Get the product type definition for a Product type.
+     * @return Reference to the ProductType containing field definitions
+     * @throws std::runtime_error if this is not a Product type
+     */
+    const ProductType& as_product() const {
+        if (!is_product()) throw std::runtime_error("Type is not a Product");
+        return *std::get<std::unique_ptr<ProductType>>(data_);
+    }
+    
+    /**
+     * @brief Get the array type definition for an Array type.
+     * @return Reference to the ArrayType containing element type info
+     * @throws std::runtime_error if this is not an Array type
+     */
+    const ArrayType& as_array() const {
+        if (!is_array()) throw std::runtime_error("Type is not an Array");
+        return *std::get<std::unique_ptr<ArrayType>>(data_);
+    }
+    
+    // -------------------------------------------------------------------------
+    // Factory Methods for Primitive Types
+    // -------------------------------------------------------------------------
+    // These methods provide a convenient API for creating primitive types.
+    // They are used extensively in code generation and manual type construction.
+    
+    // Boolean type
+    static AlgebraicType Bool() { return make_primitive<AlgebraicTypeTag::Bool>(); }
+    
+    // Signed integer types
+    static AlgebraicType I8()   { return make_primitive<AlgebraicTypeTag::I8>(); }
+    static AlgebraicType I16()  { return make_primitive<AlgebraicTypeTag::I16>(); }
+    static AlgebraicType I32()  { return make_primitive<AlgebraicTypeTag::I32>(); }
+    static AlgebraicType I64()  { return make_primitive<AlgebraicTypeTag::I64>(); }
+    static AlgebraicType I128() { return make_primitive<AlgebraicTypeTag::I128>(); }
+    static AlgebraicType I256() { return make_primitive<AlgebraicTypeTag::I256>(); }
+    
+    // Unsigned integer types
+    static AlgebraicType U8()   { return make_primitive<AlgebraicTypeTag::U8>(); }
+    static AlgebraicType U16()  { return make_primitive<AlgebraicTypeTag::U16>(); }
+    static AlgebraicType U32()  { return make_primitive<AlgebraicTypeTag::U32>(); }
+    static AlgebraicType U64()  { return make_primitive<AlgebraicTypeTag::U64>(); }
+    static AlgebraicType U128() { return make_primitive<AlgebraicTypeTag::U128>(); }
+    static AlgebraicType U256() { return make_primitive<AlgebraicTypeTag::U256>(); }
+    
+    // Floating point types
+    static AlgebraicType F32() { return make_primitive<AlgebraicTypeTag::F32>(); }
+    static AlgebraicType F64() { return make_primitive<AlgebraicTypeTag::F64>(); }
+    
+    // String type
+    static AlgebraicType String() { return make_primitive<AlgebraicTypeTag::String>(); }
+    
+    /**
+     * Creates a unit type (empty product).
+     * This represents std::monostate or Rust's () unit type.
+     * Used for variants with no data, like None in Option<T>.
+     */
+    static AlgebraicType Unit() {
+        return make_product(std::make_unique<ProductType>(std::vector<ProductTypeElement>{}));
+    }
+    // -------------------------------------------------------------------------
+    // Copy method for deep copying
+    std::unique_ptr<AlgebraicType> copy() const;
+    
+    // Factory Methods for Composite Types
+    // -------------------------------------------------------------------------
+    
+    /**
+     * Creates a reference type pointing to another type.
+     * @param type_id The ID of the referenced type in the type registry
+     */
+    static AlgebraicType Ref(uint32_t type_id) { 
+        return make_ref(type_id); 
+    }
+    
+    /**
+     * Creates an array type with elements of the specified type.
+     * @param elem_type The complete type of array elements
+     */
+    static AlgebraicType Array(AlgebraicType elem_type) {
+        return make_array(std::make_unique<ArrayType>(std::move(elem_type)));
+    }
+    
+    /**
+     * Creates an Option type (similar to Rust's Option or C++'s std::optional).
+     * This is represented as a sum type with two variants: None and Some(T).
+     * 
+     * IMPORTANT: Order must match serialization in traits.h:
+     *   - Tag 0: "none" (no data)
+     *   - Tag 1: "some" (contains inner type)
+     * 
+     * CRITICAL WASM FIX: The root cause of the crash is that during static initialization
+     * (when TABLE macros run), creating std::string objects can cause WASM traps.
+     * 
+     * However, we can't always defer Option creation because some code paths need
+     * the actual AlgebraicType::Sum. So we try to create it normally, and if that
+     * would crash (detected by checking a global flag), we return a deferred marker.
+     * 
+     * @param some_type_ref The type reference (registry index or primitive tag) for the Some variant's value
+     */
+    static AlgebraicType Option(uint32_t some_type_ref) {
+        // CRITICAL: Handle sentinel value for types that should be inlined
+        if (some_type_ref == 0xFFFFFFFF) {
+            // This should never happen - Options themselves should be inlined
+            // Return a safe fallback (Option<Unit>) to avoid crashes
+            std::vector<SumTypeVariant> variants;
+            auto unit_some = make_product(std::make_unique<ProductType>(std::vector<ProductTypeElement>{}));
+            auto unit_none = make_product(std::make_unique<ProductType>(std::vector<ProductTypeElement>{}));
+            variants.emplace_back("some", std::move(unit_some));
+            variants.emplace_back("none", std::move(unit_none));
+            return make_sum(std::make_unique<SumTypeSchema>(std::move(variants)));
+        }
+        
+        // Create the Option structure directly without markers
+        // This is a Sum type with "some" and "none" variants
+        std::vector<SumTypeVariant> variants;
+        
+        // Create the "some" variant with the inner type
+        // CRITICAL FIX: We cannot assume indices 4-19 are primitive types!
+        // They could be references to complex types in the typespace.
+        // Since this is a type_ref, it's ALWAYS a reference to a type.
+        variants.emplace_back("some", make_ref(some_type_ref));
+        
+        // Create the "none" variant as Unit (empty Product)
+        auto unit = make_product(std::make_unique<ProductType>(std::vector<ProductTypeElement>{}));
+        variants.emplace_back("none", std::move(unit));
+        
+        return make_sum(std::make_unique<SumTypeSchema>(std::move(variants)));
+    }
+    
+    
+    /**
+     * Creates a product type (struct) with named fields.
+     * @param fields Vector of field name and type ID pairs
+     * @example Product({{"name", 1}, {"age", 2}}) creates a struct with two fields
+     */
+    static AlgebraicType Product(std::vector<std::pair<std::string, uint32_t>> fields) {
+        std::vector<ProductTypeElement> elements;
+        elements.reserve(fields.size());
+        for (const auto& [name, type_id] : fields) {
+            elements.emplace_back(name, AlgebraicType::Ref(type_id));
+        }
+        return make_product(std::make_unique<ProductType>(std::move(elements)));
+    }
+    
+    /**
+     * Creates a sum type (tagged union) with named variants.
+     * @param variants Vector of variant name and type ID pairs
+     * @example Sum({{"Ok", 1}, {"Err", 2}}) creates a Result-like type
+     */
+    static AlgebraicType Sum(std::vector<std::pair<std::string, uint32_t>> variants) {
+        std::vector<SumTypeVariant> sum_variants;
+        sum_variants.reserve(variants.size());
+        for (const auto& [name, type_id] : variants) {
+            sum_variants.emplace_back(name, AlgebraicType::Ref(type_id));
+        }
+        return make_sum(std::make_unique<SumTypeSchema>(std::move(sum_variants)));
+    }
+
+private:
+    template<typename T>
+    AlgebraicType(AlgebraicTypeTag tag, T&& data) 
+        : tag_(tag), data_(std::forward<T>(data)) {}
+};
+
+// =========================================================================
+// Type Trait for C++ to AlgebraicType Mapping
+// =========================================================================
+
+/**
+ * @brief Type trait to get the AlgebraicType representation for C++ types.
+ * 
+ * This trait provides a mapping from C++ types to their corresponding
+ * AlgebraicType representation. Specialize this trait for custom types.
+ * 
+ * @tparam T The C++ type to map
+ * 
+ * @example Custom type specialization:
+ * @code
+ * template<>
+ * struct algebraic_type_of<MyCustomType> {
+ *     static AlgebraicType get() {
+ *         return AlgebraicType::Product({
+ *             {"field1", type_id_1},
+ *             {"field2", type_id_2}
+ *         });
+ *     }
+ * };
+ * @endcode
+ */
+template<typename T>
+struct algebraic_type_of {
+    static AlgebraicType get();
+};
+
+// Helper macro to reduce repetitive primitive type specializations
+#define SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(cpp_type, factory_method) \
+    template<> struct algebraic_type_of<cpp_type> { \
+        static AlgebraicType get() { return AlgebraicType::factory_method(); } \
+    }
+
+// Primitive type specializations
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(bool, Bool);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(char, U8);         // char treated as U8
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int8_t, I8);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int16_t, I16);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int32_t, I32);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(int64_t, I64);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint8_t, U8);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint16_t, U16);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint32_t, U32);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(uint64_t, U64);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(float, F32);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(double, F64);
+SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE(std::string, String);
+
+#undef SPACETIMEDB_DEFINE_ALGEBRAIC_TYPE
+
+// Container type specializations
+template<typename T> struct algebraic_type_of<std::vector<T>> {
+    static AlgebraicType get() {
+        // TODO: This needs V9TypeRegistration integration to get proper element type ID
+        return AlgebraicType::Array(AlgebraicType::Ref(0)); // Placeholder
+    }
+};
+
+template<typename T> struct algebraic_type_of<std::optional<T>> {
+    static AlgebraicType get() {
+        // For optional types, we need the type reference of the inner type
+        // For primitive types, this will be their tag value (4-19)
+        // For complex types, this needs to be resolved by the V9TypeRegistration system
+        // This is a limitation - we can't create proper Option types for complex T without V9TypeRegistration
+        
+        // Get the inner type
+        AlgebraicType inner_type = algebraic_type_of<T>::get();
+        
+        // If it's a primitive type, use its tag as the type reference
+        if (inner_type.tag() >= AlgebraicTypeTag::String && 
+            inner_type.tag() <= AlgebraicTypeTag::F64) {
+            return AlgebraicType::Option(static_cast<uint32_t>(inner_type.tag()));
+        } else {
+            // For complex types, we can't determine the correct type reference
+            // without V9TypeRegistration. Use 0 as placeholder which will need to be
+            // resolved during type registration.
+            return AlgebraicType::Option(0);
+        }
+    }
+};
+
+// TODO: Add specializations for I128, I256, U128, U256 when those types are properly defined
+
+// =========================================================================
+// Inline implementations (after AlgebraicType is complete)
+// =========================================================================
+
+// ProductTypeElement implementations
+inline ProductTypeElement::ProductTypeElement(std::optional<std::string> n, AlgebraicType type)
+    : name(std::move(n)), algebraic_type(std::make_unique<AlgebraicType>(std::move(type))) {}
+
+inline ProductTypeElement::ProductTypeElement(const ProductTypeElement& other)
+    : name(other.name), 
+      algebraic_type(other.algebraic_type ? other.algebraic_type->copy() : nullptr) {}
+
+inline ProductTypeElement& ProductTypeElement::operator=(const ProductTypeElement& other) {
+    if (this != &other) {
+        name = other.name;
+        algebraic_type = other.algebraic_type ? other.algebraic_type->copy() : nullptr;
+    }
+    return *this;
+}
+
+// SumTypeVariant implementations
+inline SumTypeVariant::SumTypeVariant(std::string n, AlgebraicType type)
+    : name(std::move(n)), algebraic_type(std::make_unique<AlgebraicType>(std::move(type))) {}
+
+inline SumTypeVariant::SumTypeVariant(const SumTypeVariant& other)
+    : name(other.name),
+      algebraic_type(other.algebraic_type ? other.algebraic_type->copy() : nullptr) {}
+
+inline SumTypeVariant& SumTypeVariant::operator=(const SumTypeVariant& other) {
+    if (this != &other) {
+        name = other.name;
+        algebraic_type = other.algebraic_type ? other.algebraic_type->copy() : nullptr;
+    }
+    return *this;
+}
+
+// ArrayType implementations
+inline ArrayType::ArrayType(AlgebraicType elem_type)
+    : element_type(std::make_unique<AlgebraicType>(std::move(elem_type))) {}
+
+inline ArrayType::ArrayType(const ArrayType& other)
+    : element_type(other.element_type ? other.element_type->copy() : nullptr) {}
+
+inline ArrayType& ArrayType::operator=(const ArrayType& other) {
+    if (this != &other) {
+        element_type = other.element_type ? other.element_type->copy() : nullptr;
+    }
+    return *this;
+}
+
+// AlgebraicType copy implementation
+inline std::unique_ptr<AlgebraicType> AlgebraicType::copy() const {
+    switch (tag_) {
+        case AlgebraicTypeTag::Ref:
+            return std::make_unique<AlgebraicType>(make_ref(std::get<uint32_t>(data_)));
+            
+        case AlgebraicTypeTag::Sum: {
+            const auto& sum = *std::get<std::unique_ptr<SumTypeSchema>>(data_);
+            std::vector<SumTypeVariant> new_variants;
+            for (const auto& variant : sum.variants) {
+                new_variants.push_back(variant);  // Uses copy constructor
+            }
+            return std::make_unique<AlgebraicType>(
+                make_sum(std::make_unique<SumTypeSchema>(std::move(new_variants)))
+            );
+        }
+        
+        case AlgebraicTypeTag::Product: {
+            const auto& prod = *std::get<std::unique_ptr<ProductType>>(data_);
+            std::vector<ProductTypeElement> new_elements;
+            for (const auto& elem : prod.elements) {
+                new_elements.push_back(elem);  // Uses copy constructor
+            }
+            return std::make_unique<AlgebraicType>(
+                make_product(std::make_unique<ProductType>(std::move(new_elements)))
+            );
+        }
+        
+        case AlgebraicTypeTag::Array: {
+            const auto& arr = *std::get<std::unique_ptr<ArrayType>>(data_);
+            return std::make_unique<AlgebraicType>(
+                make_array(std::make_unique<ArrayType>(arr))  // Uses copy constructor
+            );
+        }
+        
+        default:
+            // Primitive types - create directly with tag and monostate
+            return std::make_unique<AlgebraicType>(AlgebraicType(tag_, std::monostate{}));
+    }
+}
+
+} // namespace SpacetimeDb::bsatn
+
+#endif // SPACETIMEDB_BSATN_ALGEBRAIC_TYPE_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/bsatn.h b/crates/bindings-cpp/include/spacetimedb/bsatn/bsatn.h
new file mode 100644
index 00000000000..81d5760c45c
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/bsatn.h
@@ -0,0 +1,64 @@
+#ifndef SPACETIMEDB_BSATN_MAIN_H // Changed guard to avoid conflict if old bsatn.h was somehow included
+#define SPACETIMEDB_BSATN_MAIN_H
+
+/**
+ * @file bsatn.h
+ * @brief Main include file for the BSATN (Binary SpacetimeDB Abstract Type Notation) library components.
+ * @details This file includes the core components for BSATN serialization and deserialization:
+ *          - bsatn::Reader
+ *          - bsatn::Writer
+ *          - Placeholder types for 128-bit integers.
+ *          - Generic bsatn::serialize and bsatn::deserialize<T> free function templates and their overloads/specializations.
+ *          - Algebraic type system for type metadata
+ *          - Serialization traits and interfaces
+ *          - Type registry for managing types
+ *          - Sum type support for discriminated unions
+ */
+
+// Forward declarations
+namespace SpacetimeDb {
+    namespace bsatn {
+        class Reader;
+        class Writer;
+    }
+}
+
+// Core includes
+#include "reader.h"              // Defines Reader for deserialization
+#include "writer.h"              // Defines Writer for serialization
+#include "algebraic_type.h"      // AlgebraicType system (matches Rust/C#)
+#include "type_extensions.h"     // Extended and special types (merged from special_types.h and extended_types.h) - must come before traits.h
+#include "traits.h"              // Serialization traits and interfaces (includes struct macros)
+#include "primitive_traits.h"    // Primitive type specializations (bool, int, float, string)
+#include "serialization.h"       // Main serialize/deserialize functions with C++20 concepts
+#include "sum_type.h"            // SumType and Option (renamed from Sum)
+#include "size_calculator.h"     // Size calculation without serialization
+#include "types_impl.h"          // Implementation of BSATN methods for SpacetimeDB types
+
+// BSATN (Binary SpacetimeDB Algebraic Type Notation) C++ Implementation
+//
+// This provides a complete serialization system compatible with Rust and C#:
+//
+// 🔹 Core Types:
+//   - AlgebraicType: Type metadata system
+//   - ProductType: Structs/tuples (renamed elements for consistency)
+//   - SumType<T...>: Discriminated unions (renamed from Sum)
+//   - Option<T>: Optional values
+//
+// 🔹 Usage:
+//   serialize(writer, value);           // Serialize any supported type
+//   auto obj = deserialize<T>(reader);  // Deserialize to specific type
+//   SPACETIMEDB_STRUCT(MyType, field1, field2);  // Enable struct serialization
+//
+// 🔹 Features:
+//   ✅ All primitive types (bool, integers, floats, string)
+//   ✅ Containers (vector, optional)
+//   ✅ User-defined structs via macro
+//   ✅ Sum types and discriminated unions
+//   ✅ Special SpacetimeDB types (Identity, Timestamp, etc.)
+//   ✅ Type registry for metadata
+//   ✅ Cross-language compatibility
+//
+// Note: Legacy SpacetimeDb::bsatn namespace is available for backward compatibility.
+
+#endif // SPACETIMEDB_BSATN_MAIN_H
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/monostate_traits.h b/crates/bindings-cpp/include/spacetimedb/bsatn/monostate_traits.h
new file mode 100644
index 00000000000..c1b3421a44e
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/monostate_traits.h
@@ -0,0 +1,46 @@
+#ifndef SPACETIMEDB_BSATN_MONOSTATE_TRAITS_H
+#define SPACETIMEDB_BSATN_MONOSTATE_TRAITS_H
+
+#include <variant>
+#include "traits.h"
+#include "writer.h"
+#include "reader.h"
+#include "algebraic_type.h"
+
+namespace SpacetimeDb {
+namespace bsatn {
+
+/**
+ * BSATN traits specialization for std::monostate
+ * 
+ * std::monostate represents a unit type (empty product with 0 fields)
+ * This is equivalent to Rust's () unit type.
+ * 
+ * Serialization: Writes nothing (0 bytes)
+ * Deserialization: Reads nothing, returns std::monostate{}
+ * Algebraic type: Product with 0 fields (unit type)
+ */
+template<>
+struct bsatn_traits<std::monostate> {
+    static void serialize(Writer&, const std::monostate&) {
+        // Unit type serializes to nothing (0 bytes)
+        // This matches BSATN spec for empty products
+    }
+    
+    static std::monostate deserialize(Reader&) {
+        // Unit type deserializes from nothing
+        // Just return a default-constructed monostate
+        return std::monostate{};
+    }
+    
+    static AlgebraicType algebraic_type() {
+        // Unit is represented as an empty product (struct with 0 fields)
+        // This matches how Rust's () is serialized
+        return AlgebraicType::make_product({});
+    }
+};
+
+} // namespace bsatn
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_BSATN_MONOSTATE_TRAITS_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/primitive_traits.h b/crates/bindings-cpp/include/spacetimedb/bsatn/primitive_traits.h
new file mode 100644
index 00000000000..6c4aaf3ddff
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/primitive_traits.h
@@ -0,0 +1,275 @@
+#ifndef SPACETIMEDB_BSATN_PRIMITIVE_TRAITS_H
+#define SPACETIMEDB_BSATN_PRIMITIVE_TRAITS_H
+
+/**
+ * @file primitive_traits.h
+ * @brief BSATN trait specializations for primitive types
+ * 
+ * This file provides bsatn_traits specializations for all primitive types
+ * supported by SpacetimeDB. These specializations delegate to the existing
+ * serialize functions in writer.h and deserializer struct in reader.h.
+ */
+
+#include "traits.h"
+#include "reader.h"
+#include "writer.h"
+#include "algebraic_type.h"
+#include <string>
+#include <type_traits>
+
+namespace SpacetimeDb::bsatn {
+
+// Forward declarations of serialize functions from writer.h
+inline void serialize(Writer& w, bool value);
+inline void serialize(Writer& w, uint8_t value);
+inline void serialize(Writer& w, uint16_t value);
+inline void serialize(Writer& w, uint32_t value);
+inline void serialize(Writer& w, uint64_t value);
+inline void serialize(Writer& w, int8_t value);
+inline void serialize(Writer& w, int16_t value);
+inline void serialize(Writer& w, int32_t value);
+inline void serialize(Writer& w, int64_t value);
+inline void serialize(Writer& w, float value);
+inline void serialize(Writer& w, double value);
+inline void serialize(Writer& w, const std::string& value);
+
+// =========================================================================
+// Boolean Type
+// =========================================================================
+
+template<>
+struct bsatn_traits<bool> {
+    static void serialize(Writer& writer, bool value) {
+        writer.write_bool(value);
+    }
+    
+    static bool deserialize(Reader& reader) {
+        return reader.read_bool();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::Bool();
+    }
+};
+
+// =========================================================================
+// Signed Integer Types
+// =========================================================================
+
+template<>
+struct bsatn_traits<int8_t> {
+    static void serialize(Writer& writer, int8_t value) {
+        writer.write_i8(value);
+    }
+    
+    static int8_t deserialize(Reader& reader) {
+        return reader.read_i8();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::I8();
+    }
+};
+
+template<>
+struct bsatn_traits<int16_t> {
+    static void serialize(Writer& writer, int16_t value) {
+        writer.write_i16_le(value);
+    }
+    
+    static int16_t deserialize(Reader& reader) {
+        return reader.read_i16_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::I16();
+    }
+};
+
+template<>
+struct bsatn_traits<int32_t> {
+    static void serialize(Writer& writer, int32_t value) {
+        writer.write_i32_le(value);
+    }
+    
+    static int32_t deserialize(Reader& reader) {
+        return reader.read_i32_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::I32();
+    }
+};
+
+template<>
+struct bsatn_traits<int64_t> {
+    static void serialize(Writer& writer, int64_t value) {
+        writer.write_i64_le(value);
+    }
+    
+    static int64_t deserialize(Reader& reader) {
+        return reader.read_i64_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::I64();
+    }
+};
+
+// =========================================================================
+// Unsigned Integer Types
+// =========================================================================
+
+template<>
+struct bsatn_traits<uint8_t> {
+    static void serialize(Writer& writer, uint8_t value) {
+        writer.write_u8(value);
+    }
+    
+    static uint8_t deserialize(Reader& reader) {
+        return reader.read_u8();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::U8();
+    }
+};
+
+template<>
+struct bsatn_traits<uint16_t> {
+    static void serialize(Writer& writer, uint16_t value) {
+        writer.write_u16_le(value);
+    }
+    
+    static uint16_t deserialize(Reader& reader) {
+        return reader.read_u16_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::U16();
+    }
+};
+
+template<>
+struct bsatn_traits<uint32_t> {
+    static void serialize(Writer& writer, uint32_t value) {
+        writer.write_u32_le(value);
+    }
+    
+    static uint32_t deserialize(Reader& reader) {
+        return reader.read_u32_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::U32();
+    }
+};
+
+template<>
+struct bsatn_traits<uint64_t> {
+    static void serialize(Writer& writer, uint64_t value) {
+        writer.write_u64_le(value);
+    }
+    
+    static uint64_t deserialize(Reader& reader) {
+        return reader.read_u64_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::U64();
+    }
+};
+
+// =========================================================================
+// Floating Point Types
+// =========================================================================
+
+template<>
+struct bsatn_traits<float> {
+    static void serialize(Writer& writer, float value) {
+        writer.write_f32_le(value);
+    }
+    
+    static float deserialize(Reader& reader) {
+        return reader.read_f32_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::F32();
+    }
+};
+
+template<>
+struct bsatn_traits<double> {
+    static void serialize(Writer& writer, double value) {
+        writer.write_f64_le(value);
+    }
+    
+    static double deserialize(Reader& reader) {
+        return reader.read_f64_le();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::F64();
+    }
+};
+
+// =========================================================================
+// String Type
+// =========================================================================
+
+template<>
+struct bsatn_traits<std::string> {
+    static void serialize(Writer& writer, const std::string& value) {
+        writer.write_string(value);
+    }
+    
+    static std::string deserialize(Reader& reader) {
+        return reader.read_string();
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::String();
+    }
+};
+
+// Note: Platform-specific type aliases (like 'int' vs 'int32_t') are handled
+// by the existing type system. On most platforms, 'int' is an alias for 'int32_t'
+// and 'unsigned int' is an alias for 'uint32_t', so they use the same specializations.
+
+// =========================================================================
+// Generic Enum Type Support
+// =========================================================================
+
+/**
+ * Generic enum trait specialization that works for any enum type.
+ * Enums are serialized as their underlying type (typically uint32_t).
+ * 
+ * Usage:
+ *   enum class MyEnum : uint8_t { Zero, One, Two };
+ *   // Automatically supported for BSATN serialization
+ */
+template<typename T>
+requires std::is_enum_v<T>
+struct bsatn_traits<T> {
+    static void serialize(Writer& writer, const T& value) {
+        using underlying = std::underlying_type_t<T>;
+        // Delegate to the underlying type's serialization
+        bsatn_traits<underlying>::serialize(writer, static_cast<underlying>(value));
+    }
+    
+    static T deserialize(Reader& reader) {
+        using underlying = std::underlying_type_t<T>;
+        // Delegate to the underlying type's deserialization
+        return static_cast<T>(bsatn_traits<underlying>::deserialize(reader));
+    }
+    
+    static AlgebraicType algebraic_type() {
+        using underlying = std::underlying_type_t<T>;
+        return bsatn_traits<underlying>::algebraic_type();
+    }
+};
+
+} // namespace SpacetimeDb::bsatn
+
+#endif // SPACETIMEDB_BSATN_PRIMITIVE_TRAITS_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/reader.h b/crates/bindings-cpp/include/spacetimedb/bsatn/reader.h
new file mode 100644
index 00000000000..e52a3d002d4
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/reader.h
@@ -0,0 +1,268 @@
+#ifndef SPACETIMEDB_BSATN_READER_H
+#define SPACETIMEDB_BSATN_READER_H
+
+#include <vector>
+#include <string>
+#include <cstdint>
+#include <stdexcept>
+#include <optional>
+#include <functional>
+#include <span>
+#include <type_traits>
+#include <cstring>
+#include <variant>
+// uint128_placeholder.h removed - types are in spacetimedb/types.h
+#include "types.h"
+
+namespace SpacetimeDb::bsatn {
+
+    class Reader;
+    template<typename T> T deserialize(Reader& r);
+    template<typename T> struct bsatn_traits;
+
+    // Helper traits
+    template<typename> struct is_std_optional : std::false_type {};
+    template<typename T> struct is_std_optional<std::optional<T>> : std::true_type {};
+    template<typename T> constexpr bool is_std_optional_v = is_std_optional<T>::value;
+
+    template<typename> struct is_std_vector : std::false_type {};
+    template<typename T> struct is_std_vector<std::vector<T>> : std::true_type {};
+    template<typename T> constexpr bool is_std_vector_v = is_std_vector<T>::value;
+
+    class Reader {
+    public:
+        // Constructors - using uint8_t consistently
+        Reader(const uint8_t* data, size_t size) : current_ptr(data), end_ptr(data + size) {}
+        Reader(std::span<const uint8_t> data) : current_ptr(data.data()), end_ptr(data.data() + data.size()) {}
+        Reader(const std::vector<uint8_t>& data) : current_ptr(data.data()), end_ptr(data.data() + data.size()) {}
+        
+
+        // Template method for reading primitive types (reduces implementation duplication)
+        template<typename T>
+        T read_primitive_le() {
+            static_assert(std::is_arithmetic_v<T>, "read_primitive_le only works with arithmetic types");
+            check_available(sizeof(T));
+            T val;
+            std::memcpy(&val, current_ptr, sizeof(T));
+            advance(sizeof(T));
+            return val;
+        }
+
+        // Public API methods (delegates to template where possible)
+        inline bool read_bool() {
+            check_available(1);
+            uint8_t val = *current_ptr;
+            advance(1);
+            if (val > 1) {
+                std::abort(); // Invalid bool value in BSATN deserialization
+            }
+            return val != 0;
+        }
+        inline uint8_t read_u8() {
+            check_available(1);
+            uint8_t val = *current_ptr;
+            advance(1);
+            return val;
+        }
+        uint16_t read_u16_le() { return read_primitive_le<uint16_t>(); }
+        uint32_t read_u32_le() { return read_primitive_le<uint32_t>(); }
+        uint64_t read_u64_le() { return read_primitive_le<uint64_t>(); }
+        inline SpacetimeDb::u128 read_u128_le() {
+            uint64_t low = read_u64_le();
+            uint64_t high = read_u64_le();
+            return SpacetimeDb::u128(high, low);
+        }
+        inline SpacetimeDb::u256_placeholder read_u256_le() {
+            check_available(32);
+            SpacetimeDb::u256_placeholder val;
+            std::memcpy(val.data.data(), current_ptr, 32);
+            advance(32);
+            return val;
+        }
+
+        int8_t read_i8() { return static_cast<int8_t>(read_u8()); }
+        int16_t read_i16_le() { return static_cast<int16_t>(read_u16_le()); }
+        int32_t read_i32_le() { return static_cast<int32_t>(read_u32_le()); }
+        int64_t read_i64_le() { return static_cast<int64_t>(read_u64_le()); }
+        inline SpacetimeDb::i128 read_i128_le() {
+            uint64_t low = read_u64_le();
+            int64_t high = static_cast<int64_t>(read_u64_le());
+            return SpacetimeDb::i128(high, low);
+        }
+        inline SpacetimeDb::i256_placeholder read_i256_le() {
+            check_available(32);
+            SpacetimeDb::i256_placeholder val;
+            std::memcpy(val.data.data(), current_ptr, 32);
+            advance(32);
+            return val;
+        }
+
+        float read_f32_le() { return read_primitive_le<float>(); }
+        double read_f64_le() { return read_primitive_le<double>(); }
+
+        inline std::string read_string() {
+            uint32_t len = read_u32_le();
+            check_available(len);
+            std::string result(reinterpret_cast<const char*>(current_ptr), len);
+            advance(len);
+            return result;
+        }
+        inline std::vector<uint8_t> read_bytes() {
+            uint32_t len = read_u32_le();
+            check_available(len);
+            std::vector<uint8_t> result(current_ptr, current_ptr + len);
+            advance(len);
+            return result;
+        }
+        inline std::vector<uint8_t> read_fixed_bytes(size_t count) {
+            check_available(count);
+            std::vector<uint8_t> result(current_ptr, current_ptr + count);
+            advance(count);
+            return result;
+        }
+
+        template<typename T>
+        std::optional<T> read_optional() {
+            uint8_t tag = read_u8();
+            if (tag == 0) {
+                return std::nullopt;
+            } else if (tag == 1) {
+                return SpacetimeDb::bsatn::deserialize<T>(*this);
+            } else {
+                std::abort(); // Invalid optional tag in BSATN deserialization
+            }
+        }
+
+        template<typename T>
+        std::vector<T> read_vector() {
+            uint32_t size = read_u32_le();
+            std::vector<T> result;
+            result.reserve(size);
+            for (uint32_t i = 0; i < size; ++i) {
+                result.push_back(SpacetimeDb::bsatn::deserialize<T>(*this));
+            }
+            return result;
+        }
+
+        inline std::vector<uint8_t> read_vector_byte() {
+            return read_bytes();
+        }
+
+        // Deserialize a type using C++20 concepts for better error messages
+        template<typename T>
+            requires requires(Reader& r) { SpacetimeDb::bsatn::deserialize<T>(r); }
+        T deserialize_type() {
+            return SpacetimeDb::bsatn::deserialize<T>(*this);
+        }
+
+        inline bool is_eos() const {
+            return current_ptr >= end_ptr;
+        }
+        inline size_t remaining_bytes() const {
+            return (current_ptr <= end_ptr) ? (end_ptr - current_ptr) : 0;
+        }
+
+    private:
+        inline void check_available(size_t num_bytes) const {
+            if (current_ptr + num_bytes > end_ptr) {
+                std::abort(); // BSATN Reader: Not enough bytes remaining
+            }
+        }
+        inline void advance(size_t num_bytes) {
+            current_ptr += num_bytes;
+        }
+
+        const uint8_t* current_ptr;
+        const uint8_t* end_ptr;
+    };
+
+    // Type trait for deserializing types - primary template
+    template<typename T, typename = void>
+    struct deserializer {
+        static T deserialize(Reader& r) {
+            // Default: try bsatn_traits
+            return bsatn_traits<T>::deserialize(r);
+        }
+    };
+    
+    // Specializations for primitive types
+    template<> struct deserializer<bool> {
+        static bool deserialize(Reader& r) { return r.read_bool(); }
+    };
+    template<> struct deserializer<uint8_t> {
+        static uint8_t deserialize(Reader& r) { return r.read_u8(); }
+    };
+    template<> struct deserializer<uint16_t> {
+        static uint16_t deserialize(Reader& r) { return r.read_u16_le(); }
+    };
+    template<> struct deserializer<uint32_t> {
+        static uint32_t deserialize(Reader& r) { return r.read_u32_le(); }
+    };
+    template<> struct deserializer<uint64_t> {
+        static uint64_t deserialize(Reader& r) { return r.read_u64_le(); }
+    };
+    template<> struct deserializer<int8_t> {
+        static int8_t deserialize(Reader& r) { return r.read_i8(); }
+    };
+    template<> struct deserializer<int16_t> {
+        static int16_t deserialize(Reader& r) { return r.read_i16_le(); }
+    };
+    template<> struct deserializer<int32_t> {
+        static int32_t deserialize(Reader& r) { return r.read_i32_le(); }
+    };
+    template<> struct deserializer<int64_t> {
+        static int64_t deserialize(Reader& r) { return r.read_i64_le(); }
+    };
+    template<> struct deserializer<float> {
+        static float deserialize(Reader& r) { return r.read_f32_le(); }
+    };
+    template<> struct deserializer<double> {
+        static double deserialize(Reader& r) { return r.read_f64_le(); }
+    };
+    template<> struct deserializer<std::string> {
+        static std::string deserialize(Reader& r) { return r.read_string(); }
+    };
+    template<> struct deserializer<std::vector<uint8_t>> {
+        static std::vector<uint8_t> deserialize(Reader& r) { return r.read_bytes(); }
+    };
+    
+    // Specializations for container types
+    template<typename T>
+    struct deserializer<std::optional<T>> {
+        static std::optional<T> deserialize(Reader& r) {
+            return r.read_optional<T>();
+        }
+    };
+    
+    template<typename T>
+    struct deserializer<std::vector<T>, std::enable_if_t<!std::is_same_v<T, uint8_t>>> {
+        static std::vector<T> deserialize(Reader& r) {
+            return r.read_vector<T>();
+        }
+    };
+    
+    // Specializations for SpacetimeDB types
+    template<> struct deserializer<SpacetimeDb::Identity> {
+        static SpacetimeDb::Identity deserialize(Reader& r) {
+            SpacetimeDb::Identity id;
+            id.bsatn_deserialize(r);
+            return id;
+        }
+    };
+    template<> struct deserializer<SpacetimeDb::ConnectionId> {
+        static SpacetimeDb::ConnectionId deserialize(Reader& r) {
+            SpacetimeDb::ConnectionId conn;
+            conn.bsatn_deserialize(r);
+            return conn;
+        }
+    };
+    
+    // Generic deserialize function - now much cleaner!
+    template<typename T>
+    inline T deserialize(Reader& r) {
+        return deserializer<T>::deserialize(r);
+    }
+
+} // namespace SpacetimeDB::bsatn
+
+#endif // SPACETIMEDB_BSATN_READER_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/schedule_at.h b/crates/bindings-cpp/include/spacetimedb/bsatn/schedule_at.h
new file mode 100644
index 00000000000..5d8e2120ea9
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/schedule_at.h
@@ -0,0 +1,166 @@
+#ifndef SPACETIMEDB_BSATN_SCHEDULE_AT_H
+#define SPACETIMEDB_BSATN_SCHEDULE_AT_H
+
+#include "timestamp.h"
+#include "time_duration.h"
+#include <stdexcept>
+
+namespace SpacetimeDb {
+
+/**
+ * ScheduleAt represents when a scheduled reducer should execute.
+ * This is a sum type with two variants:
+ * - Interval(TimeDuration): Execute at regular intervals
+ * - Time(Timestamp): Execute at a specific time
+ * 
+ * Special type matching Rust's ScheduleAt enum.
+ * This enables scheduled reducers functionality in SpacetimeDB.
+ */
+class ScheduleAt {
+public:
+    enum class Variant : uint8_t {
+        Interval = 0,  // Regular interval (TimeDuration)
+        Time = 1       // Specific time (Timestamp)
+    };
+    
+private:
+    Variant variant;
+    union {
+        TimeDuration interval_value;
+        Timestamp time_value;
+    };
+    
+public:
+    // Constructors
+    ScheduleAt() : variant(Variant::Interval), interval_value(TimeDuration::from_seconds(0)) {}
+    
+    ScheduleAt(const TimeDuration& dur) 
+        : variant(Variant::Interval), interval_value(dur) {}
+    
+    ScheduleAt(const Timestamp& ts) 
+        : variant(Variant::Time), time_value(ts) {}
+    
+    // Copy constructor
+    ScheduleAt(const ScheduleAt& other) : variant(other.variant) {
+        switch (variant) {
+            case Variant::Interval:
+                new (&interval_value) TimeDuration(other.interval_value);
+                break;
+            case Variant::Time:
+                new (&time_value) Timestamp(other.time_value);
+                break;
+        }
+    }
+    
+    // Assignment operator
+    ScheduleAt& operator=(const ScheduleAt& other) {
+        if (this != &other) {
+            this->~ScheduleAt(); // Destroy current value
+            variant = other.variant;
+            switch (variant) {
+                case Variant::Interval:
+                    new (&interval_value) TimeDuration(other.interval_value);
+                    break;
+                case Variant::Time:
+                    new (&time_value) Timestamp(other.time_value);
+                    break;
+            }
+        }
+        return *this;
+    }
+    
+    // Move constructor
+    ScheduleAt(ScheduleAt&& other) noexcept : variant(other.variant) {
+        switch (variant) {
+            case Variant::Interval:
+                new (&interval_value) TimeDuration(std::move(other.interval_value));
+                break;
+            case Variant::Time:
+                new (&time_value) Timestamp(std::move(other.time_value));
+                break;
+        }
+    }
+    
+    // Move assignment
+    ScheduleAt& operator=(ScheduleAt&& other) noexcept {
+        if (this != &other) {
+            this->~ScheduleAt();
+            variant = other.variant;
+            switch (variant) {
+                case Variant::Interval:
+                    new (&interval_value) TimeDuration(std::move(other.interval_value));
+                    break;
+                case Variant::Time:
+                    new (&time_value) Timestamp(std::move(other.time_value));
+                    break;
+            }
+        }
+        return *this;
+    }
+    
+    // Destructor
+    ~ScheduleAt() {
+        switch (variant) {
+            case Variant::Interval:
+                interval_value.~TimeDuration();
+                break;
+            case Variant::Time:
+                time_value.~Timestamp();
+                break;
+        }
+    }
+    
+    // Accessors
+    Variant get_variant() const { return variant; }
+    bool is_interval() const { return variant == Variant::Interval; }
+    bool is_time() const { return variant == Variant::Time; }
+    
+    const TimeDuration& get_interval() const {
+        if (variant != Variant::Interval) {
+            static TimeDuration default_duration;
+            return default_duration;
+        }
+        return interval_value;
+    }
+    
+    const Timestamp& get_time() const {
+        if (variant != Variant::Time) {
+            static Timestamp default_timestamp;
+            return default_timestamp;
+        }
+        return time_value;
+    }
+    
+    // Static factory methods
+    static ScheduleAt interval(const TimeDuration& dur) {
+        return ScheduleAt(dur);
+    }
+    
+    static ScheduleAt time(const Timestamp& ts) {
+        return ScheduleAt(ts);
+    }
+    
+    // Comparison operators
+    bool operator==(const ScheduleAt& other) const {
+        if (variant != other.variant) return false;
+        switch (variant) {
+            case Variant::Interval:
+                return interval_value == other.interval_value;
+            case Variant::Time:
+                return time_value == other.time_value;
+        }
+        return false;
+    }
+    
+    bool operator!=(const ScheduleAt& other) const {
+        return !(*this == other);
+    }
+    
+    // BSATN serialization (implemented below)
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const;
+    void bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader);
+};
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_BSATN_SCHEDULE_AT_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/schedule_at_impl.h b/crates/bindings-cpp/include/spacetimedb/bsatn/schedule_at_impl.h
new file mode 100644
index 00000000000..efc26d25393
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/schedule_at_impl.h
@@ -0,0 +1,135 @@
+#ifndef SPACETIMEDB_BSATN_SCHEDULE_AT_IMPL_H
+#define SPACETIMEDB_BSATN_SCHEDULE_AT_IMPL_H
+
+#include "schedule_at.h"
+#include "reader.h"
+#include "writer.h"
+#include "traits.h"
+#include "type_extensions.h"  // For special type constants
+
+namespace SpacetimeDb {
+
+// ScheduleAt BSATN implementation
+inline void ScheduleAt::bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+    // Write variant tag (as u8)
+    writer.write_u8(static_cast<uint8_t>(variant));
+    
+    // Write payload based on variant
+    switch (variant) {
+        case Variant::Interval:
+            interval_value.bsatn_serialize(writer);
+            break;
+        case Variant::Time:
+            time_value.bsatn_serialize(writer);
+            break;
+    }
+}
+
+inline void ScheduleAt::bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader) {
+    // Read variant tag
+    uint8_t variant_tag = reader.read_u8();
+    
+    // Destroy current union content
+    this->~ScheduleAt();
+    
+    // Initialize based on variant
+    switch (variant_tag) {
+        case 0: // Interval
+            variant = Variant::Interval;
+            new (&interval_value) TimeDuration();
+            interval_value.bsatn_deserialize(reader);
+            break;
+        case 1: // Time
+            variant = Variant::Time;
+            new (&time_value) Timestamp();
+            time_value.bsatn_deserialize(reader);
+            break;
+        default:
+            // Default to Interval variant with 0 duration
+            variant = Variant::Interval;
+            new (&interval_value) TimeDuration();
+    }
+}
+
+} // namespace SpacetimeDb
+
+namespace SpacetimeDb::bsatn {
+
+// Explicit specialization for ScheduleAt to handle BSATN serialization
+template<>
+struct bsatn_traits<::SpacetimeDb::ScheduleAt> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::ScheduleAt& value) {
+        value.bsatn_serialize(writer);
+    }
+    
+    static ::SpacetimeDb::ScheduleAt deserialize(Reader& reader) {
+        ::SpacetimeDb::ScheduleAt result; // Default constructor
+        result.bsatn_deserialize(reader);
+        return result;
+    }
+    
+    static AlgebraicType algebraic_type() {
+        // ScheduleAt is a special Sum type with Interval and Time variants
+        // Use the existing TimeDuration and Timestamp algebraic_type specializations
+        // to ensure proper inlining like the legacy path
+        
+        std::vector<SumTypeVariant> variants;
+        
+        // Interval variant: Use TimeDuration's algebraic_type() for proper inlining
+        AlgebraicType interval_type = bsatn_traits<::SpacetimeDb::TimeDuration>::algebraic_type();
+        variants.emplace_back("Interval", std::move(interval_type));
+        
+        // Time variant: Use Timestamp's algebraic_type() for proper inlining
+        AlgebraicType time_type = bsatn_traits<::SpacetimeDb::Timestamp>::algebraic_type();
+        variants.emplace_back("Time", std::move(time_type));
+        
+        auto sum_type = std::make_unique<SumTypeSchema>(std::move(variants));
+        return AlgebraicType::make_sum(std::move(sum_type));
+    }
+};
+
+} // namespace SpacetimeDb::bsatn
+
+// BSATN serializer template specialization for ScheduleAt
+namespace SpacetimeDb {
+
+// ScheduleAt serialization - sum type with variant tag + payload
+template<>
+struct BsatnSerializer<ScheduleAt> {
+    static void serialize(std::vector<uint8_t>& buffer, const ScheduleAt& value) {
+        // Write variant tag
+        buffer.push_back(static_cast<uint8_t>(value.get_variant()));
+        
+        // Write payload based on variant
+        switch (value.get_variant()) {
+            case ScheduleAt::Variant::Interval:
+                BsatnSerializer<TimeDuration>::serialize(buffer, value.get_interval());
+                break;
+            case ScheduleAt::Variant::Time:
+                BsatnSerializer<Timestamp>::serialize(buffer, value.get_time());
+                break;
+        }
+    }
+    
+    static ScheduleAt deserialize(const uint8_t* data, size_t& offset) {
+        // Read variant tag
+        uint8_t variant_tag = data[offset++];
+        
+        switch (variant_tag) {
+            case 0: { // Interval
+                TimeDuration dur = BsatnSerializer<TimeDuration>::deserialize(data, offset);
+                return ScheduleAt::interval(dur);
+            }
+            case 1: { // Time
+                Timestamp ts = BsatnSerializer<Timestamp>::deserialize(data, offset);
+                return ScheduleAt::time(ts);
+            }
+            default:
+                return ScheduleAt::interval(TimeDuration::from_seconds(0));
+        }
+    }
+};
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_BSATN_SCHEDULE_AT_IMPL_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/serialization.h b/crates/bindings-cpp/include/spacetimedb/bsatn/serialization.h
new file mode 100644
index 00000000000..e9f3aadf21f
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/serialization.h
@@ -0,0 +1,148 @@
+#ifndef SPACETIMEDB_BSATN_SERIALIZATION_H
+#define SPACETIMEDB_BSATN_SERIALIZATION_H
+
+/**
+ * @file serialization.h
+ * @brief Core serialization and deserialization functions for BSATN
+ * 
+ * This header provides the main entry points for BSATN serialization
+ * using C++20 concepts for better type safety and error messages.
+ */
+
+#include "traits.h"
+#include "reader.h"
+#include "writer.h"
+#include "size_calculator.h"
+#include <concepts>
+#include <type_traits>
+
+namespace SpacetimeDb::bsatn {
+
+/**
+ * @brief Concept for types that can be serialized to BSATN
+ */
+template<typename T>
+concept Serializable = requires(Writer& w, const T& v) {
+    bsatn_traits<T>::serialize(w, v);
+};
+
+/**
+ * @brief Concept for types that can be deserialized from BSATN
+ */
+template<typename T>
+concept Deserializable = requires(Reader& r) {
+    { bsatn_traits<T>::deserialize(r) } -> std::same_as<T>;
+};
+
+/**
+ * @brief Serialize a value to BSATN format
+ * 
+ * @tparam T Type to serialize (must satisfy Serializable concept)
+ * @param writer The writer to serialize to
+ * @param value The value to serialize
+ * 
+ * @example
+ * @code
+ * Writer writer;
+ * MyStruct data{42, "hello"};
+ * serialize(writer, data);
+ * auto bytes = writer.take_buffer();
+ * @endcode
+ */
+template<Serializable T>
+inline void serialize(Writer& writer, const T& value) {
+    bsatn_traits<T>::serialize(writer, value);
+}
+
+/**
+ * @brief Deserialize a value from BSATN format
+ * 
+ * @tparam T Type to deserialize (must satisfy Deserializable concept)
+ * @param reader The reader to deserialize from
+ * @return The deserialized value
+ * 
+ * @example
+ * @code
+ * Reader reader(bytes);
+ * auto data = deserialize<MyStruct>(reader);
+ * @endcode
+ */
+template<Deserializable T>
+inline T deserialize(Reader& reader) {
+    return bsatn_traits<T>::deserialize(reader);
+}
+
+/**
+ * @brief Serialize multiple values at once
+ * 
+ * Uses C++20 parameter packs with concepts for type safety.
+ * 
+ * @example
+ * @code
+ * Writer writer;
+ * serialize_all(writer, 42, "hello", true, 3.14);
+ * @endcode
+ */
+template<typename... Args>
+    requires (Serializable<Args> && ...)
+inline void serialize_all(Writer& writer, const Args&... args) {
+    (serialize(writer, args), ...);
+}
+
+/**
+ * @brief Helper to serialize to a byte vector
+ * 
+ * @tparam T Type to serialize
+ * @param value The value to serialize
+ * @return Vector of bytes containing serialized data
+ */
+template<Serializable T>
+inline std::vector<uint8_t> to_bytes(const T& value) {
+    Writer writer;
+    serialize(writer, value);
+    return writer.take_buffer();
+}
+
+/**
+ * @brief Helper to deserialize from a byte vector
+ * 
+ * @tparam T Type to deserialize
+ * @param bytes The byte vector to deserialize from
+ * @return The deserialized value
+ */
+template<Deserializable T>
+inline T from_bytes(const std::vector<uint8_t>& bytes) {
+    Reader reader(bytes);
+    return deserialize<T>(reader);
+}
+
+// Note: size_calculator.h must be included for these concepts to work
+// It defines has_static_size<T> and static_size_v<T>
+
+/**
+ * @brief Concept for types that have a static size
+ * 
+ * This requires that size_calculator.h has been included to provide
+ * the has_static_size template.
+ */
+template<typename T>
+concept HasStaticSize = requires {
+    typename std::enable_if_t<std::is_class_v<has_static_size<T>>>;
+    { has_static_size<T>::value } -> std::convertible_to<bool>;
+} && has_static_size<T>::value == true;
+
+/**
+ * @brief Get the static BSATN size of a type at compile time
+ * 
+ * @tparam T Type with static size
+ * @return The size in bytes
+ */
+template<typename T>
+    requires HasStaticSize<T>
+consteval size_t static_bsatn_size() {
+    return has_static_size<T>::value;
+}
+
+} // namespace SpacetimeDb::bsatn
+
+#endif // SPACETIMEDB_BSATN_SERIALIZATION_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/size_calculator.h b/crates/bindings-cpp/include/spacetimedb/bsatn/size_calculator.h
new file mode 100644
index 00000000000..0bdcbebd7d3
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/size_calculator.h
@@ -0,0 +1,255 @@
+#ifndef SPACETIMEDB_BSATN_SIZE_CALCULATOR_H
+#define SPACETIMEDB_BSATN_SIZE_CALCULATOR_H
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <type_traits>
+#include <array>
+#include "writer.h"  // For Writer
+
+namespace SpacetimeDb::bsatn {
+
+// Forward declaration
+template<typename T> struct bsatn_traits;
+
+/**
+ * A Writer-compatible class that only counts bytes without storing them.
+ * Used for size calculation via bsatn_traits::serialize().
+ */
+class SizeWriter {
+private:
+    size_t size_ = 0;
+
+public:
+    size_t size() const { return size_; }
+    
+    // Writer interface implementation
+    void write_u8(uint8_t) { size_ += 1; }
+    void write_u16_le(uint16_t) { size_ += 2; }
+    void write_u32_le(uint32_t) { size_ += 4; }
+    void write_u64_le(uint64_t) { size_ += 8; }
+    void write_u128_le(const std::array<uint8_t, 16>&) { size_ += 16; }
+    void write_u256_le(const std::array<uint8_t, 32>&) { size_ += 32; }
+    
+    void write_i8(int8_t) { size_ += 1; }
+    void write_i16_le(int16_t) { size_ += 2; }
+    void write_i32_le(int32_t) { size_ += 4; }
+    void write_i64_le(int64_t) { size_ += 8; }
+    void write_i128_le(const std::array<uint8_t, 16>&) { size_ += 16; }
+    void write_i256_le(const std::array<uint8_t, 32>&) { size_ += 32; }
+    
+    void write_f32_le(float) { size_ += 4; }
+    void write_f64_le(double) { size_ += 8; }
+    
+    void write_bool(bool) { size_ += 1; }
+    
+    void write_string(const std::string& s) {
+        size_ += 4 + s.length();  // Length prefix + data
+    }
+    
+    void write_bytes(const std::vector<uint8_t>& bytes) {
+        size_ += 4 + bytes.size();  // Length prefix + data
+    }
+    
+    void write_bytes(const void*, size_t len) {
+        size_ += 4 + len;  // Length prefix + data
+    }
+    
+    // No-op methods for size calculation
+    std::vector<uint8_t> take_buffer() { return {}; }
+    void clear() { size_ = 0; }
+};
+
+/**
+ * Calculate the serialized size of values without actually serializing.
+ * This matches Rust's CountWriter functionality.
+ */
+class SizeCalculator {
+private:
+    size_t size_ = 0;
+    
+public:
+    size_t size() const { return size_; }
+    
+    void add_bool() { size_ += 1; }
+    void add_u8() { size_ += 1; }
+    void add_u16() { size_ += 2; }
+    void add_u32() { size_ += 4; }
+    void add_u64() { size_ += 8; }
+    void add_u128() { size_ += 16; }
+    void add_u256() { size_ += 32; }
+    
+    void add_i8() { size_ += 1; }
+    void add_i16() { size_ += 2; }
+    void add_i32() { size_ += 4; }
+    void add_i64() { size_ += 8; }
+    void add_i128() { size_ += 16; }
+    void add_i256() { size_ += 32; }
+    
+    void add_f32() { size_ += 4; }
+    void add_f64() { size_ += 8; }
+    
+    void add_string(const std::string& s) {
+        size_ += 4 + s.length();  // Length prefix + data
+    }
+    
+    void add_bytes(size_t len) {
+        size_ += 4 + len;  // Length prefix + data
+    }
+    
+    template<typename T>
+    void add_vector(const std::vector<T>& vec) {
+        size_ += 4;  // Length prefix
+        for (const auto& item : vec) {
+            add_value(item);
+        }
+    }
+    
+    template<typename T>
+    void add_optional(const std::optional<T>& opt) {
+        size_ += 1;  // Tag byte
+        if (opt.has_value()) {
+            add_value(*opt);
+        }
+    }
+    
+    // Generic value addition
+    template<typename T>
+    void add_value(const T& value);
+};
+
+/**
+ * Trait to determine if a type has a static (compile-time known) size.
+ * This matches Rust's static_bsatn_size functionality.
+ */
+template<typename T>
+struct has_static_size : std::false_type {};
+
+template<> struct has_static_size<bool> : std::true_type { static constexpr size_t value = 1; };
+template<> struct has_static_size<uint8_t> : std::true_type { static constexpr size_t value = 1; };
+template<> struct has_static_size<uint16_t> : std::true_type { static constexpr size_t value = 2; };
+template<> struct has_static_size<uint32_t> : std::true_type { static constexpr size_t value = 4; };
+template<> struct has_static_size<uint64_t> : std::true_type { static constexpr size_t value = 8; };
+template<> struct has_static_size<int8_t> : std::true_type { static constexpr size_t value = 1; };
+template<> struct has_static_size<int16_t> : std::true_type { static constexpr size_t value = 2; };
+template<> struct has_static_size<int32_t> : std::true_type { static constexpr size_t value = 4; };
+template<> struct has_static_size<int64_t> : std::true_type { static constexpr size_t value = 8; };
+template<> struct has_static_size<float> : std::true_type { static constexpr size_t value = 4; };
+template<> struct has_static_size<double> : std::true_type { static constexpr size_t value = 8; };
+
+template<typename T>
+inline constexpr bool has_static_size_v = has_static_size<T>::value;
+
+template<typename T>
+inline constexpr size_t static_size_v = has_static_size<T>::value;
+
+/**
+ * Calculate the BSATN serialized size of a value.
+ * Similar to Rust's to_len() function.
+ */
+template<typename T>
+size_t bsatn_len(const T& value) {
+    if constexpr (has_static_size_v<T>) {
+        return static_size_v<T>;
+    } else {
+        SizeCalculator calc;
+        calc.add_value(value);
+        return calc.size();
+    }
+}
+
+/**
+ * Optimized serialization that pre-allocates the exact size needed.
+ * Similar to Rust's to_bsatn_vec().
+ */
+template<typename T>
+std::vector<uint8_t> to_bsatn_vec(const T& value) {
+    size_t size = bsatn_len(value);
+    std::vector<uint8_t> result;
+    result.reserve(size);
+    
+    // Use existing Writer to serialize
+    Writer writer;
+    serialize(writer, value);
+    return writer.take_buffer();
+}
+
+/**
+ * Extend an existing vector with BSATN data.
+ * Similar to Rust's to_bsatn_extend().
+ */
+template<typename T>
+void to_bsatn_extend(std::vector<uint8_t>& vec, const T& value) {
+    size_t old_size = vec.size();
+    size_t add_size = bsatn_len(value);
+    vec.reserve(old_size + add_size);
+    
+    // Serialize directly into the vector
+    // (Would need custom Writer that appends to existing vector)
+    auto temp = to_bsatn_vec(value);
+    vec.insert(vec.end(), temp.begin(), temp.end());
+}
+
+/**
+ * Type trait to check if a type is primitive (no padding).
+ * Similar to Rust's IsPrimitiveType.
+ */
+template<typename T>
+struct is_primitive_type : std::false_type {};
+
+template<> struct is_primitive_type<bool> : std::true_type {};
+template<> struct is_primitive_type<uint8_t> : std::true_type {};
+template<> struct is_primitive_type<uint16_t> : std::true_type {};
+template<> struct is_primitive_type<uint32_t> : std::true_type {};
+template<> struct is_primitive_type<uint64_t> : std::true_type {};
+template<> struct is_primitive_type<int8_t> : std::true_type {};
+template<> struct is_primitive_type<int16_t> : std::true_type {};
+template<> struct is_primitive_type<int32_t> : std::true_type {};
+template<> struct is_primitive_type<int64_t> : std::true_type {};
+template<> struct is_primitive_type<float> : std::true_type {};
+template<> struct is_primitive_type<double> : std::true_type {};
+
+template<typename T>
+inline constexpr bool is_primitive_type_v = is_primitive_type<T>::value;
+
+// Implementation of SizeCalculator::add_value
+template<typename T>
+void SizeCalculator::add_value(const T& value) {
+    if constexpr (std::is_same_v<T, bool>) {
+        add_bool();
+    } else if constexpr (std::is_same_v<T, uint8_t>) {
+        add_u8();
+    } else if constexpr (std::is_same_v<T, uint16_t>) {
+        add_u16();
+    } else if constexpr (std::is_same_v<T, uint32_t>) {
+        add_u32();
+    } else if constexpr (std::is_same_v<T, uint64_t>) {
+        add_u64();
+    } else if constexpr (std::is_same_v<T, int8_t>) {
+        add_i8();
+    } else if constexpr (std::is_same_v<T, int16_t>) {
+        add_i16();
+    } else if constexpr (std::is_same_v<T, int32_t>) {
+        add_i32();
+    } else if constexpr (std::is_same_v<T, int64_t>) {
+        add_i64();
+    } else if constexpr (std::is_same_v<T, float>) {
+        add_f32();
+    } else if constexpr (std::is_same_v<T, double>) {
+        add_f64();
+    } else if constexpr (std::is_same_v<T, std::string>) {
+        add_string(value);
+    } else {
+        // For custom types, use a SizeWriter to calculate size via bsatn_traits
+        SizeWriter size_writer;
+        bsatn_traits<T>::serialize(size_writer, value);
+        size_ += size_writer.size();
+    }
+}
+
+} // namespace SpacetimeDb::bsatn
+
+#endif // SPACETIMEDB_BSATN_SIZE_CALCULATOR_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/sum_type.h b/crates/bindings-cpp/include/spacetimedb/bsatn/sum_type.h
new file mode 100644
index 00000000000..9f6bec90524
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/sum_type.h
@@ -0,0 +1,181 @@
+#ifndef SPACETIMEDB_BSATN_SUM_TYPE_H
+#define SPACETIMEDB_BSATN_SUM_TYPE_H
+
+#include <variant>
+#include <cstdint>
+#include <type_traits>
+#include "traits.h"
+#include "reader.h"
+#include "writer.h"
+#include "algebraic_type.h"
+
+namespace SpacetimeDb {
+namespace bsatn {
+
+/**
+ * @brief A sum type (tagged union) implementation for BSATN serialization
+ * 
+ * This class wraps std::variant to provide a sum type that can be serialized
+ * and deserialized using BSATN format. It's similar to Rust's enum types
+ * with data payloads.
+ * 
+ * @tparam Ts... The types that can be stored in this sum type
+ */
+template<typename... Ts>
+class SumType {
+public:
+    using VariantType = std::variant<Ts...>;
+    
+private:
+    VariantType value_;
+    
+public:
+    // Constructors
+    SumType() = default;
+    
+    template<typename T>
+    SumType(T&& val) : value_(std::forward<T>(val)) {}
+    
+    // Assignment operators
+    template<typename T>
+    SumType& operator=(T&& val) {
+        value_ = std::forward<T>(val);
+        return *this;
+    }
+    
+    // Get the current tag (variant index)
+    uint8_t tag() const {
+        return static_cast<uint8_t>(value_.index());
+    }
+    
+    // Check if the sum type holds a specific type
+    template<typename T>
+    bool is() const {
+        return std::holds_alternative<T>(value_);
+    }
+    
+    // Get the value as a specific type (throws if wrong type)
+    template<typename T>
+    T& get() {
+        return std::get<T>(value_);
+    }
+    
+    template<typename T>
+    const T& get() const {
+        return std::get<T>(value_);
+    }
+    
+    // Get the value as a specific type (returns nullptr if wrong type)
+    template<typename T>
+    T* get_if() {
+        return std::get_if<T>(&value_);
+    }
+    
+    template<typename T>
+    const T* get_if() const {
+        return std::get_if<T>(&value_);
+    }
+    
+    // Visit the sum type with a visitor
+    template<typename Visitor>
+    auto visit(Visitor&& vis) {
+        return std::visit(std::forward<Visitor>(vis), value_);
+    }
+    
+    template<typename Visitor>
+    auto visit(Visitor&& vis) const {
+        return std::visit(std::forward<Visitor>(vis), value_);
+    }
+    
+    // Access the underlying variant
+    VariantType& variant() { return value_; }
+    const VariantType& variant() const { return value_; }
+};
+
+// Helper to serialize a variant value at a specific index
+template<size_t I, typename... Ts>
+void serialize_variant_at_index(Writer& writer, const std::variant<Ts...>& var) {
+    if constexpr (I < sizeof...(Ts)) {
+        if (var.index() == I) {
+            serialize(writer, std::get<I>(var));
+        } else {
+            serialize_variant_at_index<I + 1>(writer, var);
+        }
+    }
+}
+
+// Helper to deserialize a variant value at a specific index  
+template<size_t I, typename... Ts>
+void deserialize_variant_at_index(Reader& reader, std::variant<Ts...>& var, uint8_t tag) {
+    if constexpr (I < sizeof...(Ts)) {
+        if (tag == I) {
+            using T = std::variant_alternative_t<I, std::variant<Ts...>>;
+            var = deserialize<T>(reader);
+        } else {
+            deserialize_variant_at_index<I + 1>(reader, var, tag);
+        }
+    } else {
+        std::abort(); // Invalid sum type tag
+    }
+}
+
+// BSATN traits specialization for SumType
+template<typename... Ts>
+struct bsatn_traits<SumType<Ts...>> {
+    using sum_type = SumType<Ts...>;
+    
+    static AlgebraicType algebraic_type() {
+        // For now, return a string type as placeholder
+        // TODO: Implement proper sum type registration in V9TypeRegistration system
+        return AlgebraicType::String();
+    }
+};
+
+// Serialization for SumType
+template<typename... Ts>
+void serialize(Writer& writer, const SumType<Ts...>& value) {
+    // Write the tag byte
+    writer.write_u8(value.tag());
+    
+    // Write the variant data
+    serialize_variant_at_index<0>(writer, value.variant());
+}
+
+// Deserialization for SumType
+template<typename... Ts>
+SumType<Ts...> deserialize(Reader& reader, std::type_identity<SumType<Ts...>>) {
+    // Read the tag byte
+    uint8_t tag = reader.read_u8();
+    
+    // Check tag is valid
+    if (tag >= sizeof...(Ts)) {
+        std::abort(); // Invalid sum type tag
+    }
+    
+    // Deserialize the appropriate variant
+    SumType<Ts...> result;
+    deserialize_variant_at_index<0>(reader, result.variant(), tag);
+    
+    return result;
+}
+
+} // namespace bsatn
+
+// Result type helper (like Rust's Result<T, E>)
+template<typename T, typename E>
+using Result = bsatn::SumType<T, E>;
+
+// Factory functions for Result
+template<typename T, typename E>
+Result<T, E> Ok(T&& value) {
+    return Result<T, E>(std::forward<T>(value));
+}
+
+template<typename T, typename E>
+Result<T, E> Err(E&& error) {
+    return Result<T, E>(std::forward<E>(error));
+}
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_BSATN_SUM_TYPE_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/time_duration.h b/crates/bindings-cpp/include/spacetimedb/bsatn/time_duration.h
new file mode 100644
index 00000000000..966588ef1ee
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/time_duration.h
@@ -0,0 +1,134 @@
+#pragma once
+
+#include <cstdint>
+#include <chrono>
+
+// Forward declarations for BSATN
+namespace SpacetimeDb {
+namespace bsatn {
+    class Writer;
+    class Reader;
+}
+}
+
+namespace SpacetimeDb {
+
+/**
+ * Represents a duration of time with microsecond precision.
+ * This corresponds to SpacetimeDB's TimeDuration type.
+ */
+class TimeDuration {
+private:
+    int64_t micros_;
+
+public:
+    // Constructors
+    explicit TimeDuration(int64_t micros = 0) : micros_(micros) {}
+    
+    // Factory methods
+    static TimeDuration from_micros(int64_t micros) { return TimeDuration(micros); }
+    static TimeDuration from_millis(int64_t millis) { return TimeDuration(millis * 1000); }
+    static TimeDuration from_seconds(int64_t seconds) { return TimeDuration(seconds * 1000000); }
+    static TimeDuration from_minutes(int64_t minutes) { return TimeDuration(minutes * 60000000); }
+    static TimeDuration from_hours(int64_t hours) { return TimeDuration(hours * 3600000000); }
+    
+    // Conversion from std::chrono
+    template<typename Rep, typename Period>
+    static TimeDuration from_chrono(std::chrono::duration<Rep, Period> duration) {
+        auto micros = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+        return TimeDuration(static_cast<int64_t>(micros));
+    }
+    
+    // Getters
+    int64_t micros() const { return micros_; }
+    int64_t millis() const { return micros_ / 1000; }
+    int64_t seconds() const { return micros_ / 1000000; }
+    
+    // Conversion to std::chrono
+    std::chrono::microseconds to_chrono() const {
+        return std::chrono::microseconds(micros_);
+    }
+    
+    // Arithmetic operations
+    TimeDuration operator+(const TimeDuration& other) const {
+        return TimeDuration(micros_ + other.micros_);
+    }
+    
+    TimeDuration operator-(const TimeDuration& other) const {
+        return TimeDuration(micros_ - other.micros_);
+    }
+    
+    TimeDuration operator*(int64_t scalar) const {
+        return TimeDuration(micros_ * scalar);
+    }
+    
+    TimeDuration operator/(int64_t scalar) const {
+        return TimeDuration(micros_ / scalar);
+    }
+    
+    // Comparison operators
+    bool operator==(const TimeDuration& other) const { return micros_ == other.micros_; }
+    bool operator!=(const TimeDuration& other) const { return micros_ != other.micros_; }
+    bool operator<(const TimeDuration& other) const { return micros_ < other.micros_; }
+    bool operator<=(const TimeDuration& other) const { return micros_ <= other.micros_; }
+    bool operator>(const TimeDuration& other) const { return micros_ > other.micros_; }
+    bool operator>=(const TimeDuration& other) const { return micros_ >= other.micros_; }
+    
+    // Absolute value
+    TimeDuration abs() const {
+        return TimeDuration(micros_ >= 0 ? micros_ : -micros_);
+    }
+    
+    // Convert to string representation (to match Rust TimeDuration::Display format exactly)
+    std::string to_string() const {
+        // Rust format: "{sign}{seconds}.{microseconds:06}"
+        // Always includes sign prefix: "+" for positive, "-" for negative
+        
+        int64_t micros = micros_;
+        const char* sign = (micros < 0) ? "-" : "+";
+        int64_t pos_micros = (micros < 0) ? -micros : micros;
+        
+        int64_t seconds = pos_micros / 1000000;
+        int64_t remaining_micros = pos_micros % 1000000;
+        
+        char buffer[32];
+        snprintf(buffer, sizeof(buffer), "%s%lld.%06lld", 
+                 sign, (long long)seconds, (long long)remaining_micros);
+        
+        return std::string(buffer);
+    }
+    
+    // BSATN serialization (implemented in time_duration_bsatn.h)
+    void bsatn_serialize(SpacetimeDb::bsatn::Writer& writer) const;
+    static TimeDuration bsatn_deserialize(SpacetimeDb::bsatn::Reader& reader);
+};
+
+// Convenience functions
+inline TimeDuration operator*(int64_t scalar, const TimeDuration& duration) {
+    return duration * scalar;
+}
+
+} // namespace SpacetimeDb
+
+// =============================================================================
+// BSATN Implementation
+// =============================================================================
+
+#include "writer.h"
+#include "reader.h"
+
+namespace SpacetimeDb {
+
+// TimeDuration BSATN implementation
+inline void TimeDuration::bsatn_serialize(bsatn::Writer& writer) const {
+    writer.write_u64_le(static_cast<uint64_t>(micros_));
+}
+
+inline TimeDuration TimeDuration::bsatn_deserialize(bsatn::Reader& reader) {
+    uint64_t micros = reader.read_u64_le();
+    return TimeDuration(static_cast<int64_t>(micros));
+}
+
+} // namespace SpacetimeDb
+
+
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/timestamp.h b/crates/bindings-cpp/include/spacetimedb/bsatn/timestamp.h
new file mode 100644
index 00000000000..7d9485b812a
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/timestamp.h
@@ -0,0 +1,178 @@
+#pragma once
+
+#include <cstdint>
+#include <chrono>
+#include <ctime>
+#include <string>
+#include "time_duration.h"
+
+// Forward declarations
+namespace SpacetimeDb {
+namespace bsatn {
+    class Writer;
+    class Reader;
+}
+
+/**
+ * Represents a point in time as microseconds since the Unix epoch.
+ * This corresponds to SpacetimeDB's Timestamp type.
+ */
+class Timestamp {
+private:
+    int64_t micros_since_epoch_;
+
+public:
+    // Constructors
+    explicit Timestamp(int64_t micros_since_epoch = 0) : micros_since_epoch_(micros_since_epoch) {}
+    
+    // Factory methods
+    static Timestamp from_micros_since_epoch(int64_t micros) {
+        return Timestamp(micros);
+    }
+    
+    static Timestamp from_millis_since_epoch(int64_t millis) {
+        return Timestamp(millis * 1000);
+    }
+    
+    static Timestamp from_seconds_since_epoch(int64_t seconds) {
+        return Timestamp(seconds * 1000000);
+    }
+    
+    // Get current timestamp
+    static Timestamp now() {
+        auto now = std::chrono::system_clock::now();
+        auto duration = now.time_since_epoch();
+        auto micros = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+        return Timestamp(micros);
+    }
+    
+    // Unix epoch (January 1, 1970 00:00:00 UTC)
+    static Timestamp unix_epoch() {
+        return Timestamp(0);
+    }
+    
+    // Conversion from std::chrono
+    static Timestamp from_chrono(std::chrono::system_clock::time_point tp) {
+        auto duration = tp.time_since_epoch();
+        auto micros = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+        return Timestamp(micros);
+    }
+    
+    // Getters
+    int64_t micros_since_epoch() const { return micros_since_epoch_; }
+    int64_t millis_since_epoch() const { return micros_since_epoch_ / 1000; }
+    int64_t seconds_since_epoch() const { return micros_since_epoch_ / 1000000; }
+    
+    // Conversion to std::chrono
+    std::chrono::system_clock::time_point to_chrono() const {
+        return std::chrono::system_clock::time_point(
+            std::chrono::microseconds(micros_since_epoch_)
+        );
+    }
+    
+    // Arithmetic operations
+    Timestamp operator+(const TimeDuration& duration) const {
+        return Timestamp(micros_since_epoch_ + duration.micros());
+    }
+    
+    Timestamp operator-(const TimeDuration& duration) const {
+        return Timestamp(micros_since_epoch_ - duration.micros());
+    }
+    
+    TimeDuration operator-(const Timestamp& other) const {
+        return TimeDuration::from_micros(micros_since_epoch_ - other.micros_since_epoch_);
+    }
+    
+    // Comparison operators
+    bool operator==(const Timestamp& other) const { return micros_since_epoch_ == other.micros_since_epoch_; }
+    bool operator!=(const Timestamp& other) const { return micros_since_epoch_ != other.micros_since_epoch_; }
+    bool operator<(const Timestamp& other) const { return micros_since_epoch_ < other.micros_since_epoch_; }
+    bool operator<=(const Timestamp& other) const { return micros_since_epoch_ <= other.micros_since_epoch_; }
+    bool operator>(const Timestamp& other) const { return micros_since_epoch_ > other.micros_since_epoch_; }
+    bool operator>=(const Timestamp& other) const { return micros_since_epoch_ >= other.micros_since_epoch_; }
+    
+    // Duration since another timestamp
+    TimeDuration duration_since(const Timestamp& earlier) const {
+        if (*this < earlier) {
+            return TimeDuration::from_micros(0);  // Return zero for negative durations
+        }
+        return TimeDuration::from_micros(micros_since_epoch_ - earlier.micros_since_epoch_);
+    }
+    
+    // Convert to string representation (ISO 8601 format to match Rust)
+    std::string to_string() const {
+        // Convert microseconds to seconds and fractional microseconds
+        std::time_t seconds = micros_since_epoch_ / 1000000;
+        int64_t remaining_micros = micros_since_epoch_ % 1000000;
+        
+        // Handle negative timestamps
+        if (micros_since_epoch_ < 0 && remaining_micros != 0) {
+            seconds -= 1;
+            remaining_micros = 1000000 + remaining_micros;
+        }
+        
+        // Convert to UTC time
+#if defined(_MSC_VER) && !defined(__EMSCRIPTEN__)
+        // Use gmtime_s on Windows (not available in Emscripten)
+        std::tm utc_time_buf;
+        errno_t err = gmtime_s(&utc_time_buf, &seconds);
+        std::tm* utc_time = (err == 0) ? &utc_time_buf : nullptr;
+#else
+        // Use standard gmtime for WASM/Emscripten and other platforms
+        std::tm* utc_time = std::gmtime(&seconds);
+#endif
+        if (!utc_time) {
+            // Fallback for invalid timestamps
+            return "1970-01-01T00:00:00.000000+00:00";
+        }
+        
+        // Format as ISO 8601 with microseconds
+        char buffer[64];
+        std::strftime(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%S", utc_time);
+        
+        // Add microseconds and timezone
+        std::string result(buffer);
+        char micros_buffer[16];
+        snprintf(micros_buffer, sizeof(micros_buffer), ".%06lld+00:00", (long long)remaining_micros);
+        result += micros_buffer;
+        
+        return result;
+    }
+    
+    // BSATN serialization
+    void bsatn_serialize(SpacetimeDb::bsatn::Writer& writer) const;
+    static Timestamp bsatn_deserialize(SpacetimeDb::bsatn::Reader& reader);
+};
+
+// Convenience operators
+inline Timestamp operator+(const TimeDuration& duration, const Timestamp& timestamp) {
+    return timestamp + duration;
+}
+
+} // namespace SpacetimeDb
+
+// =============================================================================
+// BSATN Implementation
+// =============================================================================
+
+#include "writer.h"
+#include "reader.h"
+#include "traits.h"
+#include "algebraic_type.h"
+
+namespace SpacetimeDb {
+
+// Timestamp BSATN implementation
+inline void Timestamp::bsatn_serialize(SpacetimeDb::bsatn::Writer& writer) const {
+    writer.write_i64_le(micros_since_epoch_);
+}
+
+inline Timestamp Timestamp::bsatn_deserialize(SpacetimeDb::bsatn::Reader& reader) {
+    int64_t micros = reader.read_i64_le();
+    return Timestamp(micros);
+}
+
+} // namespace SpacetimeDb
+
+// Note: bsatn_traits specialization for Timestamp is defined in type_extensions.h
+// to ensure consistent handling with other special types like TimeDuration
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/traits.h b/crates/bindings-cpp/include/spacetimedb/bsatn/traits.h
new file mode 100644
index 00000000000..e677ec58433
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/traits.h
@@ -0,0 +1,300 @@
+#ifndef SPACETIMEDB_BSATN_TRAITS_H
+#define SPACETIMEDB_BSATN_TRAITS_H
+
+#include <type_traits>
+#include <concepts>
+#include <variant>
+#include <optional>
+#include <vector>
+#include <string>
+#include <cctype>
+
+// Then custom headers
+#include "algebraic_type.h"
+#include "reader.h"
+#include "writer.h"
+#include "types.h"  // For u128, u256, i128, i256
+#include "type_extensions.h"  // For special type constants
+
+namespace SpacetimeDb::bsatn {
+
+// ============================================================================
+// CORE TYPES AND CONCEPTS
+// ============================================================================
+
+/**
+ * Concepts for types that can be serialized with BSATN
+ */
+template<typename T>
+concept HasMemberSerialize = requires(const T& t, Writer& w) {
+    { t.bsatn_serialize(w) } -> std::same_as<void>;
+};
+
+template<typename T>
+concept HasStaticDeserialize = requires(Reader& r) {
+    { T::bsatn_deserialize(r) } -> std::same_as<T>;
+};
+
+template<typename T>
+concept HasAlgebraicType = requires {
+    { algebraic_type_of<T>::get() } -> std::same_as<AlgebraicType>;
+};
+
+/**
+ * Primary template for BSATN serialization traits.
+ * Specialize this for your types to enable serialization.
+ * 
+ * The default implementation will:
+ * - Call member function bsatn_serialize() if available
+ * - Call static function T::bsatn_deserialize() if available
+ * - Use algebraic_type_of<T> for type information
+ */
+template<typename T>
+struct bsatn_traits {
+    static void serialize(Writer& writer, const T& value) {
+        if constexpr (HasMemberSerialize<T>) {
+            value.bsatn_serialize(writer);
+        } else {
+            static_assert(sizeof(T) == 0, "Type must implement bsatn_serialize or specialize bsatn_traits");
+        }
+    }
+    
+    static T deserialize(Reader& reader) {
+        if constexpr (HasStaticDeserialize<T>) {
+            return T::bsatn_deserialize(reader);
+        } else {
+            static_assert(sizeof(T) == 0, "Type must implement bsatn_deserialize or specialize bsatn_traits");
+        }
+    }
+    
+    static AlgebraicType algebraic_type() {
+        if constexpr (HasAlgebraicType<T>) {
+            return SpacetimeDb::bsatn::algebraic_type_of<T>::get();
+        } else {
+            static_assert(sizeof(T) == 0, "Type must have algebraic_type_of specialization");
+        }
+    }
+};
+
+// Primitive type specializations are in primitive_traits.h
+// Special types (u128, u256, i128, i256, Identity, etc.) are in type_extensions.h
+
+// ============================================================================
+// BUILDER HELPERS
+// ============================================================================
+
+/**
+ * Helper for building product types with named fields.
+ * Only used by SPACETIMEDB_STRUCT macro.
+ */
+class ProductTypeBuilder {
+private:
+    std::vector<SpacetimeDb::bsatn::ProductTypeElement> elements_;
+    
+public:
+    template<typename T>
+    ProductTypeBuilder& with_field(const std::string& name) {
+        elements_.emplace_back(name, bsatn_traits<T>::algebraic_type());
+        return *this;
+    }
+    
+    std::unique_ptr<SpacetimeDb::bsatn::ProductType> build() {
+        return std::make_unique<SpacetimeDb::bsatn::ProductType>(std::move(elements_));
+    }
+};
+
+/**
+ * Simplified helper for building sum types (enums).
+ * Only used by SPACETIMEDB_ENUM macro.
+ */
+class SumTypeBuilder {
+private:
+    std::vector<SpacetimeDb::bsatn::SumTypeVariant> variants_;
+    
+public:
+    SumTypeBuilder& with_unit_variant(const std::string& name) {
+        variants_.emplace_back(name, AlgebraicType::Unit());
+        return *this;
+    }
+    
+    std::unique_ptr<SpacetimeDb::bsatn::SumTypeSchema> build() {
+        return std::make_unique<SpacetimeDb::bsatn::SumTypeSchema>(std::move(variants_));
+    }
+};
+
+// Special type detection is in type_extensions.h
+
+// ============================================================================
+// CONTAINER TYPE TRAITS
+// ============================================================================
+
+/**
+ * BSATN traits for std::vector<T> (all vectors including bytes)
+ */
+template<typename T>
+struct bsatn_traits<std::vector<T>> {
+    static void serialize(Writer& writer, const std::vector<T>& value) {
+        writer.write_u32_le(static_cast<uint32_t>(value.size()));
+        for (const auto& item : value) {
+            SpacetimeDb::bsatn::serialize(writer, item);
+        }
+    }
+    
+    static std::vector<T> deserialize(Reader& reader) {
+        uint32_t len = reader.read_u32_le();
+        std::vector<T> result;
+        result.reserve(len);
+        for (uint32_t i = 0; i < len; ++i) {
+            result.push_back(bsatn_traits<T>::deserialize(reader));
+        }
+        return result;
+    }
+    
+    static AlgebraicType algebraic_type() {
+        // Arrays are ALWAYS inlined, never registered in typespace
+        auto elem_type = bsatn_traits<T>::algebraic_type();
+        
+        // Special types should always be inlined
+        if (is_special_type(elem_type)) {
+            return AlgebraicType::Array(std::move(elem_type));
+        }
+        
+        // Return Array type INLINE - matches Rust behavior
+        return AlgebraicType::Array(std::move(elem_type));
+    }
+};
+
+/**
+ * BSATN traits for std::optional<T>
+ * 
+ * IMPORTANT: SpacetimeDB uses a non-standard Option serialization:
+ * - Some(value) = discriminant 0 (not 1 as in standard Rust enums)
+ * - None = discriminant 1 (not 0 as in standard Rust enums)
+ */
+template<typename T>
+struct bsatn_traits<std::optional<T>> {
+    static void serialize(Writer& writer, const std::optional<T>& value) {
+        if (value.has_value()) {
+            writer.write_u8(0); // Some = 0 (SpacetimeDB convention)
+            bsatn_traits<T>::serialize(writer, *value);
+        } else {
+            writer.write_u8(1); // None = 1 (SpacetimeDB convention)
+        }
+    }
+    
+    static std::optional<T> deserialize(Reader& reader) {
+        uint8_t tag = reader.read_u8();
+        if (tag == 0) { // Some
+            return bsatn_traits<T>::deserialize(reader);
+        } else if (tag == 1) { // None
+            return std::nullopt;
+        } else {
+            std::abort(); // Invalid optional tag in BSATN deserialization
+        }
+    }
+    
+    static AlgebraicType algebraic_type() {
+        // Options are ALWAYS inlined, never registered as separate types
+        auto inner_type = bsatn_traits<T>::algebraic_type();
+        
+        // Create Option variants: Some(T) and None
+        std::vector<SpacetimeDb::bsatn::SumTypeVariant> variants;
+        variants.emplace_back("some", std::move(inner_type));
+        variants.emplace_back("none", AlgebraicType::Unit());
+        
+        return AlgebraicType::make_sum(
+            std::make_unique<SpacetimeDb::bsatn::SumTypeSchema>(std::move(variants))
+        );
+    }
+};
+
+// ============================================================================
+// VARIANT TYPE TRAITS
+// ============================================================================
+
+// Forward declaration for variant index_sequence helper
+template<typename Variant, typename T, std::size_t Index = 0>
+struct variant_index_of;
+
+template<typename T, typename First, typename... Rest, std::size_t Index>
+struct variant_index_of<std::variant<First, Rest...>, T, Index> 
+    : variant_index_of<std::variant<Rest...>, T, Index + 1> {};
+
+template<typename T, typename... Rest, std::size_t Index>
+struct variant_index_of<std::variant<T, Rest...>, T, Index> 
+    : std::integral_constant<std::size_t, Index> {};
+
+/**
+ * BSATN traits for std::variant
+ */
+template<typename... Ts>
+struct bsatn_traits<std::variant<Ts...>> {
+    using variant_t = std::variant<Ts...>;
+    
+    static void serialize(Writer& writer, const variant_t& value) {
+        writer.write_u8(static_cast<uint8_t>(value.index()));
+        std::visit([&writer](const auto& v) {
+            using value_type = std::decay_t<decltype(v)>;
+            if constexpr (!std::is_same_v<value_type, std::monostate>) {
+                SpacetimeDb::bsatn::serialize(writer, v);
+            }
+        }, value);
+    }
+    
+    static variant_t deserialize(Reader& reader) {
+        uint8_t tag = reader.read_u8();
+        return deserialize_variant<0>(reader, tag);
+    }
+    
+    static AlgebraicType algebraic_type() {
+        std::vector<SpacetimeDb::bsatn::SumTypeVariant> variants;
+        build_variants<0, Ts...>(variants);
+        return AlgebraicType::make_sum(
+            std::make_unique<SpacetimeDb::bsatn::SumTypeSchema>(std::move(variants))
+        );
+    }
+    
+private:
+    template<std::size_t Index>
+    static variant_t deserialize_variant(Reader& reader, uint8_t tag) {
+        if constexpr (Index < sizeof...(Ts)) {
+            if (tag == Index) {
+                using type = std::variant_alternative_t<Index, variant_t>;
+                if constexpr (std::is_same_v<type, std::monostate>) {
+                    return type{};
+                } else {
+                    return SpacetimeDb::bsatn::deserialize<type>(reader);
+                }
+            }
+            return deserialize_variant<Index + 1>(reader, tag);
+        } else {
+            std::abort(); // Invalid variant tag
+        }
+    }
+    
+    template<std::size_t Index, typename First, typename... Rest>
+    static void build_variants(std::vector<SpacetimeDb::bsatn::SumTypeVariant>& variants) {
+        if constexpr (std::is_same_v<First, std::monostate>) {
+            variants.emplace_back("variant_" + std::to_string(Index), AlgebraicType::Unit());
+        } else {
+            variants.emplace_back("variant_" + std::to_string(Index), bsatn_traits<First>::algebraic_type());
+        }
+        if constexpr (sizeof...(Rest) > 0) {
+            build_variants<Index + 1, Rest...>(variants);
+        }
+    }
+};
+
+// ============================================================================
+// FIELD REGISTRATION HELPERS
+// ============================================================================
+
+// Helper to get the AlgebraicType for field types
+template<typename T>
+inline AlgebraicType get_field_algebraic_type() {
+    return bsatn_traits<T>::algebraic_type();
+}
+
+} // namespace SpacetimeDb::bsatn
+
+#endif // SPACETIMEDB_BSATN_TRAITS_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/type_extensions.h b/crates/bindings-cpp/include/spacetimedb/bsatn/type_extensions.h
new file mode 100644
index 00000000000..4c506549d39
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/type_extensions.h
@@ -0,0 +1,503 @@
+#ifndef SPACETIMEDB_BSATN_TYPE_EXTENSIONS_H
+#define SPACETIMEDB_BSATN_TYPE_EXTENSIONS_H
+
+/**
+ * @file type_extensions.h
+ * @brief Extended type support for SpacetimeDB BSATN serialization
+ * 
+ * This header combines functionality from special_types.h and extended_types.h
+ * It provides:
+ * - Special type tags and identification functions
+ * - BSATN trait specializations for extended types
+ * - Support for large integers, container types, and SpacetimeDB core types
+ */
+
+namespace SpacetimeDb::bsatn {
+
+// =============================================================================
+// SPECIAL TYPE CONSTANTS - Must be defined early for use in other headers
+// =============================================================================
+
+// Special type field tags
+constexpr const char* IDENTITY_TAG = "__identity__";
+constexpr const char* CONNECTION_ID_TAG = "__connection_id__";
+constexpr const char* TIMESTAMP_TAG = "__timestamp_micros_since_unix_epoch__";
+constexpr const char* TIME_DURATION_TAG = "__time_duration_micros__";
+
+} // namespace SpacetimeDb::bsatn
+
+// Now include headers that may use these constants
+#include "algebraic_type.h"
+#include "types.h"
+#include "timestamp.h"
+#include "time_duration.h"
+#include <string_view>
+#include <algorithm>
+#include <optional>
+#include <vector>
+
+namespace SpacetimeDb::bsatn {
+
+// Forward declarations
+class Reader;
+class Writer;
+template<typename T> struct bsatn_traits;
+
+// Helper to detect optional types
+template<typename T>
+struct is_optional : std::false_type {};
+template<typename T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+// Helper to detect vector types
+template<typename T>
+struct is_vector : std::false_type {};
+template<typename T>
+struct is_vector<std::vector<T>> : std::true_type {};
+
+// Helper to get primitive type tags
+template<typename T>
+constexpr uint32_t get_primitive_type_tag() {
+    if constexpr (std::is_same_v<T, bool>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::Bool);
+    } else if constexpr (std::is_same_v<T, uint8_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::U8);
+    } else if constexpr (std::is_same_v<T, uint16_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::U16);
+    } else if constexpr (std::is_same_v<T, uint32_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::U32);
+    } else if constexpr (std::is_same_v<T, uint64_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::U64);
+    } else if constexpr (std::is_same_v<T, int8_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::I8);
+    } else if constexpr (std::is_same_v<T, int16_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::I16);
+    } else if constexpr (std::is_same_v<T, int32_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::I32);
+    } else if constexpr (std::is_same_v<T, int64_t>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::I64);
+    } else if constexpr (std::is_same_v<T, float>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::F32);
+    } else if constexpr (std::is_same_v<T, double>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::F64);
+    } else if constexpr (std::is_same_v<T, std::string>) {
+        return static_cast<uint32_t>(AlgebraicTypeTag::String);
+    } else {
+        return 0; // Not a primitive type
+    }
+}
+
+// =============================================================================
+// SPECIAL TYPE TAGS AND IDENTIFICATION
+// =============================================================================
+
+/**
+ * Special type tags used by SpacetimeDB to identify built-in types.
+ * These match the Rust implementation exactly.
+ * Note: Constants are defined at the top of this file before includes.
+ */
+
+/**
+ * Enumeration of special types recognized by SpacetimeDB.
+ */
+enum class SpecialTypeKind {
+    None,
+    Identity,
+    ConnectionId,
+    Timestamp,
+    TimeDuration,
+    Unit,        // Empty Product type
+    Never,       // Empty Sum type
+    ScheduleAt,  // Sum with Interval and Time variants
+    Option       // Sum with some and none variants
+};
+
+/**
+ * Check if a ProductType represents a special SpacetimeDB type.
+ * Special types include field-tagged types and structural types.
+ */
+inline bool is_special_product_type(const ProductType& product) {
+    // Unit type: empty product
+    if (product.elements.size() == 0) {
+        return true;
+    }
+    
+    // Field-tagged special types
+    if (product.elements.size() == 1 && product.elements[0].name.has_value()) {
+        const std::string& tag = *product.elements[0].name;
+        return tag == IDENTITY_TAG ||
+               tag == CONNECTION_ID_TAG ||
+               tag == TIMESTAMP_TAG ||
+               tag == TIME_DURATION_TAG;
+    }
+    
+    return false;
+}
+
+/**
+ * Check if a SumType represents a special SpacetimeDB type.
+ */
+inline bool is_special_sum_type(const SumTypeSchema& sum) {
+    // Never type: empty sum
+    if (sum.variants.size() == 0) {
+        return true;
+    }
+    
+    // Two-variant sum types: ScheduleAt and Option
+    if (sum.variants.size() == 2) {
+        bool has_interval = false, has_time = false;
+        bool has_some = false, has_none = false;
+        
+        for (const auto& variant : sum.variants) {
+            if (variant.name == "Interval") has_interval = true;
+            else if (variant.name == "Time") has_time = true;
+            else if (variant.name == "some") has_some = true;
+            else if (variant.name == "none") has_none = true;
+        }
+        
+        // ScheduleAt type: sum with Interval and Time variants
+        if (has_interval && has_time) {
+            return true;
+        }
+        
+        // Option type: sum with some and none variants
+        if (has_some && has_none) {
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+/**
+ * Check if an AlgebraicType represents a special SpacetimeDB type.
+ */
+inline bool is_special_type(const AlgebraicType& type) {
+    if (type.tag() == AlgebraicTypeTag::Product) {
+        return is_special_product_type(type.as_product());
+    } else if (type.tag() == AlgebraicTypeTag::Sum) {
+        return is_special_sum_type(type.as_sum());
+    }
+    return false;
+}
+
+
+/**
+ * Get the kind of special type represented by an AlgebraicType.
+ */
+inline SpecialTypeKind get_special_type_kind(const AlgebraicType& type) {
+    if (type.tag() == AlgebraicTypeTag::Product) {
+        const auto& product = type.as_product();
+        
+        // Unit type
+        if (product.elements.size() == 0) {
+            return SpecialTypeKind::Unit;
+        }
+        
+        // Field-tagged types
+        if (product.elements.size() == 1 && product.elements[0].name.has_value()) {
+            const std::string& tag = *product.elements[0].name;
+            // Use string_view comparison for more robust matching
+            if (tag == IDENTITY_TAG) return SpecialTypeKind::Identity;
+            if (tag == CONNECTION_ID_TAG) return SpecialTypeKind::ConnectionId;
+            if (tag == TIMESTAMP_TAG) return SpecialTypeKind::Timestamp;
+            if (tag == TIME_DURATION_TAG) return SpecialTypeKind::TimeDuration;
+            
+            // Fallback: Check for exact field name matches in case of string issues
+            if (tag == "__identity__") return SpecialTypeKind::Identity;
+            if (tag == "__connection_id__") return SpecialTypeKind::ConnectionId;
+            if (tag == "__timestamp_micros_since_unix_epoch__") return SpecialTypeKind::Timestamp;
+            if (tag == "__time_duration_micros__") return SpecialTypeKind::TimeDuration;
+        }
+    } else if (type.tag() == AlgebraicTypeTag::Sum) {
+        const auto& sum = type.as_sum();
+        
+        // Never type
+        if (sum.variants.size() == 0) {
+            return SpecialTypeKind::Never;
+        }
+        
+        // Two-variant sum types: ScheduleAt and Option
+        if (sum.variants.size() == 2) {
+            bool has_interval = false, has_time = false;
+            bool has_some = false, has_none = false;
+            
+            for (const auto& variant : sum.variants) {
+                if (variant.name == "Interval") has_interval = true;
+                else if (variant.name == "Time") has_time = true;
+                else if (variant.name == "some") has_some = true;
+                else if (variant.name == "none") has_none = true;
+            }
+            
+            // ScheduleAt type
+            if (has_interval && has_time) {
+                return SpecialTypeKind::ScheduleAt;
+            }
+            
+            // Option type
+            if (has_some && has_none) {
+                return SpecialTypeKind::Option;
+            }
+        }
+    }
+    
+    return SpecialTypeKind::None;
+}
+
+/**
+ * Create a special type ProductType with the given tag and data type.
+ */
+inline std::unique_ptr<ProductType> make_special_type(const char* tag, AlgebraicType data_type) {
+    std::vector<ProductTypeElement> elements;
+    elements.emplace_back(tag, std::move(data_type));
+    return std::make_unique<ProductType>(std::move(elements));
+}
+
+/**
+ * @brief Factory functions for SpacetimeDB special types.
+ * 
+ * These types are represented as ProductTypes with a single specially-tagged field.
+ * The tag identifies the semantic meaning of the type.
+ */
+namespace special_types {
+    
+    /**
+     * @brief Create an Identity type (256-bit identifier).
+     * 
+     * Identity is represented as an array of 32 bytes (U8[32]).
+     * 
+     * @return AlgebraicType representing an Identity
+     * @todo Integrate with type registry for proper type indexing
+     */
+    inline AlgebraicType identity() {
+        // Identity uses U256 as inner type (matches Rust implementation)
+        // CRITICAL: Pass the actual U256 type, not a Ref to it - special types are inlined!
+        auto product = make_special_type(IDENTITY_TAG, AlgebraicType::U256());
+        return AlgebraicType::make_product(std::move(product));
+    }
+    
+    /**
+     * @brief Create a ConnectionId type (64-bit connection identifier).
+     * 
+     * @return AlgebraicType representing a ConnectionId
+     * @todo Integrate with type registry for proper type indexing
+     */
+    inline AlgebraicType connection_id() {
+        // ConnectionId uses U128 as inner type (matches Rust implementation)
+        // CRITICAL: Pass the actual U128 type, not a Ref to it - special types are inlined!
+        auto product = make_special_type(CONNECTION_ID_TAG, AlgebraicType::U128());
+        return AlgebraicType::make_product(std::move(product));
+    }
+    
+    /**
+     * @brief Create a Timestamp type (microseconds since Unix epoch).
+     * 
+     * @return AlgebraicType representing a Timestamp
+     * @todo Integrate with type registry for proper type indexing
+     */
+    inline AlgebraicType timestamp() {
+        // Timestamp uses I64 as inner type (matches Rust implementation)
+        // CRITICAL: Pass the actual I64 type, not a Ref to it - special types are inlined!
+        auto product = make_special_type(TIMESTAMP_TAG, AlgebraicType::I64());
+        return AlgebraicType::make_product(std::move(product));
+    }
+    
+    /**
+     * @brief Create a TimeDuration type (duration in microseconds).
+     * 
+     * @return AlgebraicType representing a TimeDuration
+     * @todo Integrate with type registry for proper type indexing
+     */
+    inline AlgebraicType time_duration() {
+        // TimeDuration uses I64 as inner type (matches Rust implementation)
+        // CRITICAL: Pass the actual I64 type, not a Ref to it - special types are inlined!
+        auto product = make_special_type(TIME_DURATION_TAG, AlgebraicType::I64());
+        return AlgebraicType::make_product(std::move(product));
+    }
+    
+} // namespace special_types
+
+// =============================================================================
+// LARGE INTEGER TYPES (u128, i128)
+// =============================================================================
+
+/**
+ * BSATN serialization for 128-bit unsigned integer
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::u128> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::u128& value) {
+        // Serialize as 16 bytes in little-endian order
+        writer.write_u64_le(value.low);
+        writer.write_u64_le(value.high);
+    }
+    
+    static ::SpacetimeDb::u128 deserialize(Reader& reader) {
+        uint64_t low = reader.read_u64_le();
+        uint64_t high = reader.read_u64_le();
+        return ::SpacetimeDb::u128(high, low);
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::U128();
+    }
+};
+
+/**
+ * BSATN serialization for 128-bit signed integer
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::i128> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::i128& value) {
+        // Serialize as 16 bytes in little-endian order
+        writer.write_u64_le(value.low);
+        writer.write_u64_le(static_cast<uint64_t>(value.high));
+    }
+    
+    static ::SpacetimeDb::i128 deserialize(Reader& reader) {
+        uint64_t low = reader.read_u64_le();
+        uint64_t high = reader.read_u64_le();
+        return ::SpacetimeDb::i128(static_cast<int64_t>(high), low);
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::I128();
+    }
+};
+
+// u256 and i256 also need bsatn_traits specializations that call their methods
+
+/**
+ * BSATN serialization for 256-bit unsigned integer
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::u256> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::u256& value) {
+        value.bsatn_serialize(writer);
+    }
+    
+    static ::SpacetimeDb::u256 deserialize(Reader& reader) {
+        ::SpacetimeDb::u256 result;
+        result.bsatn_deserialize(reader);
+        return result;
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::U256();
+    }
+};
+
+/**
+ * BSATN serialization for 256-bit signed integer
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::i256> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::i256& value) {
+        value.bsatn_serialize(writer);
+    }
+    
+    static ::SpacetimeDb::i256 deserialize(Reader& reader) {
+        ::SpacetimeDb::i256 result;
+        result.bsatn_deserialize(reader);
+        return result;
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return AlgebraicType::I256();
+    }
+};
+
+// =============================================================================
+// SPACETIMEDB CORE TYPES (Identity, ConnectionId, Timestamp, TimeDuration)
+// =============================================================================
+
+/**
+ * BSATN serialization for Identity
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::Identity> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::Identity& value) {
+        value.bsatn_serialize(writer);
+    }
+    
+    static ::SpacetimeDb::Identity deserialize(Reader& reader) {
+        ::SpacetimeDb::Identity result;
+        result.bsatn_deserialize(reader);
+        return result;
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return special_types::identity();
+    }
+};
+
+/**
+ * BSATN serialization for ConnectionId
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::ConnectionId> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::ConnectionId& value) {
+        value.bsatn_serialize(writer);
+    }
+    
+    static ::SpacetimeDb::ConnectionId deserialize(Reader& reader) {
+        ::SpacetimeDb::ConnectionId result;
+        result.bsatn_deserialize(reader);
+        return result;
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return special_types::connection_id();
+    }
+};
+
+/**
+ * BSATN serialization for Timestamp
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::Timestamp> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::Timestamp& value) {
+        value.bsatn_serialize(writer);
+    }
+    
+    static ::SpacetimeDb::Timestamp deserialize(Reader& reader) {
+        return ::SpacetimeDb::Timestamp::bsatn_deserialize(reader);
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return special_types::timestamp();
+    }
+};
+
+/**
+ * BSATN serialization for TimeDuration
+ */
+template<>
+struct bsatn_traits<::SpacetimeDb::TimeDuration> {
+    static void serialize(Writer& writer, const ::SpacetimeDb::TimeDuration& value) {
+        value.bsatn_serialize(writer);
+    }
+    
+    static ::SpacetimeDb::TimeDuration deserialize(Reader& reader) {
+        return ::SpacetimeDb::TimeDuration::bsatn_deserialize(reader);
+    }
+    
+    static AlgebraicType algebraic_type() {
+        return special_types::time_duration();
+    }
+};
+
+// =============================================================================
+// CONTAINER TYPES
+// =============================================================================
+
+// Note: bsatn_traits specializations for std::optional<T> and std::vector<T>
+// are now defined in traits.h (as of this consolidation fix).
+// This file contains the special type trait definitions and helpers.
+
+// Convenience type aliases for SpacetimeDB vectors
+using VecTimeDuration = std::vector<::SpacetimeDb::TimeDuration>;
+
+} // namespace SpacetimeDb::bsatn
+
+#endif // SPACETIMEDB_BSATN_TYPE_EXTENSIONS_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/types.h b/crates/bindings-cpp/include/spacetimedb/bsatn/types.h
new file mode 100644
index 00000000000..2b413270896
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/types.h
@@ -0,0 +1,894 @@
+#pragma once
+
+/**
+ * SpacetimeDB C++ SDK - Extended Type System
+ * 
+ * This header provides complete support for all SpacetimeDB types including:
+ * - Special types: Identity, ConnectionId, Timestamp, TimeDuration (✅ COMPLETE)
+ * - Large integers: u128, i128, u256, i256 (✅ COMPLETE)
+ * - Container types: Option<T>, Vec<T> (✅ COMPLETE)
+ * - BSATN serialization for all types (✅ COMPLETE)
+ * 
+ * All four SpacetimeDB special types are fully implemented and tested:
+ * - Identity: U256 with __identity__ tag
+ * - ConnectionId: U128 with __connection_id__ tag  
+ * - Timestamp: I64 with __timestamp_micros_since_unix_epoch__ tag
+ * - TimeDuration: I64 with __time_duration_micros__ tag
+ */
+
+#include <cstdint>
+#include <array>
+#include <vector>
+#include <optional>
+#include <string>
+#include <cstring>
+#include <type_traits>
+#include <stdexcept>  // For std::runtime_error
+#include <algorithm>  // For std::copy
+#include <sstream>    // For std::ostringstream
+#include <iomanip>    // For std::hex, std::setfill, std::setw
+
+// Forward declarations for BSATN
+namespace SpacetimeDb {
+namespace bsatn {
+    class Writer;
+    class Reader;
+}
+
+// Forward declarations
+class Timestamp;
+class TimeDuration;
+struct u128;
+
+// =============================================================================
+// IDENTITY TYPE
+// =============================================================================
+
+#define IDENTITY_SIZE 32
+
+class Identity {
+public:
+    static constexpr size_t SIZE = IDENTITY_SIZE;
+    using ByteArray = std::array<uint8_t, IDENTITY_SIZE>;
+    
+private:
+    std::array<uint8_t, IDENTITY_SIZE> value;
+    
+public:
+    // Constructors
+    Identity();
+    Identity(const std::array<uint8_t, IDENTITY_SIZE>& bytes);
+    
+    // Accessors
+    const std::array<uint8_t, IDENTITY_SIZE>& get_bytes() const;
+    const ByteArray& to_byte_array() const { return value; }
+    std::string to_hex_string() const;
+    
+    // Convert to string (using hex representation)
+    std::string to_string() const {
+        return to_hex_string();
+    }
+    
+    // Operators
+    bool operator==(const Identity& other) const;
+    bool operator!=(const Identity& other) const;
+    bool operator<(const Identity& other) const;
+    
+    // BSATN serialization (implemented below)
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const;
+    void bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader);
+};
+
+
+// =============================================================================
+// TYPE ALIASES FOR COMMON SPACETIMEDB TYPES
+// =============================================================================
+
+// Option<T> is just std::optional<T> with some helper methods
+template<typename T>
+class Option : public std::optional<T> {
+public:
+    using std::optional<T>::optional;
+    
+    // Helper static methods for clarity
+    static Option<T> some(const T& value) {
+        return Option<T>(value);
+    }
+    
+    static Option<T> none() {
+        return Option<T>(std::nullopt);
+    }
+    
+    // Allow implicit conversion from std::optional
+    Option(const std::optional<T>& opt) : std::optional<T>(opt) {}
+    Option(std::optional<T>&& opt) : std::optional<T>(std::move(opt)) {}
+};
+
+// Vec<T> is just std::vector<T>
+template<typename T>
+using Vec = std::vector<T>;
+
+// =============================================================================
+// LARGE INTEGER TYPES
+// =============================================================================
+
+// 128-bit unsigned integer
+struct u128 {
+    uint64_t low;
+    uint64_t high;
+    
+    u128() : low(0), high(0) {}
+    u128(uint64_t l) : low(l), high(0) {}
+    u128(uint64_t h, uint64_t l) : low(l), high(h) {}
+    
+    // Factory method for clarity (high, low parameter order)
+    static u128 from_u64(uint64_t high, uint64_t low) {
+        return u128(high, low);
+    }
+    
+    bool operator==(const u128& other) const {
+        return low == other.low && high == other.high;
+    }
+    
+    bool operator!=(const u128& other) const {
+        return !(*this == other);
+    }
+    
+    // Convert to string using proper decimal conversion
+    std::string to_string() const {
+        if (high == 0) {
+            return std::to_string(low);
+        }
+        
+        // Convert u128 to decimal string using byte-level long division
+        // Treat the u128 as a 16-byte array in little-endian order
+        uint8_t bytes[16];
+        std::memcpy(bytes, &low, 8);
+        std::memcpy(bytes + 8, &high, 8);
+        
+        std::string result;
+        
+        // Repeatedly divide by 10
+        while (true) {
+            int remainder = 0;
+            bool all_zero = true;
+            
+            // Divide the 16-byte number by 10 (from most significant to least significant)
+            for (int i = 15; i >= 0; --i) {
+                int temp = remainder * 256 + bytes[i];
+                bytes[i] = temp / 10;
+                remainder = temp % 10;
+                if (bytes[i] != 0) all_zero = false;
+            }
+            
+            // Add the remainder digit to result (building in reverse)
+            result = static_cast<char>('0' + remainder) + result;
+            
+            if (all_zero) break;
+        }
+        
+        return result;
+    }
+    
+    // BSATN serialization
+    static void serialize(std::vector<uint8_t>& buffer, const u128& value) {
+        // Little-endian serialization
+        for (int i = 0; i < 8; ++i) {
+            buffer.push_back((value.low >> (i * 8)) & 0xFF);
+        }
+        for (int i = 0; i < 8; ++i) {
+            buffer.push_back((value.high >> (i * 8)) & 0xFF);
+        }
+    }
+    
+    static u128 deserialize(const uint8_t* data) {
+        u128 result;
+        result.low = 0;
+        result.high = 0;
+        for (int i = 0; i < 8; ++i) {
+            result.low |= static_cast<uint64_t>(data[i]) << (i * 8);
+        }
+        for (int i = 0; i < 8; ++i) {
+            result.high |= static_cast<uint64_t>(data[8 + i]) << (i * 8);
+        }
+        return result;
+    }
+};
+
+// 128-bit signed integer
+struct i128 {
+    uint64_t low;
+    int64_t high;
+    
+    i128() : low(0), high(0) {}
+    i128(int64_t l) : low(static_cast<uint64_t>(l)), high(l < 0 ? -1 : 0) {}
+    i128(int64_t h, uint64_t l) : low(l), high(h) {}
+    
+    // Factory method for clarity (high, low parameter order)
+    static i128 from_i64(int64_t high, uint64_t low) {
+        return i128(high, low);
+    }
+    
+    bool operator==(const i128& other) const {
+        return low == other.low && high == other.high;
+    }
+    
+    bool operator!=(const i128& other) const {
+        return !(*this == other);
+    }
+    
+    // Convert to string using proper decimal conversion
+    std::string to_string() const {
+        // Handle negative values by converting to positive and adding minus sign
+        bool is_negative = (high < 0);
+        
+        // Convert to unsigned for calculation
+        u128 abs_value;
+        if (is_negative) {
+            // Two's complement: flip bits and add 1
+            abs_value.low = ~low + 1;
+            abs_value.high = ~static_cast<uint64_t>(high);
+            if (abs_value.low == 0) {
+                abs_value.high++; // Handle carry
+            }
+        } else {
+            abs_value.low = low;
+            abs_value.high = static_cast<uint64_t>(high);
+        }
+        
+        std::string result = abs_value.to_string();
+        return is_negative ? "-" + result : result;
+    }
+    
+    // BSATN serialization
+    static void serialize(std::vector<uint8_t>& buffer, const i128& value) {
+        // Little-endian serialization
+        for (int i = 0; i < 8; ++i) {
+            buffer.push_back((value.low >> (i * 8)) & 0xFF);
+        }
+        for (int i = 0; i < 8; ++i) {
+            buffer.push_back((value.high >> (i * 8)) & 0xFF);
+        }
+    }
+    
+    static i128 deserialize(const uint8_t* data) {
+        i128 result;
+        result.low = 0;
+        result.high = 0;
+        for (int i = 0; i < 8; ++i) {
+            result.low |= static_cast<uint64_t>(data[i]) << (i * 8);
+        }
+        uint64_t high_unsigned = 0;
+        for (int i = 0; i < 8; ++i) {
+            high_unsigned |= static_cast<uint64_t>(data[8 + i]) << (i * 8);
+        }
+        result.high = static_cast<int64_t>(high_unsigned);
+        return result;
+    }
+};
+
+// 256-bit unsigned integer
+struct u256 {
+    std::array<uint8_t, 32> data;
+    
+    u256() { data.fill(0); }
+    
+    explicit u256(const uint8_t* bytes) {
+        std::memcpy(data.data(), bytes, 32);
+    }
+    
+    // Constructor from 4 uint64_t values (big-endian order: word3 is most significant)
+    u256(uint64_t word3, uint64_t word2, uint64_t word1, uint64_t word0) {
+        // Store in little-endian byte order
+        for (int i = 0; i < 8; ++i) {
+            data[i] = (word0 >> (i * 8)) & 0xFF;
+            data[8 + i] = (word1 >> (i * 8)) & 0xFF;
+            data[16 + i] = (word2 >> (i * 8)) & 0xFF;
+            data[24 + i] = (word3 >> (i * 8)) & 0xFF;
+        }
+    }
+    
+    bool operator==(const u256& other) const {
+        return data == other.data;
+    }
+    
+    bool operator!=(const u256& other) const {
+        return !(*this == other);
+    }
+    
+    // Convert to string using arbitrary precision decimal conversion
+    std::string to_string() const {
+        // Simple approach: use byte-by-byte division by 10
+        // Make a copy of the data for manipulation
+        std::array<uint8_t, 32> temp_data = data;
+        std::string result;
+        
+        // Check if all zeros
+        bool all_zero = true;
+        for (int i = 0; i < 32; ++i) {
+            if (temp_data[i] != 0) {
+                all_zero = false;
+                break;
+            }
+        }
+        if (all_zero) return "0";
+        
+        // Repeatedly divide by 10
+        while (true) {
+            // Divide the 256-bit number by 10
+            int remainder = 0;
+            bool all_zero_now = true;
+            
+            // Process from most significant byte to least significant
+            for (int i = 31; i >= 0; --i) {
+                int temp = remainder * 256 + temp_data[i];
+                temp_data[i] = temp / 10;
+                remainder = temp % 10;
+                if (temp_data[i] != 0) all_zero_now = false;
+            }
+            
+            // Add the remainder digit to result (in reverse)
+            result = std::to_string(remainder) + result;
+            
+            if (all_zero_now) break;
+        }
+        
+        return result;
+    }
+    
+    // BSATN serialization (already in little-endian)
+    static void serialize(std::vector<uint8_t>& buffer, const u256& value) {
+        buffer.insert(buffer.end(), value.data.begin(), value.data.end());
+    }
+    
+    static u256 deserialize(const uint8_t* bytes) {
+        return u256(bytes);
+    }
+    
+    // BSATN methods (implemented in types_bsatn.h)
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const;
+    void bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader);
+};
+
+// 256-bit signed integer
+struct i256 {
+    std::array<uint8_t, 32> data;
+    
+    i256() { data.fill(0); }
+    
+    explicit i256(const uint8_t* bytes) {
+        std::memcpy(data.data(), bytes, 32);
+    }
+    
+    // Constructor from 4 uint64_t values (big-endian order: word3 is most significant)
+    i256(uint64_t word3, uint64_t word2, uint64_t word1, uint64_t word0) {
+        // Store in little-endian byte order
+        for (int i = 0; i < 8; ++i) {
+            data[i] = (word0 >> (i * 8)) & 0xFF;
+            data[8 + i] = (word1 >> (i * 8)) & 0xFF;
+            data[16 + i] = (word2 >> (i * 8)) & 0xFF;
+            data[24 + i] = (word3 >> (i * 8)) & 0xFF;
+        }
+    }
+    
+    bool operator==(const i256& other) const {
+        return data == other.data;
+    }
+    
+    bool operator!=(const i256& other) const {
+        return !(*this == other);
+    }
+    
+    // Convert to string using arbitrary precision decimal conversion
+    std::string to_string() const {
+        // Check if this is a negative number (MSB set)
+        bool is_negative = (data[31] & 0x80) != 0;
+        
+        if (is_negative) {
+            // Create positive version using two's complement
+            i256 positive_version;
+            int carry = 1;
+            for (int i = 0; i < 32; ++i) {
+                int temp = (~data[i] & 0xFF) + carry;
+                positive_version.data[i] = temp & 0xFF;
+                carry = temp >> 8;
+            }
+            
+            // Convert positive version to string and add minus sign
+            u256 as_u256;
+            std::copy(positive_version.data.begin(), positive_version.data.end(), as_u256.data.begin());
+            return "-" + as_u256.to_string();
+        } else {
+            // Convert as unsigned
+            u256 as_u256;
+            std::copy(data.begin(), data.end(), as_u256.data.begin());
+            return as_u256.to_string();
+        }
+    }
+    
+    // BSATN serialization (already in little-endian)
+    static void serialize(std::vector<uint8_t>& buffer, const i256& value) {
+        buffer.insert(buffer.end(), value.data.begin(), value.data.end());
+    }
+    
+    static i256 deserialize(const uint8_t* bytes) {
+        return i256(bytes);
+    }
+    
+    // BSATN methods (implemented in types_bsatn.h)
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const;
+    void bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader);
+};
+
+// Type aliases with uppercase names for compatibility
+using U128 = u128;
+using I128 = i128;
+using U256 = u256;
+using I256 = i256;
+
+// =============================================================================
+// CONNECTION ID TYPE (defined after u128)
+// =============================================================================
+
+/**
+ * ConnectionId represents a connection identifier in SpacetimeDB.
+ * 
+ * IMPORTANT: ConnectionId uses u128 type to match Rust implementation.
+ * This was fixed from the previous uint64_t implementation that caused
+ * runtime serialization crashes.
+ * 
+ * Special type tag: "__connection_id__"
+ * Underlying type: U128 (AlgebraicTypeTag = 15)
+ * Serialization: write_u128_le/read_u128_le
+ */
+struct ConnectionId {
+    u128 id;
+    
+    ConnectionId() : id() {}
+    explicit ConnectionId(uint64_t connection_id) : id(connection_id) {}
+    explicit ConnectionId(const u128& connection_id) : id(connection_id) {}
+    
+    bool operator==(const ConnectionId& other) const { return id == other.id; }
+    bool operator!=(const ConnectionId& other) const { return id != other.id; }
+    bool operator<(const ConnectionId& other) const { 
+        return (id.high < other.id.high) || (id.high == other.id.high && id.low < other.id.low);
+    }
+    
+    // Convert to string as hex representation (32 hex chars for 16 bytes)
+    std::string to_string() const {
+        std::ostringstream oss;
+        oss << std::hex << std::setfill('0');
+        
+        // Output as 32-character hex string (little-endian byte order)
+        // Convert low 64 bits first
+        for (int i = 0; i < 8; ++i) {
+            uint8_t byte = (id.low >> (i * 8)) & 0xFF;
+            oss << std::setw(2) << static_cast<unsigned int>(byte);
+        }
+        
+        // Convert high 64 bits
+        for (int i = 0; i < 8; ++i) {
+            uint8_t byte = (id.high >> (i * 8)) & 0xFF;
+            oss << std::setw(2) << static_cast<unsigned int>(byte);
+        }
+        
+        return oss.str();
+    }
+    
+    // BSATN serialization (implemented below)
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const;
+    void bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader);
+};
+
+// Placeholder type aliases for BSATN compatibility
+using u256_placeholder = u256;
+using i256_placeholder = i256;
+
+// Address is an alias for Identity in the current implementation
+class Identity;  // Forward declaration
+using Address = Identity;
+
+// =============================================================================
+// SCHEDULE AT TYPE FORWARD DECLARATION
+// =============================================================================
+
+// ScheduleAt is defined in schedule_at.h to avoid circular dependencies
+class ScheduleAt;
+
+// =============================================================================
+// TIME DURATION TYPE
+// =============================================================================
+
+// Time duration is defined in time_duration.h
+/*
+struct TimeDuration {
+    uint64_t micros;
+    
+    TimeDuration() : micros(0) {}
+    explicit TimeDuration(uint64_t us) : micros(us) {}
+    
+    // Constructor from seconds and nanoseconds
+    TimeDuration(uint64_t seconds, uint32_t nanos) 
+        : micros(seconds * 1000000 + nanos / 1000) {}
+    
+    static TimeDuration from_micros(uint64_t us) { return TimeDuration(us); }
+    static TimeDuration from_millis(uint64_t ms) { return TimeDuration(ms * 1000); }
+    static TimeDuration from_seconds(uint64_t s) { return TimeDuration(s * 1000000); }
+    
+    uint64_t to_micros() const { return micros; }
+    uint64_t to_millis() const { return micros / 1000; }
+    uint64_t to_seconds() const { return micros / 1000000; }
+    
+    TimeDuration operator+(const TimeDuration& other) const {
+        return TimeDuration(micros + other.micros);
+    }
+    
+    TimeDuration operator-(const TimeDuration& other) const {
+        return TimeDuration(micros - other.micros);
+    }
+    
+    bool operator==(const TimeDuration& other) const {
+        return micros == other.micros;
+    }
+    
+    bool operator!=(const TimeDuration& other) const {
+        return !(*this == other);
+    }
+    
+    bool operator<(const TimeDuration& other) const {
+        return micros < other.micros;
+    }
+    
+    // BSATN serialization (as u64)
+    static void serialize(std::vector<uint8_t>& buffer, const TimeDuration& value) {
+        for (int i = 0; i < 8; ++i) {
+            buffer.push_back((value.micros >> (i * 8)) & 0xFF);
+        }
+    }
+    
+    static TimeDuration deserialize(const uint8_t* data) {
+        uint64_t micros = 0;
+        for (int i = 0; i < 8; ++i) {
+            micros |= static_cast<uint64_t>(data[i]) << (i * 8);
+        }
+        return TimeDuration(micros);
+    }
+    
+    // BSATN serialization methods (for schedule_reducer.h)
+    // These will be provided as free functions when BSATN is available
+    // void bsatn_serialize(SpacetimeDb::bsatn::Writer& writer) const;
+    // static TimeDuration bsatn_deserialize(SpacetimeDb::bsatn::Reader& reader);
+};
+*/
+
+// Timestamp operations with TimeDuration are already defined in timestamp.h
+// We'll use the existing Timestamp class operations
+
+// =============================================================================
+// BSATN SERIALIZATION TRAITS
+// =============================================================================
+
+// Primary template for BSATN serialization
+template<typename T>
+struct BsatnSerializer {
+    static void serialize(std::vector<uint8_t>& buffer, const T& value);
+    static T deserialize(const uint8_t* data, size_t& offset);
+};
+
+// Specializations for primitive types
+template<>
+struct BsatnSerializer<uint8_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const uint8_t& value) {
+        buffer.push_back(value);
+    }
+    
+    static uint8_t deserialize(const uint8_t* data, size_t& offset) {
+        return data[offset++];
+    }
+};
+
+template<>
+struct BsatnSerializer<uint16_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const uint16_t& value) {
+        buffer.push_back(value & 0xFF);
+        buffer.push_back((value >> 8) & 0xFF);
+    }
+    
+    static uint16_t deserialize(const uint8_t* data, size_t& offset) {
+        uint16_t value = data[offset] | (data[offset + 1] << 8);
+        offset += 2;
+        return value;
+    }
+};
+
+template<>
+struct BsatnSerializer<uint32_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const uint32_t& value) {
+        for (int i = 0; i < 4; ++i) {
+            buffer.push_back((value >> (i * 8)) & 0xFF);
+        }
+    }
+    
+    static uint32_t deserialize(const uint8_t* data, size_t& offset) {
+        uint32_t value = 0;
+        for (int i = 0; i < 4; ++i) {
+            value |= static_cast<uint32_t>(data[offset++]) << (i * 8);
+        }
+        return value;
+    }
+};
+
+template<>
+struct BsatnSerializer<uint64_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const uint64_t& value) {
+        for (int i = 0; i < 8; ++i) {
+            buffer.push_back((value >> (i * 8)) & 0xFF);
+        }
+    }
+    
+    static uint64_t deserialize(const uint8_t* data, size_t& offset) {
+        uint64_t value = 0;
+        for (int i = 0; i < 8; ++i) {
+            value |= static_cast<uint64_t>(data[offset++]) << (i * 8);
+        }
+        return value;
+    }
+};
+
+// Signed integers
+template<>
+struct BsatnSerializer<int8_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const int8_t& value) {
+        buffer.push_back(static_cast<uint8_t>(value));
+    }
+    
+    static int8_t deserialize(const uint8_t* data, size_t& offset) {
+        return static_cast<int8_t>(data[offset++]);
+    }
+};
+
+template<>
+struct BsatnSerializer<int16_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const int16_t& value) {
+        BsatnSerializer<uint16_t>::serialize(buffer, static_cast<uint16_t>(value));
+    }
+    
+    static int16_t deserialize(const uint8_t* data, size_t& offset) {
+        return static_cast<int16_t>(BsatnSerializer<uint16_t>::deserialize(data, offset));
+    }
+};
+
+template<>
+struct BsatnSerializer<int32_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const int32_t& value) {
+        BsatnSerializer<uint32_t>::serialize(buffer, static_cast<uint32_t>(value));
+    }
+    
+    static int32_t deserialize(const uint8_t* data, size_t& offset) {
+        return static_cast<int32_t>(BsatnSerializer<uint32_t>::deserialize(data, offset));
+    }
+};
+
+template<>
+struct BsatnSerializer<int64_t> {
+    static void serialize(std::vector<uint8_t>& buffer, const int64_t& value) {
+        BsatnSerializer<uint64_t>::serialize(buffer, static_cast<uint64_t>(value));
+    }
+    
+    static int64_t deserialize(const uint8_t* data, size_t& offset) {
+        return static_cast<int64_t>(BsatnSerializer<uint64_t>::deserialize(data, offset));
+    }
+};
+
+// Boolean
+template<>
+struct BsatnSerializer<bool> {
+    static void serialize(std::vector<uint8_t>& buffer, const bool& value) {
+        buffer.push_back(value ? 1 : 0);
+    }
+    
+    static bool deserialize(const uint8_t* data, size_t& offset) {
+        return data[offset++] != 0;
+    }
+};
+
+// Floating point
+template<>
+struct BsatnSerializer<float> {
+    static void serialize(std::vector<uint8_t>& buffer, const float& value) {
+        uint32_t bits;
+        std::memcpy(&bits, &value, sizeof(float));
+        BsatnSerializer<uint32_t>::serialize(buffer, bits);
+    }
+    
+    static float deserialize(const uint8_t* data, size_t& offset) {
+        uint32_t bits = BsatnSerializer<uint32_t>::deserialize(data, offset);
+        float value;
+        std::memcpy(&value, &bits, sizeof(float));
+        return value;
+    }
+};
+
+template<>
+struct BsatnSerializer<double> {
+    static void serialize(std::vector<uint8_t>& buffer, const double& value) {
+        uint64_t bits;
+        std::memcpy(&bits, &value, sizeof(double));
+        BsatnSerializer<uint64_t>::serialize(buffer, bits);
+    }
+    
+    static double deserialize(const uint8_t* data, size_t& offset) {
+        uint64_t bits = BsatnSerializer<uint64_t>::deserialize(data, offset);
+        double value;
+        std::memcpy(&value, &bits, sizeof(double));
+        return value;
+    }
+};
+
+// String
+template<>
+struct BsatnSerializer<std::string> {
+    static void serialize(std::vector<uint8_t>& buffer, const std::string& value) {
+        BsatnSerializer<uint32_t>::serialize(buffer, static_cast<uint32_t>(value.length()));
+        buffer.insert(buffer.end(), value.begin(), value.end());
+    }
+    
+    static std::string deserialize(const uint8_t* data, size_t& offset) {
+        uint32_t len = BsatnSerializer<uint32_t>::deserialize(data, offset);
+        std::string result(reinterpret_cast<const char*>(data + offset), len);
+        offset += len;
+        return result;
+    }
+};
+
+// Large integers
+template<>
+struct BsatnSerializer<u128> {
+    static void serialize(std::vector<uint8_t>& buffer, const u128& value) {
+        u128::serialize(buffer, value);
+    }
+    
+    static u128 deserialize(const uint8_t* data, size_t& offset) {
+        u128 result = u128::deserialize(data + offset);
+        offset += 16;
+        return result;
+    }
+};
+
+template<>
+struct BsatnSerializer<i128> {
+    static void serialize(std::vector<uint8_t>& buffer, const i128& value) {
+        i128::serialize(buffer, value);
+    }
+    
+    static i128 deserialize(const uint8_t* data, size_t& offset) {
+        i128 result = i128::deserialize(data + offset);
+        offset += 16;
+        return result;
+    }
+};
+
+template<>
+struct BsatnSerializer<u256> {
+    static void serialize(std::vector<uint8_t>& buffer, const u256& value) {
+        u256::serialize(buffer, value);
+    }
+    
+    static u256 deserialize(const uint8_t* data, size_t& offset) {
+        u256 result = u256::deserialize(data + offset);
+        offset += 32;
+        return result;
+    }
+};
+
+template<>
+struct BsatnSerializer<i256> {
+    static void serialize(std::vector<uint8_t>& buffer, const i256& value) {
+        i256::serialize(buffer, value);
+    }
+    
+    static i256 deserialize(const uint8_t* data, size_t& offset) {
+        i256 result = i256::deserialize(data + offset);
+        offset += 32;
+        return result;
+    }
+};
+
+// TimeDuration serializer commented out since TimeDuration is defined in time_duration.h
+/*
+template<>
+struct BsatnSerializer<TimeDuration> {
+    static void serialize(std::vector<uint8_t>& buffer, const TimeDuration& value) {
+        TimeDuration::serialize(buffer, value);
+    }
+    
+    static TimeDuration deserialize(const uint8_t* data, size_t& offset) {
+        TimeDuration result = TimeDuration::deserialize(data + offset);
+        offset += 8;
+        return result;
+    }
+};
+*/
+
+// Identity and ConnectionId serializers are already defined in their respective headers
+
+// Option<T> serialization (handles both Option<T> and std::optional<T>)
+template<typename T>
+struct BsatnSerializer<std::optional<T>> {
+    static void serialize(std::vector<uint8_t>& buffer, const std::optional<T>& value) {
+        if (value.has_value()) {
+            buffer.push_back(0); // Some tag
+            BsatnSerializer<T>::serialize(buffer, *value);
+        } else {
+            buffer.push_back(1); // None tag
+        }
+    }
+    
+    static std::optional<T> deserialize(const uint8_t* data, size_t& offset) {
+        uint8_t tag = data[offset++];
+        if (tag == 0) {
+            return BsatnSerializer<T>::deserialize(data, offset);
+        } else {
+            return std::nullopt;
+        }
+    }
+};
+
+// Option<T> serialization (forward to std::optional)
+template<typename T>
+struct BsatnSerializer<Option<T>> {
+    static void serialize(std::vector<uint8_t>& buffer, const Option<T>& value) {
+        BsatnSerializer<std::optional<T>>::serialize(buffer, value);
+    }
+    
+    static Option<T> deserialize(const uint8_t* data, size_t& offset) {
+        return Option<T>(BsatnSerializer<std::optional<T>>::deserialize(data, offset));
+    }
+};
+
+// Vec<T> serialization
+template<typename T>
+struct BsatnSerializer<std::vector<T>> {
+    static void serialize(std::vector<uint8_t>& buffer, const std::vector<T>& value) {
+        BsatnSerializer<uint32_t>::serialize(buffer, static_cast<uint32_t>(value.size()));
+        for (const auto& item : value) {
+            BsatnSerializer<T>::serialize(buffer, item);
+        }
+    }
+    
+    static std::vector<T> deserialize(const uint8_t* data, size_t& offset) {
+        uint32_t len = BsatnSerializer<uint32_t>::deserialize(data, offset);
+        std::vector<T> result;
+        result.reserve(len);
+        for (uint32_t i = 0; i < len; ++i) {
+            result.push_back(BsatnSerializer<T>::deserialize(data, offset));
+        }
+        return result;
+    }
+};
+
+// ScheduleAt serialization is defined in schedule_at_impl.h
+
+// =============================================================================
+// TYPE REGISTRATION FOR EXTENDED TYPES
+// =============================================================================
+
+// Type registration for large integers and time types will be handled in
+// the AlgebraicType system. Option<T> and Vec<T> need special handling.
+
+// =============================================================================
+// INLINE IMPLEMENTATIONS THAT REQUIRE COMPLETE TYPES
+// =============================================================================
+
+// TimeDuration BSATN methods will be provided as free functions in a separate header
+// that includes both types.h and bsatn.h
+
+} // namespace SpacetimeDb
+
+// =============================================================================
+// BSATN Implementation
+// =============================================================================
+// The implementation of BSATN serialization methods has been moved to types_impl.h
+// to avoid circular dependencies with reader.h and writer.h.
+// Include spacetimedb/bsatn/types_impl.h after including reader.h and writer.h
+// to get the implementations.
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/types_impl.h b/crates/bindings-cpp/include/spacetimedb/bsatn/types_impl.h
new file mode 100644
index 00000000000..f96ad4ce9ca
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/types_impl.h
@@ -0,0 +1,112 @@
+#ifndef SPACETIMEDB_BSATN_TYPES_IMPL_H
+#define SPACETIMEDB_BSATN_TYPES_IMPL_H
+
+// This file contains the implementation of BSATN serialization methods
+// for SpacetimeDB types. It must be included after reader.h and writer.h
+// to avoid circular dependencies.
+
+#include "types.h"
+#include "reader.h"
+#include "writer.h"
+#include <sstream>    // For std::ostringstream
+#include <iomanip>    // For std::hex, std::setfill, std::setw
+
+namespace SpacetimeDb {
+
+// Identity method implementations
+inline Identity::Identity() {
+    value.fill(0);
+}
+
+inline Identity::Identity(const std::array<uint8_t, IDENTITY_SIZE>& bytes) : value(bytes) {
+}
+
+inline const std::array<uint8_t, IDENTITY_SIZE>& Identity::get_bytes() const {
+    return value;
+}
+
+inline std::string Identity::to_hex_string() const {
+    std::ostringstream oss;
+    oss << std::hex << std::setfill('0');
+    
+    for (size_t i = 0; i < IDENTITY_SIZE; ++i) {
+        oss << std::setw(2) << static_cast<unsigned int>(value[i]);
+    }
+    
+    return oss.str();
+}
+
+inline bool Identity::operator==(const Identity& other) const {
+    return value == other.value;
+}
+
+inline bool Identity::operator!=(const Identity& other) const {
+    return !(*this == other);
+}
+
+inline bool Identity::operator<(const Identity& other) const {
+    return value < other.value;
+}
+
+// Identity BSATN implementation
+inline void Identity::bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+    // Write raw bytes without length prefix for fixed-size Identity
+    for (size_t i = 0; i < this->value.size(); ++i) {
+        writer.write_u8(this->value[i]);
+    }
+}
+
+inline void Identity::bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader) {
+    std::vector<uint8_t> bytes = reader.read_fixed_bytes(IDENTITY_SIZE);
+    if (bytes.size() == IDENTITY_SIZE) {
+        std::copy(bytes.begin(), bytes.end(), this->value.data());
+    } else {
+        std::abort();
+    }
+}
+
+// ConnectionId BSATN implementation
+inline void ConnectionId::bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+    writer.write_u128_le(this->id);
+}
+
+inline void ConnectionId::bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader) {
+    this->id = reader.read_u128_le();
+}
+
+// u256 BSATN implementation
+inline void u256::bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+    writer.write_u256_le(*this);
+}
+
+inline void u256::bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader) {
+    std::vector<uint8_t> bytes = reader.read_fixed_bytes(sizeof(this->data));
+    if (bytes.size() == sizeof(this->data)) {
+        std::copy(bytes.begin(), bytes.end(), this->data.data());
+    } else {
+        std::abort();
+    }
+}
+
+// i256 BSATN implementation
+inline void i256::bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+    writer.write_i256_le(*this);
+}
+
+inline void i256::bsatn_deserialize(::SpacetimeDb::bsatn::Reader& reader) {
+    std::vector<uint8_t> bytes = reader.read_fixed_bytes(sizeof(this->data));
+    if (bytes.size() == sizeof(this->data)) {
+        std::copy(bytes.begin(), bytes.end(), this->data.data());
+    } else {
+        std::abort();
+    }
+}
+
+// ScheduleAt BSATN implementation is in schedule_at_impl.h
+
+// Note: u128 and i128 have their own serialize/deserialize static methods in types.h,
+// not bsatn_serialize/deserialize member functions
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_BSATN_TYPES_IMPL_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/bsatn/writer.h b/crates/bindings-cpp/include/spacetimedb/bsatn/writer.h
new file mode 100644
index 00000000000..277fe522676
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/bsatn/writer.h
@@ -0,0 +1,254 @@
+#ifndef SPACETIMEDB_BSATN_WRITER_H
+#define SPACETIMEDB_BSATN_WRITER_H
+
+#include <vector>
+#include <string>
+#include <cstdint>
+#include <stdexcept>
+#include <optional>
+#include <functional>
+#include <type_traits>
+#include <variant>
+#include <concepts>
+#include <span>
+// uint128_placeholder.h removed - types are in spacetimedb/types.h
+#include "types.h"
+
+namespace SpacetimeDb::bsatn {
+
+    // Forward declarations
+    template<typename T> struct bsatn_traits;
+    template<typename T> void serialize(class Writer& w, const T& value);
+
+    class Writer {
+    private:
+        std::vector<uint8_t> buffer;  // Internal buffer when not using external
+        std::vector<uint8_t>* buffer_;  // Pointer to external buffer (if any)
+        
+    public:
+        Writer() : buffer_(nullptr) {}
+        explicit Writer(std::vector<uint8_t>& buffer) : buffer_(&buffer) {}
+
+        // Template method for writing primitive types using C++20 concepts
+        template<typename T>
+            requires (std::is_arithmetic_v<T> && sizeof(T) > 1)
+        void write_primitive_le(T value) {
+            write_bytes_raw(&value, sizeof(T));
+        }
+
+        // Public API methods (delegates to template where possible)
+        inline void write_bool(bool value) {
+            auto& target_buffer = buffer_ ? *buffer_ : buffer;
+            target_buffer.push_back(value ? 1 : 0);
+        }
+        inline void write_u8(uint8_t value) {
+            auto& target_buffer = buffer_ ? *buffer_ : buffer;
+            target_buffer.push_back(value);
+        }
+        void write_u16_le(uint16_t value) { write_primitive_le(value); }
+        void write_u32_le(uint32_t value) { write_primitive_le(value); }
+        void write_u64_le(uint64_t value) { write_primitive_le(value); }
+        inline void write_u128_le(const SpacetimeDb::u128& value) {
+            write_u64_le(value.low);
+            write_u64_le(value.high);
+        }
+        void write_u256_le(const SpacetimeDb::u256_placeholder& value) {
+            write_bytes_raw(value.data.data(), value.data.size());
+        }
+
+        void write_i8(int8_t value) { write_u8(static_cast<uint8_t>(value)); }
+        void write_i16_le(int16_t value) { write_u16_le(static_cast<uint16_t>(value)); }
+        void write_i32_le(int32_t value) { write_u32_le(static_cast<uint32_t>(value)); }
+        void write_i64_le(int64_t value) { write_u64_le(static_cast<uint64_t>(value)); }
+        inline void write_i128_le(const SpacetimeDb::i128& value) {
+            write_u64_le(value.low);
+            write_u64_le(static_cast<uint64_t>(value.high));
+        }
+        void write_i256_le(const SpacetimeDb::i256_placeholder& value) {
+            write_bytes_raw(value.data.data(), value.data.size());
+        }
+
+        void write_f32_le(float value) { write_primitive_le(value); }
+        void write_f64_le(double value) { write_primitive_le(value); }
+
+        inline void write_string(const std::string& value) {
+            write_u32_le(static_cast<uint32_t>(value.size()));
+            write_bytes_raw(value.data(), value.size());
+        }
+        inline void write_bytes(const std::vector<uint8_t>& value) {
+            write_u32_le(static_cast<uint32_t>(value.size()));
+            write_bytes_raw(value.data(), value.size());
+        }
+
+        template<typename T>
+        void write_optional(const std::optional<T>& opt_value) {
+            // SpacetimeDB uses non-standard Option discriminants:
+            // Some = 0, None = 1 (reversed from standard Rust)
+            if (opt_value.has_value()) {
+                write_u8(0);  // Some = 0 (SpacetimeDB convention)
+                serialize(*this, *opt_value);
+            }
+            else {
+                write_u8(1);  // None = 1 (SpacetimeDB convention)
+            }
+        }
+
+        template<typename T>
+        void write_vector(const std::vector<T>& vec) {
+            write_u32_le(static_cast<uint32_t>(vec.size()));
+            for (const auto& item : vec) {
+                serialize(*this, item);
+            }
+        }
+
+        inline void write_vector_byte(const std::vector<uint8_t>& vec) {
+            write_bytes(vec);
+        }
+
+        // Generic serialize member function
+        template<typename T>
+        void serialize_member(const T& value) {
+            serialize(*this, value);
+        }
+        
+        void write_vec_len(size_t len) {
+            // Write length as varint
+            write_u32_le(static_cast<uint32_t>(len));
+        }
+
+        const std::vector<uint8_t>& get_buffer() const { 
+            return buffer_ ? *buffer_ : buffer; 
+        }
+        
+        std::vector<uint8_t>&& take_buffer() { 
+            return std::move(buffer_ ? *buffer_ : buffer); 
+        }
+        
+        // Public method to write raw bytes without length prefix
+        // This is needed for already-serialized data that has its own length encoding
+        inline void write_raw_bytes(const std::vector<uint8_t>& data) {
+            auto& target_buffer = buffer_ ? *buffer_ : buffer;
+            target_buffer.insert(target_buffer.end(), data.begin(), data.end());
+        }
+        
+        inline void write_raw_bytes(const uint8_t* data, size_t size) {
+            auto& target_buffer = buffer_ ? *buffer_ : buffer;
+            target_buffer.insert(target_buffer.end(), data, data + size);
+        }
+
+    private:
+        inline void write_bytes_raw(const void* data, size_t size) {
+            const uint8_t* bytes = static_cast<const uint8_t*>(data);
+            auto& target_buffer = buffer_ ? *buffer_ : buffer;
+            target_buffer.insert(target_buffer.end(), bytes, bytes + size);
+        }
+    };
+
+    // Helper to detect if type has bsatn_serialize method
+    template<typename T, typename = void>
+    struct has_bsatn_serialize : std::false_type {};
+    
+    template<typename T>
+    struct has_bsatn_serialize<T, std::void_t<decltype(std::declval<const T&>().bsatn_serialize(std::declval<Writer&>()))>> 
+        : std::true_type {};
+
+    // Generic serialize implementation for types with bsatn_serialize
+    template<typename T>
+    inline void serialize(Writer& w, const T& value) {
+        if constexpr (has_bsatn_serialize<T>::value) {
+            value.bsatn_serialize(w);
+        } else {
+            // Fall back to bsatn_traits
+            bsatn_traits<T>::serialize(w, value);
+        }
+    }
+
+    // Inline implementations of serialize functions
+    inline void serialize(Writer& w, bool value) {
+        w.write_bool(value);
+    }
+
+    inline void serialize(Writer& w, uint8_t value) {
+        w.write_u8(value);
+    }
+
+    inline void serialize(Writer& w, uint16_t value) {
+        w.write_u16_le(value);
+    }
+
+    inline void serialize(Writer& w, uint32_t value) {
+        w.write_u32_le(value);
+    }
+
+    inline void serialize(Writer& w, uint64_t value) {
+        w.write_u64_le(value);
+    }
+
+    inline void serialize(Writer& w, const SpacetimeDb::u128& value) {
+        w.write_u128_le(value);
+    }
+
+    inline void serialize(Writer& w, const SpacetimeDb::u256_placeholder& value) {
+        w.write_u256_le(value);
+    }
+
+    inline void serialize(Writer& w, int8_t value) {
+        w.write_i8(value);
+    }
+
+    inline void serialize(Writer& w, int16_t value) {
+        w.write_i16_le(value);
+    }
+
+    inline void serialize(Writer& w, int32_t value) {
+        w.write_i32_le(value);
+    }
+
+    inline void serialize(Writer& w, int64_t value) {
+        w.write_i64_le(value);
+    }
+
+    inline void serialize(Writer& w, const SpacetimeDb::i128& value) {
+        w.write_i128_le(value);
+    }
+
+    inline void serialize(Writer& w, const SpacetimeDb::i256_placeholder& value) {
+        w.write_i256_le(value);
+    }
+
+    inline void serialize(Writer& w, float value) {
+        w.write_f32_le(value);
+    }
+
+    inline void serialize(Writer& w, double value) {
+        w.write_f64_le(value);
+    }
+
+    inline void serialize(Writer& w, const std::string& value) {
+        w.write_string(value);
+    }
+
+    inline void serialize(Writer& w, const std::vector<uint8_t>& value) {
+        w.write_bytes(value);
+    }
+
+    inline void serialize(Writer&, std::monostate) {
+        // Nothing to serialize for monostate
+    }
+
+    // SDK type serialization - removed to avoid circular dependency
+    // Types with bsatn_serialize methods will be handled by the generic serialize function
+
+    template<typename T>
+    inline void serialize(Writer& w, const std::optional<T>& opt_value) {
+        w.write_optional(opt_value);
+    }
+
+    template<typename T>
+    inline void serialize(Writer& w, const std::vector<T>& vec) {
+        w.write_vector(vec);
+    }
+
+} // namespace SpacetimeDB::bsatn
+
+#endif // SPACETIMEDB_BSATN_WRITER_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/client_visibility_filter.h b/crates/bindings-cpp/include/spacetimedb/client_visibility_filter.h
new file mode 100644
index 00000000000..40d778aaf1b
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/client_visibility_filter.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+
+namespace SpacetimeDb {
+
+/// A row-level security filter,
+/// which can be registered using the SPACETIMEDB_CLIENT_VISIBILITY_FILTER macro.
+///
+/// Currently, the only valid value for a filter is a Filter::Sql.
+/// This is a filter written as a SQL query. Rows that match this query will be made visible to clients.
+///
+/// The query must be of the form `SELECT * FROM table` or `SELECT table.* from table`,
+/// followed by any number of `JOIN` clauses and a `WHERE` clause.
+/// If the query includes any `JOIN`s, it must be in the form `SELECT table.* FROM table`.
+/// In any case, the query must select all of the columns from a single table, and nothing else.
+///
+/// SQL queries are not checked for syntactic or semantic validity
+/// until they are processed by the SpacetimeDB host.
+/// This means that errors in queries used as SPACETIMEDB_CLIENT_VISIBILITY_FILTER rules
+/// will be reported during `spacetime publish`, not at compile time.
+class Filter {
+private:
+    const char* sql_text_;
+
+public:
+    /// Create a SQL-based client visibility filter
+    static Filter Sql(const char* sql) {
+        return Filter(sql);
+    }
+
+    /// Get the SQL text for this filter
+    const char* sql_text() const {
+        return sql_text_;
+    }
+
+private:
+    explicit Filter(const char* sql) : sql_text_(sql) {}
+};
+
+} // namespace SpacetimeDb
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/database.h b/crates/bindings-cpp/include/spacetimedb/database.h
new file mode 100644
index 00000000000..93c329ccbd4
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/database.h
@@ -0,0 +1,263 @@
+#ifndef SPACETIMEDB_DATABASE_H
+#define SPACETIMEDB_DATABASE_H
+
+#include "table.h"
+// Removed: internal/field_metadata.h (consolidated into field_registration.h)  
+#include "abi/FFI.h"
+#include "bsatn/bsatn.h"
+#include "bsatn/traits.h"
+#include "logger.h"
+#include <type_traits>
+#include <string>
+#include <stdexcept>
+#include <string_view>
+#include <optional>
+#include <vector>
+
+// Include field-based accessor system (SpacetimeDB standard pattern)
+// #include "field_accessors.h" // Removed - field accessors are now in table_with_constraints.h
+
+// Forward declarations to avoid circular includes
+namespace SpacetimeDb {
+namespace Internal {
+    class Module;
+    struct RawModuleDef;
+}
+
+// Field constraint flags - must match Rust's ColumnAttribute bits  
+enum class FieldConstraint : uint32_t {
+    None = 0,
+    Indexed = 0b0001,                         // 1
+    AutoInc = 0b0010,                         // 2
+    Unique = Indexed | 0b0100,                // 5 (Indexed + Unique bit)
+    PrimaryKey = Unique | 0b1000,             // 13 (Unique + PrimaryKey bit)
+    Identity = Unique | AutoInc,              // 7 (Unique + AutoInc)
+    PrimaryKeyAuto = PrimaryKey | AutoInc,    // 15 (PrimaryKey + AutoInc)
+    NotNull = 1 << 4                          // 16 (not used in Rust but kept for future)
+};
+
+inline FieldConstraint operator|(FieldConstraint a, FieldConstraint b) {
+    return static_cast<FieldConstraint>(
+        static_cast<uint32_t>(a) | static_cast<uint32_t>(b)
+    );
+}
+
+constexpr bool has_constraint(FieldConstraint field, FieldConstraint constraint) {
+    return (static_cast<uint32_t>(field) & static_cast<uint32_t>(constraint)) != 0;
+}
+
+// Forward declaration for tag-based accessors
+template<typename T>
+struct TableTag;
+
+
+// Forward declaration for field tags
+template<typename TableType, typename FieldType, FieldConstraint Constraint>
+struct FieldTag;
+
+// Forward declarations for typed field accessors
+template<typename TableType, typename FieldType>
+class TypedPrimaryKeyAccessor;
+
+template<typename TableType, typename FieldType>
+class TypedUniqueAccessor;
+
+template<typename TableType, typename FieldType>
+class TypedIndexedAccessor;
+
+template<typename TableType, typename FieldType>
+class TypedRegularAccessor;
+
+// Constraint system definitions for primary key operations
+
+// Field constraint info structure
+struct FieldConstraintInfo {
+    const char* field_name;
+    FieldConstraint constraints;
+    const char* index_name = nullptr;  // For named indexes
+    std::vector<const char*> column_names;  // For multi-column indexes
+    
+    // Constructor for basic constraints
+    FieldConstraintInfo(const char* name, FieldConstraint c) 
+        : field_name(name), constraints(c), index_name(nullptr) {}
+    
+    // Constructor for named indexes
+    FieldConstraintInfo(const char* name, FieldConstraint c, const char* idx_name) 
+        : field_name(name), constraints(c), index_name(idx_name) {}
+    
+    // Constructor for multi-column indexes
+    FieldConstraintInfo(std::initializer_list<const char*> columns, FieldConstraint c, const char* idx_name)
+        : field_name(nullptr), constraints(c), index_name(idx_name), column_names(columns) {}
+};
+
+// Table accessor that resolves table names at runtime with constraint-aware operations
+template<typename T>
+class TableAccessor {
+protected:
+    mutable std::optional<TableId> table_id_;
+    std::string table_name_;
+    
+    TableId resolve_table_id() const {
+        if (!table_id_.has_value()) {
+            // Resolve table ID from name
+            
+            // Use the provided table name or lookup from module metadata
+            std::string name_to_use = table_name_;
+            
+            if (name_to_use.empty()) {
+                // For now, require explicit table names
+                // TODO: Add runtime table name lookup
+                LOG_FATAL("Table name is required");
+            }
+            
+            TableId id;
+            Status status = ::table_id_from_name(
+                reinterpret_cast<const uint8_t*>(name_to_use.c_str()),
+                name_to_use.length(),
+                &id
+            );
+            
+            if (SpacetimeDb::is_error(status)) {
+                LOG_FATAL("Table not found: " + name_to_use);
+            }
+            table_id_ = id;
+        }
+        return *table_id_;
+    }
+    
+    
+public:
+    // Constructor that accepts a table name
+    TableAccessor() = default;
+    explicit TableAccessor(const std::string& table_name) : table_name_(table_name) {}
+    
+    // Insert a row and return it with any auto-generated fields
+    T insert(const T& row) const {
+        return get_table().insert(row);
+    }
+    
+    // Count all rows in the table
+    uint64_t count() const {
+        return get_table().count();
+    }
+    
+    // Delete rows matching a value
+    uint32_t delete_by_value(const T& value) const {
+        return get_table().delete_by_value(value);
+    }
+    
+    // Internal helper used by typed field accessors for atomic updates
+    uint32_t update_by_value(const T& old_value, const T& new_value) const {
+        // Delegate to Table<T> for atomic delete + insert
+        uint32_t deleted_count = get_table().delete_by_value(old_value);
+        if (deleted_count > 0) {
+            for (uint32_t i = 0; i < deleted_count; ++i) {
+                get_table().insert(new_value);
+            }
+        }
+        return deleted_count;
+    }
+
+public:
+    // Get or create cached Table<T> instance
+    SpacetimeDb::Table<T> get_table() const {
+        return SpacetimeDb::Table<T>(resolve_table_id());
+    }
+    
+    // Iterate over all rows in the table
+    SpacetimeDb::Table<T> table() const {
+        return get_table();
+    }
+    
+    // Range-based for loop support
+    auto begin() const { return get_table().begin(); }
+    auto end() const { return get_table().end(); }
+};
+
+/**
+ * @brief Database context with name-based table accessors (RECOMMENDED API)
+ * 
+ * DatabaseContext provides the recommended interface for all table operations
+ * in C++ modules. It automatically handles table ID resolution and provides
+ * a reliable wrapper around the low-level Table API.
+ * 
+ * @note This is the RECOMMENDED way to perform table operations. Direct Table
+ *       construction has known issues with insert operations that can cause crashes.
+ * 
+ * Example usage:
+ * @code
+ * SPACETIMEDB_REDUCER(my_reducer, ReducerContext ctx, uint32_t id, std::string name)
+ * {
+ *     // ALWAYS use DatabaseContext through ctx.db
+ *     auto users = ctx.db.table<User>("users");
+ *     
+ *     // All operations work reliably
+ *     User new_user = users.insert({id, name, 30});
+ *     uint64_t count = users.count();
+ *     
+ *     for (const auto& user : users) {
+ *         LOG_INFO_F("User: %s", user.name.c_str());
+ *     }
+ * }
+ * @endcode
+ */
+// Database context with name-based table accessors
+class DatabaseContext {
+public:
+    // Generic table accessor method (type-only, requires explicit table name later)
+    template<typename T>
+    TableAccessor<T> table() const {
+        return TableAccessor<T>{};
+    }
+    
+    // Name-based accessor that returns a configured table accessor
+    template<typename T>
+    TableAccessor<T> table(const char* name) const {
+        return TableAccessor<T>(std::string(name));
+    }
+    
+    // String overload
+    template<typename T>
+    TableAccessor<T> table(const std::string& name) const {
+        return table<T>(name.c_str());
+    }
+    
+    // Tag-based accessor using operator[] (SpacetimeDB standard)
+    template<typename Tag>
+    TableAccessor<typename Tag::type> operator[](const Tag&) const {
+        return TableAccessor<typename Tag::type>(std::string(Tag::__table_name_internal));
+    }
+    
+    // Field tag accessor - NEW: ctx.db[simple_table.id] syntax
+    // Overloaded for each field constraint type
+    template<typename TableType, typename FieldType>
+    TypedPrimaryKeyAccessor<TableType, FieldType> operator[](const FieldTag<TableType, FieldType, FieldConstraint::PrimaryKey>& field_tag) const {
+        return TypedPrimaryKeyAccessor<TableType, FieldType>(field_tag.table_name, field_tag.field_name, field_tag.member_ptr);
+    }
+    
+    template<typename TableType, typename FieldType>
+    TypedUniqueAccessor<TableType, FieldType> operator[](const FieldTag<TableType, FieldType, FieldConstraint::Unique>& field_tag) const {
+        return TypedUniqueAccessor<TableType, FieldType>(field_tag.table_name, field_tag.field_name, field_tag.member_ptr);
+    }
+    
+    template<typename TableType, typename FieldType>
+    TypedIndexedAccessor<TableType, FieldType> operator[](const FieldTag<TableType, FieldType, FieldConstraint::Indexed>& field_tag) const {
+        return TypedIndexedAccessor<TableType, FieldType>(field_tag.table_name, field_tag.field_name, field_tag.member_ptr);
+    }
+    
+    template<typename TableType, typename FieldType>
+    TypedRegularAccessor<TableType, FieldType> operator[](const FieldTag<TableType, FieldType, FieldConstraint::None>& field_tag) const {
+        return TypedRegularAccessor<TableType, FieldType>(field_tag.table_name, field_tag.field_name, field_tag.member_ptr);
+    }
+};
+
+
+} // namespace SpacetimeDb
+
+// Use spacetimedb namespace for consistency
+namespace spacetimedb {
+    template<typename T>
+    using TableAccessor = SpacetimeDb::TableAccessor<T>;
+}
+
+#endif // SPACETIMEDB_DATABASE_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/enum_macro.h b/crates/bindings-cpp/include/spacetimedb/enum_macro.h
new file mode 100644
index 00000000000..9a09fe8c574
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/enum_macro.h
@@ -0,0 +1,305 @@
+#pragma once
+
+#include "spacetimedb/bsatn/traits.h"
+#include "spacetimedb/bsatn/sum_type.h"
+#include "spacetimedb/macros.h"
+#include "spacetimedb/internal/v9_type_registration.h"
+
+/**
+ * @file enum_macro.h
+ * @brief SpacetimeDB Enum Macros - Clean, efficient enum type generation
+ * 
+ * Provides unified macros for creating SpacetimeDB-compatible enum types:
+ * 
+ * Simple Unit Enums:
+ *   SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+ *   → enum class SimpleEnum : uint8_t { Zero = 0, One = 1, Two = 2 };
+ * 
+ * Complex Variant Enums:
+ *   SPACETIMEDB_ENUM(ComplexEnum, (U8, uint8_t), (Str, std::string))
+ *   → struct ComplexEnum with std::variant<uint8_t, std::string>
+ */
+
+// =============================================================================
+// HELPER MACROS FOR VARIANT EXTRACTION
+// =============================================================================
+
+// Extract type from (name, type) pair
+#define VARIANT_TYPE(pair) VARIANT_TYPE_IMPL pair
+#define VARIANT_TYPE_IMPL(name, type) type
+
+// Extract name from (name, type) pair  
+#define VARIANT_NAME(pair) VARIANT_NAME_IMPL pair
+#define VARIANT_NAME_IMPL(name, type) #name
+
+// Separator macros
+#define COMMA() ,
+#define EMPTY()
+
+// =============================================================================
+// UNIFIED ENUM SYSTEM
+// =============================================================================
+
+/**
+ * @brief SPACETIMEDB_ENUM - Unified enum macro with automatic syntax detection
+ * 
+ * Simple unit enums:
+ *   SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+ *   → enum class SimpleEnum : uint8_t { Zero = 0, One = 1, Two = 2 };
+ * 
+ * Complex variant enums:
+ *   SPACETIMEDB_ENUM(ComplexEnum, (U8, uint8_t), (Str, std::string))
+ *   → struct ComplexEnum with std::variant<uint8_t, std::string>
+ */
+
+// Detect if first argument is parenthesized (name, type) pair
+#define SPACETIMEDB_IS_PARENTHESIZED(x) SPACETIMEDB_IS_PARENTHESIZED_IMPL(SPACETIMEDB_IS_PARENTHESIZED_PROBE x)
+#define SPACETIMEDB_IS_PARENTHESIZED_IMPL(...) SPACETIMEDB_IS_PARENTHESIZED_GET_SECOND(__VA_ARGS__, 0)
+#define SPACETIMEDB_IS_PARENTHESIZED_GET_SECOND(a, b, ...) b
+#define SPACETIMEDB_IS_PARENTHESIZED_PROBE(...) ~, 1
+
+// Route to appropriate implementation
+#define SPACETIMEDB_ENUM(EnumName, ...) \
+    SPACETIMEDB_CONCAT(SPACETIMEDB_ENUM_, \
+        SPACETIMEDB_IS_PARENTHESIZED(SPACETIMEDB_FIRST_ARG(__VA_ARGS__))) \
+    (EnumName, __VA_ARGS__)
+
+#define SPACETIMEDB_ENUM_0 SPACETIMEDB_ENUM_SIMPLE
+#define SPACETIMEDB_ENUM_1 SPACETIMEDB_ENUM_VARIANT
+#define SPACETIMEDB_FIRST_ARG(first, ...) first
+
+// =============================================================================
+// SIMPLE ENUM IMPLEMENTATION (Unit Variants)
+// =============================================================================
+
+/**
+ * @brief Creates efficient enum class with uint8_t underlying type
+ * 
+ * Generates named Sum type variants for SpacetimeDB compatibility.
+ * Used internally by SPACETIMEDB_ENUM for simple syntax.
+ */
+#define SPACETIMEDB_ENUM_SIMPLE(EnumName, ...) \
+    enum class EnumName : uint8_t { \
+        SPACETIMEDB_ENUM_ASSIGN_VALUES(__VA_ARGS__) \
+    }; \
+    \
+    namespace SpacetimeDb::bsatn { \
+    template<> \
+    struct bsatn_traits<EnumName> { \
+        static AlgebraicType algebraic_type() { \
+            return SpacetimeDb::Internal::LazyTypeRegistrar<EnumName>::getOrRegister( \
+                []() -> AlgebraicType { \
+                    SumTypeBuilder builder; \
+                    SPACETIMEDB_ENUM_ADD_VARIANTS(__VA_ARGS__) \
+                    return AlgebraicType::make_sum(builder.build()); \
+                }, \
+                #EnumName \
+            ); \
+        } \
+        \
+        static void serialize(Writer& writer, const EnumName& value) { \
+            writer.write_u8(static_cast<uint8_t>(value)); \
+        } \
+        \
+        static EnumName deserialize(Reader& reader) { \
+            uint8_t tag = reader.read_u8(); \
+            return static_cast<EnumName>(tag); \
+        } \
+    }; \
+    } \
+    \
+    SPACETIMEDB_GENERATE_EMPTY_FIELD_REGISTRAR(EnumName)
+
+// Auto-assign enum values (0, 1, 2, etc.) - supports up to 10 variants
+#define SPACETIMEDB_ENUM_ASSIGN_VALUES(...) \
+    SPACETIMEDB_ENUM_DISPATCH_COUNT(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)(__VA_ARGS__)
+
+#define SPACETIMEDB_ENUM_DISPATCH_COUNT(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,N,...) SPACETIMEDB_ENUM_ASSIGN_##N
+
+#define SPACETIMEDB_ENUM_ASSIGN_1(a) a = 0
+#define SPACETIMEDB_ENUM_ASSIGN_2(a, b) a = 0, b = 1
+#define SPACETIMEDB_ENUM_ASSIGN_3(a, b, c) a = 0, b = 1, c = 2
+#define SPACETIMEDB_ENUM_ASSIGN_4(a, b, c, d) a = 0, b = 1, c = 2, d = 3
+#define SPACETIMEDB_ENUM_ASSIGN_5(a, b, c, d, e) a = 0, b = 1, c = 2, d = 3, e = 4
+#define SPACETIMEDB_ENUM_ASSIGN_6(a, b, c, d, e, f) a = 0, b = 1, c = 2, d = 3, e = 4, f = 5
+#define SPACETIMEDB_ENUM_ASSIGN_7(a, b, c, d, e, f, g) a = 0, b = 1, c = 2, d = 3, e = 4, f = 5, g = 6
+#define SPACETIMEDB_ENUM_ASSIGN_8(a, b, c, d, e, f, g, h) a = 0, b = 1, c = 2, d = 3, e = 4, f = 5, g = 6, h = 7
+#define SPACETIMEDB_ENUM_ASSIGN_9(a, b, c, d, e, f, g, h, i) a = 0, b = 1, c = 2, d = 3, e = 4, f = 5, g = 6, h = 7, i = 8
+#define SPACETIMEDB_ENUM_ASSIGN_10(a, b, c, d, e, f, g, h, i, j) a = 0, b = 1, c = 2, d = 3, e = 4, f = 5, g = 6, h = 7, i = 8, j = 9
+
+// Register variants in SumTypeBuilder
+#define SPACETIMEDB_ENUM_ADD_VARIANTS(...) \
+    SPACETIMEDB_FOR_EACH_VARIANT(SPACETIMEDB_ENUM_ADD_UNIT_VARIANT, EMPTY, __VA_ARGS__)
+
+#define SPACETIMEDB_ENUM_ADD_UNIT_VARIANT(name) \
+    builder.with_unit_variant(#name);
+
+// =============================================================================
+// VARIANT ENUM IMPLEMENTATION (Data Variants)
+// =============================================================================
+
+/**
+ * @brief Creates flexible std::variant struct with named variants
+ * 
+ * Supports data-carrying variants with explicit type specifications.
+ * Used internally by SPACETIMEDB_ENUM for complex syntax.
+ */
+#define SPACETIMEDB_ENUM_VARIANT(EnumName, ...) \
+    struct EnumName { \
+        using variant_type = std::variant<SPACETIMEDB_ENUM_VARIANT_TYPES(__VA_ARGS__)>; \
+        variant_type value; \
+        \
+        static constexpr const char* variant_names[] = { \
+            FOR_EACH_VARIANT(VARIANT_NAME, COMMA, __VA_ARGS__) \
+        }; \
+        \
+        EnumName() = default; \
+        EnumName(const variant_type& v) : value(v) {} \
+        EnumName(variant_type&& v) : value(std::move(v)) {} \
+        \
+        template<typename T, typename = std::enable_if_t< \
+            !std::is_same_v<std::decay_t<T>, EnumName> && \
+            !std::is_same_v<std::decay_t<T>, variant_type>>> \
+        EnumName(T&& t) : value(std::forward<T>(t)) {} \
+        \
+        size_t index() const { return value.index(); } \
+        const char* variant_name() const { \
+            return (index() < sizeof(variant_names)/sizeof(variant_names[0])) ? \
+                variant_names[index()] : "unknown"; \
+        } \
+    }; \
+    \
+    namespace SpacetimeDb::bsatn { \
+    template<> \
+    struct bsatn_traits<EnumName> { \
+        static AlgebraicType algebraic_type() { \
+            return SpacetimeDb::Internal::LazyTypeRegistrar<EnumName>::getOrRegister( \
+                []() -> AlgebraicType { \
+                    std::vector<SumTypeVariant> variants; \
+                    SpacetimeDb::named_variant_helper<0, SPACETIMEDB_ENUM_VARIANT_TYPES(__VA_ARGS__)>::add_variants( \
+                        variants, EnumName::variant_names); \
+                    auto sum_type = std::make_unique<SumTypeSchema>(std::move(variants)); \
+                    return AlgebraicType::make_sum(std::move(sum_type)); \
+                }, \
+                #EnumName \
+            ); \
+        } \
+        \
+        static void serialize(Writer& writer, const EnumName& enum_value) { \
+            writer.write_u8(static_cast<uint8_t>(enum_value.value.index())); \
+            std::visit([&](const auto& v) { \
+                SpacetimeDb::bsatn::serialize(writer, v); \
+            }, enum_value.value); \
+        } \
+        \
+        static EnumName deserialize(Reader& reader) { \
+            uint8_t tag = reader.read_u8(); \
+            return EnumName{SpacetimeDb::named_variant_helper<0, SPACETIMEDB_ENUM_VARIANT_TYPES(__VA_ARGS__)>:: \
+                template deserialize_variant<typename EnumName::variant_type>(tag, reader)}; \
+        } \
+    }; \
+    } \
+    \
+    SPACETIMEDB_GENERATE_EMPTY_FIELD_REGISTRAR(EnumName)
+
+// Extract variant types from (name, type) pairs
+#define SPACETIMEDB_ENUM_VARIANT_TYPES(...) FOR_EACH_VARIANT(VARIANT_TYPE, COMMA, __VA_ARGS__)
+
+// Type alias for unit variants (no data)
+using Unit = std::monostate;
+
+// =============================================================================
+// VARIANT HELPER TEMPLATES
+// =============================================================================
+
+namespace SpacetimeDb {
+
+/**
+ * @brief Recursive helper for variant type processing
+ * 
+ * Builds variant lists with compile-time names and handles serialization.
+ * Used internally by SPACETIMEDB_ENUM_VARIANT.
+ */
+template<size_t I, typename... Types>
+struct named_variant_helper;
+
+// Recursion base case
+template<size_t I>
+struct named_variant_helper<I> {
+    static void add_variants(std::vector<bsatn::SumTypeVariant>& variants, 
+                            const char* const* names) {
+        (void)variants; (void)names; // End recursion
+    }
+    
+    template<typename Variant>
+    static Variant deserialize_variant(size_t index, bsatn::Reader& reader) {
+        (void)reader;
+        std::abort(); // Invalid variant index
+    }
+};
+
+// Recursive case
+template<size_t I, typename T, typename... Rest>
+struct named_variant_helper<I, T, Rest...> {
+    static void add_variants(std::vector<bsatn::SumTypeVariant>& variants,
+                            const char* const* names) {
+        const char* name = names[I];
+        
+        // Trigger type registration if needed (bottom-up dependency resolution)
+        bsatn::AlgebraicType variant_type = bsatn::bsatn_traits<T>::algebraic_type();
+        
+        variants.emplace_back(name, std::move(variant_type));
+        
+        // Continue with remaining types
+        named_variant_helper<I + 1, Rest...>::add_variants(variants, names);
+    }
+    
+    template<typename Variant>
+    static Variant deserialize_variant(size_t index, bsatn::Reader& reader) {
+        if (index == I) {
+            return Variant{bsatn::deserialize<T>(reader)};
+        } else {
+            return named_variant_helper<I + 1, Rest...>::template deserialize_variant<Variant>(index, reader);
+        }
+    }
+};
+
+} // namespace SpacetimeDb
+
+// =============================================================================
+// COMPILE-TIME NAMESPACE STORAGE
+// =============================================================================
+
+namespace SpacetimeDb::detail {
+    // Template to store namespace information for types
+    template<typename T>
+    struct namespace_info {
+        static constexpr const char* value = nullptr;
+    };
+}
+
+/**
+ * @brief Add namespace qualification to an existing enum type
+ * 
+ * This macro creates a template specialization that stores the namespace
+ * information at compile time. When the enum is registered, the LazyTypeRegistrar
+ * will check for this namespace information and use it.
+ * 
+ * @param EnumType The C++ enum class type (already defined with SPACETIMEDB_ENUM)
+ * @param NamespacePrefix The namespace prefix as a string literal
+ * 
+ * @example
+ * SPACETIMEDB_ENUM(TestC, Foo, Bar)           // Define the enum normally
+ * SPACETIMEDB_NAMESPACE(TestC, "Namespace")   // Add namespace qualification
+ * 
+ * This stores the namespace info at compile time for use during registration.
+ */
+#define SPACETIMEDB_NAMESPACE(EnumType, NamespacePrefix) \
+    namespace SpacetimeDb::detail { \
+        template<> \
+        struct namespace_info<EnumType> { \
+            static constexpr const char* value = NamespacePrefix; \
+        }; \
+    }
+
+
diff --git a/crates/bindings-cpp/include/spacetimedb/error_handling.h b/crates/bindings-cpp/include/spacetimedb/error_handling.h
new file mode 100644
index 00000000000..67f6221ad87
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/error_handling.h
@@ -0,0 +1,260 @@
+#pragma once
+
+#include <optional>
+#include <variant>
+#include <string>
+#include <concepts>
+#include <type_traits>
+#include <source_location>
+
+namespace SpacetimeDb {
+
+// =============================================================================
+// Phase 3: C++20 Error Handling System - Closing the Gap with Rust
+// =============================================================================
+
+/// Error types for database operations
+enum class DatabaseError {
+    ConstraintViolation,
+    DuplicateKey,
+    NotFound,
+    SerializationError,
+    ConnectionError,
+    Unknown
+};
+
+/// Error information with C++20 source location support
+struct ErrorInfo {
+    DatabaseError error_type;
+    std::string message;
+    std::source_location location;
+    
+    ErrorInfo(DatabaseError type, std::string msg, 
+              std::source_location loc = std::source_location::current())
+        : error_type(type), message(std::move(msg)), location(loc) {}
+};
+
+/// Result type similar to Rust's Result<T, E> - using std::variant since std::expected is C++23
+template<typename T>
+using DatabaseResult = std::variant<T, ErrorInfo>;
+
+/// Helper concepts for database operations
+template<typename T>
+concept DatabaseType = requires(T t) {
+    // Must be serializable and have comparison operators
+    requires std::copyable<T>;
+    requires std::equality_comparable<T>;
+};
+
+// =============================================================================
+// Result helper functions (Rust-inspired API)
+// =============================================================================
+
+/// Check if result is successful
+template<typename T>
+constexpr bool is_ok(const DatabaseResult<T>& result) {
+    return std::holds_alternative<T>(result);
+}
+
+/// Check if result is an error  
+template<typename T>
+constexpr bool is_error(const DatabaseResult<T>& result) {
+    return std::holds_alternative<ErrorInfo>(result);
+}
+
+/// Get value from successful result (throws if error)
+template<typename T>
+constexpr T& get_value(DatabaseResult<T>& result) {
+    if (is_error(result)) {
+        std::abort(); // Attempted to get value from error result
+    }
+    return std::get<T>(result);
+}
+
+/// Get value from successful result (const version)
+template<typename T>
+constexpr const T& get_value(const DatabaseResult<T>& result) {
+    if (is_error(result)) {
+        std::abort(); // Attempted to get value from error result
+    }
+    return std::get<T>(result);
+}
+
+/// Get error from failed result
+template<typename T>
+constexpr const ErrorInfo& get_error(const DatabaseResult<T>& result) {
+    if (is_ok(result)) {
+        std::abort(); // Attempted to get error from successful result
+    }
+    return std::get<ErrorInfo>(result);
+}
+
+/// Unwrap result or provide default value
+template<typename T>
+constexpr T unwrap_or(const DatabaseResult<T>& result, T default_value) {
+    if (is_ok(result)) {
+        return get_value(result);
+    }
+    return default_value;
+}
+
+/// Convert result to optional (loses error information)
+template<typename T>
+constexpr std::optional<T> to_optional(const DatabaseResult<T>& result) {
+    if (is_ok(result)) {
+        return get_value(result);
+    }
+    return std::nullopt;
+}
+
+// =============================================================================
+// Upsert result types for insert_or_update operations
+// =============================================================================
+
+enum class UpsertAction {
+    Inserted,  // Row was newly inserted
+    Updated    // Existing row was updated
+};
+
+/// Result of an insert_or_update operation
+template<typename T>
+struct UpsertResult {
+    T value;
+    UpsertAction action;
+    
+    UpsertResult(T val, UpsertAction act) : value(std::move(val)), action(act) {}
+    
+    bool was_inserted() const { return action == UpsertAction::Inserted; }
+    bool was_updated() const { return action == UpsertAction::Updated; }
+};
+
+// =============================================================================
+// Enhanced table accessor base class with error handling
+// =============================================================================
+
+/// Base class providing error-safe database operations
+template<typename TableType>
+requires DatabaseType<TableType>
+class ErrorSafeTableAccessor {
+public:
+    /// Try to insert a row, returning result instead of throwing
+    /// Rust equivalent: ctx.db.table().try_insert(row)
+    DatabaseResult<TableType> try_insert(const TableType& row) const {
+        // Without exceptions, we just call perform_insert
+        // If there's an error, it will abort
+        auto result = perform_insert(row);
+        return DatabaseResult<TableType>(std::in_place_index<0>, result);
+    }
+    
+    /// Insert or update a row based on primary key
+    /// Rust equivalent: ctx.db.table().id().try_insert_or_update(row) 
+    DatabaseResult<UpsertResult<TableType>> insert_or_update(const TableType& row) const {
+        // Without exceptions, we directly perform the operations
+        auto existing = find_by_primary_key(row);
+        
+        if (existing) {
+            // Update existing row
+            auto updated = perform_update(row);
+            return DatabaseResult<UpsertResult<TableType>>(
+                std::in_place_index<0>,
+                UpsertResult<TableType>(updated, UpsertAction::Updated)
+            );
+        } else {
+            // Insert new row
+            auto inserted = perform_insert(row);
+            return DatabaseResult<UpsertResult<TableType>>(
+                std::in_place_index<0>,
+                UpsertResult<TableType>(inserted, UpsertAction::Inserted)
+            );
+        }
+    }
+    
+    /// Try to delete a row, returning whether it was found and deleted
+    DatabaseResult<bool> try_delete(const TableType& row) const {
+        // Without exceptions, we directly perform the delete
+        bool deleted = perform_delete(row);
+        return DatabaseResult<bool>(std::in_place_index<0>, deleted);
+    }
+    
+protected:
+    // Pure virtual methods to be implemented by derived classes
+    virtual TableType perform_insert(const TableType& row) const = 0;
+    virtual TableType perform_update(const TableType& row) const = 0;
+    virtual bool perform_delete(const TableType& row) const = 0;
+    virtual std::optional<TableType> find_by_primary_key(const TableType& row) const = 0;
+};
+
+// =============================================================================
+// Convenient macros for error handling patterns
+// =============================================================================
+
+/// Try an operation and return early if it fails (Rust-inspired ? operator)
+#define TRY_DB_OP(result) \
+    ([&]() { \
+        auto _temp_result = (result); \
+        if (is_error(_temp_result)) { \
+            return DatabaseResult<decltype(get_value(_temp_result))>( \
+                std::in_place_index<1>, get_error(_temp_result)); \
+        } \
+        return _temp_result; \
+    }())
+
+/// Log error information with C++20 source location
+#define LOG_DB_ERROR(result) \
+    do { \
+        if (is_error(result)) { \
+            const auto& err = get_error(result); \
+            LOG_ERROR_F("[%s:%d in %s] DB Error: %s", \
+                       err.location.file_name(), err.location.line(), \
+                       err.location.function_name(), err.message.c_str()); \
+        } \
+    } while(0)
+
+} // namespace SpacetimeDb
+
+// =============================================================================
+// Usage Examples (for documentation) 
+// =============================================================================
+
+/*
+// Basic error handling - Rust style
+auto result = ctx.db[users].try_insert(new_user);
+if (is_ok(result)) {
+    auto user = get_value(result);
+    LOG_INFO_F("Inserted user: %s", user.name.c_str());
+} else {
+    auto error = get_error(result);
+    LOG_ERROR_F("Insert failed: %s", error.message.c_str());
+}
+
+// Insert or update pattern - major missing feature
+auto upsert_result = ctx.db[users].insert_or_update(user);
+if (is_ok(upsert_result)) {
+    auto upsert = get_value(upsert_result);
+    if (upsert.was_inserted()) {
+        LOG_INFO("Created new user");
+    } else {
+        LOG_INFO("Updated existing user");
+    }
+}
+
+// Chain operations with error propagation
+DatabaseResult<User> create_user_safe(const std::string& name) {
+    User new_user{0, name, "default@example.com"};
+    
+    // Try insert, propagate error if it fails
+    auto insert_result = TRY_DB_OP(ctx.db[users].try_insert(new_user));
+    
+    // If we get here, insert succeeded
+    LOG_INFO("User created successfully");
+    return insert_result;
+}
+
+// Convert to optional for simpler handling
+auto user_opt = to_optional(ctx.db[users].try_insert(new_user));
+if (user_opt) {
+    // Success - use user_opt.value()
+} else {
+    // Failed - error info is lost
+}
+*/
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/filterable_value_concept.h b/crates/bindings-cpp/include/spacetimedb/filterable_value_concept.h
new file mode 100644
index 00000000000..9cf9ab6dd42
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/filterable_value_concept.h
@@ -0,0 +1,73 @@
+#ifndef SPACETIMEDB_FILTERABLE_VALUE_CONCEPT_H
+#define SPACETIMEDB_FILTERABLE_VALUE_CONCEPT_H
+
+#include <type_traits>
+#include <concepts>
+#include <string>
+#include "bsatn/types.h"
+
+// Note: This file should be included within the SpacetimeDb namespace context
+
+/**
+ * C++20 concept defining types that can be used as index keys.
+ * 
+ * A type is filterable if it's one of:
+ * - Integral types (including bool)
+ * - std::string
+ * - Identity, ConnectionId, Timestamp
+ * - Simple enums (C-style enums without payloads)
+ */
+template<typename T>
+concept FilterableValue = 
+    std::integral<T> ||                    // All integer types + bool
+    std::same_as<T, std::string> ||        // String
+    std::same_as<T, Identity> ||           // Identity  
+    std::same_as<T, ConnectionId> ||       // ConnectionId
+    std::same_as<T, Timestamp> ||          // Timestamp
+    std::same_as<T, I128> ||               // I128
+    std::same_as<T, U128> ||               // U128
+    std::is_enum_v<T>;                     // Simple enums
+
+/**
+ * Helper to validate constraint at compile time
+ */
+template<typename TableType, FilterableValue auto member_ptr>
+struct ValidateIndexConstraint {
+    static constexpr bool value = true;
+};
+
+/**
+ * Compile-time constraint validation helper
+ * Use this to validate that a field can have index constraints
+ */
+template<typename TableType>
+struct ConstraintValidator {
+    template<auto member_ptr>
+    static constexpr void validate_unique() {
+        using FieldType = typename std::remove_reference<decltype(((TableType*)nullptr)->*member_ptr)>::type;
+        static_assert(FilterableValue<FieldType>,
+            "Field cannot have Unique constraint. "
+            "Only integers, bool, std::string, Identity, ConnectionId, Timestamp, "
+            "and simple enums can have Unique constraints.");
+    }
+    
+    template<auto member_ptr>
+    static constexpr void validate_index() {
+        using FieldType = typename std::remove_reference<decltype(((TableType*)nullptr)->*member_ptr)>::type;
+        static_assert(FilterableValue<FieldType>,
+            "Field cannot have Index constraint. "
+            "Only integers, bool, std::string, Identity, ConnectionId, Timestamp, "
+            "and simple enums can be indexed.");
+    }
+    
+    template<auto member_ptr>
+    static constexpr void validate_primary_key() {
+        using FieldType = typename std::remove_reference<decltype(((TableType*)nullptr)->*member_ptr)>::type;
+        static_assert(FilterableValue<FieldType>,
+            "Field cannot be a PrimaryKey. "
+            "Only integers, bool, std::string, Identity, ConnectionId, Timestamp, "
+            "and simple enums can be primary keys.");
+    }
+};
+
+#endif // SPACETIMEDB_FILTERABLE_VALUE_CONCEPT_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/index_iterator.h b/crates/bindings-cpp/include/spacetimedb/index_iterator.h
new file mode 100644
index 00000000000..9f2163e135e
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/index_iterator.h
@@ -0,0 +1,284 @@
+#ifndef SPACETIMEDB_INDEX_ITERATOR_H
+#define SPACETIMEDB_INDEX_ITERATOR_H
+
+/**
+ * @file index_iterator.h
+ * @brief Index-based iteration for SpacetimeDB C++ SDK
+ * 
+ * Provides efficient index-based iteration using btree scans,
+ * matching the performance of Rust's index-based filtering.
+ */
+
+#include "spacetimedb/bsatn/types.h"
+#include <spacetimedb/bsatn/bsatn.h>
+#include <spacetimedb/abi/FFI.h>
+#include <spacetimedb/bsatn/reader.h>
+#include <spacetimedb/bsatn/writer.h>
+#include <spacetimedb/bsatn/traits.h>
+#include <spacetimedb/logger.h>
+#include <spacetimedb/range_queries.h>
+
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <optional>
+#include <algorithm>
+#include <utility>
+
+namespace SpacetimeDb {
+
+// =============================================================================
+// IndexIterator - Efficient index-based iteration
+// =============================================================================
+
+template<typename T>
+class IndexIterator {
+    static_assert(std::is_same_v<T, std::remove_cv_t<T>>, 
+                  "IndexIterator requires non-const, non-volatile type");
+
+public:
+    // STL iterator type definitions
+    using iterator_category = std::input_iterator_tag;
+    using value_type = T;
+    using difference_type = std::ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+
+    // Constructors
+    IndexIterator() noexcept : iter_handle_(Invalid::ROW_ITER), is_end_(true) {}
+    
+    // Constructor for exact value match
+    template<typename FieldType>
+    IndexIterator(IndexId index_id, const FieldType& value) {
+        // Serialize the exact value for prefix matching
+        SpacetimeDb::bsatn::Writer bound_writer;
+        bound_writer.write_u8(0);  // Bound::Included tag
+        SpacetimeDb::bsatn::serialize(bound_writer, value);
+        auto bound_buffer = bound_writer.take_buffer();
+
+        // For exact match, use the value as both prefix and range bounds
+        Status status = FFI::datastore_btree_scan_bsatn(
+            index_id,
+            nullptr, 0, ColId{0},  // prefix with 1 element
+            bound_buffer.data(), bound_buffer.size(),  // no range start
+            bound_buffer.data(), bound_buffer.size(),  // no range end
+            &iter_handle_
+        );
+        
+        if (status != StatusCode::OK) {
+            std::abort(); // IndexIterator: datastore_btree_scan_bsatn failed
+        }
+        advance();
+    }
+    
+    // Constructor for range queries
+    template<typename FieldType>
+    IndexIterator(IndexId index_id, const Range<FieldType>& range) {
+        std::vector<uint8_t> start_buffer;
+        std::vector<uint8_t> end_buffer;
+
+        // Serialize range bounds if present
+        if (range.start.has_value()) {
+            SpacetimeDb::bsatn::Writer start_writer;
+            start_writer.write_u8(0);
+            SpacetimeDb::bsatn::serialize(start_writer, range.start.value());
+            start_buffer = start_writer.take_buffer();
+        } else {
+            start_buffer.push_back(2); // Bound::Unbounded tag
+        }
+        
+        if (range.end.has_value()) {
+            SpacetimeDb::bsatn::Writer end_writer;
+            uint8_t end_tag = (range.bound_type == RangeBound::Inclusive) ? 0 : 1;
+            end_writer.write_u8(end_tag);
+            SpacetimeDb::bsatn::serialize(end_writer, range.end.value());
+            end_buffer = end_writer.take_buffer();
+        } else {
+            end_buffer.push_back(2); // Bound::Unbounded tag
+        }
+        
+        // Call btree scan with range bounds
+        Status status = FFI::datastore_btree_scan_bsatn(
+            index_id,
+            nullptr, 0, ColId{0},  // no prefix for range queries
+            start_buffer.empty() ? nullptr : start_buffer.data(), start_buffer.size(),
+            end_buffer.empty() ? nullptr : end_buffer.data(), end_buffer.size(),
+            &iter_handle_
+        );
+        
+        if (status != StatusCode::OK) {
+            std::abort(); // IndexIterator: datastore_btree_scan_bsatn failed
+        }
+        
+        // Apply inclusive/exclusive bounds during iteration
+        bound_type_ = range.bound_type;
+        // Note: bounds are handled by the btree scan itself
+        
+        advance();
+    }
+
+    ~IndexIterator() noexcept {
+        if (iter_handle_ != Invalid::ROW_ITER && !ffi_exhausted_) {
+            FFI::row_iter_bsatn_close(iter_handle_);
+        }
+    }
+
+    // Move-only semantics
+    IndexIterator(const IndexIterator&) = delete;
+    IndexIterator& operator=(const IndexIterator&) = delete;
+    
+    IndexIterator(IndexIterator&& other) noexcept : IndexIterator() {
+        swap(*this, other);
+    }
+    
+    IndexIterator& operator=(IndexIterator&& other) noexcept {
+        if (this != &other) {
+            IndexIterator temp(std::move(other));
+            swap(*this, temp);
+        }
+        return *this;
+    }
+    
+    friend void swap(IndexIterator& a, IndexIterator& b) noexcept {
+        using std::swap;
+        swap(a.iter_handle_, b.iter_handle_);
+        swap(a.row_buffer_, b.row_buffer_);
+        swap(a.current_batch_, b.current_batch_);
+        swap(a.current_index_, b.current_index_);
+        swap(a.current_row_, b.current_row_);
+        swap(a.is_valid_, b.is_valid_);
+        swap(a.is_end_, b.is_end_);
+        swap(a.ffi_exhausted_, b.ffi_exhausted_);
+        swap(a.bound_type_, b.bound_type_);
+    }
+
+    // Iterator operations
+    const T& operator*() const {
+        if (!is_valid_) std::abort();
+        return current_row_;
+    }
+    
+    const T* operator->() const { return &**this; }
+    
+    IndexIterator& operator++() {
+        advance();
+        return *this;
+    }
+    
+    bool operator==(const IndexIterator& other) const noexcept {
+        return is_valid_ == other.is_valid_;
+    }
+    
+    bool operator!=(const IndexIterator& other) const noexcept {
+        return !(*this == other);
+    }
+
+private:
+    RowIter iter_handle_ = Invalid::ROW_ITER;
+    std::vector<uint8_t> row_buffer_;
+    std::vector<T> current_batch_;
+    size_t current_index_ = 0;
+    T current_row_;
+    bool is_valid_ = false;
+    bool is_end_ = false;
+    bool ffi_exhausted_ = false;
+    
+    // For handling inclusive/exclusive bounds
+    RangeBound bound_type_ = RangeBound::Exclusive;
+    // Note: end_value_ tracking would require knowing the field type
+    // For now we rely on btree scan to handle bounds correctly
+    
+    // Constants for performance tuning
+    static constexpr size_t INITIAL_ROW_BUFFER_SIZE = 4096;
+    static constexpr size_t MAX_ROW_BUFFER_SIZE = 1024 * 1024;
+    static constexpr size_t TYPICAL_BATCH_SIZE = 32;
+    static constexpr int16_t ITER_EXHAUSTED = -1;
+    static constexpr int16_t ITER_OK = 0;
+    static constexpr uint16_t ERROR_BUFFER_TOO_SMALL = 3;
+    
+    void advance() {
+        if (is_end_) {
+            is_valid_ = false;
+            return;
+        }
+        
+        // Try current batch first
+        if (current_index_ < current_batch_.size()) {
+            current_row_ = std::move(current_batch_[current_index_++]);
+            is_valid_ = true;
+            return;
+        }
+        
+        // Need new batch - but check if FFI is already exhausted
+        if (ffi_exhausted_) {
+            is_end_ = true;
+            is_valid_ = false;
+            return;
+        }
+        
+        // Fetch new batch
+        fetch_batch();
+        
+        // Try again with new batch
+        if (current_index_ < current_batch_.size()) {
+            current_row_ = std::move(current_batch_[current_index_++]);
+            is_valid_ = true;
+        } else {
+            is_end_ = true;
+            is_valid_ = false;
+        }
+    }
+    
+    void fetch_batch() {
+        row_buffer_.resize(INITIAL_ROW_BUFFER_SIZE);
+        size_t buffer_len = row_buffer_.size();
+        
+        int16_t ret = FFI::row_iter_bsatn_advance(iter_handle_, 
+                                                  row_buffer_.data(), 
+                                                  &buffer_len);
+        
+        if (ret == ITER_EXHAUSTED) {
+            ffi_exhausted_ = true;
+            if (buffer_len > 0) {
+                row_buffer_.resize(buffer_len);
+                deserialize_batch(buffer_len);
+            }
+            return;
+        }
+        
+        if (ret == ERROR_BUFFER_TOO_SMALL) {
+            if (buffer_len > MAX_ROW_BUFFER_SIZE) {
+                std::abort(); // Buffer size exceeds maximum
+            }
+            row_buffer_.resize(buffer_len);
+            ret = FFI::row_iter_bsatn_advance(iter_handle_, 
+                                             row_buffer_.data(), 
+                                             &buffer_len);
+        }
+        
+        if (ret > 0) {
+            std::abort(); // IndexIterator: row_iter_bsatn_advance failed
+        }
+        
+        row_buffer_.resize(buffer_len);
+        deserialize_batch(buffer_len);
+    }
+    
+    void deserialize_batch(size_t buffer_len) {
+        current_batch_.clear();
+        current_batch_.reserve(TYPICAL_BATCH_SIZE);
+        current_index_ = 0;
+        
+        if (buffer_len == 0) return;
+        
+        SpacetimeDb::bsatn::Reader reader(row_buffer_.data(), buffer_len);
+        while (!reader.is_eos()) {
+            // Without exceptions, deserialization failures will abort
+            current_batch_.emplace_back(SpacetimeDb::bsatn::deserialize<T>(reader));
+        }
+    }
+};
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_INDEX_ITERATOR_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/Module.h b/crates/bindings-cpp/include/spacetimedb/internal/Module.h
new file mode 100644
index 00000000000..2d9e07a8a80
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/Module.h
@@ -0,0 +1,322 @@
+#ifndef SPACETIMEDB_MODULE_H
+#define SPACETIMEDB_MODULE_H
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <map>
+#include <memory>
+#include <optional>
+#include <typeinfo>
+#include "../bsatn/types.h"
+#include "../reducer_macros.h"
+#include "../reducer_context.h"
+#include "../abi/opaque_types.h"
+#include <spacetimedb/abi/FFI.h>  // For StatusCode
+#include "autogen/TableAccess.g.h"  // For TableAccess enum
+#include "autogen/Lifecycle.g.h"  // For Lifecycle enum
+#include "autogen/RawTypeDefV9.g.h"  // For RawTypeDefV9
+#include "autogen/RawModuleDefV9.g.h"  // For RawModuleDefV9
+
+namespace SpacetimeDb {
+struct FieldConstraintInfo;  // Forward declaration for constraint info
+
+namespace bsatn {
+class Writer;  // Forward declaration
+}
+
+namespace Internal {
+struct RawScheduleDefV9;  // Forward declaration
+struct RawModuleDefV9;    // Forward declaration
+}
+
+namespace Internal {
+
+// Forward declarations are handled by includes
+
+// FieldInfo for table registration
+struct FieldInfo {
+    const char* name;
+    uint8_t type_id;
+    size_t offset;
+    size_t size;
+    std::function<void(std::vector<uint8_t>&, const void*)> serialize;
+};
+
+// Raw module definition structure (similar to C# RawModuleDefV9)
+struct RawModuleDef {
+    // Structure to store named index information
+    struct IndexInfo {
+        std::string name;           // Index name (e.g., "foo" for test_a)
+        std::string accessor_name;  // Accessor name for the index
+        std::vector<uint16_t> columns;  // Column indices
+    };
+    
+    struct Table {
+        std::string name;
+        bool is_public;
+        const std::type_info* type;
+        std::vector<FieldInfo> fields;
+        std::function<void(std::vector<uint8_t>&)> write_schema;
+        std::function<void(std::vector<uint8_t>&, const void*)> serialize;
+        
+        // Constraint metadata
+        std::optional<uint16_t> primary_key;
+        std::vector<uint16_t> unique_columns;
+        std::vector<uint16_t> indexed_columns;
+        std::vector<uint16_t> autoinc_columns;
+        
+        // Named indexes (for NamedIndex macro support)
+        std::vector<IndexInfo> named_indexes;
+        
+        // Scheduled reducer metadata (pointer to avoid incomplete type issues)
+        SpacetimeDb::Internal::RawScheduleDefV9* schedule = nullptr;
+        
+        // Field type collection migrated to V9Builder system
+    };
+    
+    struct Reducer {
+        std::string name;
+        std::function<void(std::vector<uint8_t>&)> write_params;
+        // Legacy write_params_with_registry removed - V9 system handles parameters
+        std::function<void(ReducerContext&, uint32_t)> handler;
+        std::optional<Lifecycle> lifecycle;
+        // Parameter type collection migrated to V9Builder system
+        
+        // V9 support: Store parameter metadata for RawReducerDefV9
+        std::vector<std::string> param_names;  // Parameter names from macro
+    };
+    
+    std::vector<Table> tables;
+    std::vector<Reducer> reducers;
+    std::vector<RawTypeDefV9> types;
+    std::map<const std::type_info*, size_t> table_indices;
+    
+    // V9 ModuleDef built incrementally during registration
+    mutable RawModuleDefV9 v9_module;
+    
+    // Direct V9 type registration - replaces TypeRegistry
+    // Returns the typespace index for the type
+    uint32_t registerOrLookupType(const bsatn::AlgebraicType& type, 
+                                  const std::string& type_name = "",
+                                  bool is_table_type = false) const;
+    
+    // Helper to convert bsatn types to Internal types with proper references
+    SpacetimeDb::Internal::AlgebraicType convertWithReferences(const bsatn::AlgebraicType& type) const;
+    
+    void AddTable(Table table) {
+        table_indices[table.type] = tables.size();
+        tables.push_back(std::move(table));
+    }
+    
+    void AddReducer(Reducer reducer) {
+        reducers.push_back(std::move(reducer));
+    }
+    
+    // Serialize the entire module definition to binary format
+    std::vector<uint8_t> serialize() const;
+    
+    // Legacy serialization method (manual BSATN writing)
+    std::vector<uint8_t> serialize_legacy() const;
+    
+    // DEPRECATED: Legacy serialization - use V9Builder system instead
+    [[deprecated("Use V9Builder system instead")]]
+    RawModuleDefV9 toAutogenModuleDef() const;
+    
+private:
+    // LEGACY METHODS - All TypeRegistry methods deprecated, use V9Builder system instead
+    /*
+    void collectTableFieldTypes(TypeRegistry& type_registry) const;
+    void registerTableTypes(TypeRegistry& type_registry, 
+                          std::map<const std::type_info*, uint32_t>& type_to_index,
+                          std::vector<uint32_t>& table_type_refs) const;
+    void collectReducerParameterTypes(TypeRegistry& type_registry) const;
+    uint32_t processFieldType(...);
+    uint32_t processProductType(...);
+    uint32_t processSpecialType(...);
+    uint32_t processComplexType(...);
+    void writeTypespace(...);
+    void writeReducers(...);
+    void writeNamedTypes(...);
+    // ... other legacy TypeRegistry methods removed
+    */
+    
+    // Non-TypeRegistry helper methods (still active)
+    void writeTables(bsatn::Writer& writer, const std::vector<uint32_t>& table_type_refs) const;
+    void writeTable(bsatn::Writer& writer, const Table& table, uint32_t table_type_ref) const;
+    void writeTableIndexes(bsatn::Writer& writer, const Table& table) const;
+    void writeTableConstraints(bsatn::Writer& writer, const Table& table) const;
+    void writeTableSequences(bsatn::Writer& writer, const Table& table) const;
+    void writeTableSchedule(bsatn::Writer& writer, const Table& table) const;
+    std::string getFieldName(const Table& table, uint16_t column) const;
+    void writeRLSPolicies(bsatn::Writer& writer) const;
+    std::string sanitizeTypeName(const std::string& type_name) const;
+};
+
+// Module class - singleton pattern similar to C# static class
+class Module {
+private:
+    RawModuleDef module_def_;
+    
+    Module() = default;
+    Module(const Module&) = delete;
+    Module& operator=(const Module&) = delete;
+    
+public:
+    static Module& Instance() {
+        static Module instance;
+        return instance;
+    }
+    
+    // Get module definition (for internal use)
+    static RawModuleDef& GetModuleDef() {
+        return Instance().module_def_;
+    }
+    
+    // Initialize module (called once)
+    
+    // Module description for FFI (matching existing signature)
+    static void __describe_module__(BytesSink sink);
+    
+    // Reducer invocation for FFI (matching existing signature)
+    static Status __call_reducer__(
+        uint32_t id,
+        uint64_t sender_0, uint64_t sender_1, uint64_t sender_2, uint64_t sender_3,
+        uint64_t conn_id_0, uint64_t conn_id_1,
+        Timestamp timestamp,
+        BytesSource args_source,
+        BytesSink error_sink
+    );
+    
+    // Internal registration methods (inline to avoid linking issues)
+    template<typename T>
+    static void RegisterTableInternal(const char* name, bool is_public) {
+        // Forward declaration - implementation will be included at end of file
+        RegisterTableInternalImpl<T>(name, is_public);
+    }
+    
+    template<typename... Args>
+    static void RegisterReducerInternal(const std::string& name, void (*func)(ReducerContext, Args...)) {
+        // Forward declaration - implementation will be included at end of file  
+        RegisterReducerInternalImpl<Args...>(name, func);
+    }
+    
+    // Implementation methods (will be defined after including Module_impl.h)
+    template<typename T>
+    static void RegisterTableInternalImpl(const char* name, bool is_public);
+    
+public:
+    // New overload that accepts constraints - must be public for table_with_constraints.h
+    template<typename T>
+    static void RegisterTableInternalImpl(const char* name, bool is_public, 
+                                         const std::vector<FieldConstraintInfo>& constraints);
+    
+private:
+    
+public:
+    // These need to be public for macro access
+    template<typename... Args>
+    static void RegisterReducerInternalImpl(const std::string& name, void (*func)(ReducerContext, Args...));
+    
+    template<typename... Args>
+    static void RegisterReducerInternalWithNames(const std::string& name, void (*func)(ReducerContext, Args...), const std::vector<std::string>& param_names);
+    
+private:
+    
+public:
+    // Direct table registration (for rust_style_table.h)
+    static void RegisterTableDirect(const std::string& name, 
+                                   TableAccess access,
+                                   std::function<std::vector<uint8_t>()> typeGen);
+    
+    // Special registration for lifecycle reducers
+    static void RegisterInitReducer(void (*func)(ReducerContext));
+    static void RegisterClientConnectedReducer(void (*func)(ReducerContext, Identity));
+    static void RegisterClientDisconnectedReducer(void (*func)(ReducerContext, Identity));
+    
+public:
+    // Registration support migrated to V9Builder system
+};
+
+// Helper functions for module description
+std::vector<uint8_t> ConsumeBytes(BytesSource source);
+void WriteBytes(BytesSink sink, const std::vector<uint8_t>& bytes);
+
+// Schedule registration function
+void register_table_schedule(const char* table_name, uint16_t scheduled_at_column, const char* reducer_name);
+
+// Get the global V9 module for direct population
+RawModuleDefV9& GetV9Module();
+
+} // namespace Internal
+
+// Public API similar to C# Module class
+class Module {
+public:
+    // Table registration
+    template<typename T>
+    static void RegisterTable(const char* name, bool is_public = true) {
+        Internal::Module::RegisterTableInternal<T>(name, is_public);
+    }
+    
+    // Reducer registration
+    template<typename... Args>
+    static void RegisterReducer(const char* name, void (*func)(ReducerContext&, Args...)) {
+        Internal::Module::RegisterReducerInternal(name, func);
+    }
+    
+    // Client visibility filter (similar to C#)
+    static void RegisterClientVisibilityFilter([[maybe_unused]] const char* sql) {
+        // TODO: Implement when row-level security is added
+    }
+    
+    // Module metadata (future extension)
+    static void SetMetadata([[maybe_unused]] const char* name, [[maybe_unused]] const char* version) {
+        // TODO: Implement module metadata
+    }
+};
+
+// Global registration functions for X-Macro support
+template<typename T>
+void register_table_impl(const char* name, bool is_public) {
+    Internal::Module::RegisterTableInternal<T>(name, is_public);
+}
+
+template<typename... Args>
+void register_reducer_impl(const std::string& name, void (*func)(ReducerContext, Args...)) {
+    Internal::Module::RegisterReducerInternal(name, func);
+}
+
+// Initialize module - no longer needed in V9 as preinit functions handle everything
+inline void initialize_module() {
+    // No-op in V9
+}
+
+// Write module definition (for FFI)
+inline void spacetimedb_write_module_def(uint32_t sink) {
+    BytesSink bs{sink};
+    Internal::Module::__describe_module__(bs);
+}
+
+// Call reducer (for FFI)
+inline int16_t spacetimedb_call_reducer(uint32_t id, uint32_t args, 
+                                       uint64_t sender_0, uint64_t sender_1, 
+                                       uint64_t sender_2, uint64_t sender_3) {
+    // Create a simple timestamp
+    Timestamp ts(0);
+    BytesSource args_source{args};
+    BytesSink error_sink{0};  // Null sink for now
+    
+    auto status = Internal::Module::__call_reducer__(
+        id, sender_0, sender_1, sender_2, sender_3, 
+        0, 0, ts, args_source, error_sink);
+    
+    return is_ok(status) ? 0 : -1;
+}
+
+} // namespace SpacetimeDb
+
+// Include the template implementations
+#include "Module_impl.h"
+
+#endif // SPACETIMEDB_MODULE_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/Module_impl.h b/crates/bindings-cpp/include/spacetimedb/internal/Module_impl.h
new file mode 100644
index 00000000000..a694515cb42
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/Module_impl.h
@@ -0,0 +1,731 @@
+#ifndef SPACETIMEDB_MODULE_IMPL_H
+#define SPACETIMEDB_MODULE_IMPL_H
+
+/**
+ * SpacetimeDB C++ SDK - Module Implementation (Optimized)
+ * 
+ * Core module system implementation with optimized type handling, 
+ * table registration, and reducer management.
+ * 
+ * Architecture:
+ * - Type traits for compile-time type detection
+ * - BSATN serialization utilities
+ * - Unified table and reducer registration
+ * - V9 builder integration for constraints
+ */
+
+#include "Module.h"
+#include "field_registration.h"
+#include "../table_with_constraints.h"
+#include <spacetimedb/abi/FFI.h>
+#include "bsatn_adapters.h"
+#include <spacetimedb/bsatn/algebraic_type.h>
+#include <spacetimedb/bsatn/traits.h>
+#include <spacetimedb/bsatn/type_extensions.h>
+#include "autogen/Lifecycle.g.h"
+#include "autogen/RawConstraintDefV9.g.h"
+#include "autogen/RawUniqueConstraintDataV9.g.h"
+#include "autogen/RawIndexDefV9.g.h"
+#include "autogen/RawIndexAlgorithm.g.h"
+#include "nested_type_collection.h"
+#include "v9_builder.h"
+#include <cstring>
+#include <cstdio>
+#include <vector>
+#include <string>
+#include <optional>
+#include <functional>
+#include <unordered_map>
+#include <algorithm>
+#include <utility>
+
+namespace SpacetimeDb {
+namespace Internal {
+
+// =============================================================================
+// TYPE TRAITS
+// =============================================================================
+
+// Detect unit structs
+template<typename T>
+struct is_unit_struct_type {
+private:
+    template<typename U>
+    static auto test(int) -> decltype(U::__is_unit_type__, std::bool_constant<U::__is_unit_type__>{});
+    template<typename>
+    static std::false_type test(...);
+public:
+    static constexpr bool value = decltype(test<T>(0))::value;
+};
+
+template<typename T>
+inline constexpr bool is_unit_struct_v = is_unit_struct_type<T>::value;
+
+// Detect vector types
+template<typename T>
+struct is_vector_type : std::false_type {};
+
+template<typename T, typename Alloc>
+struct is_vector_type<std::vector<T, Alloc>> : std::true_type {};
+
+// Detect optional types
+template<typename T>
+struct is_optional : std::false_type {};
+
+template<typename T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+// Check for big integer types
+template<typename T>
+constexpr bool is_big_integer_v = std::is_same_v<T, ::SpacetimeDb::u128> ||
+                                   std::is_same_v<T, ::SpacetimeDb::i128> ||
+                                   std::is_same_v<T, ::SpacetimeDb::u256> ||
+                                   std::is_same_v<T, ::SpacetimeDb::i256>;
+
+// Check if type needs registry registration
+template<typename T>
+constexpr bool needs_type_registration_v = (!std::is_arithmetic_v<T> && 
+                                          !std::is_same_v<T, std::string> &&
+                                          !is_big_integer_v<T>) ||
+                                          requires { bsatn::bsatn_traits<T>::algebraic_type(); };
+
+// Get BSATN tag for primitive types
+template<typename T>
+struct type_id {
+    static constexpr uint8_t value = []() {
+        if constexpr (std::is_same_v<T, bool>) return 4;
+        else if constexpr (std::is_same_v<T, uint8_t>) return 5;
+        else if constexpr (std::is_same_v<T, int8_t>) return 6;
+        else if constexpr (std::is_same_v<T, uint16_t>) return 7;
+        else if constexpr (std::is_same_v<T, int16_t>) return 8;
+        else if constexpr (std::is_same_v<T, uint32_t>) return 9;
+        else if constexpr (std::is_same_v<T, int32_t>) return 10;
+        else if constexpr (std::is_same_v<T, uint64_t>) return 11;
+        else if constexpr (std::is_same_v<T, int64_t>) return 12;
+        else if constexpr (std::is_same_v<T, float>) return 17;
+        else if constexpr (std::is_same_v<T, double>) return 18;
+        else if constexpr (std::is_same_v<T, std::string>) return 19;
+        else return 0; // Complex type
+    }();
+};
+
+// Check for BSATN traits
+template<typename T, typename = void>
+struct has_bsatn_traits : std::false_type {};
+
+template<typename T>
+struct has_bsatn_traits<T, std::void_t<decltype(bsatn::bsatn_traits<T>::deserialize(std::declval<bsatn::Reader&>()))>> : std::true_type {};
+
+template<typename T>
+constexpr bool has_bsatn_traits_v = has_bsatn_traits<T>::value;
+
+// Check if type can be written inline
+template<typename T>
+constexpr bool is_basic_inlineable_v = 
+    std::is_arithmetic_v<T> || std::is_same_v<T, std::string> ||
+    std::is_same_v<T, Identity> || std::is_same_v<T, ConnectionId> || 
+    std::is_same_v<T, Timestamp> || std::is_same_v<T, TimeDuration> ||
+    std::is_same_v<T, u128> || std::is_same_v<T, u256> ||
+    std::is_same_v<T, i128> || std::is_same_v<T, i256>;
+
+// =============================================================================
+// BINARY I/O UTILITIES
+// =============================================================================
+
+inline void write_u32(std::vector<uint8_t>& buf, uint32_t val) {
+    bsatn::Writer writer(buf);
+    writer.write_u32_le(val);
+}
+
+inline void write_string(std::vector<uint8_t>& buf, const std::string& str) {
+    bsatn::Writer writer(buf);
+    writer.write_string(str);
+}
+
+inline uint8_t read_u8(uint32_t source) {
+    BytesSource src{source};
+    BytesSourceReader reader(src);
+    return reader.read_u8();
+}
+
+inline uint32_t read_u32(uint32_t source) {
+    BytesSource src{source};
+    BytesSourceReader reader(src);
+    return reader.read_u32_le();
+}
+
+// =============================================================================
+// TABLE REGISTRATION
+// =============================================================================
+
+// Apply constraints to table with optimized field lookup
+inline void apply_table_constraints(RawModuleDef::Table& table, 
+                                   const std::vector<FieldConstraintInfo>& constraints) {
+    if (constraints.empty() || table.fields.empty()) return;
+    
+    // Build field name lookup map
+    std::unordered_map<std::string, uint16_t> field_indices;
+    field_indices.reserve(table.fields.size());
+    for (size_t i = 0; i < table.fields.size(); ++i) {
+        field_indices.emplace(table.fields[i].name, static_cast<uint16_t>(i));
+    }
+    
+    // Pre-allocate constraint vectors
+    std::vector<uint16_t> unique_fields, indexed_fields, autoinc_fields;
+    unique_fields.reserve(constraints.size());
+    indexed_fields.reserve(constraints.size());
+    autoinc_fields.reserve(constraints.size());
+    
+    // Process constraints in single pass
+    for (const auto& constraint : constraints) {
+        if (constraint.field_name == nullptr) continue;
+        
+        auto field_it = field_indices.find(constraint.field_name);
+        if (field_it == field_indices.end()) continue;
+        
+        const uint16_t field_idx = field_it->second;
+        const auto constraint_flags = constraint.constraints;
+        
+        if (constraint_flags == FieldConstraint::PrimaryKey || constraint_flags == FieldConstraint::PrimaryKeyAuto) {
+            table.primary_key = field_idx;
+            unique_fields.push_back(field_idx);
+            indexed_fields.push_back(field_idx);
+        }
+        else if (constraint_flags == FieldConstraint::Unique || constraint_flags == FieldConstraint::Identity) {
+            unique_fields.push_back(field_idx);
+            indexed_fields.push_back(field_idx);
+        }
+        else if (has_constraint(constraint_flags, FieldConstraint::Indexed)) {
+            indexed_fields.push_back(field_idx);
+        }
+        
+        if (has_constraint(constraint_flags, FieldConstraint::AutoInc)) {
+            autoinc_fields.push_back(field_idx);
+        }
+    }
+    
+    // Sort and deduplicate
+    auto sort_and_dedupe = [](std::vector<uint16_t>& vec) {
+        if (!vec.empty()) {
+            std::sort(vec.begin(), vec.end());
+            vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
+        }
+    };
+    
+    sort_and_dedupe(unique_fields);
+    sort_and_dedupe(indexed_fields);
+    sort_and_dedupe(autoinc_fields);
+    
+    // Move into table
+    table.unique_columns = std::move(unique_fields);
+    table.indexed_columns = std::move(indexed_fields);
+    table.autoinc_columns = std::move(autoinc_fields);
+}
+
+// Extract fields from type and populate table structure
+template<typename T>
+void add_fields_for_type(RawModuleDef::Table& table) {
+    auto algebraic_type = bsatn::bsatn_traits<T>::algebraic_type();
+    
+    if (algebraic_type.tag() != bsatn::AlgebraicTypeTag::Product) {
+        return;
+    }
+    
+    const auto& product = algebraic_type.as_product();
+    const size_t field_count = product.elements.size();
+    
+    table.fields.reserve(field_count);
+    
+    // Type-specific storage for field names
+    static std::map<const std::type_info*, std::vector<std::string>> type_field_storage;
+    auto& field_names = type_field_storage[&typeid(T)];
+    field_names.clear();
+    field_names.reserve(field_count);
+    
+    // Update global descriptors
+    auto& global_descriptors = get_table_descriptors();
+    auto& descriptor = global_descriptors[&typeid(T)];
+    descriptor.fields.clear();
+    descriptor.fields.reserve(field_count);
+    
+    // Process fields
+    for (size_t i = 0; i < field_count; ++i) {
+        const auto& element = product.elements[i];
+        
+        std::string field_name = element.name.has_value() ? 
+            element.name.value() : 
+            "field_" + std::to_string(i);
+        field_names.push_back(std::move(field_name));
+        
+        FieldInfo field;
+        field.name = field_names[i].c_str();
+        field.offset = i * sizeof(void*);
+        field.size = sizeof(void*);
+        field.type_id = 0;
+        field.serialize = [](std::vector<uint8_t>&, const void*) {};
+        table.fields.push_back(field);
+        
+        FieldDescriptor global_field;
+        global_field.name = field_names[i];
+        global_field.offset = field.offset;
+        global_field.size = field.size;
+        global_field.write_type = [](std::vector<uint8_t>&) {};
+        global_field.get_algebraic_type = []() { return bsatn::AlgebraicType::U32(); };
+        global_field.serialize = [](std::vector<uint8_t>&, const void*) {};
+        global_field.get_type_name = []() { return std::string(); };
+        descriptor.fields.push_back(std::move(global_field));
+    }
+}
+
+// Unified table registration - single implementation
+template<typename T>
+void Module::RegisterTableInternalImpl(const char* name, bool is_public, 
+                                      const std::vector<FieldConstraintInfo>& constraints) {
+    RawModuleDef::Table table;
+    table.name = name;
+    table.is_public = is_public;
+    table.type = &typeid(T);
+    
+    add_fields_for_type<T>(table);
+    
+    if (!constraints.empty()) {
+        apply_table_constraints(table, constraints);
+    }
+    
+    // V9 registration - always register tables with V9Builder
+    getV9Builder().RegisterTable<T>(name, is_public);
+    
+    table.serialize = [](std::vector<uint8_t>& buf, const void* obj) {
+        auto& module_def = GetModuleDef();
+        auto it = module_def.table_indices.find(&typeid(T));
+        if (it == module_def.table_indices.end()) return;
+        
+        const auto& table = module_def.tables[it->second];
+        for (const auto& field : table.fields) {
+            field.serialize(buf, obj);
+        }
+    };
+    
+    GetModuleDef().AddTable(std::move(table));
+}
+
+// Overload for tables without constraints
+template<typename T>
+void Module::RegisterTableInternalImpl(const char* name, bool is_public) {
+    RegisterTableInternalImpl<T>(name, is_public, {});
+}
+
+// =============================================================================
+// ARGUMENT DESERIALIZATION
+// =============================================================================
+
+template<typename T>
+T read_arg(uint32_t source) {
+    BytesSource src{source};
+    
+    if constexpr (is_unit_struct_v<T>) {
+        return T{};
+    } else if constexpr (!needs_type_registration_v<T>) {
+        BytesSourceReader reader(src);
+        if constexpr (std::is_same_v<T, bool>) {
+            return reader.read_bool();
+        } else if constexpr (std::is_same_v<T, uint8_t>) {
+            return reader.read_u8();
+        } else if constexpr (std::is_same_v<T, uint16_t>) {
+            return reader.read_u16_le();
+        } else if constexpr (std::is_same_v<T, uint32_t>) {
+            return reader.read_u32_le();
+        } else if constexpr (std::is_same_v<T, uint64_t>) {
+            return reader.read_u64_le();
+        } else if constexpr (std::is_same_v<T, int8_t>) {
+            return reader.read_i8();
+        } else if constexpr (std::is_same_v<T, int16_t>) {
+            return reader.read_i16_le();
+        } else if constexpr (std::is_same_v<T, int32_t>) {
+            return reader.read_i32_le();
+        } else if constexpr (std::is_same_v<T, int64_t>) {
+            return reader.read_i64_le();
+        } else if constexpr (std::is_same_v<T, float>) {
+            return reader.read_f32_le();
+        } else if constexpr (std::is_same_v<T, double>) {
+            return reader.read_f64_le();
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            return reader.read_string();
+        } else {
+            static_assert(!sizeof(T), "Unsupported primitive type");
+        }
+    } else if constexpr (has_bsatn_traits_v<T>) {
+        std::vector<uint8_t> buffer;
+        constexpr size_t CHUNK_SIZE = 256;
+        uint8_t chunk[CHUNK_SIZE];
+        
+        while (true) {
+            size_t requested = CHUNK_SIZE;
+            size_t actual = requested;
+            FFI::bytes_source_read(src, chunk, &actual);
+            
+            if (actual == 0) break;
+            buffer.insert(buffer.end(), chunk, chunk + actual);
+            if (actual < requested) break;
+        }
+        
+        bsatn::Reader reader(buffer);
+        return bsatn::bsatn_traits<T>::deserialize(reader);
+    } else {
+        static_assert(std::is_default_constructible_v<T>, 
+                      "Type must be default constructible or have BSATN traits");
+        return T{};
+    }
+}
+
+// Read multiple arguments as tuple
+template<typename... Args>
+auto read_args_tuple(uint32_t args_source) {
+    BytesSource src{args_source};
+    
+    // Handle single unit struct specially
+    if constexpr (sizeof...(Args) == 1) {
+        using FirstArg = std::tuple_element_t<0, std::tuple<Args...>>;
+        if constexpr (is_unit_struct_v<FirstArg>) {
+            return std::make_tuple(FirstArg{});
+        }
+    }
+    
+    if constexpr ((has_bsatn_traits_v<Args> || ...)) {
+        std::vector<uint8_t> buffer;
+        constexpr size_t CHUNK_SIZE = 256;
+        uint8_t chunk[CHUNK_SIZE];
+        
+        while (true) {
+            size_t requested = CHUNK_SIZE;
+            size_t actual = requested;
+            FFI::bytes_source_read(src, chunk, &actual);
+            
+            if (actual == 0) break;
+            buffer.insert(buffer.end(), chunk, chunk + actual);
+            if (actual < requested) break;
+        }
+        
+        bsatn::Reader reader(buffer);
+        return std::make_tuple(bsatn::bsatn_traits<Args>::deserialize(reader)...);
+    } else {
+        BytesSourceReader reader(src);
+        return std::make_tuple([&reader]() -> Args {
+            if constexpr (std::is_same_v<Args, uint32_t>) {
+                return reader.read_u32_le();
+            } else if constexpr (std::is_same_v<Args, int32_t>) {
+                return reader.read_i32_le();
+            } else if constexpr (std::is_same_v<Args, uint64_t>) {
+                return reader.read_u64_le();
+            } else if constexpr (std::is_same_v<Args, int64_t>) {
+                return reader.read_i64_le();
+            } else if constexpr (std::is_same_v<Args, bool>) {
+                return reader.read_bool();
+            } else if constexpr (std::is_same_v<Args, std::string>) {
+                return reader.read_string();
+            } else {
+                return bsatn::bsatn_traits<Args>::deserialize(reader);
+            }
+        }()...);
+    }
+}
+
+// =============================================================================
+// REDUCER WRAPPERS
+// =============================================================================
+
+// Lifecycle reducer wrapper
+template<typename Func>
+void builtin_reducer_wrapper(Func func, ReducerContext& ctx, 
+                           uint64_t sender_0, uint64_t sender_1, 
+                           uint64_t sender_2, uint64_t sender_3) {
+    std::array<uint8_t, 32> senderBytes{};
+    memcpy(senderBytes.data(), &sender_0, sizeof(uint64_t));
+    memcpy(senderBytes.data() + 8, &sender_1, sizeof(uint64_t));
+    memcpy(senderBytes.data() + 16, &sender_2, sizeof(uint64_t));
+    memcpy(senderBytes.data() + 24, &sender_3, sizeof(uint64_t));
+    Identity sender(senderBytes);
+    
+    if constexpr (std::is_invocable_v<Func, ReducerContext>) {
+        func(ctx);
+    } else if constexpr (std::is_invocable_v<Func, ReducerContext, Identity>) {
+        func(ctx, sender);
+    }
+}
+
+// Generic reducer wrapper
+template<typename... Args>
+void spacetimedb_reducer_wrapper(void (*func)(ReducerContext, Args...), 
+                                ReducerContext& ctx, uint32_t args_source) {
+    if constexpr (sizeof...(Args) == 0) {
+        func(ctx);
+    } else {
+        auto args_tuple = read_args_tuple<Args...>(args_source);
+        std::apply([&](auto&&... args) {
+            func(ctx, std::forward<decltype(args)>(args)...);
+        }, args_tuple);
+    }
+}
+
+// =============================================================================
+// TYPE SERIALIZATION
+// =============================================================================
+
+// Write algebraic type inline (for special types and primitives)
+template<typename T>
+void write_algebraic_type_inline(std::vector<uint8_t>& buf) {
+    if constexpr (is_optional<T>::value) {
+        using inner_type = typename T::value_type;
+        
+        buf.push_back(1); // AlgebraicType::Sum
+        write_u32(buf, 2); // 2 variants
+        
+        buf.push_back(0); // Has name
+        write_string(buf, "some");
+        write_algebraic_type_inline<inner_type>(buf);
+        
+        buf.push_back(0); // Has name
+        write_string(buf, "none");
+        buf.push_back(2); // AlgebraicType::Product (empty)
+        write_u32(buf, 0); // 0 elements
+        
+    } else if constexpr (is_vector_type<T>::value) {
+        using element_type = typename T::value_type;
+        buf.push_back(3); // AlgebraicType::Array
+        write_algebraic_type_inline<element_type>(buf);
+        
+    } else if constexpr (std::is_same_v<T, int32_t>) {
+        buf.push_back(10);
+    } else if constexpr (std::is_same_v<T, uint32_t>) {
+        buf.push_back(11);
+    } else if constexpr (std::is_same_v<T, std::string>) {
+        buf.push_back(4);
+    } else if constexpr (std::is_same_v<T, bool>) {
+        buf.push_back(5);
+    } else if constexpr (std::is_same_v<T, int8_t>) {
+        buf.push_back(6);
+    } else if constexpr (std::is_same_v<T, uint8_t>) {
+        buf.push_back(7);
+    } else if constexpr (std::is_same_v<T, int16_t>) {
+        buf.push_back(8);
+    } else if constexpr (std::is_same_v<T, uint16_t>) {
+        buf.push_back(9);
+    } else if constexpr (std::is_same_v<T, int64_t>) {
+        buf.push_back(12);
+    } else if constexpr (std::is_same_v<T, uint64_t>) {
+        buf.push_back(13);
+    } else if constexpr (std::is_same_v<T, float>) {
+        buf.push_back(18);
+    } else if constexpr (std::is_same_v<T, double>) {
+        buf.push_back(19);
+    } else if constexpr (std::is_same_v<T, u128>) {
+        buf.push_back(15);
+    } else if constexpr (std::is_same_v<T, u256>) {
+        buf.push_back(17);
+    } else if constexpr (std::is_same_v<T, i128>) {
+        buf.push_back(14);
+    } else if constexpr (std::is_same_v<T, i256>) {
+        buf.push_back(16);
+    } else if constexpr (std::is_same_v<T, Identity>) {
+        buf.push_back(2); // AlgebraicType::Product
+        write_u32(buf, 1); // 1 field
+        buf.push_back(0); // Some (has name)
+        write_string(buf, bsatn::IDENTITY_TAG);
+        buf.push_back(17); // AlgebraicType::U256
+    } else if constexpr (std::is_same_v<T, ConnectionId>) {
+        buf.push_back(2); // AlgebraicType::Product
+        write_u32(buf, 1); // 1 field
+        buf.push_back(0); // Some (has name)
+        write_string(buf, bsatn::CONNECTION_ID_TAG);
+        buf.push_back(15); // AlgebraicType::U128
+    } else if constexpr (std::is_same_v<T, Timestamp>) {
+        buf.push_back(2); // AlgebraicType::Product
+        write_u32(buf, 1); // 1 field
+        buf.push_back(0); // Some (has name)
+        write_string(buf, bsatn::TIMESTAMP_TAG);
+        buf.push_back(12); // AlgebraicType::I64
+    } else if constexpr (std::is_same_v<T, TimeDuration>) {
+        buf.push_back(2); // AlgebraicType::Product
+        write_u32(buf, 1); // 1 field
+        buf.push_back(0); // Some (has name)
+        write_string(buf, bsatn::TIME_DURATION_TAG);
+        buf.push_back(12); // AlgebraicType::I64
+    } else if constexpr (std::is_enum_v<T>) {
+        buf.push_back(4); // String fallback for complex enums
+    } else {
+        buf.push_back(4); // AlgebraicType::String fallback
+    }
+}
+
+// =============================================================================
+// REDUCER REGISTRATION
+// =============================================================================
+
+inline std::optional<Lifecycle> get_lifecycle_for_name(const std::string& name) {
+    if (name == "init") return Lifecycle::Init;
+    if (name == "client_connected") return Lifecycle::OnConnect;
+    if (name == "client_disconnected") return Lifecycle::OnDisconnect;
+    return std::nullopt;
+}
+
+// Unified reducer registration
+template<typename... Args>
+void RegisterReducerUnified(const std::string& name, 
+                           void (*func)(ReducerContext, Args...), 
+                           std::optional<Lifecycle> lifecycle = std::nullopt,
+                           const std::vector<std::string>& param_names = {}) {
+    RawModuleDef::Reducer reducer;
+    reducer.name = name;
+    reducer.lifecycle = lifecycle;
+    
+    reducer.handler = [func](ReducerContext& ctx, uint32_t args) {
+        spacetimedb_reducer_wrapper(func, ctx, args);
+    };
+    
+    if constexpr (sizeof...(Args) == 0) {
+        reducer.write_params = [](std::vector<uint8_t>& buf) {
+            write_u32(buf, 0);
+        };
+        reducer.param_names = {};
+    } else {
+        reducer.param_names = param_names;
+    }
+    
+    // V9 registration
+    {
+        auto& v9_builder = getV9Builder();
+        
+        std::vector<bsatn::AlgebraicType> param_types;
+        std::vector<const std::type_info*> param_cpp_types;
+        std::vector<std::string> param_type_names;
+        
+        if constexpr (sizeof...(Args) > 0) {
+            (param_types.push_back(bsatn::bsatn_traits<Args>::algebraic_type()), ...);
+            (param_cpp_types.push_back(&typeid(Args)), ...);
+            param_type_names.resize(sizeof...(Args));
+        }
+        
+        v9_builder.AddV9Reducer(
+            name,
+            param_types,
+            param_names,
+            param_cpp_types,
+            param_type_names,
+            lifecycle
+        );
+    }
+    
+    Module::GetModuleDef().AddReducer(std::move(reducer));
+}
+
+// Lifecycle reducer registration
+inline void RegisterLifecycleReducer(const std::string& name, 
+                             std::optional<Lifecycle> lifecycle,
+                             std::function<void(ReducerContext&, uint32_t)> handler) {
+    auto& v9_builder = getV9Builder();
+    
+    v9_builder.AddV9Reducer(
+        name,
+        {},
+        {},
+        {},
+        {},
+        lifecycle
+    );
+    
+    RawModuleDef::Reducer reducer;
+    reducer.name = name;
+    reducer.lifecycle = lifecycle;
+    reducer.handler = handler;
+    reducer.write_params = [](std::vector<uint8_t>& buf) {
+        write_u32(buf, 0);
+    };
+    
+    Module::GetModuleDef().AddReducer(std::move(reducer));
+}
+
+template<typename... Args>
+void Module::RegisterReducerInternalImpl(const std::string& name, void (*func)(ReducerContext, Args...)) {
+    RegisterReducerUnified(name, func, get_lifecycle_for_name(name));
+}
+
+template<typename... Args>
+void Module::RegisterReducerInternalWithNames(const std::string& name, void (*func)(ReducerContext, Args...), const std::vector<std::string>& param_names) {
+    RegisterReducerUnified(name, func, get_lifecycle_for_name(name), param_names);
+}
+
+inline void Module::RegisterInitReducer(void (*func)(ReducerContext)) {
+    RegisterLifecycleReducer("init", Lifecycle::Init, 
+        [func](ReducerContext& ctx, uint32_t) { func(ctx); });
+}
+
+inline void Module::RegisterClientConnectedReducer(void (*func)(ReducerContext, Identity)) {
+    RegisterLifecycleReducer("client_connected", Lifecycle::OnConnect,
+        [func](ReducerContext& ctx, uint32_t) { func(ctx, ctx.sender); });
+}
+
+inline void Module::RegisterClientDisconnectedReducer(void (*func)(ReducerContext, Identity)) {
+    RegisterLifecycleReducer("client_disconnected", Lifecycle::OnDisconnect,
+        [func](ReducerContext& ctx, uint32_t) { func(ctx, ctx.sender); });
+}
+
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+
+template<typename T>
+void register_table_type(const char* name, bool is_public) {
+    Module::RegisterTableInternalImpl<T>(name, is_public);
+}
+
+// Optimized parameter name parsing
+inline std::vector<std::string> parse_parameter_names(const std::string& params_str) {
+    std::vector<std::string> names;
+    
+    size_t pos = 0;
+    bool first_param = true;
+    
+    while (pos < params_str.length()) {
+        size_t comma_pos = params_str.find(',', pos);
+        if (comma_pos == std::string::npos) comma_pos = params_str.length();
+        
+        std::string param = params_str.substr(pos, comma_pos - pos);
+        
+        // Skip ReducerContext
+        if (first_param) {
+            first_param = false;
+            pos = comma_pos + 1;
+            continue;
+        }
+        
+        // Trim whitespace
+        size_t start = param.find_first_not_of(" \t");
+        if (start != std::string::npos) {
+            param = param.substr(start);
+            size_t end = param.find_last_not_of(" \t");
+            if (end != std::string::npos) {
+                param = param.substr(0, end + 1);
+            }
+        }
+        
+        // Extract parameter name
+        size_t last_space = param.find_last_of(" \t");
+        if (last_space != std::string::npos) {
+            std::string param_name = param.substr(last_space + 1);
+            size_t name_end = param_name.find_first_of("&*[]");
+            if (name_end != std::string::npos) {
+                param_name = param_name.substr(0, name_end);
+            }
+            names.push_back(std::move(param_name));
+        }
+        
+        pos = comma_pos + 1;
+    }
+    
+    return names;
+}
+
+} // namespace Internal
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_MODULE_IMPL_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/README.md b/crates/bindings-cpp/include/spacetimedb/internal/README.md
new file mode 100644
index 00000000000..690e6e13c8d
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/README.md
@@ -0,0 +1,101 @@
+# SpacetimeDB C++ Module Library Internal API
+
+This directory contains the internal implementation of the SpacetimeDB C++ Module Library, matching the design of the C# bindings.
+
+## Overview
+
+The Internal API provides:
+- **Module Definition Management**: Automatic generation of module definitions using autogenerated types
+- **Type Registration**: Type-safe registration system for tables and reducers
+- **FFI Wrappers**: Safe wrappers around the SpacetimeDB ABI
+- **Table Operations**: Type-safe CRUD operations on tables
+- **Reducer System**: Framework for implementing reducers with proper serialization
+
+## Directory Structure
+
+- `autogen/` - Autogenerated types from Rust definitions (RawModuleDefV9, RawTableDefV9, etc.)
+- `Module.h/cpp` - Main module management and registration
+ 
+- `FFI.h/cpp` - Foreign Function Interface definitions
+
+## Key Components
+
+### 1. Module Registration
+
+The `Module` class is a singleton that manages:
+- Table registration
+- Reducer registration
+- Type registration
+- Module description generation
+- Reducer invocation
+
+### 2. Autogenerated Types
+
+All module definition types are generated from the Rust codebase:
+- `RawModuleDefV9` - Main module definition
+- `RawTableDefV9` - Table definitions
+- `RawReducerDefV9` - Reducer definitions
+- `TableAccess`, `TableType`, etc. - Enums and supporting types
+
+### 3. Table Implementation
+
+Tables are implemented using the `SPACETIMEDB_TABLE` macro system:
+1. Define row types with field registration using `SPACETIMEDB_MODULE_STRUCT` (modules) or `SPACETIMEDB_STRUCT` (clients)
+2. Register tables with `SPACETIMEDB_TABLE(Type, "name", Access, ...constraints)`
+3. Use `ctx.db.table<T>("name")` for table operations (insert, delete)
+4. Tables are automatically registered during module initialization via `__preinit__` functions
+
+### 4. Reducer Implementation
+
+Reducers are implemented using unified macro system:
+1. `SPACETIMEDB_REDUCER(name, ReducerContext ctx, ...params)` - User-defined reducers
+2. `SPACETIMEDB_INIT(name)` - Module initialization
+3. `SPACETIMEDB_CLIENT_CONNECTED(name)` - Client connection handler
+4. `SPACETIMEDB_CLIENT_DISCONNECTED(name)` - Client disconnection handler
+5. The macros handle serialization, registration, and ABI integration automatically
+
+## Usage Example
+
+```cpp
+// Define row type with field registration
+struct Person {
+    uint32_t id;
+    std::string name;
+    uint8_t age;
+};
+SPACETIMEDB_MODULE_STRUCT(Person, id, name, age);
+
+// Define table with constraints
+SPACETIMEDB_TABLE(Person, "people", Public,
+    PrimaryKeyAutoInc(id),
+    Index(name)
+);
+
+// Define reducer with ReducerContext
+SPACETIMEDB_REDUCER(add_person, ReducerContext ctx, std::string name, uint8_t age) {
+    // Access table and insert record
+    Person person{0, name, age}; // id will be auto-generated
+    ctx.db.table<Person>("people").insert(person);
+    LOG_INFO("Added person: " + name);
+}
+
+// Lifecycle reducers
+SPACETIMEDB_INIT(init) {
+    LOG_INFO("Module initialized!");
+}
+
+SPACETIMEDB_CLIENT_CONNECTED(on_connect) {
+    LOG_INFO("Client connected!");
+}
+```
+
+## Migration from Old API
+
+See `MIGRATION_GUIDE.md` for detailed steps on migrating from the manual module definition approach to this new Internal API.
+
+## Future Improvements
+
+- Automatic BSATN serialization generation
+- Macro-based table/reducer definitions
+- Query builder API
+- Index management
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/AlgebraicType.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/AlgebraicType.g.h
new file mode 100644
index 00000000000..96d40c17fda
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/AlgebraicType.g.h
@@ -0,0 +1,96 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include <variant>
+#include "spacetimedb/bsatn/bsatn.h"
+#include "../forward_declarations.h"
+
+namespace SpacetimeDb::Internal {
+
+// AlgebraicType is special - it uses pointers to break circular dependencies
+// This is a custom implementation due to circular references between:
+// AlgebraicType -> SumType -> SumTypeVariant -> AlgebraicType
+// AlgebraicType -> ProductType -> ProductTypeElement -> AlgebraicType
+class AlgebraicType {
+public:
+    enum class Tag : uint8_t {
+        Ref = 0,
+        Sum = 1, 
+        Product = 2,
+        Array = 3,
+        String = 4,
+        Bool = 5,
+        I8 = 6,
+        U8 = 7,
+        I16 = 8,
+        U16 = 9,
+        I32 = 10,
+        U32 = 11,
+        I64 = 12,
+        U64 = 13,
+        I128 = 14,
+        U128 = 15,
+        I256 = 16,
+        U256 = 17,
+        F32 = 18,
+        F64 = 19
+    };
+
+    using DataType = std::variant<
+        uint32_t,                                          // Ref
+        std::unique_ptr<SpacetimeDb::Internal::SumType>,   // Sum
+        std::unique_ptr<SpacetimeDb::Internal::ProductType>, // Product 
+        std::unique_ptr<SpacetimeDb::Internal::AlgebraicType>, // Array element type
+        std::monostate  // All primitive types (String, Bool, I8, U8, etc.)
+    >;
+
+private:
+    Tag tag_;
+    DataType data_;
+
+public:
+    AlgebraicType();
+    AlgebraicType(Tag primitive_tag);
+    AlgebraicType(const AlgebraicType& other);
+    AlgebraicType& operator=(const AlgebraicType& other);
+    
+    Tag get_tag() const { return tag_; }
+    
+    template<size_t Index>
+    const auto& get() const { return std::get<Index>(data_); }
+
+    template<size_t Index>
+    auto& get() { return std::get<Index>(data_); }
+
+    template<size_t Index, typename T>
+    void set(T&& value);
+
+    template<size_t Index>
+    bool is() const { return tag_ == static_cast<Tag>(Index); }
+
+    template<typename Visitor>
+    auto visit(Visitor&& visitor) const -> decltype(auto) {
+        return std::visit(std::forward<Visitor>(visitor), data_);
+    }
+
+    template<typename Visitor>  
+    auto visit(Visitor&& visitor) -> decltype(auto) {
+        return std::visit(std::forward<Visitor>(visitor), data_);
+    }
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const;
+
+    bool operator==(const AlgebraicType& other) const;
+    bool operator!=(const AlgebraicType& other) const { return !(*this == other); }
+};
+
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/Lifecycle.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/Lifecycle.g.h
new file mode 100644
index 00000000000..458031af2e0
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/Lifecycle.g.h
@@ -0,0 +1,23 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+enum class Lifecycle : uint8_t {
+    Init = 0,
+    OnConnect = 1,
+    OnDisconnect = 2,
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/ProductType.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/ProductType.g.h
new file mode 100644
index 00000000000..43d4bcbb000
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/ProductType.g.h
@@ -0,0 +1,27 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "ProductTypeElement.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(ProductType) {
+    std::vector<SpacetimeDb::Internal::ProductTypeElement> elements;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, elements);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(elements)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/ProductTypeElement.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/ProductTypeElement.g.h
new file mode 100644
index 00000000000..e459dd7b07a
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/ProductTypeElement.g.h
@@ -0,0 +1,29 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "AlgebraicType.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(ProductTypeElement) {
+    std::optional<std::string> name;
+    SpacetimeDb::Internal::AlgebraicType algebraic_type;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, algebraic_type);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, algebraic_type)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawConstraintDataV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawConstraintDataV9.g.h
new file mode 100644
index 00000000000..cc8543973f8
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawConstraintDataV9.g.h
@@ -0,0 +1,20 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "RawUniqueConstraintDataV9.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_TAGGED_ENUM(RawConstraintDataV9, SpacetimeDb::Internal::RawUniqueConstraintDataV9)
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawConstraintDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawConstraintDefV9.g.h
new file mode 100644
index 00000000000..c90eb9049a9
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawConstraintDefV9.g.h
@@ -0,0 +1,29 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "RawConstraintDataV9.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawConstraintDefV9) {
+    std::optional<std::string> name;
+    SpacetimeDb::Internal::RawConstraintDataV9 data;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, data);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, data)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawIndexAlgorithm.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawIndexAlgorithm.g.h
new file mode 100644
index 00000000000..14a416116ca
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawIndexAlgorithm.g.h
@@ -0,0 +1,51 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+// BTree algorithm data
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawIndexAlgorithmBTreeData) {
+    std::vector<uint16_t> columns;
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, columns);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(columns)
+};
+
+// Hash algorithm data (not currently used)
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawIndexAlgorithmHashData) {
+    std::vector<uint16_t> columns;
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, columns);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(columns)
+};
+
+// Direct algorithm data (not currently used)
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawIndexAlgorithmDirectData) {
+    uint16_t column;
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, column);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(column)
+};
+
+// RawIndexAlgorithm tagged enum with data variants
+SPACETIMEDB_INTERNAL_TAGGED_ENUM(RawIndexAlgorithm, 
+    SpacetimeDb::Internal::RawIndexAlgorithmBTreeData,
+    SpacetimeDb::Internal::RawIndexAlgorithmHashData,
+    SpacetimeDb::Internal::RawIndexAlgorithmDirectData
+)
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawIndexDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawIndexDefV9.g.h
new file mode 100644
index 00000000000..dfa44c6f776
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawIndexDefV9.g.h
@@ -0,0 +1,31 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "RawIndexAlgorithm.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawIndexDefV9) {
+    std::optional<std::string> name;
+    std::optional<std::string> accessor_name;
+    SpacetimeDb::Internal::RawIndexAlgorithm algorithm;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, accessor_name);
+        ::SpacetimeDb::bsatn::serialize(writer, algorithm);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, accessor_name, algorithm)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawMiscModuleExportV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawMiscModuleExportV9.g.h
new file mode 100644
index 00000000000..a9d829b56e8
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawMiscModuleExportV9.g.h
@@ -0,0 +1,20 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+enum class RawMiscModuleExportV9 : uint8_t {
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawModuleDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawModuleDefV9.g.h
new file mode 100644
index 00000000000..a2a3c23f8c1
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawModuleDefV9.g.h
@@ -0,0 +1,42 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "RawReducerDefV9.g.h"
+#include "RawTableDefV9.g.h"
+#include "RawMiscModuleExportV9.g.h"
+#include "Typespace.g.h"
+#include "RawTypeDefV9.g.h"
+#include "RawRowLevelSecurityDefV9.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawModuleDefV9) {
+    SpacetimeDb::Internal::Typespace typespace;
+    std::vector<SpacetimeDb::Internal::RawTableDefV9> tables;
+    std::vector<SpacetimeDb::Internal::RawReducerDefV9> reducers;
+    std::vector<SpacetimeDb::Internal::RawTypeDefV9> types;
+    std::vector<SpacetimeDb::Internal::RawMiscModuleExportV9> misc_exports;
+    std::vector<SpacetimeDb::Internal::RawRowLevelSecurityDefV9> row_level_security;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, typespace);
+        ::SpacetimeDb::bsatn::serialize(writer, tables);
+        ::SpacetimeDb::bsatn::serialize(writer, reducers);
+        ::SpacetimeDb::bsatn::serialize(writer, types);
+        ::SpacetimeDb::bsatn::serialize(writer, misc_exports);
+        ::SpacetimeDb::bsatn::serialize(writer, row_level_security);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(typespace, tables, reducers, types, misc_exports, row_level_security)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawReducerDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawReducerDefV9.g.h
new file mode 100644
index 00000000000..bc4ec0605da
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawReducerDefV9.g.h
@@ -0,0 +1,32 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "Lifecycle.g.h"
+#include "ProductType.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawReducerDefV9) {
+    std::string name;
+    SpacetimeDb::Internal::ProductType params;
+    std::optional<SpacetimeDb::Internal::Lifecycle> lifecycle;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, params);
+        ::SpacetimeDb::bsatn::serialize(writer, lifecycle);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, params, lifecycle)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawRowLevelSecurityDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawRowLevelSecurityDefV9.g.h
new file mode 100644
index 00000000000..5a2af847a62
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawRowLevelSecurityDefV9.g.h
@@ -0,0 +1,26 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawRowLevelSecurityDefV9) {
+    std::string sql;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, sql);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(sql)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawScheduleDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawScheduleDefV9.g.h
new file mode 100644
index 00000000000..54feaef20c5
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawScheduleDefV9.g.h
@@ -0,0 +1,30 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawScheduleDefV9) {
+    std::optional<std::string> name;
+    std::string reducer_name;
+    uint16_t scheduled_at_column;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, reducer_name);
+        ::SpacetimeDb::bsatn::serialize(writer, scheduled_at_column);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, reducer_name, scheduled_at_column)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawScopedTypeNameV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawScopedTypeNameV9.g.h
new file mode 100644
index 00000000000..05936b17678
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawScopedTypeNameV9.g.h
@@ -0,0 +1,28 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawScopedTypeNameV9) {
+    std::vector<std::string> scope;
+    std::string name;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, scope);
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(scope, name)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawSequenceDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawSequenceDefV9.g.h
new file mode 100644
index 00000000000..05a6ade1566
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawSequenceDefV9.g.h
@@ -0,0 +1,36 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawSequenceDefV9) {
+    std::optional<std::string> name;
+    uint16_t column;
+    std::optional<SpacetimeDb::I128> start;
+    std::optional<SpacetimeDb::I128> min_value;
+    std::optional<SpacetimeDb::I128> max_value;
+    SpacetimeDb::I128 increment;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, column);
+        ::SpacetimeDb::bsatn::serialize(writer, start);
+        ::SpacetimeDb::bsatn::serialize(writer, min_value);
+        ::SpacetimeDb::bsatn::serialize(writer, max_value);
+        ::SpacetimeDb::bsatn::serialize(writer, increment);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, column, start, min_value, max_value, increment)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawTableDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawTableDefV9.g.h
new file mode 100644
index 00000000000..1ff1194f8cd
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawTableDefV9.g.h
@@ -0,0 +1,48 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "RawScheduleDefV9.g.h"
+#include "RawSequenceDefV9.g.h"
+#include "TableType.g.h"
+#include "TableAccess.g.h"
+#include "RawIndexDefV9.g.h"
+#include "RawConstraintDefV9.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawTableDefV9) {
+    std::string name;
+    uint32_t product_type_ref;
+    std::vector<uint16_t> primary_key;
+    std::vector<SpacetimeDb::Internal::RawIndexDefV9> indexes;
+    std::vector<SpacetimeDb::Internal::RawConstraintDefV9> constraints;
+    std::vector<SpacetimeDb::Internal::RawSequenceDefV9> sequences;
+    std::optional<SpacetimeDb::Internal::RawScheduleDefV9> schedule;
+    SpacetimeDb::Internal::TableType table_type;
+    SpacetimeDb::Internal::TableAccess table_access;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, product_type_ref);
+        ::SpacetimeDb::bsatn::serialize(writer, primary_key);
+        ::SpacetimeDb::bsatn::serialize(writer, indexes);
+        ::SpacetimeDb::bsatn::serialize(writer, constraints);
+        ::SpacetimeDb::bsatn::serialize(writer, sequences);
+        ::SpacetimeDb::bsatn::serialize(writer, schedule);
+        ::SpacetimeDb::bsatn::serialize(writer, table_type);
+        ::SpacetimeDb::bsatn::serialize(writer, table_access);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, product_type_ref, primary_key, indexes, constraints, sequences, schedule, table_type, table_access)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawTypeDefV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawTypeDefV9.g.h
new file mode 100644
index 00000000000..be13be3edf4
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawTypeDefV9.g.h
@@ -0,0 +1,31 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "RawScopedTypeNameV9.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawTypeDefV9) {
+    SpacetimeDb::Internal::RawScopedTypeNameV9 name;
+    uint32_t ty;
+    bool custom_ordering;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, ty);
+        ::SpacetimeDb::bsatn::serialize(writer, custom_ordering);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, ty, custom_ordering)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawUniqueConstraintDataV9.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawUniqueConstraintDataV9.g.h
new file mode 100644
index 00000000000..c2e7ad2811a
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/RawUniqueConstraintDataV9.g.h
@@ -0,0 +1,26 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawUniqueConstraintDataV9) {
+    std::vector<uint16_t> columns;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, columns);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(columns)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/SumType.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/SumType.g.h
new file mode 100644
index 00000000000..30966ddbe7e
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/SumType.g.h
@@ -0,0 +1,27 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "SumTypeVariant.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(SumType) {
+    std::vector<SpacetimeDb::Internal::SumTypeVariant> variants;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, variants);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(variants)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/SumTypeVariant.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/SumTypeVariant.g.h
new file mode 100644
index 00000000000..90fb0d2ed95
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/SumTypeVariant.g.h
@@ -0,0 +1,29 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "AlgebraicType.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(SumTypeVariant) {
+    std::optional<std::string> name;
+    SpacetimeDb::Internal::AlgebraicType algebraic_type;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, name);
+        ::SpacetimeDb::bsatn::serialize(writer, algebraic_type);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(name, algebraic_type)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/TableAccess.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/TableAccess.g.h
new file mode 100644
index 00000000000..246ba98b29d
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/TableAccess.g.h
@@ -0,0 +1,22 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+enum class TableAccess : uint8_t {
+    Public = 0,
+    Private = 1,
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/TableType.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/TableType.g.h
new file mode 100644
index 00000000000..52f3e94dd6c
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/TableType.g.h
@@ -0,0 +1,22 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+enum class TableType : uint8_t {
+    System = 0,
+    User = 1,
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen/Typespace.g.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen/Typespace.g.h
new file mode 100644
index 00000000000..0291605c122
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen/Typespace.g.h
@@ -0,0 +1,27 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include "../autogen_base.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "AlgebraicType.g.h"
+
+namespace SpacetimeDb::Internal {
+
+SPACETIMEDB_INTERNAL_PRODUCT_TYPE(Typespace) {
+    std::vector<SpacetimeDb::Internal::AlgebraicType> types;
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+        ::SpacetimeDb::bsatn::serialize(writer, types);
+    }
+    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(types)
+};
+} // namespace SpacetimeDb::Internal
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/autogen_base.h b/crates/bindings-cpp/include/spacetimedb/internal/autogen_base.h
new file mode 100644
index 00000000000..1c024fba219
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/autogen_base.h
@@ -0,0 +1,124 @@
+#pragma once
+
+// Autogenerated Type Support
+// This file provides base classes and macros exclusively for the autogenerated
+// internal types used in the V9 module definition system.
+
+#include <variant>
+#include <cstdint>
+#include <tuple>
+#include "../bsatn/bsatn.h"
+
+namespace SpacetimeDb::Internal {
+
+// =============================================================================
+// TAGGED ENUM BASE CLASS (for autogenerated sum types)
+// =============================================================================
+
+template<typename... Variants>
+class TaggedEnumBase {
+    static_assert(sizeof...(Variants) > 0, "TaggedEnum must have at least one variant");
+
+protected:
+    std::variant<Variants...> data_;
+
+public:
+    // Default constructor - initializes to first variant
+    TaggedEnumBase() : data_{} {}
+
+    // Get current tag (variant index)
+    uint8_t get_tag() const noexcept {
+        return static_cast<uint8_t>(data_.index());
+    }
+
+    // Get variant by index (const)
+    template<size_t Index>
+    const auto& get() const {
+        return std::get<Index>(data_);
+    }
+
+    // Get variant by index (mutable)  
+    template<size_t Index>
+    auto& get() {
+        return std::get<Index>(data_);
+    }
+
+    // Set variant by index
+    template<size_t Index, typename T>
+    void set(T&& value) {
+        data_.template emplace<Index>(std::forward<T>(value));
+    }
+
+    // Check if currently holds specific index
+    template<size_t Index>
+    bool is() const noexcept {
+        return data_.index() == Index;
+    }
+
+    // Visit pattern - used for serialization
+    template<typename Visitor>
+    auto visit(Visitor&& visitor) const {
+        return std::visit(std::forward<Visitor>(visitor), data_);
+    }
+
+    // Equality
+    bool operator==(const TaggedEnumBase& other) const noexcept {
+        return data_ == other.data_;
+    }
+
+    bool operator!=(const TaggedEnumBase& other) const noexcept {
+        return !(*this == other);
+    }
+};
+
+} // namespace SpacetimeDb::Internal
+
+// =============================================================================
+// MACROS FOR AUTOGENERATED INTERNAL TYPES
+// =============================================================================
+
+// Macro for internal tagged enums (sum types)
+// Generates a class that inherits from TaggedEnumBase and adds BSATN serialization
+#define SPACETIMEDB_INTERNAL_TAGGED_ENUM(TypeName, ...) \
+    class TypeName : public ::SpacetimeDb::Internal::TaggedEnumBase<__VA_ARGS__> { \
+    private: \
+        using Base = ::SpacetimeDb::Internal::TaggedEnumBase<__VA_ARGS__>; \
+    public: \
+        using Base::Base; \
+        using Base::get_tag; \
+        using Base::get; \
+        using Base::set; \
+        using Base::is; \
+        using Base::visit; \
+        using Base::operator==; \
+        using Base::operator!=; \
+        \
+        void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const { \
+            /* Write tag (variant index) */ \
+            writer.write_u8(this->get_tag()); \
+            /* Write variant data based on current tag */ \
+            this->visit([&writer](const auto& variant) { \
+                using VariantType = std::decay_t<decltype(variant)>; \
+                if constexpr (!std::is_same_v<VariantType, std::monostate>) { \
+                    /* Non-unit variant - serialize the data */ \
+                    ::SpacetimeDb::bsatn::serialize(writer, variant); \
+                } \
+                /* Unit variant - write nothing */ \
+            }); \
+        } \
+    };
+
+// Macro for internal product types (structs)
+// Just creates a simple struct - no base class needed
+#define SPACETIMEDB_INTERNAL_PRODUCT_TYPE(TypeName) \
+    struct TypeName
+
+// Macro for product type equality - generates == and != operators
+// This generates a simple equality comparison using std::tie
+#define SPACETIMEDB_PRODUCT_TYPE_EQUALITY(...) \
+    bool operator==(const auto& other) const noexcept { \
+        return std::tie(__VA_ARGS__) == std::tie(other.__VA_ARGS__); \
+    } \
+    bool operator!=(const auto& other) const noexcept { \
+        return !(*this == other); \
+    }
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/bsatn_adapters.h b/crates/bindings-cpp/include/spacetimedb/internal/bsatn_adapters.h
new file mode 100644
index 00000000000..f63770a3712
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/bsatn_adapters.h
@@ -0,0 +1,126 @@
+#pragma once
+
+#include <spacetimedb/bsatn/writer.h>
+#include <spacetimedb/bsatn/reader.h>
+#include <spacetimedb/abi/FFI.h>
+#include <vector>
+#include <cstdint>
+
+namespace SpacetimeDb {
+namespace Internal {
+
+/**
+ * Adapter class that allows using BSATN Reader with BytesSource
+ * 
+ * This is needed because FFI uses BytesSource handles while our
+ * BSATN system uses Reader objects. This adapter bridges the gap.
+ */
+class BytesSourceReader {
+private:
+    BytesSource source_;
+    
+public:
+    explicit BytesSourceReader(BytesSource source) : source_(source) {}
+    
+    void read_bytes(uint8_t* buffer, size_t len) {
+        size_t bytes_read = len;
+        FFI::bytes_source_read(source_, buffer, &bytes_read);
+        if (bytes_read != len) {
+            std::abort(); // Failed to read expected number of bytes
+        }
+    }
+    
+    uint8_t read_u8() {
+        uint8_t value;
+        read_bytes(&value, 1);
+        return value;
+    }
+    
+    uint16_t read_u16_le() {
+        uint8_t bytes[2];
+        read_bytes(bytes, 2);
+        return bytes[0] | (static_cast<uint16_t>(bytes[1]) << 8);
+    }
+    
+    uint32_t read_u32_le() {
+        uint8_t bytes[4];
+        read_bytes(bytes, 4);
+        return bytes[0] | 
+               (static_cast<uint32_t>(bytes[1]) << 8) |
+               (static_cast<uint32_t>(bytes[2]) << 16) |
+               (static_cast<uint32_t>(bytes[3]) << 24);
+    }
+    
+    uint64_t read_u64_le() {
+        uint8_t bytes[8];
+        read_bytes(bytes, 8);
+        uint64_t result = 0;
+        for (int i = 0; i < 8; ++i) {
+            result |= static_cast<uint64_t>(bytes[i]) << (i * 8);
+        }
+        return result;
+    }
+    
+    int8_t read_i8() { return static_cast<int8_t>(read_u8()); }
+    int16_t read_i16_le() { return static_cast<int16_t>(read_u16_le()); }
+    int32_t read_i32_le() { return static_cast<int32_t>(read_u32_le()); }
+    int64_t read_i64_le() { return static_cast<int64_t>(read_u64_le()); }
+    
+    float read_f32_le() {
+        uint32_t bits = read_u32_le();
+        float value;
+        std::memcpy(&value, &bits, sizeof(float));
+        return value;
+    }
+    
+    double read_f64_le() {
+        uint64_t bits = read_u64_le();
+        double value;
+        std::memcpy(&value, &bits, sizeof(double));
+        return value;
+    }
+    
+    std::string read_string() {
+        uint32_t len = read_u32_le();
+        std::string result(len, '\0');
+        read_bytes(reinterpret_cast<uint8_t*>(&result[0]), len);
+        return result;
+    }
+    
+    std::vector<uint8_t> read_fixed_bytes(size_t len) {
+        std::vector<uint8_t> result(len);
+        read_bytes(result.data(), len);
+        return result;
+    }
+    
+    // For compatibility with BSATN Reader interface
+    bool read_bool() { return read_u8() != 0; }
+    
+    // Big integer support
+    ::SpacetimeDb::u128 read_u128_le() {
+        uint64_t low = read_u64_le();
+        uint64_t high = read_u64_le();
+        return ::SpacetimeDb::u128(high, low);
+    }
+    
+    ::SpacetimeDb::i128 read_i128_le() {
+        uint64_t low = read_u64_le();
+        uint64_t high = read_u64_le();
+        return ::SpacetimeDb::i128(static_cast<int64_t>(high), low);
+    }
+    
+    ::SpacetimeDb::u256 read_u256_le() {
+        ::SpacetimeDb::u256 result;
+        read_bytes(result.data.data(), 32);
+        return result;
+    }
+    
+    ::SpacetimeDb::i256 read_i256_le() {
+        ::SpacetimeDb::i256 result;
+        read_bytes(result.data.data(), 32);
+        return result;
+    }
+};
+
+} // namespace Internal
+} // namespace SpacetimeDb
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/debug.h b/crates/bindings-cpp/include/spacetimedb/internal/debug.h
new file mode 100644
index 00000000000..4f64d361c15
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/debug.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <cstdio>
+
+/**
+ * @file debug.h
+ * @brief Conditional debugging macros for SpacetimeDB C++ bindings
+ * 
+ * This header provides conditional debugging output that can be enabled/disabled
+ * at compile time to reduce runtime overhead and output clutter.
+ */
+
+// Control debug output with compile-time flag
+#ifdef SPACETIMEDB_DEBUG
+    #define STDB_DEBUG_ENABLED 1
+#else
+    #define STDB_DEBUG_ENABLED 0
+#endif
+
+/**
+ * @brief Main debug macro - outputs to stderr with [STDB] prefix
+ * 
+ * Usage: STDB_DEBUG("Type %s registered with index %u", type_name.c_str(), index);
+ * 
+ * When SPACETIMEDB_DEBUG is not defined, this compiles to nothing (zero overhead).
+ */
+#if STDB_DEBUG_ENABLED
+    #define STDB_DEBUG(fmt, ...) \
+        fprintf(stderr, "[STDB] " fmt "\n", ##__VA_ARGS__)
+#else
+    #define STDB_DEBUG(fmt, ...) ((void)0)
+#endif
+
+/**
+ * @brief Verbose debug macro for detailed tracing
+ * 
+ * Usage: STDB_VERBOSE("Processing field %zu: %s", i, field_name);
+ * 
+ * Even more detailed than STDB_DEBUG, only enabled with SPACETIMEDB_VERBOSE.
+ */
+#ifdef SPACETIMEDB_VERBOSE
+    #define STDB_VERBOSE(fmt, ...) \
+        fprintf(stderr, "[STDB:VERBOSE] " fmt "\n", ##__VA_ARGS__)
+#else
+    #define STDB_VERBOSE(fmt, ...) ((void)0)
+#endif
+
+/**
+ * @brief Error output (always enabled)
+ * 
+ * Usage: STDB_ERROR("Failed to register type: %s", error_msg);
+ * 
+ * Always outputs regardless of debug flags.
+ */
+#define STDB_ERROR(fmt, ...) \
+    fprintf(stderr, "[STDB:ERROR] " fmt "\n", ##__VA_ARGS__)
+
+/**
+ * @brief Warning output (always enabled)
+ * 
+ * Usage: STDB_WARN("Type %s already registered", type_name);
+ * 
+ * Always outputs regardless of debug flags.
+ */
+#define STDB_WARN(fmt, ...) \
+    fprintf(stderr, "[STDB:WARN] " fmt "\n", ##__VA_ARGS__)
+
+/**
+ * @brief Conditional debug macro for specific subsystems
+ * 
+ * Usage: STDB_DEBUG_TYPE("Registered enum %s", enum_name);
+ * 
+ * Can be independently controlled with SPACETIMEDB_DEBUG_TYPE.
+ */
+#ifdef SPACETIMEDB_DEBUG_TYPE
+    #define STDB_DEBUG_TYPE(fmt, ...) \
+        fprintf(stderr, "[STDB:TYPE] " fmt "\n", ##__VA_ARGS__)
+#else
+    #define STDB_DEBUG_TYPE(fmt, ...) ((void)0)
+#endif
+
+// Usage example in code:
+// #define SPACETIMEDB_DEBUG  // Enable general debugging
+// #include "debug.h"
+// 
+// void registerType() {
+//     STDB_DEBUG("Starting type registration");
+//     STDB_VERBOSE("Detailed step-by-step trace");
+//     STDB_ERROR("Something went wrong");
+//     STDB_WARN("Non-fatal issue");
+// }
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/field_registration.h b/crates/bindings-cpp/include/spacetimedb/internal/field_registration.h
new file mode 100644
index 00000000000..2d9d338ffd6
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/field_registration.h
@@ -0,0 +1,400 @@
+#ifndef SPACETIMEDB_FIELD_REGISTRATION_H
+#define SPACETIMEDB_FIELD_REGISTRATION_H
+
+#include <cstdint>
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <optional>
+#include <variant>
+#include <type_traits>
+#include "../macros.h"
+#include <functional>
+#include <map>
+#include <typeinfo>
+#include "spacetimedb/bsatn/types.h"
+#include "spacetimedb/bsatn/timestamp.h"
+#include "spacetimedb/bsatn/algebraic_type.h"
+#include "spacetimedb/bsatn/writer.h"
+#include "spacetimedb/bsatn/traits.h"
+
+namespace SpacetimeDb {
+
+// Helper templates for type detection
+template<typename T>
+struct is_vector : std::false_type {};
+template<typename T>
+struct is_vector<std::vector<T>> : std::true_type {};
+
+template<typename T>
+struct is_optional : std::false_type {};
+template<typename T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+// =============================================================================
+// Field Registration System
+// =============================================================================
+// 
+// This system provides runtime metadata about struct fields for SpacetimeDB
+// table registration. It bridges C++ compile-time type information to 
+// SpacetimeDB's runtime type system.
+//
+// Primary use cases:
+// - Table schema generation from C++ structs
+// - Field constraint application
+// - Type validation
+// - Cross-language compatibility
+//
+// Note: For most use cases, prefer SPACETIMEDB_STRUCT from traits.h
+// which provides both serialization and field registration in one macro.
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+// Type System Mapping
+// -----------------------------------------------------------------------------
+
+// Type traits for BSATN type mapping - simplified to use AlgebraicTypeTag directly
+template<typename T> 
+struct bsatn_type_id { 
+    static constexpr bool is_primitive = false;
+    static constexpr uint8_t value = 0; 
+};
+
+// Primitive type specializations
+template<> struct bsatn_type_id<bool> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::Bool); 
+};
+template<> struct bsatn_type_id<uint8_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U8); 
+};
+template<> struct bsatn_type_id<uint16_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U16); 
+};
+template<> struct bsatn_type_id<uint32_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U32); 
+};
+template<> struct bsatn_type_id<uint64_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U64); 
+};
+template<> struct bsatn_type_id<int8_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::I8); 
+};
+template<> struct bsatn_type_id<int16_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::I16); 
+};
+template<> struct bsatn_type_id<int32_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::I32); 
+};
+template<> struct bsatn_type_id<int64_t> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::I64); 
+};
+template<> struct bsatn_type_id<float> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::F32); 
+};
+template<> struct bsatn_type_id<double> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::F64); 
+};
+template<> struct bsatn_type_id<std::string> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::String); 
+};
+
+// SpacetimeDB special types
+template<> struct bsatn_type_id<Identity> { 
+    static constexpr bool is_primitive = false;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::Product); 
+};
+template<> struct bsatn_type_id<ConnectionId> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U64); 
+};
+template<> struct bsatn_type_id<Timestamp> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U64); 
+};
+template<> struct bsatn_type_id<SpacetimeDb::u128> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U128); 
+};
+template<> struct bsatn_type_id<SpacetimeDb::i128> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::I128); 
+};
+template<> struct bsatn_type_id<SpacetimeDb::u256> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::U256); 
+};
+template<> struct bsatn_type_id<SpacetimeDb::i256> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::I256); 
+};
+template<> struct bsatn_type_id<ScheduleAt> { 
+    static constexpr bool is_primitive = false;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::Sum); 
+};
+
+// Container types
+template<typename T> 
+struct bsatn_type_id<std::vector<T>> { 
+    static constexpr bool is_primitive = false;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::Array); 
+};
+
+template<typename T> 
+struct bsatn_type_id<std::optional<T>> { 
+    static constexpr bool is_primitive = false;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::Sum); 
+};
+
+// Special case for byte arrays
+template<> struct bsatn_type_id<std::vector<uint8_t>> { 
+    static constexpr bool is_primitive = true;
+    static constexpr uint8_t value = static_cast<uint8_t>(bsatn::AlgebraicTypeTag::Array); 
+};
+
+// -----------------------------------------------------------------------------
+// Field Descriptor System
+// -----------------------------------------------------------------------------
+
+// Field descriptor for runtime reflection
+struct FieldDescriptor {
+    std::string name;
+    size_t offset;
+    size_t size;
+    std::function<void(std::vector<uint8_t>&)> write_type;      // Writes AlgebraicType (legacy)
+    std::function<bsatn::AlgebraicType()> get_algebraic_type;   // Returns AlgebraicType for type registry
+    std::function<void(std::vector<uint8_t>&, const void*)> serialize;  // Serializes value
+    std::function<std::string()> get_type_name;  // Returns the type name for complex types
+};
+
+// Table descriptor
+struct TableDescriptor {
+    std::vector<FieldDescriptor> fields;
+};
+
+// Global registry for table descriptors
+inline std::map<const std::type_info*, TableDescriptor>& get_table_descriptors() {
+    static std::map<const std::type_info*, TableDescriptor> descriptors;
+    return descriptors;
+}
+
+// -----------------------------------------------------------------------------
+// Type Writing Utilities
+// -----------------------------------------------------------------------------
+
+// Forward declaration
+template<typename T>
+void write_field_type(std::vector<uint8_t>& buf);
+
+// Utility functions for writing BSATN data
+inline void write_u32(std::vector<uint8_t>& buf, uint32_t val) {
+    buf.push_back(val & 0xFF);
+    buf.push_back((val >> 8) & 0xFF);
+    buf.push_back((val >> 16) & 0xFF);
+    buf.push_back((val >> 24) & 0xFF);
+}
+
+inline void write_string(std::vector<uint8_t>& buf, const std::string& str) {
+    write_u32(buf, str.length());
+    buf.insert(buf.end(), str.begin(), str.end());
+}
+
+// Unified type writer using modern C++ features
+template<typename T>
+void write_field_type(std::vector<uint8_t>& buf) {
+    using Tag = bsatn::AlgebraicTypeTag;
+    
+    if constexpr (std::is_enum_v<T>) {
+        // Enums are serialized as u32
+        buf.push_back(static_cast<uint8_t>(Tag::U32));
+    } 
+    else if constexpr (bsatn_type_id<T>::is_primitive) {
+        // Primitive types
+        buf.push_back(bsatn_type_id<T>::value);
+    }
+    else if constexpr (is_vector<T>::value) {
+        // Vector types
+        buf.push_back(static_cast<uint8_t>(Tag::Array));
+        write_field_type<typename T::value_type>(buf);
+    }
+    else if constexpr (is_optional<T>::value) {
+        // Optional types
+        buf.push_back(static_cast<uint8_t>(Tag::Sum));
+        write_u32(buf, 2);  // 2 variants
+        
+        // Variant 0: Some
+        buf.push_back(0);  // Some tag
+        write_string(buf, "some");
+        write_field_type<typename T::value_type>(buf);
+        
+        // Variant 1: None
+        buf.push_back(0);  // Some tag
+        write_string(buf, "none");
+        buf.push_back(static_cast<uint8_t>(Tag::Product));  // Unit type
+        write_u32(buf, 0);  // 0 fields
+    }
+    else if constexpr (std::is_same_v<T, Identity>) {
+        // Identity is array of 32 bytes
+        buf.push_back(static_cast<uint8_t>(Tag::Array));
+        buf.push_back(static_cast<uint8_t>(Tag::U8));
+    }
+    else {
+        // Custom struct types
+        auto& descriptors = get_table_descriptors();
+        auto it = descriptors.find(&typeid(T));
+        
+        if (it != descriptors.end()) {
+            // Write as Product type
+            buf.push_back(static_cast<uint8_t>(Tag::Product));
+            write_u32(buf, it->second.fields.size());
+            
+            for (const auto& field : it->second.fields) {
+                buf.push_back(0);  // Some (field name present)
+                write_string(buf, field.name);
+                field.write_type(buf);
+            }
+        } else {
+            // Fallback - empty product
+            buf.push_back(static_cast<uint8_t>(Tag::Product));
+            write_u32(buf, 0);
+        }
+    }
+}
+
+// Universal serialize_value function using BSATN
+template<typename T>
+void serialize_value(std::vector<uint8_t>& buf, const T& val) {
+    bsatn::Writer writer;
+    bsatn::serialize(writer, val);
+    const auto& serialized = writer.get_buffer();
+    buf.insert(buf.end(), serialized.begin(), serialized.end());
+}
+
+// -----------------------------------------------------------------------------
+// Helper Functions
+// -----------------------------------------------------------------------------
+
+// Forward declaration for recursive BSATN size calculation
+template<typename T>
+constexpr size_t calculate_bsatn_size();
+
+// Helper function to get correct BSATN serialization size (not C++ sizeof with padding)
+template<typename T>
+constexpr size_t get_field_size() {
+    // CRITICAL: Unit types should have size = 0, not sizeof() = 1
+    if constexpr (requires { T::__is_unit_type__; } && T::__is_unit_type__) {
+        return 0;  // Unit types serialize as 0 bytes
+    } else if constexpr (std::is_same_v<T, std::monostate>) {
+        return 0;  // std::monostate is also a unit type
+    } else {
+        // For complex types, calculate actual BSATN size, not C++ sizeof()
+        return calculate_bsatn_size<T>();
+    }
+}
+
+// Calculate BSATN serialization size for any type
+template<typename T>
+constexpr size_t calculate_bsatn_size() {
+    // Unit types
+    if constexpr ((requires { T::__is_unit_type__; } && T::__is_unit_type__) || 
+                  std::is_same_v<T, std::monostate>) {
+        return 0;
+    }
+    // Primitive types - use their natural sizes (no padding in BSATN)
+    else if constexpr (std::is_same_v<T, bool> || std::is_same_v<T, uint8_t> || std::is_same_v<T, int8_t>) {
+        return 1;
+    }
+    else if constexpr (std::is_same_v<T, uint16_t> || std::is_same_v<T, int16_t>) {
+        return 2;
+    }
+    else if constexpr (std::is_same_v<T, uint32_t> || std::is_same_v<T, int32_t> || std::is_same_v<T, float>) {
+        return 4;
+    }
+    else if constexpr (std::is_same_v<T, uint64_t> || std::is_same_v<T, int64_t> || std::is_same_v<T, double>) {
+        return 8;
+    }
+    // For complex types (structs), we'd need runtime field information
+    // For now, fall back to sizeof() but this should be improved
+    else {
+        return sizeof(T);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Field Registration Macros
+// -----------------------------------------------------------------------------
+
+// Primary macro for registering a field with auto-initialization
+#define REGISTER_FIELD(struct_type, field_name, field_type) \
+    __attribute__((export_name("__preinit__10_field_" #struct_type "_" #field_name))) \
+    extern "C" void CONCAT(_preinit_register_field_, CONCAT(struct_type, field_name))() { \
+        SpacetimeDb::FieldDescriptor desc; \
+        desc.name = #field_name; \
+        desc.offset = offsetof(struct_type, field_name); \
+        desc.size = SpacetimeDb::get_field_size<field_type>(); \
+        desc.write_type = [](std::vector<uint8_t>& buf) { \
+            SpacetimeDb::write_field_type<field_type>(buf); \
+        }; \
+        desc.get_algebraic_type = []() { \
+            return SpacetimeDb::bsatn::bsatn_traits<field_type>::algebraic_type(); \
+        }; \
+        desc.serialize = [](std::vector<uint8_t>& buf, const void* obj) { \
+            const struct_type* typed_obj = static_cast<const struct_type*>(obj); \
+            SpacetimeDb::serialize_value(buf, typed_obj->field_name); \
+        }; \
+        desc.get_type_name = []() -> std::string { \
+            /* UNIFIED REGISTRY: Type names handled by demangling */ \
+            return demangle_cpp_type_name(typeid(field_type).name()); \
+        }; \
+        SpacetimeDb::get_table_descriptors()[&typeid(struct_type)].fields.push_back(desc); \
+    }
+
+// -----------------------------------------------------------------------------
+// Field Registrar Template
+// -----------------------------------------------------------------------------
+
+// Template for on-demand field registration - used by Module_impl.h
+template<typename T>
+struct field_registrar {
+    static void register_fields() {
+        // Default implementation - no fields to register
+        // Specialized by SPACETIMEDB_STRUCT macro in traits.h
+    }
+};
+
+// Specialization to prevent direct registration of std::variant as table types
+template<typename... Ts>
+struct field_registrar<std::variant<Ts...>> {
+    static void register_fields() {
+        static_assert(sizeof...(Ts) == 0, 
+            "std::variant types cannot be used directly. "
+            "Use SPACETIMEDB_VARIANT_ENUM macro to create variant types with named variants. "
+            "Example: SPACETIMEDB_VARIANT_ENUM(MyEnum, (VariantA, uint32_t), (VariantB, std::string))");
+        
+        // This should never execute due to static_assert, but provide runtime error as backup
+        std::abort(); // Cannot use std::variant directly
+    }
+};
+
+// -----------------------------------------------------------------------------
+// Legacy Support
+// -----------------------------------------------------------------------------
+// These are kept for backward compatibility but should not be used in new code.
+// Use SPACETIMEDB_STRUCT from traits.h instead.
+
+// Use unified macro system from macros.h
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_FIELD_REGISTRATION_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/forward_declarations.h b/crates/bindings-cpp/include/spacetimedb/internal/forward_declarations.h
new file mode 100644
index 00000000000..43e09d3acdb
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/forward_declarations.h
@@ -0,0 +1,10 @@
+// Forward declarations for Internal types to break circular dependencies
+#pragma once
+
+namespace SpacetimeDb::Internal {
+    class AlgebraicType;
+    struct SumType;
+    struct ProductType;
+    struct SumTypeVariant;
+    struct ProductTypeElement;
+} // namespace SpacetimeDb::Internal
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/nested_type_collection.h b/crates/bindings-cpp/include/spacetimedb/internal/nested_type_collection.h
new file mode 100644
index 00000000000..08b9437932c
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/nested_type_collection.h
@@ -0,0 +1,685 @@
+#ifndef SPACETIMEDB_NESTED_TYPE_COLLECTION_H
+#define SPACETIMEDB_NESTED_TYPE_COLLECTION_H
+
+// TypeRegistry system removed - use V9TypeRegistration instead
+// This entire file is deprecated as it was designed for the legacy TypeRegistry system
+/*
+// type_name_registry.h removed - functionality moved to TypeRegistry
+#include "../bsatn/traits.h"
+#include <vector>
+#include <optional>
+#include <variant>
+
+namespace SpacetimeDb {
+
+namespace Internal {
+
+// Forward declarations - these are defined in Module_impl.h
+template<typename T> struct is_optional;
+template<typename T> struct is_vector_type;
+
+// Enhanced version of collect_single_param_type that properly handles nested types
+template<typename T>
+void collect_single_param_type_v2(TypeRegistry& registry) {
+    // CRITICAL DEDUPLICATION: Check if this type is already registered FIRST
+    // This prevents the massive over-registration that was causing 2.4x type inflation
+    if (registry.find_type_index_by_cpp_type(&typeid(T)) != static_cast<uint32_t>(-1)) {
+        return; // Type already registered - skip collection entirely
+    }
+    
+    // Early exit for primitive types (including big integers)
+    constexpr bool is_primitive = std::is_same_v<T, bool> || 
+                                 std::is_same_v<T, uint8_t> || std::is_same_v<T, uint16_t> ||
+                                 std::is_same_v<T, uint32_t> || std::is_same_v<T, uint64_t> ||
+                                 std::is_same_v<T, int8_t> || std::is_same_v<T, int16_t> ||
+                                 std::is_same_v<T, int32_t> || std::is_same_v<T, int64_t> ||
+                                 std::is_same_v<T, float> || std::is_same_v<T, double> ||
+                                 std::is_same_v<T, std::string> ||
+                                 std::is_same_v<T, ::SpacetimeDb::u128> || std::is_same_v<T, ::SpacetimeDb::i128> ||
+                                 std::is_same_v<T, ::SpacetimeDb::u256> || std::is_same_v<T, ::SpacetimeDb::i256>;
+    
+    if constexpr (is_primitive) {
+        return; // Primitive types don't need registration
+    }
+    
+    // Handle special SpacetimeDB types separately
+    if constexpr (std::is_same_v<T, ::SpacetimeDb::Identity> ||
+                  std::is_same_v<T, ::SpacetimeDb::ConnectionId> ||
+                  std::is_same_v<T, ::SpacetimeDb::Timestamp> ||
+                  std::is_same_v<T, ::SpacetimeDb::TimeDuration> ||
+                  std::is_same_v<T, ::SpacetimeDb::ScheduleAt>) {
+        // Special types should NOT be registered - they should be inlined
+        // Rust inlines these types completely  
+        return;
+    }
+    
+    if constexpr (is_vector_type<T>::value) {
+        using element_type = typename T::value_type;
+        
+        // First, recursively collect the element type (unless it's a special type)
+        if constexpr (!(std::is_same_v<element_type, ::SpacetimeDb::Identity> ||
+                       std::is_same_v<element_type, ::SpacetimeDb::ConnectionId> ||
+                       std::is_same_v<element_type, ::SpacetimeDb::Timestamp> ||
+                       std::is_same_v<element_type, ::SpacetimeDb::TimeDuration>)) {
+            collect_single_param_type_v2<element_type>(registry);
+        }
+        
+        // Now create the vector type with proper element reference
+        uint32_t elem_ref = static_cast<uint32_t>(-1);  // Initialize to invalid
+        
+        // Determine element type reference
+        if constexpr (std::is_same_v<element_type, bool>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::Bool);
+        } else if constexpr (std::is_same_v<element_type, uint8_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U8);
+        } else if constexpr (std::is_same_v<element_type, uint16_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U16);
+        } else if constexpr (std::is_same_v<element_type, uint32_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U32);
+        } else if constexpr (std::is_same_v<element_type, uint64_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U64);
+        } else if constexpr (std::is_same_v<element_type, int8_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I8);
+        } else if constexpr (std::is_same_v<element_type, int16_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I16);
+        } else if constexpr (std::is_same_v<element_type, int32_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I32);
+        } else if constexpr (std::is_same_v<element_type, int64_t>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I64);
+        } else if constexpr (std::is_same_v<element_type, float>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::F32);
+        } else if constexpr (std::is_same_v<element_type, double>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::F64);
+        } else if constexpr (std::is_same_v<element_type, std::string>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::String);
+        } else if constexpr (std::is_same_v<element_type, ::SpacetimeDb::u128>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U128);
+        } else if constexpr (std::is_same_v<element_type, ::SpacetimeDb::i128>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I128);
+        } else if constexpr (std::is_same_v<element_type, ::SpacetimeDb::u256>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U256);
+        } else if constexpr (std::is_same_v<element_type, ::SpacetimeDb::i256>) {
+            elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I256);
+        } else {
+            // Complex type - need to find it in the registry
+            // For Option<T>, we need to register it first
+            if constexpr (is_optional<element_type>::value) {
+                // First register the Option<T> type by calling its collection function
+                collect_single_param_type_v2<element_type>(registry);
+                
+                // Set the thread-local registry for algebraic_type generation
+                
+                // Now get the Option<T> type and find it in the registry
+                auto option_type = bsatn::bsatn_traits<element_type>::algebraic_type();
+                
+                // Restore old registry
+                
+                // Options are never registered - they are inlined when needed
+                elem_ref = static_cast<uint32_t>(-1); // Mark as not found, will be inlined
+            } else if constexpr (std::is_same_v<element_type, ::SpacetimeDb::Identity> ||
+                                 std::is_same_v<element_type, ::SpacetimeDb::ConnectionId> ||
+                                 std::is_same_v<element_type, ::SpacetimeDb::Timestamp> ||
+                                 std::is_same_v<element_type, ::SpacetimeDb::TimeDuration>) {
+                // CRITICAL: Special types should NEVER be registered - they must be inlined
+                // For Array<SpecialType>, we'll create the array with the special type inlined
+                // Don't set elem_ref - handle this case specially below
+            } else if constexpr (std::is_enum_v<element_type>) {
+                // Enum type - register it if it has custom bsatn_traits (like Sum types)
+                if constexpr (requires { bsatn::bsatn_traits<element_type>::algebraic_type(); }) {
+                    // First collect the enum type itself
+                    collect_single_param_type_v2<element_type>(registry);
+                    
+                    // Then find/register the enum type
+                    auto enum_type = bsatn::bsatn_traits<element_type>::algebraic_type();
+                    
+                    elem_ref = registry.find_type_index(enum_type);
+                    if (elem_ref == static_cast<uint32_t>(-1)) {
+                        // Not found - register it WITH type info to preserve name
+                        elem_ref = registry.register_type_with_info(enum_type, &typeid(element_type));
+                    }
+                } else {
+                    // Plain enum without custom traits - use underlying type
+                    using underlying = std::underlying_type_t<element_type>;
+                    if constexpr (std::is_same_v<underlying, uint8_t>) {
+                        elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U8);
+                    } else if constexpr (std::is_same_v<underlying, uint16_t>) {
+                        elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U16);
+                    } else if constexpr (std::is_same_v<underlying, uint32_t>) {
+                        elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U32);
+                    } else {
+                        // Other underlying types can be added as needed
+                        elem_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U8);
+                    }
+                }
+            } else if constexpr (requires { bsatn::bsatn_traits<element_type>::algebraic_type(); }) {
+                // Regular struct type
+                // CRITICAL FIX: Must collect the element type FIRST before trying to find it!
+                // This was causing BTreeU32 fallback because types weren't registered yet
+                collect_single_param_type_v2<element_type>(registry);
+                
+                // Set the thread-local registry for type generation
+                
+                auto elem_type = bsatn::bsatn_traits<element_type>::algebraic_type();
+                
+                // Restore old registry
+                elem_ref = registry.find_type_index(elem_type);
+                if (elem_ref == static_cast<uint32_t>(-1)) {
+                    // Not found - register it with type info to preserve name
+                    elem_ref = registry.register_type_with_info(elem_type, &typeid(element_type));
+                }
+            } else {
+                // Fallback for any other complex types
+                // This should not happen if all types are properly handled above
+                static_assert(sizeof(element_type) == 0, "Unsupported element type in vector");
+            }
+        }
+        
+        // Ensure we have a valid elem_ref before creating the array type
+        // Note: We can't throw exceptions in WASM modules during initialization
+        
+        // ARRAYS ARE NEVER REGISTERED IN TYPESPACE - they are always inlined like in Rust
+        // The bsatn_traits<std::vector<T>>::algebraic_type() will handle array creation
+        // when the type is actually needed for serialization or client generation
+        
+    } else if constexpr (is_optional<T>::value) {
+        using inner_type = typename T::value_type;
+        
+        // Process all optional types, including complex nested ones
+        // Now that we properly handle TypeRegistry context, we can support
+        // optional<vector<T>> and other complex nested types
+        
+        // First, recursively collect the inner type (unless it's a special type)
+        if constexpr (!(std::is_same_v<inner_type, ::SpacetimeDb::Identity> ||
+                       std::is_same_v<inner_type, ::SpacetimeDb::ConnectionId> ||
+                       std::is_same_v<inner_type, ::SpacetimeDb::Timestamp> ||
+                       std::is_same_v<inner_type, ::SpacetimeDb::TimeDuration>)) {
+            collect_single_param_type_v2<inner_type>(registry);
+        }
+        
+        // Determine inner type reference for Some variant
+        uint32_t inner_ref = static_cast<uint32_t>(-1);  // Initialize to invalid
+        
+        if constexpr (std::is_same_v<inner_type, bool>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::Bool);
+        } else if constexpr (std::is_same_v<inner_type, uint8_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U8);
+        } else if constexpr (std::is_same_v<inner_type, uint16_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U16);
+        } else if constexpr (std::is_same_v<inner_type, uint32_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U32);
+        } else if constexpr (std::is_same_v<inner_type, uint64_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U64);
+        } else if constexpr (std::is_same_v<inner_type, int8_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I8);
+        } else if constexpr (std::is_same_v<inner_type, int16_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I16);
+        } else if constexpr (std::is_same_v<inner_type, int32_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I32);
+        } else if constexpr (std::is_same_v<inner_type, int64_t>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I64);
+        } else if constexpr (std::is_same_v<inner_type, float>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::F32);
+        } else if constexpr (std::is_same_v<inner_type, double>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::F64);
+        } else if constexpr (std::is_same_v<inner_type, std::string>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::String);
+        } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::u128>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U128);
+        } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::i128>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I128);
+        } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::u256>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U256);
+        } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::i256>) {
+            inner_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I256);
+        } else {
+            // Complex type - handle vectors specially
+            if constexpr (is_vector_type<inner_type>::value) {
+                // For vectors inside optionals, we need to handle them carefully
+                // The vector needs its element type to be registered first
+                using vector_element = typename inner_type::value_type;
+                
+                // First ensure the vector's element type is collected
+                collect_single_param_type_v2<vector_element>(registry);
+                
+                // Now register the vector type itself
+                // Set the thread-local registry for type generation
+                
+                auto inner_alg_type = bsatn::bsatn_traits<inner_type>::algebraic_type();
+                
+                // Restore old registry
+                
+                inner_ref = registry.find_type_index(inner_alg_type);
+                if (inner_ref == static_cast<uint32_t>(-1)) {
+                    inner_ref = registry.register_type(inner_alg_type);
+                }
+            } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::Identity> ||
+                          std::is_same_v<inner_type, ::SpacetimeDb::ConnectionId> ||
+                          std::is_same_v<inner_type, ::SpacetimeDb::Timestamp> ||
+                          std::is_same_v<inner_type, ::SpacetimeDb::TimeDuration>) {
+                // Special SpacetimeDB types should NEVER be registered
+                // For Option<SpecialType>, we'll inline the special type directly
+                // Don't set inner_ref - handle this case specially below
+            } else if constexpr (requires { bsatn::bsatn_traits<inner_type>::algebraic_type(); }) {
+                // CRITICAL FIX: Must collect the inner type FIRST before trying to find it!
+                // This was causing BTreeU32 fallback for Option<StructType>
+                collect_single_param_type_v2<inner_type>(registry);
+                
+                // Set the thread-local registry for type generation
+                
+                auto inner_alg_type = bsatn::bsatn_traits<inner_type>::algebraic_type();
+                
+                // Restore old registry
+                inner_ref = registry.find_type_index(inner_alg_type);
+                if (inner_ref == static_cast<uint32_t>(-1)) {
+                    inner_ref = registry.register_type_with_info(inner_alg_type, &typeid(inner_type));
+                }
+            } else {
+                // This should not happen
+                static_assert(sizeof(inner_type) == 0, "Unsupported inner type in optional");
+            }
+        }
+        
+        // Ensure we have a valid inner_ref before creating the option type
+        
+        // Create Option type with proper inline handling
+        std::vector<bsatn::SumTypeVariant> variants;
+        
+        // Check if inner_type is a special type that needs inlining
+        if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::Identity> ||
+                      std::is_same_v<inner_type, ::SpacetimeDb::ConnectionId> ||
+                      std::is_same_v<inner_type, ::SpacetimeDb::Timestamp> ||
+                      std::is_same_v<inner_type, ::SpacetimeDb::TimeDuration>) {
+            // Create the special type inline for the "some" variant
+            std::vector<bsatn::ProductTypeElement> elements;
+            if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::Identity>) {
+                elements.emplace_back(bsatn::IDENTITY_TAG, bsatn::AlgebraicType::U256());
+            } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::ConnectionId>) {
+                elements.emplace_back(bsatn::CONNECTION_ID_TAG, bsatn::AlgebraicType::U128());
+            } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::Timestamp>) {
+                elements.emplace_back(bsatn::TIMESTAMP_TAG, bsatn::AlgebraicType::I64());
+            } else if constexpr (std::is_same_v<inner_type, ::SpacetimeDb::TimeDuration>) {
+                elements.emplace_back(bsatn::TIME_DURATION_TAG, bsatn::AlgebraicType::I64());
+            }
+            
+            auto special_product = std::make_unique<bsatn::ProductType>(std::move(elements));
+            auto special_type = bsatn::AlgebraicType::make_product(std::move(special_product));
+            
+            // Use the inline special type for the "some" variant
+            variants.emplace_back("some", std::move(special_type));
+        } else {
+            // Regular type - but check if it's a sentinel value
+            if (inner_ref == 0xFFFFFFFF) {
+                // This inner type is a special type that should be inlined
+                // Get the actual type and inline it
+                auto inner_alg_type = bsatn::bsatn_traits<inner_type>::algebraic_type();
+                variants.emplace_back("some", std::move(inner_alg_type));
+            } else {
+                // Valid reference - use it
+                variants.emplace_back("some", bsatn::AlgebraicType::Ref(inner_ref));
+            }
+        }
+        
+        // CRITICAL FIX: The "none" variant should be an INLINE empty Product, NOT a reference!
+        // This matches Rust behavior where Option's None variant contains Unit directly
+        // This prevents registering empty Products in the typespace for every Option type
+        auto none_unit = bsatn::AlgebraicType::make_product(
+            std::make_unique<bsatn::ProductType>(std::vector<bsatn::ProductTypeElement>{})
+        );
+        variants.emplace_back("none", std::move(none_unit));
+        
+        // OPTIONS ARE NEVER REGISTERED IN TYPESPACE - they are always inlined like in Rust
+        // The bsatn_traits<std::optional<T>>::algebraic_type() will handle option creation
+        // when the type is actually needed for serialization or client generation
+        
+    } else {
+        // Handle non-primitive types (structs, variants, enums with custom traits)
+        
+        // CRITICAL: Check for SPACETIMEDB_VARIANT_ENUM wrapper structs FIRST
+        // These have a variant_type member and special bsatn_traits that return Sum types
+        if constexpr (requires { typename T::variant_type; }) {
+            
+            // Get the type name for proper registration
+            std::string type_name = demangle_cpp_type_name(typeid(T).name());
+            
+            // Clean up the demangled name
+            size_t pos = type_name.rfind("::");
+            if (pos != std::string::npos) {
+                type_name = type_name.substr(pos + 2);
+            } else if (!type_name.empty() && std::isdigit(type_name[0])) {
+                size_t i = 0;
+                while (i < type_name.length() && std::isdigit(type_name[i])) i++;
+                type_name = type_name.substr(i);
+            }
+            
+            
+            // Set thread-local registry for type generation
+            
+            // Get the Sum type from the wrapper's bsatn_traits
+            auto variant_type = bsatn::bsatn_traits<T>::algebraic_type();
+            
+            // Restore old registry
+            
+            // Register with type info to preserve name
+            uint32_t type_ref = registry.register_type_with_info(variant_type, &typeid(T));
+            
+            // Ensure name is registered
+            if (!type_name.empty()) {
+                registry.register_type_name(type_ref, type_name);
+            }
+            
+            return; // Done with variant wrapper
+        }
+        
+        // For enums with custom bsatn_traits, register with type info
+        if constexpr (std::is_enum_v<T> && requires { bsatn::bsatn_traits<T>::algebraic_type(); }) {
+            // UNIFIED: Use same name extraction as structs/variants
+            std::string type_name = demangle_cpp_type_name(typeid(T).name());
+            
+            // Clean up the demangled name
+            size_t pos = type_name.rfind("::");
+            if (pos != std::string::npos) {
+                type_name = type_name.substr(pos + 2);
+            } else if (!type_name.empty() && std::isdigit(type_name[0])) {
+                size_t i = 0;
+                while (i < type_name.length() && std::isdigit(type_name[i])) i++;
+                type_name = type_name.substr(i);
+            }
+            
+            
+            // Set the global registry temporarily for enum registration
+            
+            auto enum_type = bsatn::bsatn_traits<T>::algebraic_type();
+            // UNIFIED API: Register enum with both type identity and name in one call
+            [[maybe_unused]] uint32_t type_ref = registry.register_type(enum_type, {
+                .cpp_type = &typeid(T),
+                .type_name = type_name
+            });
+            
+            // Restore old registry
+        } else if constexpr (requires { typename T::_Base; } || requires { typename T::variant_type; }) { // std::variant has _Base, wrapper has variant_type
+            // This is a std::variant or variant wrapper - need to handle it specially
+            
+            // CRITICAL: For wrapper structs, we want to register the Sum type, not a Product
+            // The SPACETIMEDB_VARIANT_ENUM macro creates a wrapper struct with a specialized
+            // bsatn_traits that returns a Sum type
+            if constexpr (requires { typename T::variant_type; }) {
+            }
+            
+            // First, recursively collect all variant types
+            if constexpr (requires { bsatn::bsatn_traits<T>::algebraic_type(); }) {
+                // CRITICAL FIX: Get variant name directly from demangling, eliminating TypeNameRegistry
+                std::string type_name = demangle_cpp_type_name(typeid(T).name());
+                
+                // Clean up the demangled name to extract just the type name
+                size_t pos = type_name.rfind("::");
+                if (pos != std::string::npos) {
+                    type_name = type_name.substr(pos + 2);
+                } else if (!type_name.empty() && std::isdigit(type_name[0])) {
+                    // Handle simple mangled names
+                    size_t i = 0;
+                    while (i < type_name.length() && std::isdigit(type_name[i])) i++;
+                    type_name = type_name.substr(i);
+                }
+                
+                
+                // Set the global registry temporarily for variant registration
+                
+                auto variant_type = bsatn::bsatn_traits<T>::algebraic_type();
+                
+                // Use register_type_with_info to ensure proper name registration
+                uint32_t type_ref = registry.register_type_with_info(variant_type, &typeid(T));
+                
+                // CRITICAL: Ensure the name is registered in the local TypeRegistry
+                // register_type_with_info might not have the correct name, so register it explicitly
+                if (!type_name.empty()) {
+                    registry.register_type_name(type_ref, type_name);
+                }
+                
+                // Restore old registry
+            }
+        } else {
+            // Regular struct type
+            if constexpr (requires { bsatn::bsatn_traits<T>::algebraic_type(); }) {
+                // CRITICAL FIX: Get type name directly from demangling, eliminating TypeNameRegistry dependency
+                // This unifies the system to use a single registry with consistent naming
+                std::string type_name = demangle_cpp_type_name(typeid(T).name());
+                
+                // Clean up the demangled name to extract just the type name
+                size_t pos = type_name.rfind("::");
+                if (pos != std::string::npos) {
+                    type_name = type_name.substr(pos + 2);
+                } else if (!type_name.empty() && std::isdigit(type_name[0])) {
+                    // Handle simple mangled names like "13MinimalStruct" -> "MinimalStruct"
+                    size_t i = 0;
+                    while (i < type_name.length() && std::isdigit(type_name[i])) i++;
+                    type_name = type_name.substr(i);
+                }
+                
+                
+                // CRITICAL FIX: Before generating the algebraic type, we need to
+                // recursively collect all nested field types. This ensures that
+                // when ProductTypeBuilder tries to reference field types, they're
+                // already registered.
+                // 
+                // For wrapper structs like VecU8 { n: std::vector<uint8_t> },
+                // we need to ensure the vector type is registered first.
+                //
+                // Since we can't easily introspect struct fields at compile time,
+                // we'll generate the algebraic type twice - once to discover field types,
+                // then again after registering them.
+                
+                // CRITICAL FIX: Set thread-local registry for type generation
+                
+                auto param_type = bsatn::bsatn_traits<T>::algebraic_type();
+                
+                // Restore old registry
+                
+                // Register the type with type info to enable TypeNameRegistry lookup
+                // This allows Module.cpp to find the proper struct name
+                // Type registration complete
+                
+                uint32_t registered_ref = registry.register_type_with_info(param_type, &typeid(T));
+                
+                // CRITICAL: Ensure the name is registered in the local TypeRegistry
+                // register_type_with_info might not have the correct name, so register it explicitly
+                if (!type_name.empty()) {
+                    registry.register_type_name(registered_ref, type_name);
+                        
+                    // Name registration completed
+                }
+                
+                // Type registration completed
+                
+            }
+        }
+    }
+}
+
+// UNIFIED TYPE REFERENCE FUNCTION
+// Gets the appropriate type reference for any type T:
+// - Primitives: returns AlgebraicTypeTag
+// - Special types: returns special marker
+// - Complex types: ensures registered and returns index
+template<typename T>
+uint32_t get_type_reference(TypeRegistry& registry) {
+    // No need for context switching with global registry
+    uint32_t type_ref = 0;
+    
+    // Primitive types - return their AlgebraicTypeTag directly
+    if constexpr (std::is_same_v<T, bool>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::Bool);
+    } else if constexpr (std::is_same_v<T, uint8_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U8);
+    } else if constexpr (std::is_same_v<T, uint16_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U16);
+    } else if constexpr (std::is_same_v<T, uint32_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U32);
+    } else if constexpr (std::is_same_v<T, uint64_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U64);
+    } else if constexpr (std::is_same_v<T, int8_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I8);
+    } else if constexpr (std::is_same_v<T, int16_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I16);
+    } else if constexpr (std::is_same_v<T, int32_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I32);
+    } else if constexpr (std::is_same_v<T, int64_t>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I64);
+    } else if constexpr (std::is_same_v<T, float>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::F32);
+    } else if constexpr (std::is_same_v<T, double>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::F64);
+    } else if constexpr (std::is_same_v<T, std::string>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::String);
+    } else if constexpr (std::is_same_v<T, ::SpacetimeDb::u128>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U128);
+    } else if constexpr (std::is_same_v<T, ::SpacetimeDb::i128>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I128);
+    } else if constexpr (std::is_same_v<T, ::SpacetimeDb::u256>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::U256);
+    } else if constexpr (std::is_same_v<T, ::SpacetimeDb::i256>) {
+        type_ref = static_cast<uint32_t>(bsatn::AlgebraicTypeTag::I256);
+    }
+    // Special types - NEVER register them, they must be inlined
+    // Return INVALID_TYPE_ID to signal that this type should be inlined wherever used
+    else if constexpr (std::is_same_v<T, ::SpacetimeDb::Identity> ||
+                      std::is_same_v<T, ::SpacetimeDb::ConnectionId> ||
+                      std::is_same_v<T, ::SpacetimeDb::Timestamp> ||
+                      std::is_same_v<T, ::SpacetimeDb::TimeDuration> ||
+                      std::is_same_v<T, ::SpacetimeDb::ScheduleAt>) {
+        // Special types should NOT be registered in the typespace
+        // They are always inlined at their point of use
+        type_ref = TypeConstants::INVALID_TYPE_ID;
+    }
+    // Complex types - ensure registered and return index
+    else {
+        // CRITICAL: Only collect/register types during module initialization
+        // After init, all types should already be in the registry
+        // Ensure the type is collected/registered
+        collect_single_param_type_v2<T>(registry);
+        
+        // For EnumWithPayload and other complex types that have names,
+        // look them up by type info rather than calling algebraic_type() again
+        if constexpr (requires { typename T::variant_type; } || std::is_enum_v<T>) {
+            // This is likely a named type - find it by type info
+            type_ref = registry.find_type_index_by_cpp_type(&typeid(T));
+            
+            if (type_ref != static_cast<uint32_t>(-1)) {
+                fprintf(stdout, "DEBUG: Found complex type %s at index=%u via type_info\n",
+                        typeid(T).name(), type_ref);
+            } else {
+                // Fallback: try to find by algebraic type structure
+                auto alg_type = bsatn::bsatn_traits<T>::algebraic_type();
+                type_ref = registry.find_type_index(alg_type);
+                // Found type via algebraic type structure
+            }
+        } else {
+            // Other complex types - use the original approach  
+            auto alg_type = bsatn::bsatn_traits<T>::algebraic_type();
+            
+            // CRITICAL: Handle Array types specially to prevent BTreeU32 substitution  
+            // Arrays need special handling when registered in typespace
+            if (alg_type.tag() == bsatn::AlgebraicTypeTag::Array) {
+                // Array type detected
+                
+                // Arrays should NOT be registered in typespace - they should be inlined
+                // However, if we don't register them, we get BTreeU32 substitution
+                // So we need to register them but ensure element types are correct
+                
+                // Just register the Array as-is and let the codegen handle it
+                type_ref = registry.register_type(alg_type);
+                // Array registered
+            } else {
+                type_ref = registry.find_type_index(alg_type);
+                // Found complex type
+            }
+        }
+        
+        if (type_ref == static_cast<uint32_t>(-1)) {
+            // Type not found - register it now
+            // Type not found - register it now
+            auto alg_type = bsatn::bsatn_traits<T>::algebraic_type();
+            type_ref = registry.register_type_with_info(alg_type, &typeid(T));
+        }
+    }
+    
+    return type_ref;
+}
+
+// Runtime version of get_type_reference for AlgebraicType objects
+// This provides the same unified registration/lookup logic for runtime types
+inline uint32_t get_type_reference_runtime(TypeRegistry& registry, const bsatn::AlgebraicType& type) {
+    // Check for primitive types by tag
+    // CRITICAL FIX: Primitive types are String (4) through F64 (19), NOT everything <= F64!
+    // Product (2) was incorrectly being treated as primitive due to bad comparison
+    if ((type.tag() >= bsatn::AlgebraicTypeTag::String && type.tag() <= bsatn::AlgebraicTypeTag::F64)) {
+        // Primitive types use their tag directly
+        return static_cast<uint32_t>(type.tag());
+    }
+    
+    // CRITICAL: Handle Array types specially to prevent BTreeU32 substitution
+    // Register Arrays normally instead of using markers - let serialization handle them correctly
+    if (type.tag() == bsatn::AlgebraicTypeTag::Array) {
+        fprintf(stdout, "DEBUG: Runtime Array type detected - registering in typespace\n");
+        
+        // Register the Array type normally like other complex types
+        uint32_t array_ref = registry.register_type(type);
+        fprintf(stdout, "DEBUG: Runtime Array registered at type index: %u\n", array_ref);
+        return array_ref;
+    }
+    
+    // CRITICAL: Handle special types properly - they should NEVER be registered
+    // Special types need to be handled inline during serialization, not as type references
+    bsatn::SpecialTypeKind special = bsatn::get_special_type_kind(type);
+    if (special != bsatn::SpecialTypeKind::None && special != bsatn::SpecialTypeKind::Option) {
+        fprintf(stdout, "DEBUG: Runtime special type detected: %d - returning INVALID_TYPE_ID for inline serialization\n", static_cast<int>(special));
+        // Special types must be inlined, never registered
+        return TypeConstants::INVALID_TYPE_ID;
+    }
+    
+    // CRITICAL: Check for special array markers - these should NOT be registered
+    if (type.tag() == bsatn::AlgebraicTypeTag::Ref) {
+        uint32_t ref_value = type.as_ref();
+        // Check if this is a special array marker (0x60000000 range)
+        if (ref_value >= 0x60000000 && ref_value < 0x70000000) {
+            // Return the marker directly without registering
+            return ref_value;
+        }
+    }
+    
+    // For complex types, try to find existing registration
+    uint32_t existing_ref = registry.find_type_index(type);
+    if (existing_ref != static_cast<uint32_t>(-1)) {
+        return existing_ref;
+    }
+    
+    // Not found - but check one more time if this is a special type that slipped through
+    // This is a safety net to prevent special types from being registered
+    if (type.tag() == bsatn::AlgebraicTypeTag::Product) {
+        const auto& product = type.as_product();
+        if (product.elements.size() == 1 && product.elements[0].name.has_value()) {
+            const std::string& field_name = *product.elements[0].name;
+            // Check for special type field names
+            if (field_name == bsatn::IDENTITY_TAG ||
+                field_name == bsatn::CONNECTION_ID_TAG ||
+                field_name == bsatn::TIMESTAMP_TAG ||
+                field_name == bsatn::TIME_DURATION_TAG ||
+                field_name == "__identity__" ||
+                field_name == "__connection_id__" ||
+                field_name == "__timestamp_micros_since_unix_epoch__" ||
+                field_name == "__time_duration_micros__") {
+                fprintf(stderr, "WARNING: Special type '%s' almost registered! Returning INVALID_TYPE_ID\n", field_name.c_str());
+                return TypeConstants::INVALID_TYPE_ID;
+            }
+        }
+    }
+    
+    // Not found - register it
+    uint32_t new_ref = registry.register_type(type);
+    return new_ref;
+}
+
+} // namespace Internal
+} // namespace SpacetimeDb
+*/
+
+#endif // SPACETIMEDB_NESTED_TYPE_COLLECTION_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/v9_builder.h b/crates/bindings-cpp/include/spacetimedb/internal/v9_builder.h
new file mode 100644
index 00000000000..9538fb7a96e
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/v9_builder.h
@@ -0,0 +1,679 @@
+#ifndef SPACETIMEDB_V9_BUILDER_H
+#define SPACETIMEDB_V9_BUILDER_H
+
+#include <memory>
+#include <vector>
+#include <optional>
+#include <typeinfo>
+#include <cstring>
+#include <tuple>
+#include "autogen/RawModuleDefV9.g.h"
+#include "autogen/AlgebraicType.g.h"
+#include "autogen/RawTableDefV9.g.h"
+#include "autogen/RawReducerDefV9.g.h"
+#include "autogen/RawConstraintDefV9.g.h"
+#include "autogen/RawSequenceDefV9.g.h"
+#include "autogen/RawScheduleDefV9.g.h"
+#include "autogen/RawTypeDefV9.g.h"
+#include "autogen/RawIndexDefV9.g.h"
+#include "autogen/RawConstraintDataV9.g.h"
+#include "autogen/RawIndexAlgorithm.g.h"  // Contains RawIndexAlgorithmBTreeData
+#include "autogen/RawUniqueConstraintDataV9.g.h"
+#include "autogen/ProductType.g.h"
+#include "autogen/Lifecycle.g.h"
+#include "../bsatn/bsatn.h"
+#include "../database.h"  // For FieldConstraintInfo
+#include "field_registration.h"  // For get_table_descriptors
+#include "v9_type_registration.h"  // For getV9TypeRegistration
+
+namespace SpacetimeDb {
+namespace Internal {
+
+// Forward declare the handler registration function from Module.cpp
+void RegisterReducerHandler(const std::string& name, 
+                           std::function<void(ReducerContext&, BytesSource)> handler,
+                           std::optional<Lifecycle> lifecycle = std::nullopt);
+
+// Helper to consume bytes from BytesSource (declared in Module.cpp)
+std::vector<uint8_t> ConsumeBytes(BytesSource source);
+
+// Forward declare the multiple primary key error function from Module.cpp
+void SetMultiplePrimaryKeyError(const std::string& table_name);
+
+// External global flags for circular reference detection (defined in v9_type_registration.cpp)
+extern bool g_circular_ref_error;
+extern std::string g_circular_ref_type_name;
+
+/**
+ * V9Builder - Builds a RawModuleDefV9 structure during module registration
+ * 
+ * This builder now uses the unified V9TypeRegistration system for all type handling.
+ * It focuses solely on building tables, reducers, and module structure.
+ * 
+ * Type registration principles:
+ * - Only user-defined structs/enums get registered (have entries in types array)
+ * - Primitives, arrays, Options, special types are always inlined
+ * - Single entry point for types: registerType() -> V9TypeRegistration
+ */
+class V9Builder {
+public:
+    V9Builder();
+    
+    /**
+     * Register a type using the unified type registration system
+     * Delegates to V9TypeRegistration::registerType()
+     * 
+     * @param bsatn_type The type to register
+     * @param explicit_name Optional explicit name for the type
+     * @param cpp_type Optional C++ type info
+     * @return AlgebraicType - either inline or Ref to registered type
+     */
+    AlgebraicType registerType(const bsatn::AlgebraicType& bsatn_type,
+                               const std::string& explicit_name = "",
+                               const std::type_info* cpp_type = nullptr);
+    
+    /**
+     * Register a table with all its constraints and metadata
+     * This is the main entry point from SPACETIMEDB_TABLE macro
+     * 
+     * @tparam T The table struct type
+     * @param table_name The name of the table
+     * @param is_public Whether the table is public
+     */
+    template<typename T>
+    void RegisterTable(const std::string& table_name, 
+                       bool is_public);
+    
+    /**
+     * Add a field constraint to a table after it has been registered
+     * This is called by FIELD_ macros to add constraints separately
+     * 
+     * @tparam T The table struct type
+     * @param table_name The name of the table
+     * @param field_name The name of the field
+     * @param constraint The constraint to add
+     */
+    template<typename T>
+    void AddFieldConstraint(const std::string& table_name,
+                           const std::string& field_name,
+                           FieldConstraint constraint);
+    
+    /**
+     * Add a multi-column index to a table after it has been registered
+     * This is called by FIELD_NamedMultiColumnIndex macro
+     * 
+     * @tparam T The table struct type
+     * @param table_name The name of the table
+     * @param index_name The name of the index
+     * @param field_names The field names in the index
+     */
+    template<typename T>
+    void AddMultiColumnIndex(const std::string& table_name,
+                            const std::string& index_name,
+                            const std::vector<std::string>& field_names);
+    
+    /**
+     * Register a reducer function with C++20 concepts
+     * This is the main entry point from REGISTER_REDUCER macro
+     * 
+     * @tparam Func The reducer function type
+     * @param reducer_name The name of the reducer
+     * @param func The reducer function pointer
+     */
+    template<typename Func>
+    void RegisterReducer(const std::string& reducer_name, Func func);
+    
+    /**
+     * Register a reducer function with explicit parameter names
+     * This overload is used when parameter names are available
+     * 
+     * @tparam Func The reducer function type
+     * @param reducer_name The name of the reducer
+     * @param func The reducer function pointer
+     * @param param_names The names of the parameters (excluding ReducerContext)
+     */
+    template<typename Func>
+    void RegisterReducer(const std::string& reducer_name, Func func,
+                        const std::vector<std::string>& param_names);
+    
+    /**
+     * Register a lifecycle reducer function
+     * 
+     * @tparam Func The reducer function type
+     * @param reducer_name The name of the reducer
+     * @param func The reducer function pointer
+     * @param lifecycle The lifecycle type (Init, OnConnect, OnDisconnect)
+     */
+    template<typename Func>
+    void RegisterLifecycleReducer(const std::string& reducer_name, Func func,
+                                 Lifecycle lifecycle);
+    
+    /**
+     * Register a schedule for a table to automatically call a reducer
+     * when the scheduled_at field indicates it's time.
+     * 
+     * @param table_name The name of the table containing scheduled data
+     * @param scheduled_at_column The column index of the ScheduleAt field (0-based)
+     * @param reducer_name The name of the reducer to call
+     */
+    void RegisterSchedule(const std::string& table_name, 
+                         uint16_t scheduled_at_column,
+                         const std::string& reducer_name);
+    
+    /**
+     * Register a row level security (RLS) policy for client visibility filtering.
+     * These are collected and added to the module's row_level_security field.
+     * 
+     * @param sql_query The SQL query that defines the visibility filter
+     */
+    void RegisterRowLevelSecurity(const std::string& sql_query);
+    
+    /**
+     * Add a complete V9 table definition with type registration and metadata.
+     * This method handles the complete table addition including type registration.
+     */
+    void AddV9Table(const std::string& table_name,
+                       const bsatn::AlgebraicType& table_type,
+                       const std::type_info* cpp_type,
+                       bool is_public,
+                       const std::vector<uint16_t>& primary_key,
+                       const std::vector<RawIndexDefV9>& indexes,
+                       const std::vector<RawConstraintDefV9>& constraints,
+                       const std::vector<RawSequenceDefV9>& sequences,
+                       const std::optional<RawScheduleDefV9>& schedule);
+    
+    /**
+     * Add a complete V9 reducer definition with parameter type registration.
+     * This method handles the complete reducer addition including parameter type registration.
+     */
+    void AddV9Reducer(const std::string& reducer_name,
+                         const std::vector<bsatn::AlgebraicType>& param_types,
+                         const std::vector<std::string>& param_names,
+                         const std::vector<const std::type_info*>& param_cpp_types,
+                         const std::vector<std::string>& param_type_names,
+                         std::optional<Lifecycle> lifecycle);
+    
+    /**
+     * Serialize the module definition to binary.
+     */
+    std::vector<uint8_t> serialize() const;
+    
+private:
+    // Store pending schedules to be applied when tables are registered
+    struct PendingSchedule {
+        std::string table_name;
+        uint16_t scheduled_at_column;
+        std::string reducer_name;
+    };
+    std::map<std::string, PendingSchedule> pending_schedules_;
+    
+    // Helper to find existing table by name in the module
+    RawTableDefV9* findTableByName(const std::string& table_name);
+    
+    /**
+     * Get field name from Product type structure.
+     */
+    std::string getFieldName(const bsatn::AlgebraicType& table_type, uint16_t column_index) const;
+    
+    /**
+     * Generate constraints for primary key.
+     */
+    std::vector<RawConstraintDefV9> generateConstraintsForPrimaryKey(
+        const std::string& table_name,
+        const bsatn::AlgebraicType& table_type,
+        const std::vector<uint16_t>& primary_key) const;
+        
+    /**
+     * Generate indexes for primary key.
+     */
+    std::vector<RawIndexDefV9> generateIndexesForPrimaryKey(
+        const std::string& table_name,
+        const bsatn::AlgebraicType& table_type,
+        const std::vector<uint16_t>& primary_key) const;
+    
+    /**
+     * Helper to create a BTree index for a field
+     */
+    RawIndexDefV9 createBTreeIndex(const std::string& table_name,
+                                   const std::string& field_name,
+                                   uint16_t field_idx) const;
+    
+    /**
+     * Helper to create a unique constraint for a field
+     */
+    RawConstraintDefV9 createUniqueConstraint(const std::string& table_name,
+                                              const std::string& field_name,
+                                              uint16_t field_idx) const;
+    
+    /**
+     * @brief Common implementation for reducer registration
+     * 
+     * This helper eliminates ~80% code duplication between RegisterReducer and
+     * RegisterLifecycleReducer by consolidating the common parameter extraction,
+     * handler creation, and registration logic.
+     * 
+     * @tparam Func The function pointer type of the reducer
+     * @param reducer_name Name of the reducer
+     * @param func The reducer function
+     * @param param_names Optional parameter names  
+     * @param lifecycle Optional lifecycle type (nullopt for regular reducers)
+     */
+    template<typename Func>
+    void RegisterReducerCommon(const std::string& reducer_name, 
+                               Func func,
+                               const std::vector<std::string>& param_names,
+                               std::optional<Lifecycle> lifecycle);
+};
+
+// Template implementation for RegisterTable
+template<typename T>
+void V9Builder::RegisterTable(const std::string& table_name, 
+                              bool is_public) {
+    // RegisterTable implementation
+    
+    // First, ensure field registration happens
+    SpacetimeDb::field_registrar<T>::register_fields();
+    
+    // Check if circular reference was detected during field registration
+    if (g_circular_ref_error) {
+        // Circular reference detected - don't register the table
+        // preinit_99 will handle creating the error module
+        fprintf(stdout, "DEBUG: Circular reference detected in table '%s', skipping registration\n", 
+                table_name.c_str());
+        return;
+    }
+    
+    // Get field descriptors for the table type
+    auto& descriptor_map = SpacetimeDb::get_table_descriptors();
+    auto it = descriptor_map.find(&typeid(T));
+    if (it == descriptor_map.end()) {
+        // No descriptors registered for this type - this shouldn't happen if SPACETIMEDB_STRUCT was used
+        return;
+    }
+    const auto& field_descs = it->second.fields;
+    
+    // Build a vector of BSATN ProductTypeElements
+    std::vector<bsatn::ProductTypeElement> elements;
+    
+    // First collect all field types with their names and register enum types
+    for (const auto& field_desc : field_descs) {
+        bsatn::AlgebraicType field_type = field_desc.get_algebraic_type();
+        std::string field_type_name = field_desc.get_type_name ? field_desc.get_type_name() : "";
+        
+        // For enum types (Sum types), register them by name first
+        // This ensures they get proper type names in the V9 system
+        if (!field_type_name.empty() && field_type.tag() == bsatn::AlgebraicTypeTag::Sum) {
+            // Check if it's not an Option type (which should be inlined)
+            const auto& sum = field_type.as_sum();
+            bool is_option = (sum.variants.size() == 2 && 
+                             sum.variants[0].name == "some" && 
+                             sum.variants[1].name == "none");
+            
+            // Check if it's ScheduleAt (which should be inlined)
+            bool is_schedule_at = (sum.variants.size() == 2 && 
+                                  sum.variants[0].name == "Interval" && 
+                                  sum.variants[1].name == "Time");
+            
+            if (!is_option && !is_schedule_at) {
+                // This is a user-defined enum, register it by name
+                // Strip namespace from type name if present
+                size_t last_colon = field_type_name.rfind("::");
+                if (last_colon != std::string::npos) {
+                    field_type_name = field_type_name.substr(last_colon + 2);
+                }
+                fprintf(stdout, "DEBUG: Registering enum type '%s' for field '%s'\n", 
+                        field_type_name.c_str(), field_desc.name.c_str());
+                getV9TypeRegistration().registerTypeByName(field_type_name, field_type, nullptr);
+            }
+        }
+        
+        elements.emplace_back(
+            std::make_optional(field_desc.name),
+            std::move(field_type)
+        );
+    }
+    
+    // Create the BSATN Product type with the elements
+    bsatn::ProductType bsatn_product(std::move(elements));
+    
+    // Create the BSATN AlgebraicType with Product type
+    bsatn::AlgebraicType table_type = bsatn::AlgebraicType::make_product(
+        std::make_unique<bsatn::ProductType>(std::move(bsatn_product)));
+    
+    // Process constraints to create V9 structures
+    std::vector<uint16_t> primary_key;
+    std::vector<RawIndexDefV9> indexes;
+    std::vector<RawConstraintDefV9> v9_constraints;
+    std::vector<RawSequenceDefV9> sequences;
+    
+    // Constraints and indexes will be added later by FIELD_ macros via AddFieldConstraint
+    // For now, start with empty vectors
+    
+    // Check if there's a pending schedule for this table
+    std::optional<RawScheduleDefV9> schedule = std::nullopt;
+    auto schedule_it = pending_schedules_.find(table_name);
+    if (schedule_it != pending_schedules_.end()) {
+        RawScheduleDefV9 schedule_def;
+        schedule_def.scheduled_at_column = schedule_it->second.scheduled_at_column;
+        schedule_def.reducer_name = schedule_it->second.reducer_name;
+        schedule = schedule_def;
+        
+        // Remove the pending schedule since we've used it
+        pending_schedules_.erase(schedule_it);
+    }
+    
+    // Add the complete V9 table definition
+    AddV9Table(table_name, table_type, &typeid(T), is_public,
+               primary_key, indexes, v9_constraints, sequences, schedule);
+}
+
+// Template implementation for AddFieldConstraint
+template<typename T>
+void V9Builder::AddFieldConstraint(const std::string& table_name,
+                                   const std::string& field_name,
+                                   FieldConstraint constraint) {
+    // AddFieldConstraint implementation
+    
+    // Find the existing table by name
+    RawTableDefV9* table = findTableByName(table_name);
+    if (!table) {
+        fprintf(stderr, "ERROR: Table '%s' not found when trying to add constraint to field '%s'\n",
+                table_name.c_str(), field_name.c_str());
+        return;
+    }
+    
+    // Get field descriptors to find the field index
+    SpacetimeDb::field_registrar<T>::register_fields();
+    auto& descriptor_map = SpacetimeDb::get_table_descriptors();
+    auto it = descriptor_map.find(&typeid(T));
+    if (it == descriptor_map.end()) {
+        fprintf(stderr, "ERROR: No field descriptors found for table %s\n", table_name.c_str());
+        return;
+    }
+    
+    const auto& field_descs = it->second.fields;
+    uint16_t field_idx = 0;
+    bool field_found = false;
+    
+    // Find the field index
+    for (const auto& field_desc : field_descs) {
+        if (field_desc.name == field_name) {
+            field_found = true;
+            break;
+        }
+        field_idx++;
+    }
+    
+    if (!field_found) {
+        fprintf(stderr, "ERROR: Field '%s' not found in table '%s'\n", 
+                field_name.c_str(), table_name.c_str());
+        return;
+    }
+    
+    // Add constraint based on type
+    int constraint_bits = static_cast<int>(constraint);
+    
+    // Check for PrimaryKey (has specific bit 0b1000)
+    if (constraint_bits & 0b1000) {  // PrimaryKey-specific bit
+        // Validate that there isn't already a primary key
+        if (!table->primary_key.empty()) {
+            // Set the error flag instead of crashing - this will be handled by preinit_99
+            SetMultiplePrimaryKeyError(table_name);
+            return; // Exit early to avoid adding the conflicting primary key
+        }
+        table->primary_key.push_back(field_idx);
+        
+        // PrimaryKey implies Unique constraint and index
+        table->constraints.push_back(createUniqueConstraint(table_name, field_name, field_idx));
+        table->indexes.push_back(createBTreeIndex(table_name, field_name, field_idx));
+        
+        fprintf(stdout, "DEBUG: Added PrimaryKey constraint and index for %s.%s\n", 
+                table_name.c_str(), field_name.c_str());
+    }
+    // Check for Unique (has bit 0b0100, but not PrimaryKey)
+    else if ((constraint_bits & 0b0100) && !(constraint_bits & 0b1000)) {
+        table->constraints.push_back(createUniqueConstraint(table_name, field_name, field_idx));
+        table->indexes.push_back(createBTreeIndex(table_name, field_name, field_idx));
+        
+        fprintf(stdout, "DEBUG: Added Unique constraint and index for %s.%s\n", 
+                table_name.c_str(), field_name.c_str());
+    }
+    // Check for plain Index (has bit 0b0001, but not Unique or PrimaryKey bits)
+    else if ((constraint_bits & 0b0001) && !(constraint_bits & 0b1100)) {
+        // Just create an index, no constraint
+        table->indexes.push_back(createBTreeIndex(table_name, field_name, field_idx));
+        
+        fprintf(stdout, "DEBUG: Added Index for %s.%s\n", 
+                table_name.c_str(), field_name.c_str());
+    }
+    
+    // Check for AutoInc
+    if (constraint_bits & static_cast<int>(FieldConstraint::AutoInc)) {
+        RawSequenceDefV9 seq_def;
+        seq_def.name = table_name + "_" + field_name + "_seq";
+        seq_def.column = field_idx;
+        seq_def.start = std::nullopt;
+        seq_def.increment = SpacetimeDb::I128(1);
+        seq_def.min_value = std::nullopt;
+        seq_def.max_value = std::nullopt;
+        table->sequences.push_back(std::move(seq_def));
+        
+        fprintf(stdout, "DEBUG: Added AutoInc sequence for %s.%s\n", 
+                table_name.c_str(), field_name.c_str());
+    }
+}
+
+// Template implementation for AddMultiColumnIndex
+template<typename T>
+void V9Builder::AddMultiColumnIndex(const std::string& table_name,
+                                    const std::string& index_name,
+                                    const std::vector<std::string>& field_names) {
+    fprintf(stdout, "DEBUG: Adding multi-column index '%s' to table '%s' with %zu fields\n", 
+            index_name.c_str(), table_name.c_str(), field_names.size());
+    
+    // Find the existing table
+    RawTableDefV9* table = findTableByName(table_name);
+    if (!table) {
+        fprintf(stderr, "ERROR: Table '%s' not found for multi-column index '%s'\n",
+                table_name.c_str(), index_name.c_str());
+        return;
+    }
+    
+    // Get field descriptors to find the field index
+    SpacetimeDb::field_registrar<T>::register_fields();
+    auto& descriptor_map = SpacetimeDb::get_table_descriptors();
+    auto it = descriptor_map.find(&typeid(T));
+    if (it == descriptor_map.end()) {
+        fprintf(stderr, "ERROR: No field descriptors found for table %s\n", table_name.c_str());
+        return;
+    }
+    
+    const auto& field_descs = it->second.fields;
+    std::vector<uint16_t> field_indexes;
+    
+    // Find field indices for each field name
+    for (const std::string& field_name : field_names) {
+        uint16_t field_idx = 0;
+        bool field_found = false;
+        
+        for (const auto& field_desc : field_descs) {
+            if (field_desc.name == field_name) {
+                field_indexes.push_back(field_idx);
+                field_found = true;
+                fprintf(stdout, "DEBUG: Field '%s' -> index %u\n", field_name.c_str(), field_idx);
+                break;
+            }
+            field_idx++;
+        }
+        
+        if (!field_found) {
+            fprintf(stderr, "ERROR: Field '%s' not found in table '%s' for multi-column index\n",
+                    field_name.c_str(), table_name.c_str());
+            return;
+        }
+    }
+    
+    // Create the multi-column BTree algorithm
+    RawIndexAlgorithmBTreeData btree_data;
+    btree_data.columns = field_indexes;
+    
+    RawIndexAlgorithm algorithm;
+    algorithm.set<0>(btree_data);  // Set BTree variant
+    
+    // Create the index definition with both the user-provided name and generated btree name
+    RawIndexDefV9 index_def;
+    std::string generated_name = table_name + "_" + field_names[0];
+    for (size_t i = 1; i < field_names.size(); ++i) {
+        generated_name += "_" + field_names[i];
+    }
+    generated_name += "_idx_btree";  // Generated btree index name
+    index_def.name = generated_name;
+    index_def.accessor_name = index_name;  // User-provided index name for access
+    index_def.algorithm = algorithm;
+    
+    // Add to table's indexes
+    table->indexes.push_back(std::move(index_def));
+    
+    fprintf(stdout, "DEBUG: Successfully added multi-column index '%s' -> '%s' with %zu fields\n",
+            index_name.c_str(), generated_name.c_str(), field_indexes.size());
+}
+
+// Helper trait to extract function parameter types
+template<typename T>
+struct function_traits;
+
+template<typename R, typename... Args>
+struct function_traits<R(*)(Args...)> {
+    static constexpr size_t arity = sizeof...(Args);
+    using result_type = R;
+    
+    template<size_t N>
+    using arg_t = typename std::tuple_element<N, std::tuple<Args...>>::type;
+};
+
+
+// Template implementation for RegisterReducerCommon - shared logic
+template<typename Func>
+void V9Builder::RegisterReducerCommon(const std::string& reducer_name, 
+                                      Func func,
+                                      const std::vector<std::string>& param_names,
+                                      std::optional<Lifecycle> lifecycle) {
+    // Skip reducer registration if circular reference was detected
+    if (g_circular_ref_error) {
+        fprintf(stdout, "DEBUG: Skipping reducer '%s' registration due to circular reference error\n", 
+                reducer_name.c_str());
+        return;
+    }
+    
+    using traits = function_traits<Func>;
+    
+    // Build vectors of parameter information
+    std::vector<bsatn::AlgebraicType> param_types;
+    std::vector<const std::type_info*> param_cpp_types;
+    std::vector<std::string> param_type_names;
+    
+    // Extract parameter types (skip ReducerContext at index 0)
+    if constexpr (traits::arity > 1) {
+        []<std::size_t... Is>(std::index_sequence<Is...>, 
+                              std::vector<bsatn::AlgebraicType>& types,
+                              std::vector<const std::type_info*>& cpp_types) {
+            (([]<std::size_t I>(std::vector<bsatn::AlgebraicType>& types_inner,
+                                std::vector<const std::type_info*>& cpp_types_inner) {
+                if constexpr (I > 0) {  // Skip the first parameter (ReducerContext)
+                    using param_type = typename traits::template arg_t<I>;
+                    types_inner.push_back(bsatn::bsatn_traits<param_type>::algebraic_type());
+                    cpp_types_inner.push_back(&typeid(param_type));
+                }
+            }.template operator()<Is>(types, cpp_types)), ...);
+        }(std::make_index_sequence<traits::arity>{}, param_types, param_cpp_types);
+    }
+    
+    // Create the handler wrapper
+    std::function<void(ReducerContext&, BytesSource)> handler;
+    
+    if constexpr (traits::arity == 1) {
+        // Only ReducerContext parameter
+        handler = [func](ReducerContext& ctx, BytesSource) {
+            func(ctx);
+        };
+    } else {
+        // Has additional parameters
+        handler = [func](ReducerContext& ctx, BytesSource args_source) {
+            std::vector<uint8_t> args_bytes = ConsumeBytes(args_source);
+            
+            []<std::size_t... Js>(std::index_sequence<Js...>, 
+                                  Func fn,
+                                  ReducerContext& ctx_inner,
+                                  const std::vector<uint8_t>& bytes) {
+                if constexpr (sizeof...(Js) > 0) {
+                    bsatn::Reader reader(bytes.data(), bytes.size());
+                    auto args = std::make_tuple(
+                        bsatn::deserialize<typename traits::template arg_t<Js + 1>>(reader)...
+                    );
+                    
+                    std::apply([&ctx_inner, fn](auto&&... args) {
+                        fn(ctx_inner, std::forward<decltype(args)>(args)...);
+                    }, args);
+                }
+            }(std::make_index_sequence<traits::arity - 1>{}, func, ctx, args_bytes);
+        };
+    }
+    
+    // Generate parameter names if not provided
+    std::vector<std::string> actual_param_names = param_names;
+    if (actual_param_names.size() < param_types.size()) {
+        actual_param_names.resize(param_types.size());
+        for (size_t i = param_names.size(); i < param_types.size(); ++i) {
+            actual_param_names[i] = "arg" + std::to_string(i);
+        }
+    }
+    
+    // Add the complete V9 reducer definition
+    AddV9Reducer(reducer_name, param_types, actual_param_names, 
+                 param_cpp_types, param_type_names, lifecycle);
+    
+    // Register the handler for runtime dispatch
+    RegisterReducerHandler(reducer_name, handler, lifecycle);
+}
+
+// Template implementation for RegisterReducer using C++20 features
+template<typename Func>
+void V9Builder::RegisterReducer(const std::string& reducer_name, Func func) {
+    // Call the overload with empty parameter names (for backwards compatibility)
+    RegisterReducer(reducer_name, func, std::vector<std::string>{});
+}
+
+// Template implementation for RegisterReducer with explicit parameter names
+template<typename Func>
+void V9Builder::RegisterReducer(const std::string& reducer_name, Func func,
+                                const std::vector<std::string>& param_names) {
+    // Use the common helper function
+    RegisterReducerCommon(reducer_name, func, param_names, std::nullopt);
+}
+
+// Template implementation for RegisterLifecycleReducer 
+template<typename Func>
+void V9Builder::RegisterLifecycleReducer(const std::string& reducer_name, Func func,
+                                         Lifecycle lifecycle) {
+    // Generate default parameter names and use the common helper
+    std::vector<std::string> empty_names;
+    RegisterReducerCommon(reducer_name, func, empty_names, lifecycle);
+}
+
+// Global V9Builder instance for the module
+extern std::unique_ptr<V9Builder> g_v9_builder;
+
+// Initialize the V9 builder (called once at module startup)
+void initializeV9Builder();
+
+// Get the global V9 builder
+V9Builder& getV9Builder();
+
+// =============================================================================
+// Helper Functions (used internally by RegisterTable and RegisterReducer)
+// =============================================================================
+
+} // namespace Internal
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_V9_BUILDER_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/internal/v9_type_registration.h b/crates/bindings-cpp/include/spacetimedb/internal/v9_type_registration.h
new file mode 100644
index 00000000000..0b57077264e
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/internal/v9_type_registration.h
@@ -0,0 +1,403 @@
+#ifndef SPACETIMEDB_V9_TYPE_REGISTRATION_H
+#define SPACETIMEDB_V9_TYPE_REGISTRATION_H
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <string>
+#include <typeinfo>
+#include <cxxabi.h>
+#include "../bsatn/bsatn.h"
+
+// Forward declarations
+namespace SpacetimeDb {
+namespace Internal {
+    class AlgebraicType;
+}
+namespace detail {
+    // Forward declaration for namespace storage
+    template<typename T>
+    struct namespace_info;
+}
+}
+
+// Helper function to demangle C++ type names - inline implementation for template usage
+inline std::string demangle_cpp_type_name(const char* name) {
+    int status = 0;
+    std::unique_ptr<char, void(*)(void*)> demangled(
+        abi::__cxa_demangle(name, nullptr, nullptr, &status),
+        std::free
+    );
+    return (status == 0 && demangled) ? std::string(demangled.get()) : std::string(name);
+}
+
+namespace SpacetimeDb {
+namespace Internal {
+
+/**
+ * V9TypeRegistration - Single unified type registration system for V9 modules
+ * 
+ * Core principles:
+ * - Only user-defined structs and enums get registered in the types array
+ * - Primitives, arrays, Options, and special types are always inlined
+ * - Every registered type gets a name and RawTypeDefV9 export
+ * - Single entry point: registerType()
+ * 
+ * Type handling:
+ * - Primitives (Bool, U8, I32, etc.) → Return inline, never registered
+ * - Arrays → Return inline with recursive element processing
+ * - Options → Return inline Sum structure
+ * - Special types (Identity, etc.) → Return inline Product structure
+ * - User structs/enums → Register in typespace, return Ref
+ */
+class V9TypeRegistration {
+private:
+    // Cache of type name -> typespace index (built from GetV9Module().types)
+    std::unordered_map<std::string, uint32_t> type_name_cache_;
+    
+    // Track types currently being registered to detect cycles
+    std::unordered_set<std::string> types_being_registered_;
+    
+    // Error state - set when we detect validation errors
+    bool has_error_ = false;
+    std::string error_message_;
+    std::string error_type_description_;  // Stores the type structure for debugging
+    
+
+public:
+    /**
+     * THE ONLY type registration function - single entry point for all types
+     * 
+     * @param bsatn_type The type to process
+     * @param explicit_name Optional explicit name for the type
+     * @param cpp_type Optional C++ type info for name extraction
+     * @return AlgebraicType - either inline (primitives/arrays/special) or Ref to registered type
+     */
+    ::SpacetimeDb::Internal::AlgebraicType registerType(const bsatn::AlgebraicType& bsatn_type,
+                                                        const std::string& explicit_name = "",
+                                                        const std::type_info* cpp_type = nullptr);
+    
+    /**
+     * Register a type immediately by name (called by enum macros)
+     * This registers the type the first time its algebraic_type() is called
+     */
+    void registerTypeByName(const std::string& type_name, 
+                            const bsatn::AlgebraicType& algebraic_type,
+                            const std::type_info* cpp_type);
+    
+    /**
+     * Register a type and return its typespace index
+     * Used by simple enums to get a Ref they can return
+     */
+    uint32_t registerAndGetIndex(const bsatn::AlgebraicType& bsatn_type,
+                                 const std::string& type_name,
+                                 const std::type_info* cpp_type = nullptr);
+    
+    /**
+     * Check if any errors occurred during type registration
+     */
+    bool hasError() const { return has_error_; }
+    
+    /**
+     * Get the error message if an error occurred
+     */
+    const std::string& getErrorMessage() const { return error_message_; }
+    
+    /**
+     * Get the error type description if an error occurred
+     */
+    const std::string& getErrorTypeDescription() const { return error_type_description_; }
+    
+    /**
+     * Add namespace qualification to an existing registered type
+     * 
+     * This is called by SPACETIMEDB_NAMESPACE macros during preinit to modify
+     * the registered type name with a namespace prefix.
+     * 
+     * @tparam T The C++ type to modify
+     * @param namespace_prefix The namespace prefix to prepend (e.g., "Namespace")
+     */
+    template<typename T>
+    void set_type_namespace(const std::string& namespace_prefix) {
+        // Get the type name that was registered
+        std::string original_name = demangle_cpp_type_name(typeid(T).name());
+        
+        // Find the type in our cache
+        auto it = type_name_cache_.find(original_name);
+        if (it != type_name_cache_.end()) {
+            uint32_t type_index = it->second;
+            std::string qualified_name = namespace_prefix + "." + original_name;
+            
+            // Update the cache with the new name
+            type_name_cache_.erase(it);
+            type_name_cache_[qualified_name] = type_index;
+            
+            // Update the actual type name in the module definition
+            updateTypeNameInModule(type_index, qualified_name);
+        }
+    }
+    
+    /**
+     * Clear all registration state - used to reset between module builds
+     */
+    void clear() {
+        type_name_cache_.clear();
+        types_being_registered_.clear();
+        has_error_ = false;
+        error_message_.clear();
+        error_type_description_.clear();
+    }
+
+private:
+    /**
+     * Check if a type is a primitive (tags 0-19)
+     */
+    bool isPrimitive(const bsatn::AlgebraicType& type) const;
+    
+    /**
+     * Check if a type is a special type (Identity, ConnectionId, etc.)
+     */
+    bool isSpecialType(const bsatn::AlgebraicType& type) const;
+    
+    /**
+     * Check if a type is an Option (Sum with "some" and "none" variants)
+     */
+    bool isOptionType(const bsatn::AlgebraicType& type) const;
+    
+    /**
+     * Check if a type is ScheduleAt (Sum with "Interval" and "Time" variants)
+     */
+    bool isScheduleAtType(const bsatn::AlgebraicType& type) const;
+    
+    /**
+     * Check if a type is Unit (empty Product)
+     */
+    bool isUnitType(const bsatn::AlgebraicType& type) const;
+    
+    /**
+     * Extract a clean type name from C++ type_info
+     */
+    std::string extractTypeName(const std::type_info* cpp_type) const;
+    
+    /**
+     * Parse namespace and name from qualified name (e.g., "Namespace.TestC" -> ["Namespace"], "TestC")
+     */
+    std::pair<std::vector<std::string>, std::string> parseNamespaceAndName(const std::string& qualified_name) const;
+    
+    /**
+     * Convert a primitive BSATN type to internal AlgebraicType
+     */
+    ::SpacetimeDb::Internal::AlgebraicType convertPrimitive(const bsatn::AlgebraicType& type) const;
+    
+    /**
+     * Convert an array type, recursively processing the element
+     */
+    ::SpacetimeDb::Internal::AlgebraicType convertArray(const bsatn::AlgebraicType& type);
+    
+    /**
+     * Convert a special type to its inline Product structure
+     */
+    ::SpacetimeDb::Internal::AlgebraicType convertSpecialType(const bsatn::AlgebraicType& type);
+    
+    /**
+     * Convert an Option or ScheduleAt to its inline Sum structure
+     */
+    ::SpacetimeDb::Internal::AlgebraicType convertInlineSum(const bsatn::AlgebraicType& type);
+    
+    /**
+     * Convert a Unit type to its inline Product structure
+     */
+    ::SpacetimeDb::Internal::AlgebraicType convertUnitType() const;
+    
+    /**
+     * Register a complex user-defined type (struct or enum)
+     */
+    ::SpacetimeDb::Internal::AlgebraicType registerComplexType(const bsatn::AlgebraicType& type,
+                                                               const std::string& type_name);
+    
+    /**
+     * Process a Product type, recursively registering field types
+     */
+    ::SpacetimeDb::Internal::AlgebraicType processProduct(const bsatn::AlgebraicType& type);
+    
+    /**
+     * Process a Sum type, recursively registering variant types
+     */
+    ::SpacetimeDb::Internal::AlgebraicType processSum(const bsatn::AlgebraicType& type);
+    
+    /**
+     * Describe a type structure for error messages
+     */
+    std::string describeType(const bsatn::AlgebraicType& type) const;
+    
+    /**
+     * Update the type name in the actual module definition
+     * 
+     * This modifies the RawTypeDefV9 entry in the module to use the new
+     * namespace-qualified name for client generation.
+     * 
+     * @param type_index The index of the type to update
+     * @param new_name The new qualified name to use
+     */
+    void updateTypeNameInModule(uint32_t type_index, const std::string& new_name);
+    
+};
+
+// Global V9 type registration instance
+extern std::unique_ptr<V9TypeRegistration> g_v9_type_registration;
+
+// Initialize the V9 type registration (called once at module startup)
+void initializeV9TypeRegistration();
+
+// Get the global V9 type registration
+V9TypeRegistration& getV9TypeRegistration();
+
+} // namespace Internal
+
+namespace Internal {
+
+// Thread-local storage for tracking the chain of types being registered
+// This is used to detect circular references during type building
+extern thread_local std::vector<std::string> g_type_registration_chain;
+
+// Global flag to indicate circular reference error (set during type building)
+extern bool g_circular_ref_error;
+extern std::string g_circular_ref_type_name;
+
+/**
+ * @brief Template helper to abstract the lazy type registration pattern
+ * 
+ * This eliminates code duplication between enums and structs that all follow
+ * the same pattern:
+ * - Static variable to cache the type index
+ * - One-time registration on first call
+ * - Return Ref to the registered type
+ * 
+ * Benefits of this abstraction:
+ * - Reduces code duplication by ~15 lines per type
+ * - Consistent registration behavior across all user-defined types
+ * - Better error handling and validation
+ * - Thread-safe initialization
+ * - Cleaner macro implementations
+ * 
+ * @tparam T The C++ type being registered
+ */
+template<typename T>
+class LazyTypeRegistrar {
+private:
+    static inline uint32_t type_index_ = 0xFFFFFFFF;
+    
+public:
+    /**
+     * Get or register a type with lazy initialization
+     * 
+     * This method uses lazy initialization to register a type only when first needed.
+     * The registration is thread-safe and cached for subsequent calls.
+     * 
+     * @tparam BuilderFunc Function type that builds the AlgebraicType
+     * @param build_func Function that constructs the AlgebraicType for this type
+     * @param type_name Explicit name for the type (typically from #Type macro)
+     * @return AlgebraicType::Ref to the registered type
+     * 
+     * @note The build_func should be a lambda that constructs the AlgebraicType
+     *       without any side effects, as it may be called during registration.
+     */
+    template<typename BuilderFunc>
+    static bsatn::AlgebraicType getOrRegister(BuilderFunc&& build_func, 
+                                              const std::string& type_name) {
+        // Check if already registered (fast path for subsequent calls)
+        if (type_index_ != 0xFFFFFFFF) {
+            return bsatn::AlgebraicType::make_ref(type_index_);
+        }
+        
+        // Check if this type has namespace information and build qualified name
+        std::string qualified_name = type_name;
+        if constexpr (requires { SpacetimeDb::detail::namespace_info<T>::value; }) {
+            constexpr const char* namespace_prefix = SpacetimeDb::detail::namespace_info<T>::value;
+            if (namespace_prefix != nullptr) {
+                qualified_name = std::string(namespace_prefix) + "." + type_name;
+            }
+        }
+        
+        // CRITICAL: Check for circular references BEFORE building the type
+        // This prevents infinite recursion during type construction
+        for (const auto& type_in_chain : g_type_registration_chain) {
+            if (type_in_chain == qualified_name) {
+                // Circular reference detected!
+                fprintf(stderr, "\n\n[CIRCULAR REFERENCE DETECTED]\n");
+                fprintf(stderr, "ERROR: Circular reference detected for type '%s'\n", qualified_name.c_str());
+                fprintf(stderr, "  Registration chain: ");
+                for (const auto& t : g_type_registration_chain) {
+                    fprintf(stderr, "%s -> ", t.c_str());
+                }
+                fprintf(stderr, "%s (circular!)\n", qualified_name.c_str());
+                fprintf(stderr, "Setting g_circular_ref_error = true\n");
+                fprintf(stderr, "[END CIRCULAR REFERENCE DETECTION]\n\n");
+                fflush(stderr);
+                
+                // Set global error flag for preinit_99 to handle
+                g_circular_ref_error = true;
+                g_circular_ref_type_name = qualified_name;
+                
+                // Return a simple primitive type to break the infinite recursion
+                // This prevents any invalid references from being created
+                // The error will be handled in preinit_99
+                return bsatn::AlgebraicType::U32();  // Return a safe primitive type
+            }
+        }
+        
+        // Add this type to the registration chain
+        g_type_registration_chain.push_back(qualified_name);
+        
+        // Slow path: first registration
+        // Build the algebraic type using the provided function
+        bsatn::AlgebraicType algebraic_type = build_func();
+        
+        // Remove from chain after successful building
+        g_type_registration_chain.pop_back();
+        
+        // Check if circular reference was detected during type building
+        if (g_circular_ref_error) {
+            // Don't register anything - just return the safe type
+            // The error will be handled in preinit_99
+            return algebraic_type;
+        }
+        
+        // Register with V9 system and cache the index using the qualified name
+        type_index_ = getV9TypeRegistration().registerAndGetIndex(
+            algebraic_type, qualified_name, &typeid(T));
+        
+        return bsatn::AlgebraicType::make_ref(type_index_);
+    }
+    
+    /**
+     * Check if this type has been registered yet
+     * @return true if the type has been registered and cached
+     */
+    static bool isRegistered() {
+        return type_index_ != 0xFFFFFFFF;
+    }
+    
+    /**
+     * Get the cached type index (only valid if isRegistered() returns true)
+     * @return The cached type index
+     * @warning Only call this if isRegistered() returns true
+     */
+    static uint32_t getTypeIndex() {
+        return type_index_;
+    }
+    
+    /**
+     * Force reset the registration state (for testing purposes only)
+     * @warning This should not be used in production code
+     */
+    static void resetForTesting() {
+        type_index_ = 0xFFFFFFFF;
+    }
+};
+
+
+} // namespace Internal
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_V9_TYPE_REGISTRATION_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/logger.h b/crates/bindings-cpp/include/spacetimedb/logger.h
new file mode 100644
index 00000000000..344f16c76da
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/logger.h
@@ -0,0 +1,294 @@
+#ifndef SPACETIMEDB_LIBRARY_LOGGING_H
+#define SPACETIMEDB_LIBRARY_LOGGING_H
+
+#include "spacetimedb/abi/FFI.h" // For LogLevel
+#include <string>
+#include <string_view>
+#include <chrono>
+#include <memory>
+#include <cstring>
+#include <cstdio>
+
+namespace SpacetimeDb {
+
+// LogLevel is now from opaque_types.h, imported via FFI.h
+
+// Compile-time filename extraction to avoid runtime filesystem operations
+namespace detail {
+    constexpr const char* extract_filename(const char* path) {
+        const char* file = path;
+        while (*path) {
+            if (*path == '/' || *path == '\\') {
+                file = path + 1;
+            }
+            ++path;
+        }
+        return file;
+    }
+    
+    // Simple printf-style formatting
+    template<typename... Args>
+    std::string format(const char* fmt, Args... args) {
+        // Get required size
+        int size = std::snprintf(nullptr, 0, fmt, args...);
+        if (size <= 0) { return ""; }
+        
+        // Format string
+        std::string result(size + 1, '\0');
+        std::snprintf(result.data(), result.size(), fmt, args...);
+        result.resize(size); // Remove null terminator from std::string
+        return result;
+    }
+}
+
+// Compile-time macro for extracting just the filename
+#define STDB_FILENAME ::SpacetimeDb::detail::extract_filename(__FILE__)
+
+// Default log level - can be overridden at compile time
+#ifndef STDB_LOG_LEVEL
+    #ifdef NDEBUG
+        #define STDB_LOG_LEVEL ::SpacetimeDb::LogLevelValue::INFO
+    #else
+        #define STDB_LOG_LEVEL ::SpacetimeDb::LogLevelValue::DEBUG
+    #endif
+#endif
+
+/**
+ * @brief Optimized logging with caller information using string_view.
+ * @param level The severity level of the message.
+ * @param message The message to log.
+ * @param target The function/method name.
+ * @param filename The source file name (just filename, not full path).
+ * @param line_number The source line number.
+ * @ingroup sdk_runtime sdk_logging
+ */
+inline void log_with_caller_info(LogLevel level, std::string_view message, 
+                                std::string_view target = "", 
+                                std::string_view filename = "", 
+                                uint32_t line_number = 0) {
+    FFI::console_log(level,
+                   reinterpret_cast<const uint8_t*>(target.data()), target.length(),
+                   reinterpret_cast<const uint8_t*>(filename.data()), filename.length(),
+                   line_number,
+                   reinterpret_cast<const uint8_t*>(message.data()), message.length());
+}
+
+/**
+ * @brief Simple logging without caller information (optimized).
+ * @param level The severity level of the message.
+ * @param message The message to log.
+ * @ingroup sdk_runtime sdk_logging
+ */
+inline void log(LogLevel level, std::string_view message) {
+    log_with_caller_info(level, message, "", "", 0);
+}
+
+// Legacy overloads for backward compatibility
+inline void log_with_caller_info(LogLevel level, const std::string& message, 
+                                const char* target = nullptr, 
+                                const char* filename = nullptr, 
+                                uint32_t line_number = 0) {
+    log_with_caller_info(level, std::string_view(message), 
+                        target ? std::string_view(target) : std::string_view(""),
+                        filename ? std::string_view(filename) : std::string_view(""),
+                        line_number);
+}
+
+inline void log(LogLevel level, const std::string& message) {
+    log(level, std::string_view(message));
+}
+
+// Optimized logging macros with compile-time level filtering
+#define LOG_ERROR(message) \
+    do { \
+        if constexpr (STDB_LOG_LEVEL >= ::SpacetimeDb::LogLevelValue::ERROR) { \
+            ::SpacetimeDb::log_with_caller_info(::SpacetimeDb::LogLevelValue::ERROR, (message), __func__, STDB_FILENAME, __LINE__); \
+        } \
+    } while(0)
+
+#define LOG_WARN(message) \
+    do { \
+        if constexpr (STDB_LOG_LEVEL >= ::SpacetimeDb::LogLevelValue::WARN) { \
+            ::SpacetimeDb::log_with_caller_info(::SpacetimeDb::LogLevelValue::WARN, (message), __func__, STDB_FILENAME, __LINE__); \
+        } \
+    } while(0)
+
+#define LOG_INFO(message) \
+    do { \
+        if constexpr (STDB_LOG_LEVEL >= ::SpacetimeDb::LogLevelValue::INFO) { \
+            ::SpacetimeDb::log_with_caller_info(::SpacetimeDb::LogLevelValue::INFO, (message), __func__, STDB_FILENAME, __LINE__); \
+        } \
+    } while(0)
+
+#define LOG_DEBUG(message) \
+    do { \
+        if constexpr (STDB_LOG_LEVEL >= ::SpacetimeDb::LogLevelValue::DEBUG) { \
+            ::SpacetimeDb::log_with_caller_info(::SpacetimeDb::LogLevelValue::DEBUG, (message), __func__, STDB_FILENAME, __LINE__); \
+        } \
+    } while(0)
+
+#define LOG_TRACE(message) \
+    do { \
+        if constexpr (STDB_LOG_LEVEL >= ::SpacetimeDb::LogLevelValue::TRACE) { \
+            ::SpacetimeDb::log_with_caller_info(::SpacetimeDb::LogLevelValue::TRACE, (message), __func__, STDB_FILENAME, __LINE__); \
+        } \
+    } while(0)
+
+// Printf-style logging macros for convenience
+#define LOG_ERROR_F(fmt, ...) LOG_ERROR(::SpacetimeDb::detail::format(fmt, ##__VA_ARGS__))
+#define LOG_WARN_F(fmt, ...) LOG_WARN(::SpacetimeDb::detail::format(fmt, ##__VA_ARGS__))
+#define LOG_INFO_F(fmt, ...) LOG_INFO(::SpacetimeDb::detail::format(fmt, ##__VA_ARGS__))
+#define LOG_DEBUG_F(fmt, ...) LOG_DEBUG(::SpacetimeDb::detail::format(fmt, ##__VA_ARGS__))
+#define LOG_TRACE_F(fmt, ...) LOG_TRACE(::SpacetimeDb::detail::format(fmt, ##__VA_ARGS__))
+
+// Special panic macro that logs as ERROR level
+#define LOG_PANIC(message) \
+    do { \
+        ::SpacetimeDb::log_with_caller_info(::SpacetimeDb::LogLevelValue::ERROR, (message), __func__, STDB_FILENAME, __LINE__); \
+    } while(0)
+
+// Fatal error macro that logs and aborts (for exception-free code)
+#define LOG_FATAL(message) \
+    do { \
+        ::SpacetimeDb::log_with_caller_info(::SpacetimeDb::LogLevelValue::ERROR, (message), __func__, STDB_FILENAME, __LINE__); \
+        std::abort(); \
+    } while(0)
+
+// Convenience functions using string_view (inline for optimization)
+inline void log_error(std::string_view message) { log(LogLevelValue::ERROR, message); }
+inline void log_warn(std::string_view message) { log(LogLevelValue::WARN, message); }
+inline void log_info(std::string_view message) { log(LogLevelValue::INFO, message); }
+inline void log_debug(std::string_view message) { log(LogLevelValue::DEBUG, message); }
+inline void log_trace(std::string_view message) { log(LogLevelValue::TRACE, message); }
+inline void log_panic(std::string_view message) { log(LogLevelValue::ERROR, message); } // Panic logs as ERROR
+
+// Legacy overloads for backward compatibility
+inline void log_error(const std::string& message) { log_error(std::string_view(message)); }
+inline void log_warn(const std::string& message) { log_warn(std::string_view(message)); }
+inline void log_info(const std::string& message) { log_info(std::string_view(message)); }
+inline void log_debug(const std::string& message) { log_debug(std::string_view(message)); }
+inline void log_trace(const std::string& message) { log_trace(std::string_view(message)); }
+
+/**
+ * @brief Optimized RAII performance measurement utility.
+ * 
+ * This class provides automatic performance timing with SpacetimeDB's
+ * console timer system. The timer starts when constructed and automatically
+ * ends when the object is destroyed (RAII pattern).
+ * 
+ * Improvements:
+ * - Uses string_view to avoid allocations
+ * - Supports retrieving elapsed time
+ * - Better move semantics
+ * - Inline implementation for better optimization
+ * 
+ * Example usage:
+ * @code
+ * {
+ *     LogStopwatch timer("database_operation");
+ *     // ... perform database operations ...
+ *     // Timer automatically ends when timer goes out of scope
+ * }
+ * @endcode
+ * 
+ * @ingroup sdk_runtime sdk_logging
+ */
+class LogStopwatch {
+public:
+    /**
+     * @brief Start a performance timer with the given name.
+     * @param name The name of the operation being timed.
+     */
+    explicit LogStopwatch(std::string_view name) : ended_(false) {
+        timer_id_ = FFI::console_timer_start(
+            reinterpret_cast<const uint8_t*>(name.data()),
+            name.length()
+        );
+        start_time_ = std::chrono::steady_clock::now();
+    }
+    
+    // Constructor accepting std::string for backward compatibility
+    explicit LogStopwatch(const std::string& name) : LogStopwatch(std::string_view(name)) {}
+    
+    /**
+     * @brief Destructor automatically ends the timer.
+     */
+    ~LogStopwatch() {
+        if (!ended_) {
+            end();
+        }
+    }
+    
+    /**
+     * @brief Manually end the timer (optional - destructor will do this automatically).
+     */
+    void end() {
+        if (!ended_) {
+            auto status = FFI::console_timer_end(timer_id_);
+            ended_ = true;
+            end_time_ = std::chrono::steady_clock::now();
+            // TODO: Add error handling when we implement exception system
+            (void)status; // Suppress unused variable warning for now
+        }
+    }
+    
+    /**
+     * @brief Get elapsed time in microseconds.
+     * @return Elapsed time or 0 if timer hasn't ended.
+     */
+    uint64_t elapsed_microseconds() const {
+        if (ended_) {
+            return std::chrono::duration_cast<std::chrono::microseconds>(
+                end_time_ - start_time_).count();
+        }
+        // Return current elapsed time if not ended
+        auto now = std::chrono::steady_clock::now();
+        return std::chrono::duration_cast<std::chrono::microseconds>(
+            now - start_time_).count();
+    }
+    
+    /**
+     * @brief Get elapsed time in milliseconds.
+     * @return Elapsed time or 0 if timer hasn't ended.
+     */
+    uint64_t elapsed_milliseconds() const {
+        return elapsed_microseconds() / 1000;
+    }
+    
+    // Disable copy construction and assignment
+    LogStopwatch(const LogStopwatch&) = delete;
+    LogStopwatch& operator=(const LogStopwatch&) = delete;
+    
+    // Allow move construction and assignment
+    LogStopwatch(LogStopwatch&& other) noexcept
+        : timer_id_(other.timer_id_), 
+          ended_(other.ended_),
+          start_time_(other.start_time_),
+          end_time_(other.end_time_) {
+        other.ended_ = true; // Prevent double-ending
+    }
+    
+    LogStopwatch& operator=(LogStopwatch&& other) noexcept {
+        if (this != &other) {
+            if (!ended_) {
+                end(); // End current timer
+            }
+            timer_id_ = other.timer_id_;
+            ended_ = other.ended_;
+            start_time_ = other.start_time_;
+            end_time_ = other.end_time_;
+            other.ended_ = true; // Prevent double-ending
+        }
+        return *this;
+    }
+
+private:
+    ConsoleTimerId timer_id_;
+    bool ended_;
+    std::chrono::steady_clock::time_point start_time_;
+    std::chrono::steady_clock::time_point end_time_;
+};
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_LIBRARY_LOGGING_H
diff --git a/crates/bindings-cpp/include/spacetimedb/macros.h b/crates/bindings-cpp/include/spacetimedb/macros.h
new file mode 100644
index 00000000000..f18fa6769ec
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/macros.h
@@ -0,0 +1,613 @@
+#ifndef SPACETIMEDB_MACROS_H
+#define SPACETIMEDB_MACROS_H
+
+#include "spacetimedb/bsatn/bsatn.h"
+#include "spacetimedb/reducer_context.h"
+#include "spacetimedb/table.h"
+#include "spacetimedb/schedule_reducer.h"
+#include "spacetimedb/rls.h" // For future Row Level Security functionality
+#include "spacetimedb/bsatn/traits.h"
+
+#include <string>
+
+// =============================================================================
+// UNIFIED HELPER MACROS FOR SPACETIMEDB TYPE REGISTRATION
+// =============================================================================
+
+/**
+ * @brief Common CONCAT macros - unified from multiple files
+ * 
+ * These eliminate duplication of CONCAT macro definitions across files.
+ */
+#ifndef SPACETIMEDB_CONCAT_IMPL
+#define SPACETIMEDB_CONCAT_IMPL(a, b) a##b
+#define SPACETIMEDB_CONCAT(a, b) SPACETIMEDB_CONCAT_IMPL(a, b)
+#endif
+
+/**
+ * @brief Helper for stringifying values (used in export names)
+ */
+#ifndef SPACETIMEDB_STRINGIFY_IMPL
+#define SPACETIMEDB_STRINGIFY_IMPL(x) #x  
+#define SPACETIMEDB_STRINGIFY(x) SPACETIMEDB_STRINGIFY_IMPL(x)
+#endif
+
+/**
+ * @brief Compatibility aliases for files that use different macro names
+ * 
+ * This provides backward compatibility while centralizing macro definitions.
+ * Files can gradually migrate to the SPACETIMEDB_* prefixed versions.
+ */
+
+// Non-prefixed compatibility aliases
+#ifndef CONCAT_IMPL
+#define CONCAT_IMPL(a, b) SPACETIMEDB_CONCAT_IMPL(a, b)
+#define CONCAT(a, b) SPACETIMEDB_CONCAT(a, b)
+#endif
+
+#ifndef STRINGIFY_IMPL  
+#define STRINGIFY_IMPL(x) SPACETIMEDB_STRINGIFY_IMPL(x)
+#define STRINGIFY(x) SPACETIMEDB_STRINGIFY(x)
+#endif
+
+// SPACETIMEDB_PASTE compatibility alias (some files use PASTE instead of CONCAT)
+#ifndef SPACETIMEDB_PASTE_IMPL
+#define SPACETIMEDB_PASTE_IMPL(a, b) SPACETIMEDB_CONCAT_IMPL(a, b)
+#define SPACETIMEDB_PASTE(a, b) SPACETIMEDB_CONCAT(a, b)
+#endif
+
+// TypeRegistry system removed - use V9TypeRegistration instead
+/*
+// Register a C++ type name in the global TypeRegistry for reducer parameter lookup
+// This replaces the old TypeNameRegistry approach with a unified one.
+// Used by all macros that need reducer parameter support.
+#define SPACETIMEDB_REGISTER_CPP_TYPE_NAME(Type) \
+    namespace { \
+        struct Type##_cpp_name_registrar { \
+            Type##_cpp_name_registrar() { \
+                ::SpacetimeDb::TypeRegistry::global_instance().register_cpp_type_name<Type>(#Type); \
+            } \
+        }; \
+        static Type##_cpp_name_registrar Type##_cpp_name_registrar_instance; \
+    }
+
+// Register a type in the active TypeRegistry with proper naming
+// This is the single registration point that eliminates triple registration.
+// Only registers if a registry is available and not already registered.
+#define SPACETIMEDB_REGISTER_TYPE_IN_REGISTRY(Type, algebraic_type) \
+    do { \
+        static bool Type##_v9_registered = false; \
+        if (!Type##_v9_registered) { \
+            Type##_v9_registered = true; \
+            std::string type_name = #Type; \
+            ::SpacetimeDb::Internal::getV9TypeRegistration().registerTypeByName(type_name, algebraic_type, &typeid(Type)); \
+        } \
+    } while(0)
+*/
+
+/**
+ * @brief Updated registration using V9TypeRegistration system
+ * 
+ * This is the new registration point using the V9TypeRegistration system.
+ */
+#define SPACETIMEDB_REGISTER_TYPE_IN_V9(Type, algebraic_type) \
+    do { \
+        static bool Type##_v9_registered = false; \
+        if (!Type##_v9_registered) { \
+            Type##_v9_registered = true; \
+            std::string type_name = #Type; \
+            /* Register immediately with name and structure */ \
+            ::SpacetimeDb::Internal::getV9TypeRegistration().registerTypeByName(type_name, algebraic_type, &typeid(Type)); \
+        } \
+    } while(0)
+
+/**
+ * @brief Complete type registration (registry + global name registration)
+ * 
+ * This combines both registry registration and global name registration
+ * in a single, atomic operation. Use this in algebraic_type() methods.
+ */
+#define SPACETIMEDB_REGISTER_TYPE_COMPLETE(Type, algebraic_type) \
+    SPACETIMEDB_REGISTER_TYPE_IN_V9(Type, algebraic_type)
+
+/**
+ * @brief Generate a default field_registrar specialization that does nothing
+ * 
+ * Most types don't need field registration (only table types do).
+ * This provides a clean default implementation.
+ */
+#define SPACETIMEDB_GENERATE_EMPTY_FIELD_REGISTRAR(Type) \
+    template<> \
+    struct ::SpacetimeDb::field_registrar<Type> { \
+        static void register_fields() { \
+            /* Default: no field registration needed */ \
+        } \
+    };
+
+/**
+ * @brief Generate a field_registrar that actually registers field descriptors
+ * 
+ * This version is used by SPACETIMEDB_STRUCT to ensure fields
+ * are properly registered for table types.
+ */
+#define SPACETIMEDB_GENERATE_FIELD_REGISTRAR_WITH_FIELDS(Type, ...) \
+    template<> \
+    struct ::SpacetimeDb::field_registrar<Type> { \
+        static void register_fields() { \
+            static bool registered = false; \
+            if (registered) return; \
+            registered = true; \
+            SPACETIMEDB_REGISTER_FIELD_DESCRIPTORS(Type, __VA_ARGS__) \
+        } \
+    };
+
+/**
+ * @brief Generate the complete registration bundle for a type
+ * 
+ * This combines all the registration pieces that most macros need:
+ * - BSATN algebraic_type_of specialization
+ * - Empty field_registrar specialization  
+ * 
+ * Use this for simple types that don't need custom field registration.
+ * Note: Type name registration is now handled automatically by V9TypeRegistration.
+ */
+#define SPACETIMEDB_GENERATE_TYPE_REGISTRATION_BUNDLE(Type) \
+    template<> \
+    struct ::SpacetimeDb::bsatn::algebraic_type_of<Type> { \
+        static ::SpacetimeDb::bsatn::AlgebraicType get() { \
+            return ::SpacetimeDb::bsatn::bsatn_traits<Type>::algebraic_type(); \
+        } \
+    }; \
+    SPACETIMEDB_GENERATE_EMPTY_FIELD_REGISTRAR(Type)
+
+/**
+ * @brief Generate the complete registration bundle with field registration
+ * 
+ * This version includes actual field registration for table types.
+ * Note: Type name registration is now handled automatically by V9TypeRegistration.
+ */
+#define SPACETIMEDB_GENERATE_TYPE_REGISTRATION_BUNDLE_WITH_FIELDS(Type, ...) \
+    template<> \
+    struct ::SpacetimeDb::bsatn::algebraic_type_of<Type> { \
+        static ::SpacetimeDb::bsatn::AlgebraicType get() { \
+            return ::SpacetimeDb::bsatn::bsatn_traits<Type>::algebraic_type(); \
+        } \
+    }; \
+    SPACETIMEDB_GENERATE_FIELD_REGISTRAR_WITH_FIELDS(Type, __VA_ARGS__)
+
+/**
+ * @brief Helper to check if a type is already registered (for optimization)
+ * 
+ * This can be used to avoid expensive operations if a type is already registered.
+ */
+#define SPACETIMEDB_IS_TYPE_REGISTERED(Type) \
+    ([]() { \
+        static bool Type##_checked = false; \
+        return Type##_checked; \
+    }())
+
+/**
+ * @brief Mark a type as registered (for optimization)
+ */
+#define SPACETIMEDB_MARK_TYPE_REGISTERED(Type) \
+    do { \
+        static bool Type##_checked = false; \
+        Type##_checked = true; \
+    } while(0)
+
+/**
+ * @brief Unified preinit function generator
+ * 
+ * This consolidates the pattern used by all table/reducer registration macros:
+ * - Generates unique export name with priority, category, name, and line number
+ * - Creates the preinit function with proper C linkage
+ * 
+ * @param priority Registration order (20 for tables, 30 for reducers)
+ * @param category Type of registration (register_table, reducer, etc.)
+ * @param name Specific name of the item being registered
+ * @param registration_body The actual registration code
+ */
+#define SPACETIMEDB_GENERATE_PREINIT_FUNCTION(priority, category, name, registration_body) \
+    __attribute__((export_name("__preinit__" #priority "_" #category "_" #name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    extern "C" void SPACETIMEDB_CONCAT(__preinit__, SPACETIMEDB_CONCAT(priority, SPACETIMEDB_CONCAT(_, SPACETIMEDB_CONCAT(category, SPACETIMEDB_CONCAT(_, SPACETIMEDB_CONCAT(name, SPACETIMEDB_CONCAT(_line_, __LINE__)))))))() { \
+        registration_body \
+    }
+
+/**
+ * @brief Unified table registration pattern
+ * 
+ * Consolidates the common table registration logic used by SPACETIMEDB_TABLE macro.
+ * 
+ * @param type The table struct type
+ * @param name_str Table name string  
+ * @param access_enum Public/Private access
+ * @param constraint_list Vector initializer for field constraints
+ */
+// SPACETIMEDB_REGISTER_TABLE_TYPE macro removed - replaced by V9Builder system
+
+/**
+ * @brief Unified reducer registration pattern
+ * 
+ * Consolidates the common reducer registration logic used by SPACETIMEDB_REDUCER macro.
+ * 
+ * @param function_name Name of the reducer function
+ * @param function_signature Full parameter list for the function
+ */
+#define SPACETIMEDB_REGISTER_REDUCER_FUNCTION(function_name, function_signature) \
+    void function_name function_signature; \
+    SPACETIMEDB_GENERATE_PREINIT_FUNCTION(30, reducer, function_name, \
+        SpacetimeDb::Internal::register_reducer_func_with_params(std::string(#function_name), function_name, #function_signature); \
+    ) \
+    void function_name function_signature
+
+/**
+ * @brief Unified lifecycle reducer registration
+ * 
+ * Consolidates the pattern used by SPACETIMEDB_INIT, SPACETIMEDB_CLIENT_CONNECTED, etc.
+ * 
+ * @param lifecycle_type Type of lifecycle (init, client_connected, client_disconnected)
+ * @param function_name Name of the reducer function  
+ * @param function_signature Full parameter list for the function
+ * @param register_call The specific registration call for this lifecycle type
+ */
+#define SPACETIMEDB_REGISTER_LIFECYCLE_REDUCER(lifecycle_type, function_name, function_signature, register_call) \
+    void function_name function_signature; \
+    SPACETIMEDB_GENERATE_PREINIT_FUNCTION(20, reducer, lifecycle_type, register_call) \
+    void function_name function_signature
+
+// =============================================================================
+// VARIADIC ARGUMENT PROCESSING UTILITIES
+// =============================================================================
+
+// Consolidated variadic macro system (supports up to 50 arguments)
+// Used by SPACETIMEDB_STRUCT and SPACETIMEDB_VARIANT_ENUM
+#define SPACETIMEDB_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50,NAME,...) NAME
+
+#define SPACETIMEDB_FOR_EACH_ARG(MACRO, obj, extra, ...) \
+    SPACETIMEDB_GET_MACRO(__VA_ARGS__, \
+        SPACETIMEDB_FE_50, SPACETIMEDB_FE_49, SPACETIMEDB_FE_48, SPACETIMEDB_FE_47, SPACETIMEDB_FE_46, \
+        SPACETIMEDB_FE_45, SPACETIMEDB_FE_44, SPACETIMEDB_FE_43, SPACETIMEDB_FE_42, SPACETIMEDB_FE_41, \
+        SPACETIMEDB_FE_40, SPACETIMEDB_FE_39, SPACETIMEDB_FE_38, SPACETIMEDB_FE_37, SPACETIMEDB_FE_36, \
+        SPACETIMEDB_FE_35, SPACETIMEDB_FE_34, SPACETIMEDB_FE_33, SPACETIMEDB_FE_32, SPACETIMEDB_FE_31, \
+        SPACETIMEDB_FE_30, SPACETIMEDB_FE_29, SPACETIMEDB_FE_28, SPACETIMEDB_FE_27, SPACETIMEDB_FE_26, \
+        SPACETIMEDB_FE_25, SPACETIMEDB_FE_24, SPACETIMEDB_FE_23, SPACETIMEDB_FE_22, SPACETIMEDB_FE_21, \
+        SPACETIMEDB_FE_20, SPACETIMEDB_FE_19, SPACETIMEDB_FE_18, SPACETIMEDB_FE_17, SPACETIMEDB_FE_16, \
+        SPACETIMEDB_FE_15, SPACETIMEDB_FE_14, SPACETIMEDB_FE_13, SPACETIMEDB_FE_12, SPACETIMEDB_FE_11, \
+        SPACETIMEDB_FE_10, SPACETIMEDB_FE_9, SPACETIMEDB_FE_8, SPACETIMEDB_FE_7, SPACETIMEDB_FE_6, \
+        SPACETIMEDB_FE_5, SPACETIMEDB_FE_4, SPACETIMEDB_FE_3, SPACETIMEDB_FE_2, SPACETIMEDB_FE_1) \
+    (MACRO, obj, extra, __VA_ARGS__)
+
+#define SPACETIMEDB_FE_1(MACRO, obj, extra, X) MACRO(obj, extra, X)
+#define SPACETIMEDB_FE_2(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_1(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_3(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_2(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_4(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_3(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_5(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_4(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_6(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_5(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_7(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_6(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_8(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_7(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_9(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_8(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_10(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_9(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_11(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_10(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_12(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_11(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_13(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_12(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_14(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_13(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_15(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_14(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_16(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_15(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_17(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_16(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_18(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_17(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_19(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_18(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_20(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_19(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_21(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_20(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_22(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_21(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_23(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_22(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_24(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_23(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_25(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_24(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_26(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_25(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_27(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_26(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_28(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_27(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_29(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_28(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_30(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_29(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_31(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_30(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_32(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_31(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_33(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_32(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_34(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_33(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_35(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_34(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_36(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_35(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_37(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_36(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_38(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_37(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_39(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_38(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_40(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_39(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_41(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_40(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_42(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_41(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_43(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_42(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_44(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_43(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_45(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_44(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_46(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_45(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_47(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_46(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_48(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_47(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_49(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_48(MACRO, obj, extra, __VA_ARGS__)
+#define SPACETIMEDB_FE_50(MACRO, obj, extra, X, ...) MACRO(obj, extra, X) SPACETIMEDB_FE_49(MACRO, obj, extra, __VA_ARGS__)
+
+// =============================================================================
+// SPECIALIZED FOR_EACH MACROS FOR DIFFERENT USE CASES
+// =============================================================================
+
+/**
+ * @brief FOR_EACH_VARIANT - specialized macro for enum variant processing
+ * 
+ * This adapts the unified SPACETIMEDB_FOR_EACH_ARG to use separator-based syntax
+ * instead of obj-extra syntax. Used by enum_macro.h for variant processing.
+ */
+#define SPACETIMEDB_FOR_EACH_VARIANT(macro, sep, ...) \
+    SPACETIMEDB_FOR_EACH_VARIANT_IMPL(macro, sep, ##__VA_ARGS__)
+
+#define SPACETIMEDB_FOR_EACH_VARIANT_IMPL(macro, sep, ...) \
+    SPACETIMEDB_GET_MACRO(__VA_ARGS__, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_50, SPACETIMEDB_FOR_EACH_VARIANT_FE_49, SPACETIMEDB_FOR_EACH_VARIANT_FE_48, SPACETIMEDB_FOR_EACH_VARIANT_FE_47, SPACETIMEDB_FOR_EACH_VARIANT_FE_46, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_45, SPACETIMEDB_FOR_EACH_VARIANT_FE_44, SPACETIMEDB_FOR_EACH_VARIANT_FE_43, SPACETIMEDB_FOR_EACH_VARIANT_FE_42, SPACETIMEDB_FOR_EACH_VARIANT_FE_41, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_40, SPACETIMEDB_FOR_EACH_VARIANT_FE_39, SPACETIMEDB_FOR_EACH_VARIANT_FE_38, SPACETIMEDB_FOR_EACH_VARIANT_FE_37, SPACETIMEDB_FOR_EACH_VARIANT_FE_36, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_35, SPACETIMEDB_FOR_EACH_VARIANT_FE_34, SPACETIMEDB_FOR_EACH_VARIANT_FE_33, SPACETIMEDB_FOR_EACH_VARIANT_FE_32, SPACETIMEDB_FOR_EACH_VARIANT_FE_31, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_30, SPACETIMEDB_FOR_EACH_VARIANT_FE_29, SPACETIMEDB_FOR_EACH_VARIANT_FE_28, SPACETIMEDB_FOR_EACH_VARIANT_FE_27, SPACETIMEDB_FOR_EACH_VARIANT_FE_26, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_25, SPACETIMEDB_FOR_EACH_VARIANT_FE_24, SPACETIMEDB_FOR_EACH_VARIANT_FE_23, SPACETIMEDB_FOR_EACH_VARIANT_FE_22, SPACETIMEDB_FOR_EACH_VARIANT_FE_21, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_20, SPACETIMEDB_FOR_EACH_VARIANT_FE_19, SPACETIMEDB_FOR_EACH_VARIANT_FE_18, SPACETIMEDB_FOR_EACH_VARIANT_FE_17, SPACETIMEDB_FOR_EACH_VARIANT_FE_16, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_15, SPACETIMEDB_FOR_EACH_VARIANT_FE_14, SPACETIMEDB_FOR_EACH_VARIANT_FE_13, SPACETIMEDB_FOR_EACH_VARIANT_FE_12, SPACETIMEDB_FOR_EACH_VARIANT_FE_11, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_10, SPACETIMEDB_FOR_EACH_VARIANT_FE_9, SPACETIMEDB_FOR_EACH_VARIANT_FE_8, SPACETIMEDB_FOR_EACH_VARIANT_FE_7, SPACETIMEDB_FOR_EACH_VARIANT_FE_6, \
+        SPACETIMEDB_FOR_EACH_VARIANT_FE_5, SPACETIMEDB_FOR_EACH_VARIANT_FE_4, SPACETIMEDB_FOR_EACH_VARIANT_FE_3, SPACETIMEDB_FOR_EACH_VARIANT_FE_2, SPACETIMEDB_FOR_EACH_VARIANT_FE_1) \
+    (macro, sep, ##__VA_ARGS__)
+
+// Adapter macros that apply macro + separator pattern (instead of macro-obj-extra pattern)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_1(macro, sep, X) macro(X)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_2(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_1(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_3(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_2(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_4(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_3(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_5(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_4(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_6(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_5(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_7(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_6(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_8(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_7(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_9(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_8(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_10(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_9(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_11(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_10(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_12(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_11(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_13(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_12(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_14(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_13(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_15(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_14(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_16(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_15(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_17(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_16(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_18(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_17(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_19(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_18(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_20(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_19(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_21(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_20(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_22(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_21(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_23(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_22(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_24(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_23(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_25(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_24(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_26(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_25(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_27(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_26(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_28(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_27(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_29(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_28(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_30(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_29(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_31(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_30(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_32(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_31(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_33(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_32(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_34(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_33(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_35(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_34(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_36(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_35(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_37(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_36(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_38(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_37(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_39(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_38(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_40(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_39(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_41(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_40(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_42(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_41(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_43(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_42(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_44(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_43(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_45(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_44(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_46(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_45(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_47(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_46(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_48(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_47(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_49(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_48(macro, sep, __VA_ARGS__)
+#define SPACETIMEDB_FOR_EACH_VARIANT_FE_50(macro, sep, X, ...) macro(X) sep() SPACETIMEDB_FOR_EACH_VARIANT_FE_49(macro, sep, __VA_ARGS__)
+
+// Compatibility aliases for files that expect non-prefixed names
+#define FOR_EACH_VARIANT SPACETIMEDB_FOR_EACH_VARIANT
+
+// =============================================================================
+// INTERNAL UTILITIES
+// =============================================================================
+
+// REMOVED: internal::get_table_id - unused dead code
+
+// =============================================================================
+// TYPE GENERATION AND REGISTRATION
+// =============================================================================
+
+// REMOVED: spacetimedb_generate_type<T>() - 67 lines of unused dead code
+
+// =============================================================================
+// TABLE MACROS - C# [SpacetimeDB.Table] Equivalent
+// =============================================================================
+
+// Enhanced table macro with optional scheduling support
+// Usage: SPACETIMEDB_TABLE(MyStruct, "table_name", Public)
+//    or: SPACETIMEDB_TABLE(MyStruct, "table_name", Private)
+// REMOVED: SPACETIMEDB_TABLE is now defined in field_metadata.h
+// #define SPACETIMEDB_TABLE(...) \
+//     SPACETIMEDB_PASTE(SPACETIMEDB_TABLE_, SPACETIMEDB_NARGS(__VA_ARGS__))(__VA_ARGS__)
+
+// All table macros have been moved to field_metadata.h to avoid duplicates.
+// The SPACETIMEDB_TABLE macro in field_metadata.h supports:
+//   - SPACETIMEDB_TABLE(Type, table_name, Public)
+//   - SPACETIMEDB_TABLE(Type, table_name, Private)
+//   - Multiple tables using the same struct type
+
+// =============================================================================
+// REDUCER MACROS - MOVED TO reducer_macros.h
+// =============================================================================
+
+// All reducer macros have been moved to reducer_macros.h
+// This includes SPACETIMEDB_REDUCER, SPACETIMEDB_INIT, 
+// SPACETIMEDB_CLIENT_CONNECTED, and SPACETIMEDB_CLIENT_DISCONNECTED
+
+
+
+
+// =============================================================================
+// CONSTRAINT AND FIELD ATTRIBUTES
+// =============================================================================
+// Use SPACETIMEDB_TABLE with constraint macros for field attributes:
+//   SPACETIMEDB_TABLE(MyTable, "my_table", Public,
+//       PrimaryKey(id), Unique(email), Index(name)
+//   )
+
+// =============================================================================
+// VISIBILITY FILTER MACRO
+// =============================================================================
+
+/**
+ * @brief Register a client visibility filter with the SpacetimeDB module system
+ * 
+ * This macro registers a SQL string as a client visibility filter.
+ * 
+ * @param filter_name The unique name for this filter
+ * @param sql_query The SQL query string for the filter
+ * 
+ * Usage:
+ *    SPACETIMEDB_CLIENT_VISIBILITY_FILTER(user_owns_data, "SELECT * FROM user_data WHERE owner_id = current_user_identity()")
+ */
+#define SPACETIMEDB_CLIENT_VISIBILITY_FILTER(filter_name, sql_query) \
+    __attribute__((export_name("__preinit__25_register_row_level_security_" #filter_name))) \
+    extern "C" void __register_client_visibility_filter_##filter_name() { \
+        SpacetimeDb::Internal::getV9Builder().RegisterRowLevelSecurity(sql_query); \
+    }
+
+// =============================================================================
+// STRUCT TYPE MACROS  
+// =============================================================================
+
+/**
+ * @brief Enable BSATN serialization for unit struct types
+ * 
+ * Unit structs are structs with no fields, similar to std::monostate.
+ * They serialize/deserialize as empty (0 bytes).
+ * 
+ * Usage:
+ *   struct UnitType {};
+ *   SPACETIMEDB_UNIT_STRUCT(UnitType)
+ */
+#define SPACETIMEDB_UNIT_STRUCT(Type) \
+    struct Type { \
+        static constexpr bool __is_unit_type__ = true; \
+        Type() = default; \
+        Type(std::monostate) {} \
+        operator std::monostate() const { return std::monostate{}; } \
+    }; \
+    template<> \
+    struct SpacetimeDb::bsatn::bsatn_traits<Type> { \
+        static void serialize(SpacetimeDb::bsatn::Writer& w, const Type& v) { \
+            /* Unit struct serializes as empty */ \
+        } \
+        static Type deserialize(SpacetimeDb::bsatn::Reader& r) { \
+            return Type{}; \
+        } \
+        static SpacetimeDb::bsatn::AlgebraicType algebraic_type() { \
+            return SpacetimeDb::Internal::LazyTypeRegistrar<Type>::getOrRegister( \
+                []() -> SpacetimeDb::bsatn::AlgebraicType { \
+                    return SpacetimeDb::bsatn::AlgebraicType::make_product( \
+                        std::make_unique<SpacetimeDb::bsatn::ProductType>(std::vector<SpacetimeDb::bsatn::ProductTypeElement>{}) \
+                    ); \
+                }, \
+                #Type \
+            ); \
+        } \
+    }; \
+    SPACETIMEDB_GENERATE_TYPE_REGISTRATION_BUNDLE(Type)
+
+/**
+ * @brief Enable BSATN serialization for struct types with fields
+ * 
+ * Generates complete serialization support for structs by serializing
+ * each field in the order specified.
+ * 
+ * Usage:
+ *   struct MyStruct {
+ *       int32_t id;
+ *       std::string name;
+ *   };
+ *   SPACETIMEDB_STRUCT(MyStruct, id, name)
+ */
+#define SPACETIMEDB_STRUCT(Type, ...) \
+    template<> \
+    struct SpacetimeDb::bsatn::bsatn_traits<Type> { \
+        static void serialize(SpacetimeDb::bsatn::Writer& w, const Type& v) { \
+            SPACETIMEDB_SERIALIZE_FIELDS(v, w, __VA_ARGS__) \
+        } \
+        static Type deserialize(SpacetimeDb::bsatn::Reader& r) { \
+            Type v; \
+            SPACETIMEDB_DESERIALIZE_FIELDS(v, r, __VA_ARGS__) \
+            return v; \
+        } \
+        static SpacetimeDb::bsatn::AlgebraicType algebraic_type() { \
+            fprintf(stderr, "[DEBUG] bsatn_traits<" #Type ">::algebraic_type() called\n"); \
+            fflush(stderr); \
+            return SpacetimeDb::Internal::LazyTypeRegistrar<Type>::getOrRegister( \
+                []() -> SpacetimeDb::bsatn::AlgebraicType { \
+                    fprintf(stderr, "[DEBUG] Building ProductType for " #Type "\n"); \
+                    fflush(stderr); \
+                    SpacetimeDb::bsatn::ProductTypeBuilder builder; \
+                    SPACETIMEDB_REGISTER_FIELDS(Type, builder, __VA_ARGS__) \
+                    fprintf(stderr, "[DEBUG] Finished building ProductType for " #Type "\n"); \
+                    fflush(stderr); \
+                    return SpacetimeDb::bsatn::AlgebraicType::make_product(builder.build()); \
+                }, \
+                #Type \
+            ); \
+        } \
+    }; \
+    SPACETIMEDB_GENERATE_TYPE_REGISTRATION_BUNDLE_WITH_FIELDS(Type, __VA_ARGS__)
+
+// Field processing helper macros (used by SPACETIMEDB_STRUCT)
+#define SPACETIMEDB_SERIALIZE_FIELD(obj, writer, field) \
+    SpacetimeDb::bsatn::serialize(writer, obj.field);
+    
+#define SPACETIMEDB_DESERIALIZE_FIELD(obj, reader, field) \
+    obj.field = SpacetimeDb::bsatn::deserialize<decltype(obj.field)>(reader);
+    
+#define SPACETIMEDB_REGISTER_FIELD(Type, builder, field) \
+    builder.with_field<decltype(Type::field)>(#field);
+
+#define SPACETIMEDB_SERIALIZE_FIELDS(obj, writer, ...) \
+    SPACETIMEDB_FOR_EACH_ARG(SPACETIMEDB_SERIALIZE_FIELD, obj, writer, __VA_ARGS__)
+    
+#define SPACETIMEDB_DESERIALIZE_FIELDS(obj, reader, ...) \
+    SPACETIMEDB_FOR_EACH_ARG(SPACETIMEDB_DESERIALIZE_FIELD, obj, reader, __VA_ARGS__)
+    
+#define SPACETIMEDB_REGISTER_FIELDS(Type, builder, ...) \
+    SPACETIMEDB_FOR_EACH_ARG(SPACETIMEDB_REGISTER_FIELD, Type, builder, __VA_ARGS__)
+
+// Field descriptor registration for runtime reflection
+#define SPACETIMEDB_REGISTER_FIELD_DESCRIPTOR(Type, dummy, field) \
+    { \
+        ::SpacetimeDb::FieldDescriptor desc; \
+        desc.name = #field; \
+        desc.offset = offsetof(Type, field); \
+        desc.size = sizeof(decltype(Type::field)); \
+        desc.write_type = [](std::vector<uint8_t>& buf) { \
+            ::SpacetimeDb::write_field_type<decltype(Type::field)>(buf); \
+        }; \
+        desc.get_algebraic_type = []() { \
+            return ::SpacetimeDb::bsatn::bsatn_traits<decltype(Type::field)>::algebraic_type(); \
+        }; \
+        desc.serialize = [](std::vector<uint8_t>& buf, const void* obj) { \
+            const Type* typed_obj = static_cast<const Type*>(obj); \
+            ::SpacetimeDb::serialize_value(buf, typed_obj->field); \
+        }; \
+        desc.get_type_name = []() -> std::string { \
+            return demangle_cpp_type_name(typeid(decltype(Type::field)).name()); \
+        }; \
+        ::SpacetimeDb::get_table_descriptors()[&typeid(Type)].fields.push_back(desc); \
+    }
+
+#define SPACETIMEDB_REGISTER_FIELD_DESCRIPTORS(Type, ...) \
+    SPACETIMEDB_FOR_EACH_ARG(SPACETIMEDB_REGISTER_FIELD_DESCRIPTOR, Type, dummy, __VA_ARGS__)
+
+
+#endif // SPACETIMEDB_MACROS_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/random.h b/crates/bindings-cpp/include/spacetimedb/random.h
new file mode 100644
index 00000000000..8f3b430d116
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/random.h
@@ -0,0 +1,142 @@
+#ifndef SPACETIMEDB_RANDOM_H
+#define SPACETIMEDB_RANDOM_H
+
+#include <random>
+#include <limits>
+#include <memory>
+#include <spacetimedb/bsatn/timestamp.h>
+
+namespace SpacetimeDb {
+
+// Random number generator for reducer contexts
+// Similar to Rust's StdbRng and C#'s Random
+// Seeded with the timestamp for deterministic behavior
+class StdbRng {
+private:
+    // Use mt19937_64 for 64-bit Mersenne Twister (same quality as Rust's StdRng)
+    mutable std::mt19937_64 engine;
+    mutable bool initialized = false;
+    Timestamp seed_timestamp;
+    
+    void ensure_initialized() const {
+        if (!initialized) {
+            // Seed with timestamp's microseconds since Unix epoch
+            // This matches the Rust implementation's approach
+            uint64_t seed = static_cast<uint64_t>(seed_timestamp.micros_since_epoch());
+            engine.seed(seed);
+            initialized = true;
+        }
+    }
+    
+public:
+    // Constructor that takes a timestamp for seeding
+    explicit StdbRng(Timestamp ts) : seed_timestamp(ts) {}
+    
+    // Generate a random 32-bit unsigned integer
+    uint32_t next_u32() const {
+        ensure_initialized();
+        return static_cast<uint32_t>(engine() & 0xFFFFFFFF);
+    }
+    
+    // Generate a random 64-bit unsigned integer
+    uint64_t next_u64() const {
+        ensure_initialized();
+        return engine();
+    }
+    
+    // Generate a random integer in the range [min, max]
+    template<typename T>
+    T gen_range(T min, T max) const {
+        ensure_initialized();
+        if constexpr (std::is_integral_v<T>) {
+            std::uniform_int_distribution<T> dist(min, max);
+            return dist(engine);
+        } else {
+            std::uniform_real_distribution<T> dist(min, max);
+            return dist(engine);
+        }
+    }
+    
+    // Generate a random integer of type T
+    template<typename T>
+    T gen() const {
+        ensure_initialized();
+        if constexpr (std::is_same_v<T, bool>) {
+            return engine() & 1;
+        } else if constexpr (std::is_integral_v<T>) {
+            if constexpr (std::is_unsigned_v<T>) {
+                if constexpr (sizeof(T) <= 4) {
+                    return static_cast<T>(next_u32());
+                } else {
+                    return static_cast<T>(next_u64());
+                }
+            } else {
+                // For signed types, use the full range
+                std::uniform_int_distribution<T> dist(
+                    std::numeric_limits<T>::min(),
+                    std::numeric_limits<T>::max()
+                );
+                return dist(engine);
+            }
+        } else if constexpr (std::is_floating_point_v<T>) {
+            // Generate float in [0, 1)
+            if constexpr (std::is_same_v<T, float>) {
+                return static_cast<float>(next_u32()) / static_cast<float>(UINT32_MAX);
+            } else {
+                return static_cast<double>(next_u64()) / static_cast<double>(UINT64_MAX);
+            }
+        }
+    }
+    
+    // Fill a buffer with random bytes
+    void fill_bytes(uint8_t* dest, size_t count) const {
+        ensure_initialized();
+        for (size_t i = 0; i < count; i++) {
+            dest[i] = static_cast<uint8_t>(engine() & 0xFF);
+        }
+    }
+    
+    // Fill a vector with random bytes
+    void fill_bytes(std::vector<uint8_t>& dest) const {
+        fill_bytes(dest.data(), dest.size());
+    }
+    
+    // Generate a random float in [0, 1)
+    float gen_float() const {
+        return gen<float>();
+    }
+    
+    // Generate a random double in [0, 1)
+    double gen_double() const {
+        return gen<double>();
+    }
+    
+    // Generate a random boolean
+    bool gen_bool() const {
+        return gen<bool>();
+    }
+    
+    // Shuffle a container randomly
+    template<typename RandomIt>
+    void shuffle(RandomIt first, RandomIt last) const {
+        ensure_initialized();
+        std::shuffle(first, last, engine);
+    }
+    
+    // Sample a random element from a container
+    template<typename Container>
+    auto sample(const Container& container) const -> decltype(container[0]) {
+        ensure_initialized();
+        if (container.empty()) {
+            // Return first element for empty container (undefined behavior)
+            // In production, you should check container size before calling sample
+            return container[0];
+        }
+        std::uniform_int_distribution<size_t> dist(0, container.size() - 1);
+        return container[dist(engine)];
+    }
+};
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_RANDOM_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/range_queries.h b/crates/bindings-cpp/include/spacetimedb/range_queries.h
new file mode 100644
index 00000000000..60b9e44d859
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/range_queries.h
@@ -0,0 +1,212 @@
+#pragma once
+
+#include <concepts>
+#include <optional>
+#include <type_traits>
+
+namespace SpacetimeDb {
+
+// =============================================================================
+// C++20 Concepts-based Range Query System
+// =============================================================================
+
+/// Concept defining types that can be used in range queries
+template<typename T>
+concept Rangeable = std::totally_ordered<T> && std::copyable<T> && std::destructible<T>;
+
+/// Range bound types for different query patterns
+enum class RangeBound {
+    Exclusive,  // 25..30 (excludes end)
+    Inclusive   // 25..=30 (includes end) 
+};
+
+/// Core Range type supporting all Rust range patterns
+template<Rangeable T>
+struct Range {
+    std::optional<T> start;  // None for ..30
+    std::optional<T> end;    // None for 25..
+    RangeBound bound_type = RangeBound::Exclusive;
+    
+    // Constructors for different range types
+    Range() = default;
+    
+    Range(std::optional<T> start_val, std::optional<T> end_val, RangeBound bound = RangeBound::Exclusive)
+        : start(start_val), end(end_val), bound_type(bound) {}
+    
+    // Copy/move constructors
+    Range(const Range&) = default;
+    Range(Range&&) = default;
+    Range& operator=(const Range&) = default;
+    Range& operator=(Range&&) = default;
+    
+    // Check if value is in range
+    constexpr bool contains(const T& value) const {
+        bool within_start = !start || value >= *start;
+        bool within_end;
+        
+        if (!end) {
+            within_end = true;  // No upper bound
+        } else {
+            within_end = (bound_type == RangeBound::Inclusive) 
+                        ? (value <= *end)
+                        : (value < *end);
+        }
+        
+        return within_start && within_end;
+    }
+    
+    // Debug string representation
+    std::string to_string() const {
+        std::string result;
+        
+        if (start) {
+            result += std::to_string(*start);
+        }
+        
+        result += (bound_type == RangeBound::Inclusive) ? "..=" : "..";
+        
+        if (end) {
+            result += std::to_string(*end);
+        }
+        
+        return result;
+    }
+};
+
+// =============================================================================
+// Factory functions for different range patterns (Rust-like syntax)
+// =============================================================================
+
+/// Create range from start to end (exclusive): 25..30
+template<Rangeable T>
+constexpr auto range(T start, T end) -> Range<T> {
+    return Range<T>(start, end, RangeBound::Exclusive);
+}
+
+/// Create inclusive range from start to end: 25..=30  
+template<Rangeable T>
+constexpr auto range_inclusive(T start, T end) -> Range<T> {
+    return Range<T>(start, end, RangeBound::Inclusive);
+}
+
+/// Create range from start with no upper bound: 25..
+template<Rangeable T>
+constexpr auto range_from(T start) -> Range<T> {
+    return Range<T>(start, std::nullopt, RangeBound::Exclusive);
+}
+
+/// Create range with no lower bound to end (exclusive): ..30
+template<Rangeable T>  
+constexpr auto range_to(T end) -> Range<T> {
+    return Range<T>(std::nullopt, end, RangeBound::Exclusive);
+}
+
+/// Create inclusive range with no lower bound to end: ..=30
+template<Rangeable T>
+constexpr auto range_to_inclusive(T end) -> Range<T> {
+    return Range<T>(std::nullopt, end, RangeBound::Inclusive);
+}
+
+/// Create unbounded range (all values): ..
+template<Rangeable T>
+constexpr auto range_full() -> Range<T> {
+    return Range<T>();
+}
+
+// =============================================================================
+// Type trait to detect Range types
+// =============================================================================
+
+template<typename T>
+struct is_range : std::false_type {};
+
+template<Rangeable T>
+struct is_range<Range<T>> : std::true_type {};
+
+template<typename T>
+constexpr bool is_range_v = is_range<T>::value;
+
+// Concept for range types
+template<typename T>
+concept RangeType = is_range_v<T>;
+
+// =============================================================================
+// Integration with field accessors
+// =============================================================================
+
+/// Extend field accessor base class with range query support
+template<typename Derived, typename FieldType>
+requires Rangeable<FieldType>
+class RangeQueryAccessor {
+public:
+    /// Filter by exact value (existing functionality)
+    auto filter(const FieldType& value) {
+        return static_cast<Derived*>(this)->filter_impl(value);
+    }
+    
+    /// Filter by range (NEW - major feature addition)
+    auto filter(const Range<FieldType>& range) {
+        return static_cast<Derived*>(this)->filter_range_impl(range);
+    }
+    
+    /// Delete all rows in range (NEW)
+    uint32_t delete_range(const Range<FieldType>& range) {
+        return static_cast<Derived*>(this)->delete_range_impl(range);
+    }
+    
+    /// Count rows in range (NEW)
+    size_t count_range(const Range<FieldType>& range) {
+        return static_cast<Derived*>(this)->count_range_impl(range);
+    }
+};
+
+// =============================================================================
+// Convenient operator overloads for natural syntax
+// =============================================================================
+
+/// Enable range construction with custom operators
+namespace range_operators {
+    /// Placeholder type for range construction
+    struct RangeStart {};
+    struct RangeEnd {};
+    
+    constexpr RangeStart range_start{};
+    constexpr RangeEnd range_end{};
+}
+
+} // namespace SpacetimeDb
+
+// =============================================================================
+// Usage Examples (for documentation)
+// =============================================================================
+
+/*
+// Rust patterns                    C++ equivalent
+// ---------------                  --------------
+// ctx.db.person().age().filter(25..)     → ctx.db[person_age].filter(range_from(25))
+// ctx.db.person().age().filter(..30)     → ctx.db[person_age].filter(range_to(30))  
+// ctx.db.person().age().filter(25..30)   → ctx.db[person_age].filter(range(25, 30))
+// ctx.db.person().age().filter(25..=30)  → ctx.db[person_age].filter(range_inclusive(25, 30))
+// ctx.db.person().age().filter(..)       → ctx.db[person_age].filter(range_full<uint8_t>())
+
+Example usage in a reducer:
+
+SPACETIMEDB_REDUCER(test_range_queries, ReducerContext ctx) {
+    using namespace SpacetimeDb;
+    
+    // Find all people aged 25 and above
+    auto adults = ctx.db[person_age].filter(range_from(25));
+    
+    // Find people aged 18-25 (exclusive end) 
+    auto young_adults = ctx.db[person_age].filter(range(18, 25));
+    
+    // Find people up to and including age 65
+    auto working_age = ctx.db[person_age].filter(range_to_inclusive(65));
+    
+    // Delete all people in a specific age range
+    uint32_t deleted = ctx.db[person_age].delete_range(range(100, 150));
+    
+    // Count people in range
+    size_t count = ctx.db[person_age].count_range(range_from(50));
+}
+*/
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/reducer_context.h b/crates/bindings-cpp/include/spacetimedb/reducer_context.h
new file mode 100644
index 00000000000..443c3f9a4c4
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/reducer_context.h
@@ -0,0 +1,67 @@
+#ifndef REDUCER_CONTEXT_H
+#define REDUCER_CONTEXT_H
+
+#include <spacetimedb/bsatn/types.h> // For Identity, ConnectionId
+#include <spacetimedb/bsatn/timestamp.h> // For Timestamp
+#include <spacetimedb/random.h> // For StdbRng
+#include <optional>
+#include <array>
+#include <memory>
+
+// Include database for DatabaseContext
+#include <spacetimedb/database.h>
+
+namespace SpacetimeDb {
+
+// Enhanced ReducerContext with database access - matches Rust pattern
+struct ReducerContext {
+    // Core fields - directly accessible like in Rust
+    Identity sender;
+    std::optional<ConnectionId> connection_id;
+    Timestamp timestamp;
+    
+    // Database context with name-based access
+    DatabaseContext db;
+    
+private:
+    // Lazily initialized RNG (similar to Rust's OnceCell pattern)
+    // Using shared_ptr to make ReducerContext copyable
+    mutable std::shared_ptr<StdbRng> rng_instance;
+    
+public:
+    // Get the random number generator for this reducer call
+    // Lazily initialized and seeded with the timestamp
+    StdbRng& rng() const {
+        if (!rng_instance) {
+            rng_instance = std::make_unique<StdbRng>(timestamp);
+        }
+        return *rng_instance;
+    }
+
+    Identity identity() const {
+        std::array<uint8_t, 32> buffer;
+        ::identity(buffer.data());
+        
+        // Reverse the bytes to convert from little-endian to big-endian
+        std::reverse(buffer.begin(), buffer.end());
+        
+        // Use constructor instead of from_byte_array
+        return Identity(buffer);
+    }
+
+    // Convenience method to generate a random value (similar to Rust's ctx.random())
+    template<typename T>
+    T random() const {
+        return rng().gen<T>();
+    }
+    
+    // Constructors
+    ReducerContext() = default;
+    
+    ReducerContext(Identity s, std::optional<ConnectionId> cid, Timestamp ts)
+        : sender(s), connection_id(cid), timestamp(ts) {}
+};
+
+} // namespace SpacetimeDB
+
+#endif // REDUCER_CONTEXT_H
diff --git a/crates/bindings-cpp/include/spacetimedb/reducer_error.h b/crates/bindings-cpp/include/spacetimedb/reducer_error.h
new file mode 100644
index 00000000000..978c76067fb
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/reducer_error.h
@@ -0,0 +1,128 @@
+#ifndef SPACETIMEDB_REDUCER_ERROR_H
+#define SPACETIMEDB_REDUCER_ERROR_H
+
+#include <string>
+#include <optional>
+
+/**
+ * @file reducer_error.h
+ * @brief Graceful error handling for reducers without exceptions or panics
+ *
+ * This module provides a thread-safe mechanism for reducers to fail gracefully
+ * with error messages, similar to Rust's Result<(), E> pattern.
+ *
+ * Usage:
+ * @code
+ * SPACETIMEDB_REDUCER(my_reducer, ReducerContext& ctx, uint32_t id) {
+ *     if (id == 0) {
+ *         SpacetimeDb::fail_reducer("ID must be non-zero");
+ *         return;  // Early exit - transaction will be rolled back
+ *     }
+ *     // ... rest of logic
+ * }
+ * @endcode
+ *
+ * When a reducer calls fail_reducer():
+ * - The transaction is rolled back (not committed to the log)
+ * - The error message is captured and returned to the caller
+ * - No database changes are persisted
+ * - No WASM crash or panic occurs
+ *
+ * @ingroup sdk_runtime
+ */
+
+namespace SpacetimeDb {
+
+namespace Internal {
+    /**
+     * Thread-local error state for the current reducer invocation.
+     * This is cleared at the start of each reducer call and checked at the end.
+     */
+    extern thread_local std::optional<std::string> g_reducer_error_message;
+
+    /**
+     * Clear the error state. Called automatically at the start of each reducer.
+     * @internal
+     */
+    inline void clear_reducer_error() {
+        g_reducer_error_message = std::nullopt;
+    }
+
+    /**
+     * Check if the current reducer has failed.
+     * @internal
+     */
+    inline bool has_reducer_error() {
+        return g_reducer_error_message.has_value();
+    }
+
+    /**
+     * Get the error message if one exists.
+     * @internal
+     */
+    inline std::string get_reducer_error() {
+        return g_reducer_error_message.value_or(std::string());
+    }
+}
+
+/**
+ * @brief Fail the current reducer with an error message.
+ *
+ * This function marks the current reducer invocation as failed.
+ * The transaction will be rolled back and the error message will be
+ * returned to the caller. Failed transactions are NOT committed to the
+ * log and will not appear in temporal queries or transaction history.
+ *
+ * After calling this function, the reducer should return immediately
+ * to avoid executing additional logic on inconsistent state.
+ *
+ * @param message A descriptive error message explaining why the reducer failed
+ *
+ * @code
+ * if (amount <= 0) {
+ *     SpacetimeDb::fail_reducer("Amount must be positive");
+ *     return;
+ * }
+ * @endcode
+ *
+ * @note This is thread-safe and works in WASM single-threaded environments.
+ * @note This does NOT throw exceptions or cause panics.
+ */
+inline void fail_reducer(std::string message) {
+    Internal::g_reducer_error_message = std::move(message);
+}
+
+/**
+ * @brief Fail the current reducer with a formatted error message.
+ *
+ * Convenience function for creating formatted error messages.
+ *
+ * @tparam Args Variadic template arguments for formatting
+ * @param format Printf-style format string
+ * @param args Arguments to format into the message
+ *
+ * @code
+ * fail_reducer_fmt("Tracker %u not found", tracker_id);
+ * fail_reducer_fmt("Invalid coordinates (%.2f, %.2f)", lat, lon);
+ * @endcode
+ */
+template<typename... Args>
+inline void fail_reducer_fmt(const char* format, Args... args) {
+    // Get required size
+    int size = std::snprintf(nullptr, 0, format, args...);
+    if (size <= 0) {
+        fail_reducer("Error formatting failure message");
+        return;
+    }
+
+    // Format string
+    std::string result(size + 1, '\0');
+    std::snprintf(result.data(), result.size(), format, args...);
+    result.resize(size); // Remove null terminator
+
+    fail_reducer(std::move(result));
+}
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_REDUCER_ERROR_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/reducer_macros.h b/crates/bindings-cpp/include/spacetimedb/reducer_macros.h
new file mode 100644
index 00000000000..d26384c815f
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/reducer_macros.h
@@ -0,0 +1,204 @@
+#pragma once
+
+#include "spacetimedb/bsatn/types.h"
+#include "spacetimedb/reducer_context.h"
+#include "spacetimedb/internal/Module.h"
+#include "spacetimedb/internal/v9_builder.h"
+#include "spacetimedb/macros.h"
+
+#include <string>
+#include <vector>
+#include <sstream>
+
+namespace SpacetimeDb {
+namespace Internal {
+
+/**
+ * @brief Helper function to parse parameter names from stringified parameter list
+ * 
+ * This is used internally by the SPACETIMEDB_REDUCER macro to extract parameter names
+ * from the stringified function signature.
+ * 
+ * @param param_list The stringified parameter list (e.g., "ReducerContext ctx, uint32_t id, std::string name")
+ * @return Vector of parameter names (excluding the first ReducerContext parameter)
+ */
+inline std::vector<std::string> parseReducerParameterNames(const std::string& param_list) {
+    std::vector<std::string> param_names;
+    
+    // Split by comma
+    std::istringstream stream(param_list);
+    std::string param;
+    bool first = true;
+    
+    while (std::getline(stream, param, ',')) {
+        // Skip the first parameter (ReducerContext)
+        if (first) {
+            first = false;
+            continue;
+        }
+        
+        // Trim whitespace
+        param.erase(0, param.find_first_not_of(" \t\n\r"));
+        param.erase(param.find_last_not_of(" \t\n\r") + 1);
+        
+        // Extract the parameter name (last word before end or default value)
+        // Handle cases like:
+        // - "int x"
+        // - "const std::string& name"
+        // - "std::vector<int> values"
+        // - "MyType* ptr"
+        // - "int x = 5"
+        
+        // Remove default value if present
+        size_t eq_pos = param.find('=');
+        std::string decl = (eq_pos != std::string::npos) ? param.substr(0, eq_pos) : param;
+        
+        // Trim trailing whitespace
+        decl.erase(decl.find_last_not_of(" \t\n\r") + 1);
+        
+        // Find the last word (parameter name)
+        size_t last_space = decl.find_last_of(" \t&*");
+        if (last_space != std::string::npos && last_space + 1 < decl.length()) {
+            std::string name = decl.substr(last_space + 1);
+            if (!name.empty()) {
+                param_names.push_back(name);
+            }
+        }
+    }
+    
+    return param_names;
+}
+
+} // namespace Internal
+} // namespace SpacetimeDb
+
+/**
+ * @brief Unified SPACETIMEDB_REDUCER macro for defining SpacetimeDB reducers
+ * 
+ * This macro provides a clean, consistent syntax for defining reducers with
+ * automatic registration in the SpacetimeDB module system.
+ * 
+ * @usage
+ * ```cpp
+ * // Reducer with no extra parameters
+ * SPACETIMEDB_REDUCER(my_reducer, ReducerContext ctx) {
+ *     ctx.db.table<MyTable>("my_table").insert(MyTable{});
+ * }
+ * 
+ * // Reducer with parameters
+ * SPACETIMEDB_REDUCER(my_reducer, ReducerContext ctx, uint32_t id, std::string name) {
+ *     ctx.db.table<MyTable>("my_table").insert(MyTable{id, name});
+ * }
+ * ```
+ * 
+ * @param name The name of the reducer function
+ * @param ... The full parameter list including ReducerContext as the first parameter
+ * 
+ * @details
+ * The macro generates:
+ * 1. A function declaration and definition with the provided signature
+ * 2. A preinit registration function that registers the reducer with SpacetimeDB
+ * 
+ * The first parameter must always be `ReducerContext ctx`. Additional parameters
+ * can be any types that support BSATN serialization.
+ * 
+ * @note This is a simplified implementation for the v2-cpp-library branch.
+ * Full parameter deserialization support requires additional runtime work.
+ */
+#undef SPACETIMEDB_REDUCER
+#define SPACETIMEDB_REDUCER(name, ...) \
+    /* Forward declaration of the reducer function */ \
+    void name(__VA_ARGS__); \
+    \
+    /* Preinit registration function */ \
+    /* This function is called during module initialization to register the reducer */ \
+    __attribute__((export_name("__preinit__30_reducer_" #name))) \
+    extern "C" void CONCAT(_spacetimedb_preinit_register_, name)() { \
+        /* Parse parameter names from the stringified parameter list */ \
+        std::string param_list = #__VA_ARGS__; \
+        std::vector<std::string> param_names = \
+            SpacetimeDb::Internal::parseReducerParameterNames(param_list); \
+        /* Register the reducer with the unified V9Builder system */ \
+        SpacetimeDb::Internal::getV9Builder().RegisterReducer(#name, name, param_names); \
+    } \
+    \
+    /* The actual reducer function definition follows */ \
+    void name(__VA_ARGS__)
+
+// -----------------------------------------------------------------------------
+// Lifecycle Reducer Macros
+// -----------------------------------------------------------------------------
+
+// Use unified macro system from macro_helpers.h
+
+/**
+ * @brief Macro for defining an init reducer
+ * 
+ * Init reducers are called when the module is first initialized.
+ * They take only a ReducerContext parameter.
+ * 
+ * @usage
+ * ```cpp
+ * SPACETIMEDB_INIT(my_init) {
+ *     ctx.db.table<MyTable>().insert({...});
+ * }
+ * ```
+ */
+#ifdef SPACETIMEDB_INIT
+#undef SPACETIMEDB_INIT
+#endif
+#define SPACETIMEDB_INIT(function_name) \
+    void function_name(SpacetimeDb::ReducerContext ctx); \
+    __attribute__((export_name("__preinit__20_reducer_init"))) \
+    extern "C" void CONCAT(_preinit_register_init_reducer_, function_name)() { \
+        ::SpacetimeDb::Internal::getV9Builder().RegisterLifecycleReducer(#function_name, function_name, ::SpacetimeDb::Internal::Lifecycle::Init); \
+    } \
+    void function_name(SpacetimeDb::ReducerContext ctx)
+
+/**
+ * @brief Macro for defining a client_connected reducer
+ * 
+ * Client connected reducers are called when a client connects to the module.
+ * They receive the connecting client's Identity as a parameter.
+ * 
+ * @usage
+ * ```cpp
+ * SPACETIMEDB_CLIENT_CONNECTED(on_connect) {
+ *     LOG_INFO("Client connected: " + sender.to_hex());
+ * }
+ * ```
+ */
+#ifdef SPACETIMEDB_CLIENT_CONNECTED
+#undef SPACETIMEDB_CLIENT_CONNECTED
+#endif
+#define SPACETIMEDB_CLIENT_CONNECTED(function_name) \
+    void function_name(SpacetimeDb::ReducerContext ctx); \
+    __attribute__((export_name("__preinit__20_reducer_client_connected"))) \
+    extern "C" void CONCAT(_preinit_register_client_connected_, function_name)() { \
+        ::SpacetimeDb::Internal::getV9Builder().RegisterLifecycleReducer(#function_name, function_name, ::SpacetimeDb::Internal::Lifecycle::OnConnect); \
+    } \
+    void function_name(SpacetimeDb::ReducerContext ctx)
+
+/**
+ * @brief Macro for defining a client_disconnected reducer
+ * 
+ * Client disconnected reducers are called when a client disconnects from the module.
+ * They receive the disconnecting client's Identity as a parameter.
+ * 
+ * @usage
+ * ```cpp
+ * SPACETIMEDB_CLIENT_DISCONNECTED(on_disconnect) {
+ *     LOG_INFO("Client disconnected: " + sender.to_hex());
+ * }
+ * ```
+ */
+#ifdef SPACETIMEDB_CLIENT_DISCONNECTED
+#undef SPACETIMEDB_CLIENT_DISCONNECTED
+#endif
+#define SPACETIMEDB_CLIENT_DISCONNECTED(function_name) \
+    void function_name(SpacetimeDb::ReducerContext ctx); \
+    __attribute__((export_name("__preinit__20_reducer_client_disconnected"))) \
+    extern "C" void CONCAT(_preinit_register_client_disconnected_, function_name)() { \
+        ::SpacetimeDb::Internal::getV9Builder().RegisterLifecycleReducer(#function_name, function_name, ::SpacetimeDb::Internal::Lifecycle::OnDisconnect); \
+    } \
+    void function_name(SpacetimeDb::ReducerContext ctx)
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/rls.h b/crates/bindings-cpp/include/spacetimedb/rls.h
new file mode 100644
index 00000000000..15a7b50bd62
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/rls.h
@@ -0,0 +1,196 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <optional>
+#include <algorithm>
+#include <cctype>
+#include "bsatn/writer.h"
+
+namespace SpacetimeDb {
+
+// RLS operation types
+enum class RlsOperation : uint8_t {
+    Select = 0,
+    Insert = 1,
+    Update = 2,
+    Delete = 3
+};
+
+// RLS policy definition
+struct RlsPolicy {
+    std::string table_name;
+    std::string policy_name;
+    RlsOperation operation;
+    std::string sql_condition;
+    
+    RlsPolicy(const std::string& table, const std::string& policy, 
+              RlsOperation op, const std::string& condition)
+        : table_name(table), policy_name(policy), operation(op), sql_condition(condition) {}
+};
+
+// RLS policy registry
+class RlsPolicyRegistry {
+private:
+    std::vector<RlsPolicy> policies_;
+    
+    RlsPolicyRegistry() = default;
+    
+public:
+    static RlsPolicyRegistry& instance() {
+        static RlsPolicyRegistry registry;
+        return registry;
+    }
+    
+    void register_policy(const std::string& table_name, 
+                        const std::string& policy_name,
+                        RlsOperation operation,
+                        const std::string& sql_condition) {
+        policies_.emplace_back(table_name, policy_name, operation, sql_condition);
+    }
+    
+    const std::vector<RlsPolicy>& get_policies() const {
+        return policies_;
+    }
+    
+    // Write RLS policies to BSATN for module definition
+    void write_policies(bsatn::Writer& writer) const {
+        writer.write_vec_len(policies_.size());
+        
+        for (const auto& policy : policies_) {
+            // RawRowLevelSecurityDefV9 structure:
+            // table_name: String
+            writer.write_string(policy.table_name);
+            
+            // policy_name: String
+            writer.write_string(policy.policy_name);
+            
+            // operations: Vec<RlsOp>
+            writer.write_vec_len(1); // Single operation per policy
+            writer.write_u8(static_cast<uint8_t>(policy.operation));
+            
+            // sql: String
+            writer.write_string(policy.sql_condition);
+        }
+    }
+};
+
+// Helper function to extract table name from SQL query
+inline std::string extract_table_name_from_sql(const std::string& sql) {
+    // Simple parser to extract table name from "SELECT * FROM table_name" or similar
+    std::string lower_sql = sql;
+    std::transform(lower_sql.begin(), lower_sql.end(), lower_sql.begin(), ::tolower);
+    
+    // Find "from " keyword
+    size_t from_pos = lower_sql.find("from ");
+    if (from_pos == std::string::npos) {
+        return "unknown_table";
+    }
+    
+    // Skip "from "
+    from_pos += 5;
+    
+    // Skip whitespace
+    while (from_pos < lower_sql.length() && std::isspace(lower_sql[from_pos])) {
+        from_pos++;
+    }
+    
+    // Find the end of the table name (next whitespace, comma, or end of string)
+    size_t end_pos = from_pos;
+    while (end_pos < lower_sql.length() && 
+           !std::isspace(lower_sql[end_pos]) && 
+           lower_sql[end_pos] != ',' &&
+           lower_sql[end_pos] != '.' &&
+           lower_sql[end_pos] != '(' &&
+           lower_sql[end_pos] != ')') {
+        end_pos++;
+    }
+    
+    if (end_pos > from_pos) {
+        return lower_sql.substr(from_pos, end_pos - from_pos);
+    }
+    
+    return "unknown_table";
+}
+
+// Helper function to validate SQL conditions (basic validation)
+inline bool validate_sql_condition(const std::string& condition) {
+    // Basic validation - ensure it's not empty and doesn't contain dangerous keywords
+    if (condition.empty()) return false;
+    
+    // Convert to lowercase for checking
+    std::string lower_condition = condition;
+    std::transform(lower_condition.begin(), lower_condition.end(), 
+                  lower_condition.begin(), ::tolower);
+    
+    // Check for dangerous keywords that shouldn't be in RLS conditions
+    const std::vector<std::string> dangerous_keywords = {
+        "drop ", "delete ", "truncate ", "alter ", "create ", "grant ", "revoke "
+    };
+    
+    for (const auto& keyword : dangerous_keywords) {
+        if (lower_condition.find(keyword) != std::string::npos) {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+// Predefined SQL condition builders for common patterns
+namespace rls {
+
+// Check if a column equals the current user's identity
+inline std::string user_owns(const std::string& column_name) {
+    return column_name + " = current_user_identity()";
+}
+
+// Check if a column is in a set of values
+inline std::string column_in(const std::string& column_name, const std::vector<std::string>& values) {
+    if (values.empty()) return "false";
+    
+    std::string condition = column_name + " IN (";
+    for (size_t i = 0; i < values.size(); ++i) {
+        if (i > 0) condition += ", ";
+        condition += "'" + values[i] + "'";
+    }
+    condition += ")";
+    return condition;
+}
+
+// Check if user has a specific role
+inline std::string user_has_role(const std::string& role) {
+    return "current_user_has_role('" + role + "')";
+}
+
+// Combine conditions with AND
+inline std::string and_conditions(const std::vector<std::string>& conditions) {
+    if (conditions.empty()) return "true";
+    if (conditions.size() == 1) return conditions[0];
+    
+    std::string result = "(";
+    for (size_t i = 0; i < conditions.size(); ++i) {
+        if (i > 0) result += " AND ";
+        result += "(" + conditions[i] + ")";
+    }
+    result += ")";
+    return result;
+}
+
+// Combine conditions with OR
+inline std::string or_conditions(const std::vector<std::string>& conditions) {
+    if (conditions.empty()) return "false";
+    if (conditions.size() == 1) return conditions[0];
+    
+    std::string result = "(";
+    for (size_t i = 0; i < conditions.size(); ++i) {
+        if (i > 0) result += " OR ";
+        result += "(" + conditions[i] + ")";
+    }
+    result += ")";
+    return result;
+}
+
+} // namespace rls
+
+} // namespace SpacetimeDb
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/schedule_reducer.h b/crates/bindings-cpp/include/spacetimedb/schedule_reducer.h
new file mode 100644
index 00000000000..8a3f2c9ce12
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/schedule_reducer.h
@@ -0,0 +1,92 @@
+#ifndef SPACETIMEDB_SCHEDULE_REDUCER_H
+#define SPACETIMEDB_SCHEDULE_REDUCER_H
+
+#include "spacetimedb/bsatn/types.h"
+#include <chrono>
+#include <string>
+
+namespace SpacetimeDb {
+
+// Duration type that matches SpacetimeDB's expectations
+struct Duration {
+    uint64_t milliseconds;
+    
+    Duration(uint64_t ms) : milliseconds(ms) {}
+    
+    static Duration from_seconds(uint64_t seconds) {
+        return Duration(seconds * 1000);
+    }
+    
+    static Duration from_minutes(uint64_t minutes) {
+        return Duration(minutes * 60 * 1000);
+    }
+    
+    static Duration from_hours(uint64_t hours) {
+        return Duration(hours * 60 * 60 * 1000);
+    }
+    
+    static Duration from_milliseconds(uint64_t ms) {
+        return Duration(ms);
+    }
+    
+    // Support conversion from std::chrono types
+    template<typename Rep, typename Period>
+    static Duration from_chrono(std::chrono::duration<Rep, Period> duration) {
+        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
+        return Duration(static_cast<uint64_t>(ms.count()));
+    }
+};
+
+// ScheduleReducer class to handle scheduled reducer registration
+class ScheduleReducer {
+public:
+    // Register a reducer to run at fixed intervals
+    static void register_scheduled([[maybe_unused]] const char* reducer_name, [[maybe_unused]] Duration interval) {
+        // The actual scheduling happens during module description generation
+        // This is stored and used when __describe_module__ is called
+        // For now, we'll use the existing FFI::schedule_reducer function
+        // which takes the reducer ID (we'll use the name for now)
+        
+        // TODO: This needs to be integrated with the module description system
+        // For now, log that we're attempting to schedule
+        #ifdef DEBUG
+        SpacetimeDb::Log::debug("Scheduling reducer", reducer_name, "with interval", 
+                                std::to_string(interval.milliseconds), "ms");
+        #endif
+    }
+    
+    // Register a reducer to run at specific times (cron-style)
+    static void register_scheduled_at([[maybe_unused]] const char* reducer_name) {
+        // This will be called for reducers that have a scheduled_at column
+        // The actual scheduling is handled by SpacetimeDB based on table rows
+        #ifdef DEBUG
+        SpacetimeDb::Log::debug("Registering scheduled_at reducer", reducer_name);
+        #endif
+    }
+    
+    // Validate cron expression (placeholder for future implementation)
+    static bool validate_cron_expression(const std::string& cron_expr) {
+        // TODO: Implement actual cron validation
+        // For now, just check it's not empty and has the right format
+        // Basic cron format: "minute hour day month weekday"
+        if (cron_expr.empty()) return false;
+        
+        // Count spaces to ensure we have 5 fields
+        int spaces = 0;
+        for (char c : cron_expr) {
+            if (c == ' ') spaces++;
+        }
+        
+        return spaces == 4; // 5 fields = 4 spaces
+    }
+};
+
+} // namespace SpacetimeDb
+
+// Legacy namespace support
+namespace SpacetimeDb {
+    using Duration = SpacetimeDb::Duration;
+    using ScheduleReducer = SpacetimeDb::ScheduleReducer;
+}
+
+#endif // SPACETIMEDB_SCHEDULE_REDUCER_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/table.h b/crates/bindings-cpp/include/spacetimedb/table.h
new file mode 100644
index 00000000000..08ecb10e1f8
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/table.h
@@ -0,0 +1,568 @@
+#ifndef SPACETIMEDB_LIBRARY_TABLE_H
+#define SPACETIMEDB_LIBRARY_TABLE_H
+
+/**
+ * @file table.h
+ * @brief Core table operations for SpacetimeDB C++ SDK
+ * 
+ * Provides type-safe Table<T> class and TableIterator<T> for CRUD operations
+ * on SpacetimeDB tables with efficient batch iteration and STL compatibility.
+ */
+
+#include "spacetimedb/bsatn/types.h"
+#include <spacetimedb/bsatn/bsatn.h>
+#include <spacetimedb/abi/FFI.h>
+#include <spacetimedb/bsatn/reader.h>
+#include <spacetimedb/bsatn/writer.h>
+#include <spacetimedb/bsatn/traits.h>
+#include <spacetimedb/logger.h>
+
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <optional>
+#include <algorithm>
+#include <utility>
+
+namespace SpacetimeDb {
+
+// Forward declarations
+template<typename T> class Table;
+template<typename T> class TableIterator;
+
+// =============================================================================
+// Insert Error Handling
+// =============================================================================
+
+/**
+ * Error types for insert operations
+ */
+enum class InsertErrorType {
+    UniqueConstraintViolation,
+    AutoIncOverflow,
+    Other
+};
+
+/**
+ * Insert error details
+ */
+struct InsertError {
+    InsertErrorType type;
+    Status status_code;
+    std::string message;
+    
+    InsertError(InsertErrorType t, Status s, const std::string& msg) 
+        : type(t), status_code(s), message(msg) {}
+};
+
+/**
+ * Result type for try_insert operations
+ */
+template<typename T>
+class InsertResult {
+private:
+    std::variant<T, InsertError> result_;
+    
+public:
+    InsertResult(T&& value) : result_(std::move(value)) {}
+    InsertResult(const InsertError& error) : result_(error) {}
+    
+    bool is_ok() const { return std::holds_alternative<T>(result_); }
+    bool is_err() const { return !is_ok(); }
+    
+    const T& ok() const { return std::get<T>(result_); }
+    T&& take_ok() { return std::move(std::get<T>(result_)); }
+    
+    const InsertError& err() const { return std::get<InsertError>(result_); }
+};
+
+// =============================================================================
+// Implementation Details
+// =============================================================================
+
+namespace detail {
+    // Performance tuning constants
+    constexpr size_t INITIAL_ROW_BUFFER_SIZE = 128 * 1024; // default to 128KB like C#
+    constexpr size_t MAX_ROW_BUFFER_SIZE = 1024 * 1024;
+    constexpr size_t TYPICAL_BATCH_SIZE = 32;
+    constexpr size_t AUTO_INCREMENT_BUFFER_SPACE = 1024;
+    
+    // FFI result codes
+    constexpr int16_t ITER_EXHAUSTED = -1;
+    constexpr int16_t ITER_OK = 0;
+    constexpr uint16_t ERROR_BUFFER_TOO_SMALL = 11;
+    
+    /**
+     * Auto-Increment Integration System
+     * 
+     * This system enables automatic integration of generated auto-increment values
+     * back into user row objects after insert operations. The system uses function
+     * pointers registered during module initialization to handle the integration
+     * per struct type.
+     */
+    
+    /** Function pointer type for auto-increment integration callbacks */
+    template<typename T>
+    using AutoIncIntegratorFn = void(*)(T&, SpacetimeDb::bsatn::Reader&);
+    
+    /** Registry to store auto-increment integrators per type */
+    template<typename T>
+    inline AutoIncIntegratorFn<T>& get_autoinc_integrator() {
+        static AutoIncIntegratorFn<T> integrator = nullptr;
+        return integrator;
+    }
+    
+    /**
+     * Integrate auto-increment values into a row object.
+     * 
+     * This function is called automatically by Table::insert() when SpacetimeDB
+     * returns generated auto-increment values. It looks up the registered integrator
+     * for the struct type and calls it to update the row with generated values.
+     * 
+     * @param row The row object to update with generated values
+     * @param reader BSATN reader containing the generated column values
+     */
+    template<typename T>
+    void integrate_autoinc(T& row, SpacetimeDb::bsatn::Reader& reader) {
+        auto integrator = get_autoinc_integrator<T>();
+        if (integrator) {
+            integrator(row, reader);
+        }
+        // If no integrator registered, do nothing (no auto-increment fields)
+    }
+    
+    // Error handling utilities
+    inline std::string format_error(const std::string& context, 
+                                   const std::string& operation, 
+                                   int code) {
+        return context + ": " + operation + " failed with code " + std::to_string(code);
+    }
+    
+    inline void check_buffer_size(size_t size) {
+        if (size > MAX_ROW_BUFFER_SIZE) {
+            LOG_FATAL("Buffer size exceeds maximum limit");
+        }
+    }
+    
+    // Generic error handler for FFI operations
+    template<typename Op>
+    inline void handle_ffi_error(Status status, 
+                                [[maybe_unused]] const std::string& context, 
+                                [[maybe_unused]] Op operation) {
+        if (is_error(status)) {
+            LOG_FATAL("FFI operation failed: " + context);
+        }
+    }
+}
+
+// =============================================================================
+// TableIterator - Efficient batch iteration
+// =============================================================================
+
+template<typename T>
+class TableIterator {
+    static_assert(std::is_same_v<T, std::remove_cv_t<T>>, 
+                  "TableIterator requires non-const, non-volatile type");
+
+public:
+    // STL iterator type definitions
+    using iterator_category = std::input_iterator_tag;
+    using value_type = T;
+    using difference_type = std::ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+
+    // Constructors
+    TableIterator() noexcept : iter_handle_(Invalid::ROW_ITER), is_end_(true) {}
+    
+    explicit TableIterator(TableId table_id) {
+        Status status = FFI::datastore_table_scan_bsatn(table_id, &iter_handle_);
+        detail::handle_ffi_error(status, "TableIterator", "datastore_table_scan_bsatn");
+        advance();
+    }
+
+    ~TableIterator() noexcept {
+        if (iter_handle_ != Invalid::ROW_ITER && !ffi_exhausted_) {
+            FFI::row_iter_bsatn_close(iter_handle_);
+        }
+    }
+
+    // Move-only semantics
+    TableIterator(const TableIterator&) = delete;
+    TableIterator& operator=(const TableIterator&) = delete;
+    
+    TableIterator(TableIterator&& other) noexcept : TableIterator() {
+        swap(*this, other);
+    }
+    
+    TableIterator& operator=(TableIterator&& other) noexcept {
+        if (this != &other) {
+            TableIterator temp(std::move(other));
+            swap(*this, temp);
+        }
+        return *this;
+    }
+    
+    friend void swap(TableIterator& a, TableIterator& b) noexcept {
+        using std::swap;
+        swap(a.iter_handle_, b.iter_handle_);
+        swap(a.row_buffer_, b.row_buffer_);
+        swap(a.current_batch_, b.current_batch_);
+        swap(a.current_index_, b.current_index_);
+        swap(a.current_row_, b.current_row_);
+        swap(a.is_valid_, b.is_valid_);
+        swap(a.is_end_, b.is_end_);
+        swap(a.ffi_exhausted_, b.ffi_exhausted_);
+    }
+
+    // Iterator operations
+
+    // Returns mutable reference to current row
+    T& operator*() {
+        if (!is_valid_) LOG_FATAL("Attempted to dereference invalid iterator");
+        return current_row_;
+    }
+
+    const T& operator*() const {
+        if (!is_valid_) LOG_FATAL("Attempted to dereference invalid iterator");
+        return current_row_;
+    }
+    
+    const T* operator->() const { return &**this; }
+    
+    TableIterator& operator++() {
+        advance();
+        return *this;
+    }
+    
+    bool operator==(const TableIterator& other) const noexcept {
+        return is_valid_ == other.is_valid_;
+    }
+    
+    bool operator!=(const TableIterator& other) const noexcept {
+        return !(*this == other);
+    }
+
+private:
+    RowIter iter_handle_ = Invalid::ROW_ITER;
+    std::vector<uint8_t> row_buffer_;
+    std::vector<T> current_batch_;
+    size_t current_index_ = 0;
+    T current_row_;
+    bool is_valid_ = false;
+    bool is_end_ = false;
+    bool ffi_exhausted_ = false;  // Track when FFI iterator is exhausted
+    
+    void advance() {
+        if (is_end_) {
+            is_valid_ = false;
+            return;
+        }
+        
+        // Try current batch first
+        if (current_index_ < current_batch_.size()) {
+            current_row_ = std::move(current_batch_[current_index_++]);
+            is_valid_ = true;
+            return;
+        }
+        
+        // Need new batch - but check if FFI is already exhausted
+        if (ffi_exhausted_) {
+            // FFI iterator exhausted and we've consumed all rows
+            is_end_ = true;
+            is_valid_ = false;
+            return;
+        }
+        
+        // Fetch new batch
+        fetch_batch();
+        
+        // Try again with new batch
+        if (current_index_ < current_batch_.size()) {
+            current_row_ = std::move(current_batch_[current_index_++]);
+            is_valid_ = true;
+        } else {
+            // No rows in batch and FFI is exhausted
+            is_end_ = true;
+            is_valid_ = false;
+        }
+    }
+    
+    void fetch_batch() {
+        row_buffer_.resize(detail::INITIAL_ROW_BUFFER_SIZE);
+        size_t buffer_len = row_buffer_.size();
+        
+        int16_t ret = FFI::row_iter_bsatn_advance(iter_handle_, 
+                                                  row_buffer_.data(), 
+                                                  &buffer_len);
+        
+        if (ret == detail::ITER_EXHAUSTED) {
+            // Iterator is exhausted, but there might be a final batch of data
+            ffi_exhausted_ = true;
+            if (buffer_len > 0) {
+                // Resize buffer to actual data size and deserialize the final batch
+                row_buffer_.resize(buffer_len);
+                deserialize_batch(buffer_len);
+            }
+            // Don't set is_end_ here! We may have multiple rows in this batch
+            return;
+        }
+        
+        if (ret == detail::ERROR_BUFFER_TOO_SMALL) {
+            detail::check_buffer_size(buffer_len);
+            row_buffer_.resize(buffer_len);
+            ret = FFI::row_iter_bsatn_advance(iter_handle_, 
+                                             row_buffer_.data(), 
+                                             &buffer_len);
+        }
+        
+        if (ret > 0) {
+            LOG_FATAL("TableIterator::advance failed with error: " + std::to_string(ret));
+        }
+        
+        // CRITICAL: Resize buffer to actual data size before deserializing!
+        row_buffer_.resize(buffer_len);
+        deserialize_batch(buffer_len);
+    }
+    
+    void deserialize_batch(size_t buffer_len) {
+        current_batch_.clear();
+        current_batch_.reserve(detail::TYPICAL_BATCH_SIZE);
+        current_index_ = 0;
+        
+        if (buffer_len == 0) return;
+        
+        SpacetimeDb::bsatn::Reader reader(row_buffer_.data(), buffer_len);
+        while (!reader.is_eos()) {
+            // Without exceptions, deserialization failures will abort
+            current_batch_.emplace_back(SpacetimeDb::bsatn::deserialize<T>(reader));
+        }
+    }
+};
+
+// =============================================================================
+// Table - Type-safe table interface
+// =============================================================================
+
+template<typename T>
+class Table {
+    static_assert(std::is_same_v<T, std::remove_cv_t<T>>, 
+                  "Table requires non-const, non-volatile row type");
+
+public:
+    explicit Table(TableId table_id) noexcept : table_id_(table_id) {}
+
+    // -------------------------------------------------------------------------
+    // Core CRUD Operations
+    // -------------------------------------------------------------------------
+    
+    /**
+     * Insert a row and return it with auto-generated fields populated.
+     * 
+     * For tables with auto-increment fields (defined with FIELD_PrimaryKeyAutoInc, 
+     * FIELD_UniqueAutoInc, FIELD_IndexAutoInc, or FIELD_AutoInc), this method 
+     * automatically integrates the generated values back into the returned row.
+     * 
+     * @param row_data The row to insert. Auto-increment fields can be set to 0 
+     *                 or any placeholder value - they will be overwritten.
+     * @return The inserted row with all auto-increment fields populated with 
+     *         their generated values.
+     * 
+     * @example
+     * // Table with auto-increment ID
+     * SPACETIMEDB_TABLE(User, users, Public);
+     * FIELD_PrimaryKeyAutoInc(users, id);
+     * 
+     * // In a reducer
+     * User user{0, "Alice", true};  // id=0 is placeholder
+     * User inserted = ctx.db[users].insert(user);
+     * LOG_INFO("Created user with ID: " + std::to_string(inserted.id));
+     * 
+     * @note The integration system uses registry-based callbacks registered during
+     *       module initialization (__preinit__19_) to handle the auto-increment 
+     *       value integration automatically.
+     */
+    T insert(const T& row_data) {
+        auto result = try_insert(row_data);
+        if (result.is_err()) {
+            const auto& error = result.err();
+            // Convert to LOG_FATAL to maintain current behavior
+            LOG_FATAL("Table::insert failed: " + error.message);
+        }
+        return result.take_ok();
+    }
+    
+    /**
+     * Insert a row and return Result-like type instead of throwing on error.
+     * 
+     * This method provides the same functionality as insert() but returns
+     * an InsertResult<T> that contains either the successfully inserted row
+     * (with auto-generated fields populated) or an InsertError with details
+     * about what went wrong.
+     * 
+     * @param row_data The row to insert
+     * @return InsertResult<T> containing either the inserted row or error details
+     * 
+     * @example
+     * auto result = ctx.db[users].try_insert(User{0, "Alice", true});
+     * if (result.is_ok()) {
+     *     const auto& user = result.ok();
+     *     LOG_INFO("Created user with ID: " + std::to_string(user.id));
+     * } else {
+     *     const auto& error = result.err();
+     *     LOG_INFO("Insert failed: " + error.message);
+     * }
+     */
+    InsertResult<T> try_insert(const T& row_data) {
+        SpacetimeDb::bsatn::Writer writer;
+        SpacetimeDb::bsatn::serialize(writer, row_data);
+        auto buffer_vec = writer.get_buffer();
+        
+        // Prepare buffer with extra space for auto-increment writeback
+        const size_t original_len = buffer_vec.size();
+        const size_t extra_space = detail::AUTO_INCREMENT_BUFFER_SPACE;
+        std::vector<uint8_t> buffer(buffer_vec.begin(), buffer_vec.end());
+        buffer.resize(original_len + extra_space);
+        
+        size_t buffer_len = original_len;
+        Status status = ::datastore_insert_bsatn(table_id_, buffer.data(), &buffer_len);
+        
+        // Instead of calling detail::handle_ffi_error (which LOG_FATALs), 
+        // handle errors and return appropriate InsertError
+        if (is_error(status)) {
+            InsertErrorType error_type;
+            std::string message;
+            
+            // Map status codes to our error types
+            if (status == StatusCode::UNIQUE_ALREADY_EXISTS) {
+                error_type = InsertErrorType::UniqueConstraintViolation;
+                message = "Unique constraint violation";
+            } else if (status == StatusCode::AUTO_INC_OVERFLOW) {
+                error_type = InsertErrorType::AutoIncOverflow;
+                message = "Auto increment overflow";
+            } else {
+                error_type = InsertErrorType::Other;
+                message = "Insert failed with status: " + std::string(StatusCode::to_string(status));
+            }
+            
+            return InsertResult<T>(InsertError(error_type, status, message));
+        }
+        
+        // Success path - same as current insert()
+        if (buffer_len == 0) {
+            // No auto-generated fields, return the original row
+            return InsertResult<T>(T(row_data));
+        }
+        
+        // The buffer contains ONLY the generated column values in BSATN format
+        T updated_row = row_data;
+        SpacetimeDb::bsatn::Reader reader(buffer.data(), buffer_len);
+        detail::integrate_autoinc(updated_row, reader);
+        
+        return InsertResult<T>(std::move(updated_row));
+    }
+   
+
+    /**
+     * Delete all rows matching the given values
+     */
+    uint32_t delete_all_by_eq(const std::vector<T>& rows) {
+        if (rows.empty()) return 0;
+        
+        SpacetimeDb::bsatn::Writer writer;
+        writer.write_u32_le(static_cast<uint32_t>(rows.size()));
+        for (const auto& row : rows) {
+            SpacetimeDb::bsatn::serialize(writer, row);
+        }
+        
+        auto buffer = writer.take_buffer();
+        uint32_t deleted = 0;
+        Status status = FFI::datastore_delete_all_by_eq_bsatn(
+            table_id_, buffer.data(), buffer.size(), &deleted);
+        detail::handle_ffi_error(status, "Table::delete_all_by_eq", 
+                               "datastore_delete_all_by_eq_bsatn");
+        
+        return deleted;
+    }
+    
+    /**
+     * Delete a single row by value
+     */
+    bool delete_by_value(const T& row) {
+        return delete_all_by_eq({row}) > 0;
+    }
+    
+    /**
+     * Update a row using a unique index
+     */
+    std::optional<T> update_by_index(IndexId index_id, const T& row) {
+        SpacetimeDb::bsatn::Writer writer;
+        SpacetimeDb::bsatn::serialize(writer, row);
+        auto buffer_vec = writer.get_buffer();
+        
+        // Prepare buffer with extra space for auto-increment writeback
+        const size_t original_len = buffer_vec.size();
+        const size_t extra_space = detail::AUTO_INCREMENT_BUFFER_SPACE;
+        std::vector<uint8_t> buffer(buffer_vec.begin(), buffer_vec.end());
+        buffer.resize(original_len + extra_space);
+        
+        size_t buffer_len = original_len;
+        Status status = FFI::datastore_update_bsatn(
+            table_id_, index_id, buffer.data(), &buffer_len);
+        
+        if (status == StatusCode::NO_SUCH_ROW) {
+            return std::nullopt;
+        }
+        
+        if (status == StatusCode::INDEX_NOT_UNIQUE) {
+            LOG_FATAL("Update failed: index is not unique");
+        }
+        
+        if (status == StatusCode::NO_SUCH_INDEX) {
+            LOG_FATAL("Update failed: index does not exist");
+        }
+        
+        detail::handle_ffi_error(status, "Table::update_by_index", 
+                               "datastore_update_bsatn");
+        
+        // Handle the case where buffer_len might be 0 (no auto-increment fields)
+        if (buffer_len == 0) {
+            // No auto-generated fields, return the original row
+            return row;
+        }
+        
+        // Return the updated row with any auto-generated fields
+        buffer.resize(buffer_len);
+        SpacetimeDb::bsatn::Reader reader(buffer.data(), buffer_len);
+        return SpacetimeDb::bsatn::deserialize<T>(reader);
+    }
+
+    // -------------------------------------------------------------------------
+    // Iteration Support
+    // -------------------------------------------------------------------------
+    
+    TableIterator<T> begin() { return TableIterator<T>(table_id_); }
+    TableIterator<T> end() { return TableIterator<T>(); }
+
+    // -------------------------------------------------------------------------
+    // Table Metadata
+    // -------------------------------------------------------------------------
+    
+    uint64_t count() {
+        uint64_t result = 0;
+        Status status = FFI::datastore_table_row_count(table_id_, &result);
+        detail::handle_ffi_error(status, "Table::count", "datastore_table_row_count");
+        return result;
+    }
+    
+    bool empty() { return count() == 0; }
+    
+    TableId get_table_id() const noexcept { return table_id_; }
+
+private:
+    TableId table_id_;
+};
+
+} // namespace SpacetimeDb
+
+#endif // SPACETIMEDB_LIBRARY_TABLE_H
\ No newline at end of file
diff --git a/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h b/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h
new file mode 100644
index 00000000000..6936fe09e5a
--- /dev/null
+++ b/crates/bindings-cpp/include/spacetimedb/table_with_constraints.h
@@ -0,0 +1,696 @@
+#pragma once
+
+#include "internal/Module.h"
+#include "internal/field_registration.h"
+#include "internal/autogen/RawScheduleDefV9.g.h"
+#include "macros.h"
+#include "error_handling.h" // For DatabaseResult, DatabaseError, UpsertResult
+#include "index_iterator.h" // For IndexIterator
+#include "range_queries.h"  // For Range types and is_range_v
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <cstring>
+#include <optional>
+#include <type_traits>
+#include <concepts>
+
+namespace SpacetimeDb {
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+namespace detail {
+    // Common index name patterns for different constraint types
+    inline std::vector<std::string> get_index_patterns(const std::string& table_name, 
+                                                       const std::string& field_name,
+                                                       FieldConstraint constraint_type) {
+        // Check for primary key (with or without auto-increment)
+        if (has_constraint(constraint_type, FieldConstraint::PrimaryKey)) {
+            return {
+                table_name + "_" + field_name + "_idx_btree",
+                table_name + "_" + field_name + "_idx",
+                "btree_" + table_name + "_" + field_name
+            };
+        }
+        // Check for unique (with or without auto-increment)
+        else if (has_constraint(constraint_type, FieldConstraint::Unique)) {
+            return {
+                table_name + "_" + field_name + "_idx_btree",
+                table_name + "_" + field_name + "_unique_idx",
+                "btree_" + table_name + "_" + field_name
+            };
+        }
+        // Check for indexed (with or without auto-increment)
+        else if (has_constraint(constraint_type, FieldConstraint::Indexed)) {
+            return {
+                table_name + "_" + field_name + "_idx",
+                "idx_" + table_name + "_" + field_name
+            };
+        }
+        return {};
+    }
+}
+
+// =============================================================================
+// Core Table Tag System
+// =============================================================================
+
+/**
+ * @brief Base class for table tag types
+ * 
+ * Each table gets a tag type that acts as an alias for clean syntax:
+ * ctx.db[person].insert(...) instead of ctx.db.table<Person>("person")
+ */
+template<typename T>
+struct TableTag {
+    using type = T;
+    static constexpr const char* name = nullptr;
+    
+    static std::vector<FieldConstraintInfo> get_constraints() {
+        return {};
+    }
+    
+    constexpr TableTag() = default;
+};
+
+// =============================================================================
+// Table Registration
+// =============================================================================
+
+template<typename T>
+void register_table_type_with_constraints(const char* name, bool is_public, 
+                                        const std::vector<FieldConstraintInfo>& constraints) {
+    SpacetimeDb::Internal::Module::RegisterTableInternalImpl<T>(name, is_public, constraints);
+}
+
+// template<typename T>
+// void register_scheduled_table_type_with_constraints(const char* name, const char* reducer_name, bool is_public,
+//                                                    const std::vector<FieldConstraintInfo>& constraints) {
+//     register_table_type_with_constraints<T>(name, is_public, constraints);
+    
+//     auto& module_def = SpacetimeDb::Internal::Module::GetModuleDef();
+//     auto it = module_def.table_indices.find(&typeid(T));
+//     if (it != module_def.table_indices.end()) {
+//         auto& table = module_def.tables[it->second];
+        
+//         uint16_t scheduled_at_column = UINT16_MAX;
+//         for (size_t i = 0; i < table.fields.size(); ++i) {
+//             if (table.fields[i].name == std::string("scheduled_at")) {
+//                 scheduled_at_column = static_cast<uint16_t>(i);
+//                 break;
+//             }
+//         }
+        
+//         if (scheduled_at_column == UINT16_MAX) {
+//             std::abort(); // Scheduled table must have a 'scheduled_at' field of type ScheduleAt
+//         }
+        
+//         SpacetimeDb::Internal::RawScheduleDefV9 schedule_def;
+//         schedule_def.name = std::nullopt;
+//         schedule_def.reducer_name = reducer_name;
+//         schedule_def.scheduled_at_column = scheduled_at_column;
+        
+//         table.schedule = new SpacetimeDb::Internal::RawScheduleDefV9(std::move(schedule_def));
+//     }
+// }
+
+// =============================================================================
+// Main Table Registration Macro
+// =============================================================================
+
+/**
+ * @brief Register a table with the SpacetimeDB module
+ * 
+ * Usage: SPACETIMEDB_TABLE(Type, table_name, Public)
+ * Creates: Database table named "table_name" and tag variable 'table_name'
+ * 
+ * Note: Constraints must be added using FIELD_ macros after the table declaration:
+ *   SPACETIMEDB_TABLE(User, users, Public)
+ *   FIELD_PrimaryKeyAutoInc(users, id)
+ *   FIELD_Unique(users, email)
+ */
+#define SPACETIMEDB_TABLE(type, table_name, access_enum) \
+    extern "C" __attribute__((export_name("__preinit__20_register_table_" #type "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__20_register_table_, SPACETIMEDB_PASTE(type, SPACETIMEDB_PASTE(_line_, __LINE__)))() { \
+        bool is_public = (access_enum == SpacetimeDb::Internal::TableAccess::Public); \
+        SpacetimeDb::Module::RegisterTable<type>(#table_name, is_public); \
+    } \
+    struct SPACETIMEDB_PASTE(table_name, _tag_type) : SpacetimeDb::TableTag<type> { \
+        static constexpr const char* __table_name_internal = #table_name; \
+    }; \
+    constexpr SPACETIMEDB_PASTE(table_name, _tag_type) table_name{};
+
+/**
+ * @brief Schedule a table for automatic reducer execution
+ */
+#define SPACETIMEDB_SCHEDULE(table_name, scheduled_at_column_index, reducer_name) \
+    extern "C" __attribute__((export_name("__preinit__19_schedule_" #table_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__19_schedule_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_line_, __LINE__)))() { \
+        SpacetimeDb::Internal::getV9Builder().RegisterSchedule(#table_name, scheduled_at_column_index, #reducer_name); \
+    }
+
+// =============================================================================
+// Field Tag System
+// =============================================================================
+
+template<typename TableType, typename FieldType, SpacetimeDb::FieldConstraint Constraint>
+struct FieldTag {
+    const char* field_name;
+    const char* table_name;
+    FieldType TableType::*member_ptr;
+    
+    static constexpr SpacetimeDb::FieldConstraint constraint = Constraint;
+    using table_type = TableType;
+    using field_type = FieldType;
+    
+    constexpr FieldTag(const char* table, const char* field, FieldType TableType::*ptr) 
+        : field_name(field), table_name(table), member_ptr(ptr) {}
+};
+
+template<typename TableType, typename FieldType>
+using PrimaryKeyFieldTag = FieldTag<TableType, FieldType, SpacetimeDb::FieldConstraint::PrimaryKey>;
+
+template<typename TableType, typename FieldType>  
+using UniqueFieldTag = FieldTag<TableType, FieldType, SpacetimeDb::FieldConstraint::Unique>;
+
+template<typename TableType, typename FieldType>
+using IndexedFieldTag = FieldTag<TableType, FieldType, SpacetimeDb::FieldConstraint::Indexed>;
+
+// =============================================================================
+// Constraint Concepts
+// =============================================================================
+
+template<typename T>
+concept FilterableValue = 
+    std::integral<T> ||
+    std::same_as<T, std::string> ||
+    std::same_as<T, SpacetimeDb::Identity> ||
+    std::same_as<T, SpacetimeDb::ConnectionId> ||
+    std::same_as<T, SpacetimeDb::Timestamp> ||
+    std::same_as<T, SpacetimeDb::I128> ||
+    std::same_as<T, SpacetimeDb::U128> ||
+    std::same_as<T, SpacetimeDb::I256> ||
+    std::same_as<T, SpacetimeDb::U256> ||
+    std::same_as<T, SpacetimeDb::i256> ||
+    std::same_as<T, SpacetimeDb::u256> ||
+    std::is_enum_v<T>;
+
+template<typename T>
+concept AutoIncrementable = 
+    std::same_as<T, int8_t> ||
+    std::same_as<T, int16_t> ||
+    std::same_as<T, int32_t> ||
+    std::same_as<T, int64_t> ||
+    std::same_as<T, uint8_t> ||
+    std::same_as<T, uint16_t> ||
+    std::same_as<T, uint32_t> ||
+    std::same_as<T, uint64_t> ||
+    std::same_as<T, SpacetimeDb::I128> ||
+    std::same_as<T, SpacetimeDb::U128> ||
+    std::same_as<T, SpacetimeDb::i256> ||
+    std::same_as<T, SpacetimeDb::u256>;
+
+// =============================================================================
+// Unified Field Accessor Base Class
+// =============================================================================
+
+template<typename TableType, typename FieldType>
+class TypedFieldAccessor : public SpacetimeDb::TableAccessor<TableType> {
+protected:
+    std::string_view field_name_;
+    FieldType TableType::*member_ptr_;
+    mutable std::optional<IndexId> cached_index_id_;
+    
+    [[nodiscard]] constexpr FieldType get_field_value(const TableType& row) const {
+        return row.*member_ptr_;
+    }
+    
+    [[nodiscard]] IndexId resolve_index_with_patterns(std::initializer_list<std::string> patterns) const {
+        if (cached_index_id_) {
+            return *cached_index_id_;
+        }
+        
+        for (const auto& pattern : patterns) {
+            IndexId id;
+            Status result = ::index_id_from_name(
+                reinterpret_cast<const uint8_t*>(pattern.data()),
+                pattern.length(),
+                &id
+            );
+            
+            if (is_ok(result)) {
+                cached_index_id_ = id;
+                return id;
+            }
+        }
+        
+        return IndexId{0}; // Invalid ID
+    }
+    
+    // Common index-based delete operation
+    [[nodiscard]] uint32_t delete_by_index_scan(const FieldType& value, bool exact_match = true) const {
+        IndexId index_id = get_index_id();
+        if (index_id.inner == 0) {
+            return 0; // No index available
+        }
+        
+        SpacetimeDb::bsatn::Writer bound_writer;
+        bound_writer.write_u8(0); // Bound::Included
+        SpacetimeDb::bsatn::serialize(bound_writer, value);
+        auto bound_buffer = bound_writer.get_buffer();
+        
+        uint32_t deleted_count = 0;
+        Status status;
+        
+        if (exact_match) {
+            // Exact match for primary/unique keys
+            status = ::datastore_delete_by_index_scan_range_bsatn(
+                index_id,
+                nullptr, 0, ColId{0},
+                bound_buffer.data(), bound_buffer.size(),
+                bound_buffer.data(), bound_buffer.size(),
+                &deleted_count
+            );
+        } else {
+            // Prefix match for indexed fields
+            status = ::datastore_delete_by_index_scan_range_bsatn(
+                index_id,
+                bound_buffer.data(), bound_buffer.size(), ColId{1},
+                nullptr, 0,
+                nullptr, 0,
+                &deleted_count
+            );
+        }
+        
+        return is_ok(status) ? deleted_count : 0;
+    }
+    
+    // Common index-based update operation
+    [[nodiscard]] bool update_by_index(const TableType& new_row) const {
+        IndexId index_id = get_index_id();
+        auto result = this->get_table().update_by_index(index_id, new_row);
+        return result.has_value();
+    }
+    
+    // Must be implemented by derived classes
+    virtual IndexId get_index_id() const = 0;
+    
+public:
+    using table_type = TableType;
+    using field_type = FieldType;
+    
+    TypedFieldAccessor(const char* table_name, const char* field_name, FieldType TableType::*ptr) 
+        : SpacetimeDb::TableAccessor<TableType>(table_name), 
+          field_name_(field_name), 
+          member_ptr_(ptr) {}
+    
+    [[nodiscard]] constexpr std::string_view field_name() const { return field_name_; }
+    [[nodiscard]] constexpr auto member_pointer() const { return member_ptr_; }
+    
+    // Common operations available to all field types
+    // std::vector<TableType> filter(const FieldType& value) const {
+    //     return this->get_table().filter([this, &value](const TableType& row) {
+    //         return get_field_value(row) == value;
+    //     });
+    // }
+
+    uint32_t delete_by_value(const FieldType& value) const {
+        return delete_by_index_scan(value, true);
+    }
+    
+    // DatabaseResult<TableType> try_insert(const TableType& row) const {
+    //     // Without exceptions, we just call insert and return success
+    //     // If there's a constraint violation, insert will abort
+    //     this->insert(row);
+    //     return DatabaseResult<TableType>(std::in_place_index<0>, row);
+    // }
+};
+
+// =============================================================================
+// Specialized Field Accessors (Minimal Duplication)
+// =============================================================================
+
+template<typename TableType, typename FieldType>
+class TypedPrimaryKeyAccessor : public TypedFieldAccessor<TableType, FieldType> {
+private:
+    [[nodiscard]] IndexId get_index_id() const override {
+        auto patterns = detail::get_index_patterns(
+            std::string(this->table_name_), 
+            std::string(this->field_name_),
+            FieldConstraint::PrimaryKey
+        );
+        IndexId id = this->resolve_index_with_patterns({patterns[0], patterns[1], patterns[2]});
+        
+        if (id.inner == 0) {
+            std::abort(); // Failed to resolve index ID for primary key field
+        }
+        return id;
+    }
+    
+public:
+    using TypedFieldAccessor<TableType, FieldType>::TypedFieldAccessor;
+    
+    [[nodiscard]] std::optional<TableType> find(const FieldType& key_value) const {
+        IndexId index_id = get_index_id();
+        if (index_id.inner != 0) {
+            // Use efficient index-based iteration
+            IndexIterator<TableType> iter(index_id, key_value);
+            if (iter != IndexIterator<TableType>()) {
+                return *iter;
+            } else {
+                return std::nullopt;
+            }
+        }
+        return std::nullopt;
+        // // Fallback to iteration
+        // return SpacetimeDb::TableAccessor<TableType>::find([&](const TableType& row) {
+        //     return this->get_field_value(row) == key_value;
+        // });
+    }
+
+    [[nodiscard]] bool delete_by_key(const FieldType& key_value) const {
+        uint32_t count = this->delete_by_index_scan(key_value, true);
+        if (count > 0) return true;
+
+        return false;
+        // // Fallback to iteration
+        // return this->delete_where_primary_key([&](const TableType& row) {
+        //     return this->get_field_value(row) == key_value;
+        // });
+    }
+    
+    [[nodiscard]] bool update(const TableType& new_row) const {
+        if (this->update_by_index(new_row)) return true;
+        
+        // Fallback
+        FieldType key_val = this->get_field_value(new_row);
+        auto existing = find(key_val);
+        if (existing) {
+            this->update_by_value(*existing, new_row);
+            return true;
+        }
+        return false;
+    }
+    
+    TableType try_insert_or_update(const TableType& row) const {
+        FieldType key_val = this->get_field_value(row);
+        auto existing = find(key_val);
+        if (existing) {
+            auto _ = update(row);
+            return row;
+        } else {
+            return this->insert(row);
+        }
+    }
+};
+
+template<typename TableType, typename FieldType>
+class TypedUniqueAccessor : public TypedFieldAccessor<TableType, FieldType> {
+private:
+    [[nodiscard]] IndexId get_index_id() const override {
+        auto patterns = detail::get_index_patterns(
+            std::string(this->table_name_), 
+            std::string(this->field_name_),
+            FieldConstraint::Unique
+        );
+        IndexId id = this->resolve_index_with_patterns({patterns[0], patterns[1], patterns[2]});
+        
+        if (id.inner == 0) {
+            std::abort(); // Failed to resolve index ID for unique field
+        }
+        return id;
+    }
+    
+public:
+    using TypedFieldAccessor<TableType, FieldType>::TypedFieldAccessor;
+    
+    std::optional<TableType> find(const FieldType& value) const {
+        IndexId index_id = get_index_id();
+        if (index_id.inner != 0) {
+            // Use efficient index-based iteration
+            IndexIterator<TableType> iter(index_id, value);
+            if (iter != IndexIterator<TableType>()) {
+                return *iter;
+            } else {
+                return std::nullopt;
+            }
+        }
+        return std::nullopt;
+
+        // return SpacetimeDb::TableAccessor<TableType>::find([&](const TableType& row) {
+        //     return this->get_field_value(row) == value;
+        // });
+    }
+    
+    bool delete_by_value(const FieldType& value) const {
+        uint32_t count = this->delete_by_index_scan(value, true);
+        if (count > 0) return true;
+        
+        // Fallback
+        auto match = find(value);
+        return match ? SpacetimeDb::TableAccessor<TableType>::delete_by_value(*match) > 0 : false;
+    }
+    
+    bool update(const TableType& new_row) const {
+        if (this->update_by_index(new_row)) return true;
+        
+        // Fallback
+        FieldType field_val = this->get_field_value(new_row);
+        auto existing = find(field_val);
+        if (existing) {
+            this->TableAccessor<TableType>::update_by_value(*existing, new_row);
+            return true;
+        }
+        return false;
+    }
+};
+
+template<typename TableType, typename FieldType>
+class TypedIndexedAccessor : public TypedFieldAccessor<TableType, FieldType> {
+private:
+    [[nodiscard]] IndexId get_index_id() const override {
+        auto patterns = detail::get_index_patterns(
+            std::string(this->table_name_), 
+            std::string(this->field_name_),
+            FieldConstraint::Indexed
+        );
+        if (patterns.size() >= 2) {
+            return this->resolve_index_with_patterns({patterns[0], patterns[1]});
+        } else if (patterns.size() == 1) {
+            return this->resolve_index_with_patterns({patterns[0]});
+        }
+        return IndexId{0};
+    }
+    
+public:
+    using TypedFieldAccessor<TableType, FieldType>::TypedFieldAccessor;
+    
+    // Override filter to use index-based iteration for efficiency
+    std::vector<TableType> filter(const FieldType& value) const {
+        IndexId index_id = get_index_id();
+        
+        if (index_id.inner != 0) {
+            // Use efficient index-based iteration
+            std::vector<TableType> results;
+            for (IndexIterator<TableType> iter(index_id, value); iter != IndexIterator<TableType>(); ++iter) {
+                results.push_back(*iter);
+            }
+            return results;
+        }
+
+        return std::vector<TableType>{};
+        // // Fallback to base implementation if index not found
+        // return TypedFieldAccessor<TableType, FieldType>::filter(value);
+    }
+    
+    // Filter by range using index (new functionality!)
+    template<typename RangeType>
+    std::enable_if_t<is_range_v<RangeType>, std::vector<TableType>>
+    filter(const RangeType& range) const {
+        IndexId index_id = get_index_id();
+        
+        if (index_id.inner != 0) {
+            // Use efficient index-based iteration with range
+            std::vector<TableType> results;
+            for (IndexIterator<TableType> iter(index_id, range); iter != IndexIterator<TableType>(); ++iter) {
+                results.push_back(*iter);
+            }
+            return results;
+        }
+
+        return std::vector<TableType>{};
+        // // Fallback to manual filtering if index not found
+        // return this->get_table().filter([this, &range](const TableType& row) {
+        //     return range.contains(this->get_field_value(row));
+        // });
+    }
+    
+    uint32_t delete_all(const FieldType& value) const {
+        uint32_t count = this->delete_by_index_scan(value, false);
+        if (count > 0) return count;
+        
+        // Fallback
+        auto matches = this->filter(value);
+        uint32_t deleted_count = 0;
+        for (const auto& row : matches) {
+            if (this->delete_by_value(row) > 0) {
+                deleted_count++;
+            }
+        }
+        return deleted_count;
+    }
+};
+
+// =============================================================================
+// Auto-Increment Integration Helper
+// =============================================================================
+
+// Helper macro to register auto-increment integration function
+// Creates a unique function and registers it for the struct type
+#define SPACETIMEDB_AUTOINC_INTEGRATION_IMPL(StructType, field_name) \
+    namespace SpacetimeDb { namespace detail { \
+        static void SPACETIMEDB_PASTE(autoinc_integrate_, __LINE__)(StructType& row, SpacetimeDb::bsatn::Reader& reader) { \
+            using FieldType = decltype(std::declval<StructType>().field_name); \
+            FieldType generated_value = SpacetimeDb::bsatn::deserialize<FieldType>(reader); \
+            row.field_name = generated_value; \
+        } \
+    }} \
+    extern "C" __attribute__((export_name("__preinit__19_autoinc_register_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__19_autoinc_register_, __LINE__)() { \
+        SpacetimeDb::detail::get_autoinc_integrator<StructType>() = \
+            &SpacetimeDb::detail::SPACETIMEDB_PASTE(autoinc_integrate_, __LINE__); \
+    }
+
+// =============================================================================
+// Field Constraint Registration Macros
+// =============================================================================
+
+#define FIELD_PrimaryKey(table_name, field_name) \
+    static constexpr SpacetimeDb::PrimaryKeyFieldTag<typename std::remove_cv_t<decltype(table_name)>::type, \
+                                                      decltype(std::declval<typename std::remove_cv_t<decltype(table_name)>::type>().field_name)> \
+    table_name##_##field_name { #table_name, #field_name, &std::remove_cv_t<decltype(table_name)>::type::field_name }; \
+    extern "C" __attribute__((export_name("__preinit__21_field_constraint_" #table_name "_" #field_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_constraint_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(field_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddFieldConstraint<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #field_name, ::SpacetimeDb::FieldConstraint::PrimaryKey); \
+    }
+
+#define FIELD_Unique(table_name, field_name) \
+    static_assert([]() constexpr { \
+        using TableType = typename std::remove_cv_t<decltype(table_name)>::type; \
+        using FieldType = decltype(std::declval<TableType>().field_name); \
+        static_assert(FilterableValue<FieldType>, \
+            "Field '" #field_name "' cannot have Unique constraint - type is not filterable."); \
+        return true; \
+    }(), "Constraint validation for " #table_name "." #field_name); \
+    static constexpr SpacetimeDb::UniqueFieldTag<typename std::remove_cv_t<decltype(table_name)>::type, \
+                                                  decltype(std::declval<typename std::remove_cv_t<decltype(table_name)>::type>().field_name)> \
+    table_name##_##field_name { #table_name, #field_name, &std::remove_cv_t<decltype(table_name)>::type::field_name }; \
+    extern "C" __attribute__((export_name("__preinit__21_field_constraint_" #table_name "_" #field_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_constraint_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(field_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddFieldConstraint<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #field_name, ::SpacetimeDb::FieldConstraint::Unique); \
+    }
+
+#define FIELD_Index(table_name, field_name) \
+    static_assert([]() constexpr { \
+        using TableType = typename std::remove_cv_t<decltype(table_name)>::type; \
+        using FieldType = decltype(std::declval<TableType>().field_name); \
+        static_assert(FilterableValue<FieldType>, \
+            "Field '" #field_name "' cannot have Index constraint - type is not filterable."); \
+        return true; \
+    }(), "Constraint validation for " #table_name "." #field_name); \
+    static constexpr SpacetimeDb::IndexedFieldTag<typename std::remove_cv_t<decltype(table_name)>::type, \
+                                                   decltype(std::declval<typename std::remove_cv_t<decltype(table_name)>::type>().field_name)> \
+    table_name##_##field_name { #table_name, #field_name, &std::remove_cv_t<decltype(table_name)>::type::field_name }; \
+    extern "C" __attribute__((export_name("__preinit__21_field_constraint_" #table_name "_" #field_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_constraint_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(field_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddFieldConstraint<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #field_name, ::SpacetimeDb::FieldConstraint::Indexed); \
+    }
+
+#define FIELD_PrimaryKeyAutoInc(table_name, field_name) \
+    static_assert([]() constexpr { \
+        using TableType = typename std::remove_cv_t<decltype(table_name)>::type; \
+        using FieldType = decltype(std::declval<TableType>().field_name); \
+        static_assert(AutoIncrementable<FieldType>, \
+            "Field '" #field_name "' cannot have AutoIncrement constraint - type is not auto-incrementable."); \
+        return true; \
+    }(), "AutoIncrement validation for " #table_name "." #field_name); \
+    static constexpr SpacetimeDb::PrimaryKeyFieldTag<typename std::remove_cv_t<decltype(table_name)>::type, \
+                                                      decltype(std::declval<typename std::remove_cv_t<decltype(table_name)>::type>().field_name)> \
+    table_name##_##field_name { #table_name, #field_name, &std::remove_cv_t<decltype(table_name)>::type::field_name }; \
+    extern "C" __attribute__((export_name("__preinit__21_field_constraint_" #table_name "_" #field_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_constraint_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(field_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddFieldConstraint<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #field_name, static_cast<::SpacetimeDb::FieldConstraint>( \
+                static_cast<int>(::SpacetimeDb::FieldConstraint::PrimaryKey) | static_cast<int>(::SpacetimeDb::FieldConstraint::AutoInc))); \
+    } \
+    SPACETIMEDB_AUTOINC_INTEGRATION_IMPL(typename std::remove_cv_t<decltype(table_name)>::type, field_name)
+
+#define FIELD_UniqueAutoInc(table_name, field_name) \
+    static_assert([]() constexpr { \
+        using TableType = typename std::remove_cv_t<decltype(table_name)>::type; \
+        using FieldType = decltype(std::declval<TableType>().field_name); \
+        static_assert(FilterableValue<FieldType>, \
+            "Field '" #field_name "' cannot have Unique constraint - type is not filterable."); \
+        static_assert(AutoIncrementable<FieldType>, \
+            "Field '" #field_name "' cannot have AutoIncrement constraint - type is not auto-incrementable."); \
+        return true; \
+    }(), "Constraint validation for " #table_name "." #field_name); \
+    static constexpr SpacetimeDb::UniqueFieldTag<typename std::remove_cv_t<decltype(table_name)>::type, \
+                                                  decltype(std::declval<typename std::remove_cv_t<decltype(table_name)>::type>().field_name)> \
+    table_name##_##field_name { #table_name, #field_name, &std::remove_cv_t<decltype(table_name)>::type::field_name }; \
+    extern "C" __attribute__((export_name("__preinit__21_field_constraint_" #table_name "_" #field_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_constraint_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(field_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddFieldConstraint<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #field_name, static_cast<::SpacetimeDb::FieldConstraint>( \
+                static_cast<int>(::SpacetimeDb::FieldConstraint::Unique) | static_cast<int>(::SpacetimeDb::FieldConstraint::AutoInc))); \
+    } \
+    SPACETIMEDB_AUTOINC_INTEGRATION_IMPL(typename std::remove_cv_t<decltype(table_name)>::type, field_name)
+
+#define FIELD_IndexAutoInc(table_name, field_name) \
+    static_assert([]() constexpr { \
+        using TableType = typename std::remove_cv_t<decltype(table_name)>::type; \
+        using FieldType = decltype(std::declval<TableType>().field_name); \
+        static_assert(FilterableValue<FieldType>, \
+            "Field '" #field_name "' cannot have Index constraint - type is not filterable."); \
+        static_assert(AutoIncrementable<FieldType>, \
+            "Field '" #field_name "' cannot have AutoIncrement constraint - type is not auto-incrementable."); \
+        return true; \
+    }(), "Constraint validation for " #table_name "." #field_name); \
+    static constexpr SpacetimeDb::IndexedFieldTag<typename std::remove_cv_t<decltype(table_name)>::type, \
+                                                   decltype(std::declval<typename std::remove_cv_t<decltype(table_name)>::type>().field_name)> \
+    table_name##_##field_name { #table_name, #field_name, &std::remove_cv_t<decltype(table_name)>::type::field_name }; \
+    extern "C" __attribute__((export_name("__preinit__21_field_constraint_" #table_name "_" #field_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_constraint_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(field_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddFieldConstraint<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #field_name, static_cast<::SpacetimeDb::FieldConstraint>( \
+                static_cast<int>(::SpacetimeDb::FieldConstraint::Indexed) | static_cast<int>(::SpacetimeDb::FieldConstraint::AutoInc))); \
+    }
+
+#define FIELD_AutoInc(table_name, field_name) \
+    static_assert([]() constexpr { \
+        using TableType = typename std::remove_cv_t<decltype(table_name)>::type; \
+        using FieldType = decltype(std::declval<TableType>().field_name); \
+        static_assert(AutoIncrementable<FieldType>, \
+            "Field '" #field_name "' cannot have AutoIncrement constraint - type is not auto-incrementable."); \
+        return true; \
+    }(), "AutoIncrement validation for " #table_name "." #field_name); \
+    extern "C" __attribute__((export_name("__preinit__21_field_constraint_" #table_name "_" #field_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_constraint_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(field_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddFieldConstraint<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #field_name, ::SpacetimeDb::FieldConstraint::AutoInc); \
+    } \
+    SPACETIMEDB_AUTOINC_INTEGRATION_IMPL(typename std::remove_cv_t<decltype(table_name)>::type, field_name)
+
+#define FIELD_NamedMultiColumnIndex(table_name, index_name, field1, field2) \
+    extern "C" __attribute__((export_name("__preinit__21_field_multi_index_" #table_name "_" #index_name "_line_" SPACETIMEDB_STRINGIFY(__LINE__)))) \
+    void SPACETIMEDB_PASTE(__preinit__21_field_multi_index_, SPACETIMEDB_PASTE(table_name, SPACETIMEDB_PASTE(_, SPACETIMEDB_PASTE(index_name, SPACETIMEDB_PASTE(_line_, __LINE__)))))() { \
+        SpacetimeDb::Internal::getV9Builder().AddMultiColumnIndex<typename std::remove_cv_t<decltype(table_name)>::type>( \
+            #table_name, #index_name, {#field1, #field2}); \
+    }
+
+} // namespace SpacetimeDb
diff --git a/crates/bindings-cpp/src/abi/module_exports.cpp b/crates/bindings-cpp/src/abi/module_exports.cpp
new file mode 100644
index 00000000000..36baf570fa9
--- /dev/null
+++ b/crates/bindings-cpp/src/abi/module_exports.cpp
@@ -0,0 +1,55 @@
+#include "spacetimedb/abi/FFI.h"
+#include "spacetimedb/internal/autogen/SumType.g.h"  // Complete SumType definition before Module.h
+#include "spacetimedb/internal/Module.h"  // Use new Module API
+#include "spacetimedb/bsatn/timestamp.h"     // For Timestamp
+
+#include <vector>
+#include <cstddef> // For size_t
+#include <string>  // For std::string in error handling
+#include <iostream> // For temporary error logging if needed
+
+// Export definitions - these implement the declarations from abi.h
+
+extern "C" {
+
+    STDB_EXPORT(__describe_module__)
+    void __describe_module__(SpacetimeDb::BytesSink description) {
+        // Use the new Module API directly with opaque type
+        SpacetimeDb::Internal::Module::__describe_module__(description);
+    }
+
+    STDB_EXPORT(__call_reducer__)
+    int16_t __call_reducer__(
+        uint32_t reducer_id,
+        uint64_t sender_0, uint64_t sender_1, uint64_t sender_2, uint64_t sender_3,
+        uint64_t conn_id_0, uint64_t conn_id_1,
+        uint64_t timestamp_us,
+        SpacetimeDb::BytesSource args,
+        SpacetimeDb::BytesSink error
+    ) {
+        // Create timestamp - already in microseconds
+        SpacetimeDb::Timestamp ts(timestamp_us);
+        
+        // Call Module's implementation with opaque types
+        auto result = SpacetimeDb::Internal::Module::__call_reducer__(
+            reducer_id,
+            sender_0, sender_1, sender_2, sender_3,
+            conn_id_0, conn_id_1,
+            ts,
+            args,
+            error
+        );
+        
+        // Convert Status to int16_t
+        if (result == SpacetimeDb::StatusCode::OK) {
+            return 0;
+        } else if (result == SpacetimeDb::StatusCode::NO_SUCH_REDUCER) {
+            return -1;
+        } else if (result == SpacetimeDb::StatusCode::HOST_CALL_FAILURE) {
+            return 1;
+        } else {
+            return -4;
+        }
+    }
+
+} // extern "C"
diff --git a/crates/bindings-cpp/src/abi/wasi_shims.cpp b/crates/bindings-cpp/src/abi/wasi_shims.cpp
new file mode 100644
index 00000000000..e9a8886fbc8
--- /dev/null
+++ b/crates/bindings-cpp/src/abi/wasi_shims.cpp
@@ -0,0 +1,158 @@
+// WASI shims for SpacetimeDB C++ modules
+// This file provides stub implementations of WASI functions to enable
+// C++ standard library usage without requiring actual WASI support
+
+#include <cstdint>
+#include <cstddef>
+
+// SpacetimeDB imports we need for console output
+// Import from spacetime_10.0 module as required by SpacetimeDB ABI
+extern "C" __attribute__((import_module("spacetime_10.0"), import_name("console_log")))
+void console_log(uint8_t log_level, const uint8_t* target, uint32_t target_len,
+                 const uint8_t* filename, uint32_t filename_len, uint32_t line_number,
+                 const uint8_t* message, uint32_t message_len);
+
+// Helper macro for string literals
+#define CSTR(s) (uint8_t*)s, sizeof(s) - 1
+
+// WASI types
+struct __wasi_ciovec_t {
+    const uint8_t* buf;
+    size_t buf_len;
+};
+
+typedef uint32_t __wasi_fd_t;
+typedef uint32_t __wasi_size_t;
+typedef uint32_t __wasi_errno_t;
+
+// File descriptors
+#define STDIN_FILENO 0
+#define STDOUT_FILENO 1
+#define STDERR_FILENO 2
+
+// WASI error codes
+#define __WASI_ERRNO_SUCCESS 0
+#define __WASI_ERRNO_BADF 8
+
+// Macro to define WASI shim functions that always succeed
+#define WASI_SHIM(name, params) \
+    extern "C" __wasi_errno_t __wasi_##name params { return __WASI_ERRNO_SUCCESS; }
+
+// Environment functions
+WASI_SHIM(environ_get, (int32_t, int32_t))
+WASI_SHIM(environ_sizes_get, (int32_t, int32_t))
+
+// Clock functions
+WASI_SHIM(clock_time_get, (int32_t, int64_t, int32_t))
+
+// File descriptor functions
+WASI_SHIM(fd_advise, (int32_t, int64_t, int64_t, int32_t))
+WASI_SHIM(fd_allocate, (int32_t, int64_t, int64_t))
+WASI_SHIM(fd_close, (int32_t))
+WASI_SHIM(fd_datasync, (int32_t))
+WASI_SHIM(fd_fdstat_get, (int32_t, int32_t))
+WASI_SHIM(fd_fdstat_set_flags, (int32_t, int32_t))
+WASI_SHIM(fd_fdstat_set_rights, (int32_t, int64_t, int64_t))
+WASI_SHIM(fd_filestat_get, (int32_t, int32_t))
+WASI_SHIM(fd_filestat_set_size, (int32_t, int64_t))
+WASI_SHIM(fd_filestat_set_times, (int32_t, int64_t, int64_t, int32_t))
+WASI_SHIM(fd_pread, (int32_t, int32_t, int32_t, int64_t, int32_t))
+WASI_SHIM(fd_prestat_dir_name, (int32_t, int32_t, int32_t))
+WASI_SHIM(fd_pwrite, (int32_t, int32_t, int32_t, int64_t, int32_t))
+WASI_SHIM(fd_read, (int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(fd_readdir, (int32_t, int32_t, int32_t, int64_t, int32_t))
+WASI_SHIM(fd_renumber, (int32_t, int32_t))
+WASI_SHIM(fd_seek, (int32_t, int64_t, int32_t, int32_t))
+WASI_SHIM(fd_sync, (int32_t))
+WASI_SHIM(fd_tell, (int32_t, int32_t))
+
+// Path functions
+WASI_SHIM(path_create_directory, (int32_t, int32_t, int32_t))
+WASI_SHIM(path_filestat_get, (int32_t, int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(path_filestat_set_times, (int32_t, int32_t, int32_t, int32_t, int64_t, int64_t, int32_t))
+WASI_SHIM(path_link, (int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(path_open, (int32_t, int32_t, int32_t, int32_t, int32_t, int64_t, int64_t, int32_t, int32_t))
+WASI_SHIM(path_readlink, (int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(path_remove_directory, (int32_t, int32_t, int32_t))
+WASI_SHIM(path_rename, (int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(path_symlink, (int32_t, int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(path_unlink_file, (int32_t, int32_t, int32_t))
+
+// Other functions
+WASI_SHIM(poll_oneoff, (int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(sched_yield, ())
+WASI_SHIM(random_get, (int32_t, int32_t))
+WASI_SHIM(sock_accept, (int32_t, int32_t, int32_t))
+WASI_SHIM(sock_recv, (int32_t, int32_t, int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(sock_send, (int32_t, int32_t, int32_t, int32_t, int32_t))
+WASI_SHIM(sock_shutdown, (int32_t, int32_t))
+
+// Special handling for args_sizes_get and args_get
+// We provide a dummy executable name to avoid issues
+extern "C" {
+const char executable_name[] = "stdb.wasm";
+
+__wasi_errno_t __wasi_args_sizes_get(__wasi_size_t* argc, __wasi_size_t* argv_buf_size) {
+    *argc = 1;
+    *argv_buf_size = sizeof(executable_name);
+    return __WASI_ERRNO_SUCCESS;
+}
+
+__wasi_errno_t __wasi_args_get(uint8_t** argv, uint8_t* argv_buf) {
+    argv[0] = argv_buf;
+    __builtin_memcpy(argv_buf, executable_name, sizeof(executable_name));
+    return __WASI_ERRNO_SUCCESS;
+}
+
+// Clock resolution should be non-zero
+__wasi_errno_t __wasi_clock_res_get(int32_t, uint64_t* timestamp) {
+    *timestamp = 1;
+    return __WASI_ERRNO_SUCCESS;
+}
+
+// Special handling for fd_write to avoid infinite loops
+// Redirect output to console_log
+__wasi_errno_t __wasi_fd_write(__wasi_fd_t fd, const __wasi_ciovec_t* iovs,
+                        size_t iovs_len, __wasi_size_t* retptr0) {
+    *retptr0 = 0;
+    for (size_t i = 0; i < iovs_len; i++) {
+        // Map file descriptors to log levels
+        uint8_t log_level = (fd == STDERR_FILENO) ? 1 : 2; // 1=WARN, 2=INFO
+        
+        console_log(log_level, CSTR("wasi"), CSTR(__FILE__), __LINE__, 
+                   iovs[i].buf, iovs[i].buf_len);
+        *retptr0 += iovs[i].buf_len;
+    }
+    return __WASI_ERRNO_SUCCESS;
+}
+
+// fd_prestat_get returns BADF to indicate end of iteration
+__wasi_errno_t __wasi_fd_prestat_get(int32_t, int32_t) {
+    return __WASI_ERRNO_BADF;
+}
+
+// Actually exit on proc_exit
+[[noreturn]] void __wasi_proc_exit(int32_t code) {
+    // In a WASM module, we can't actually exit
+    // Mark the exit code as used (could be useful for debugging)
+    (void)code;
+    // Just spin forever
+    while (true) {}
+}
+
+// Additional sock_accept for compatibility
+__wasi_errno_t sock_accept(int32_t, int32_t, int32_t) {
+    return __WASI_ERRNO_SUCCESS;
+}
+
+} // extern "C"
+
+// Emscripten-specific shims
+extern "C" {
+
+// Emscripten runtime functions that might be imported
+void emscripten_notify_memory_growth(int32_t) {
+    // No-op - memory growth is handled by the runtime
+}
+
+} // extern "C"
\ No newline at end of file
diff --git a/crates/bindings-cpp/src/internal/AlgebraicType.cpp b/crates/bindings-cpp/src/internal/AlgebraicType.cpp
new file mode 100644
index 00000000000..22f236e4154
--- /dev/null
+++ b/crates/bindings-cpp/src/internal/AlgebraicType.cpp
@@ -0,0 +1,171 @@
+// Implementation for AlgebraicType to handle circular dependencies
+#include "spacetimedb/internal/autogen/AlgebraicType.g.h"
+#include "spacetimedb/internal/autogen/SumType.g.h"
+#include "spacetimedb/internal/autogen/ProductType.g.h"
+#include "spacetimedb/internal/autogen/SumTypeVariant.g.h"
+#include "spacetimedb/internal/autogen/ProductTypeElement.g.h"
+
+namespace SpacetimeDb::Internal {
+
+// Default constructor - String type
+AlgebraicType::AlgebraicType() : tag_(Tag::String), data_(std::in_place_index<4>, std::monostate{}) {}
+
+// Constructor for primitive types using in_place_index
+AlgebraicType::AlgebraicType(Tag primitive_tag) : tag_(primitive_tag) {
+    switch (primitive_tag) {
+        case Tag::Ref: 
+            data_.emplace<0>(uint32_t{0}); 
+            break;
+        case Tag::Sum: 
+            data_.emplace<1>(std::unique_ptr<SpacetimeDb::Internal::SumType>{}); 
+            break;
+        case Tag::Product: 
+            data_.emplace<2>(std::unique_ptr<SpacetimeDb::Internal::ProductType>{}); 
+            break;
+        case Tag::Array: 
+            data_.emplace<3>(std::unique_ptr<SpacetimeDb::Internal::AlgebraicType>{}); 
+            break;
+        default: 
+            // All primitive types use index 4 with monostate
+            data_.emplace<4>(std::monostate{}); 
+            break;
+    }
+}
+
+// Copy constructor - must handle unique_ptr deep copy manually
+AlgebraicType::AlgebraicType(const AlgebraicType& other) : tag_(other.tag_) {
+    // Deep copy for pointer types, direct copy for others
+    switch (tag_) {
+        case Tag::Ref:
+            data_.emplace<0>(std::get<0>(other.data_));
+            break;
+        case Tag::Sum: {
+            auto& ptr = std::get<1>(other.data_);
+            if (ptr) {
+                data_.emplace<1>(std::make_unique<SpacetimeDb::Internal::SumType>(*ptr));
+            } else {
+                data_.emplace<1>(std::unique_ptr<SpacetimeDb::Internal::SumType>{});
+            }
+            break;
+        }
+        case Tag::Product: {
+            auto& ptr = std::get<2>(other.data_);
+            if (ptr) {
+                data_.emplace<2>(std::make_unique<SpacetimeDb::Internal::ProductType>(*ptr));
+            } else {
+                data_.emplace<2>(std::unique_ptr<SpacetimeDb::Internal::ProductType>{});
+            }
+            break;
+        }
+        case Tag::Array: {
+            auto& ptr = std::get<3>(other.data_);
+            if (ptr) {
+                data_.emplace<3>(std::make_unique<SpacetimeDb::Internal::AlgebraicType>(*ptr));
+            } else {
+                data_.emplace<3>(std::unique_ptr<SpacetimeDb::Internal::AlgebraicType>{});
+            }
+            break;
+        }
+        default: 
+            // All primitive types use index 4 with monostate
+            data_.emplace<4>(std::monostate{});
+            break;
+    }
+}
+
+// Assignment operator
+AlgebraicType& AlgebraicType::operator=(const AlgebraicType& other) {
+    if (this != &other) {
+        AlgebraicType temp(other);
+        std::swap(tag_, temp.tag_);
+        std::swap(data_, temp.data_);
+    }
+    return *this;
+}
+
+// Template setters by index
+template<size_t Index, typename T>
+void AlgebraicType::set(T&& value) {
+    // For primitive types, always use index 4
+    if (Index >= 4) {
+        tag_ = static_cast<Tag>(Index);
+        data_.template emplace<4>(std::monostate{});
+    } else {
+        tag_ = static_cast<Tag>(Index);
+        data_.template emplace<Index>(std::forward<T>(value));
+    }
+}
+
+// BSATN serialization (only serialization needed for Internal types)
+void AlgebraicType::bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {
+    writer.write_u8(static_cast<uint8_t>(tag_));
+    fprintf(stdout, "DEBUG: AlgebraicType serializing tag=%d START\n", static_cast<int>(tag_));
+    
+    // Serialize data based on tag
+    switch (tag_) {
+        case Tag::Ref:
+            // Write the type reference
+            writer.write_u32_le(std::get<0>(data_));
+            fprintf(stdout, "  Ref to type %u\n", std::get<0>(data_));
+            break;
+            
+        case Tag::Sum: {
+            // Serialize the SumType
+            const auto& sum_ptr = std::get<1>(data_);
+            if (sum_ptr) {
+                sum_ptr->bsatn_serialize(writer);
+            } else {
+                // Write empty sum (0 variants)
+                writer.write_u32_le(0);
+            }
+            break;
+        }
+        
+        case Tag::Product: {
+            // Serialize the ProductType
+            const auto& product_ptr = std::get<2>(data_);
+            if (product_ptr) {
+                fprintf(stdout, "  Product with %zu elements\n", product_ptr->elements.size());
+                product_ptr->bsatn_serialize(writer);
+            } else {
+                // Write empty product (0 elements)
+                fprintf(stdout, "  Empty Product (nullptr) - writing 0 elements\n");
+                writer.write_u32_le(0);
+            }
+            break;
+        }
+        
+        case Tag::Array: {
+            // Serialize the element type
+            const auto& elem_ptr = std::get<3>(data_);
+            if (elem_ptr) {
+                elem_ptr->bsatn_serialize(writer);
+            } else {
+                // Write String as default element type
+                writer.write_u8(static_cast<uint8_t>(Tag::String));
+            }
+            break;
+        }
+        
+        default:
+            // Primitive types - no additional data to write
+            fprintf(stdout, "DEBUG: AlgebraicType primitive tag=%d END\n", static_cast<int>(tag_));
+            break;
+    }
+    fprintf(stdout, "DEBUG: AlgebraicType serializing tag=%d COMPLETE\n", static_cast<int>(tag_));
+}
+
+// Equality
+bool AlgebraicType::operator==(const AlgebraicType& other) const {
+    return tag_ == other.tag_ && data_ == other.data_;
+}
+
+// Explicit template instantiations for all possible indices
+template void AlgebraicType::set<0, uint32_t>(uint32_t&&);
+template void AlgebraicType::set<0, uint32_t&>(uint32_t&);  // For lvalue references
+template void AlgebraicType::set<1, std::unique_ptr<SumType>>(std::unique_ptr<SumType>&&);
+template void AlgebraicType::set<2, std::unique_ptr<ProductType>>(std::unique_ptr<ProductType>&&);
+template void AlgebraicType::set<3, std::unique_ptr<AlgebraicType>>(std::unique_ptr<AlgebraicType>&&);
+template void AlgebraicType::set<4, std::monostate>(std::monostate&&);
+
+} // namespace SpacetimeDb::Internal
\ No newline at end of file
diff --git a/crates/bindings-cpp/src/internal/Module.cpp b/crates/bindings-cpp/src/internal/Module.cpp
new file mode 100644
index 00000000000..2777dc471ba
--- /dev/null
+++ b/crates/bindings-cpp/src/internal/Module.cpp
@@ -0,0 +1,370 @@
+// SpacetimeDB C++ SDK - V9 Serialization Implementation
+// Clean implementation for simplified type registration and serialization
+
+#include "spacetimedb.h"
+#include "spacetimedb/internal/Module.h"
+#include "spacetimedb/internal/autogen/RawModuleDefV9.g.h"
+#include "spacetimedb/internal/bsatn_adapters.h"
+#include "spacetimedb/internal/v9_type_registration.h"
+#include "spacetimedb/abi/FFI.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "spacetimedb/reducer_error.h"
+#include <cstring>
+#include <iostream>
+#include <vector>
+#include <functional>
+#include <cctype>
+
+namespace SpacetimeDb {
+
+// Global V9 module structure - accessible from preinit functions
+namespace Internal {
+    // Thread-local reducer error message storage
+    thread_local std::optional<std::string> g_reducer_error_message = std::nullopt;
+
+    // The global V9 module that preinit functions will populate directly
+    static RawModuleDefV9 g_v9_module;
+    
+    // Global reducer handler storage for runtime dispatch
+    struct ReducerHandler {
+        std::string name;
+        std::function<void(ReducerContext&, BytesSource)> handler;
+        std::optional<Lifecycle> lifecycle;
+    };
+    static std::vector<ReducerHandler> g_reducer_handlers;
+    
+    // Global error flag for multiple primary key detection
+    static bool g_multiple_primary_key_error = false;
+    static std::string g_multiple_primary_key_table_name = "";
+    
+    // External global flags for circular reference detection (defined in v9_type_registration.cpp)
+    extern bool g_circular_ref_error;
+    extern std::string g_circular_ref_type_name;
+    
+    // Function to set the multiple primary key error flag
+    void SetMultiplePrimaryKeyError(const std::string& table_name) {
+        g_multiple_primary_key_error = true;
+        g_multiple_primary_key_table_name = table_name;
+        fprintf(stderr, "ERROR: Multiple primary keys detected in table '%s'\n", table_name.c_str());
+    }
+    
+    // Register a reducer handler (called by V9Builder during registration)
+    void RegisterReducerHandler(const std::string& name, 
+                                std::function<void(ReducerContext&, BytesSource)> handler,
+                                std::optional<Lifecycle> lifecycle) {
+        g_reducer_handlers.push_back({name, handler, lifecycle});
+    }
+    
+    // Get the global V9 module
+    RawModuleDefV9& GetV9Module() {
+        return g_v9_module;
+    }
+    
+    // Clear the global V9 module state - called at module initialization
+    void ClearV9Module() {
+        g_v9_module = RawModuleDefV9{};  // Reset to default state
+        g_reducer_handlers.clear();  // Also clear reducer handlers
+        g_multiple_primary_key_error = false;  // Reset error flag
+        g_multiple_primary_key_table_name = "";  // Reset error table name
+    }
+    
+    
+    // Legacy DeferredRegistry system removed - all registration now handled by V9Builder
+
+// Clear global state preinit function - runs before anything else
+// The number 01 ensures this runs first to clear any leftover state
+extern "C" __attribute__((export_name("__preinit__01_clear_global_state")))
+void __preinit__01_clear_global_state() {
+    ClearV9Module();
+    // Also clear the V9 type registration state
+    auto& type_reg = getV9TypeRegistration();
+    type_reg.clear();
+}
+
+// Validation preinit function - runs after tables (20) and reducers (30)
+// The number 99 ensures this runs last, just before __describe_module__
+extern "C" __attribute__((export_name("__preinit__99_validate_types")))
+void __preinit__99_validate_types() {
+    fprintf(stdout, "\n[PREINIT_99] Starting validation\n");
+    fprintf(stdout, "  g_circular_ref_error = %s\n", g_circular_ref_error ? "true" : "false");
+    if (g_circular_ref_error) {
+        fprintf(stdout, "  g_circular_ref_type_name = %s\n", g_circular_ref_type_name.c_str());
+    }
+    fflush(stdout);
+    
+    // Check if circular reference error occurred during type building
+    if (g_circular_ref_error) {
+        // Circular reference error detected - create a special error module
+        
+        // Clear the entire V9 module to start fresh
+        RawModuleDefV9& v9_module = GetV9Module();
+        v9_module.typespace.types.clear();
+        v9_module.types.clear();
+        v9_module.tables.clear();
+        v9_module.reducers.clear();
+        v9_module.misc_exports.clear();
+        
+        // Also clear the V9 type registration to remove any partial registrations
+        auto& type_reg = getV9TypeRegistration();
+        type_reg.clear();
+        
+        // Create the error type name that indicates the circular reference
+        std::string error_type_name = "ERROR_CIRCULAR_REFERENCE_" + g_circular_ref_type_name;
+        
+        // Add a single named type export that points to a non-existent typespace index
+        // This will cause SpacetimeDB to error when it tries to resolve the type
+        RawTypeDefV9 error_type;
+        error_type.name.scope = {};
+        error_type.name.name = error_type_name;
+        error_type.ty = 999999; // Invalid typespace index - will cause an error
+        error_type.custom_ordering = false;
+        
+        v9_module.types.push_back(error_type);
+        
+        // Don't add anything to the typespace - this ensures the reference is invalid
+        // The server will fail with an error message that includes our error type name
+        
+        // Also log to stderr for debugging
+        fprintf(stderr, "\n[CIRCULAR REFERENCE ERROR] Module cleared and replaced with error type: %s\n", error_type_name.c_str());
+        fprintf(stderr, "  Type '%s' contains a circular reference to itself\n", g_circular_ref_type_name.c_str());
+        fflush(stderr);
+        return; // Exit early, don't check other errors
+    }
+    
+    // Check if multiple primary key error occurred during constraint registration
+    if (g_multiple_primary_key_error) {
+        // Multiple primary key error detected - create a special error module
+        
+        // Clear the entire V9 module to start fresh
+        RawModuleDefV9& v9_module = GetV9Module();
+        v9_module.typespace.types.clear();
+        v9_module.types.clear();
+        v9_module.tables.clear();
+        v9_module.reducers.clear();
+        v9_module.misc_exports.clear();
+        
+        // Create the error type name
+        std::string error_type_name = "ERROR_MULTIPLE_PRIMARY_KEYS_" + g_multiple_primary_key_table_name;
+        
+        // Add a single named type export that points to a non-existent typespace index
+        // This will cause SpacetimeDB to error when it tries to resolve the type
+        RawTypeDefV9 error_type;
+        error_type.name.scope = {};
+        error_type.name.name = error_type_name;
+        error_type.ty = 999999; // Invalid typespace index - will cause an error
+        error_type.custom_ordering = false;
+        
+        v9_module.types.push_back(error_type);
+        
+        // Don't add anything to the typespace - this ensures the reference is invalid
+        // The server will fail with an error message that includes our error type name
+        
+        // Also log to stderr for debugging
+        fprintf(stderr, "\n[CONSTRAINT ERROR] Module cleared and replaced with error type: %s\n", error_type_name.c_str());
+        fprintf(stderr, "Original error: Multiple primary keys detected in table '%s'\n\n", g_multiple_primary_key_table_name.c_str());
+        fflush(stderr);
+        
+        return; // Exit early, don't check type registration errors
+    }
+    
+    // Check if any errors occurred during type registration
+    auto& type_reg = getV9TypeRegistration();
+    if (type_reg.hasError()) {
+        // Type registration detected an error - create a special error module
+        const std::string& error = type_reg.getErrorMessage();
+        
+        // Clear the entire V9 module to start fresh
+        RawModuleDefV9& v9_module = GetV9Module();
+        v9_module.typespace.types.clear();
+        v9_module.types.clear();
+        v9_module.tables.clear();
+        v9_module.reducers.clear();
+        v9_module.misc_exports.clear();
+        
+        // Create an error type name that embeds the error message and type structure
+        std::string error_type_name;
+        if (error.find("Recursive type reference") != std::string::npos) {
+            // Extract the type name from the error message
+            size_t start = error.find("'");
+            size_t end = error.rfind("'");
+            std::string problematic_type = "unknown";
+            if (start != std::string::npos && end != std::string::npos && end > start) {
+                problematic_type = error.substr(start + 1, end - start - 1);
+            }
+            error_type_name = "ERROR_RECURSIVE_TYPE_" + problematic_type;
+        } else if (error.find("Missing type name") != std::string::npos) {
+            // Get the type description and sanitize it for use in the error name
+            std::string type_desc = type_reg.getErrorTypeDescription();
+            
+            // Replace problematic characters with underscores
+            for (char& c : type_desc) {
+                if (!std::isalnum(c) && c != '_') {
+                    c = '_';
+                }
+            }
+            
+            // Limit length to avoid overly long names
+            if (type_desc.length() > 100) {
+                type_desc = type_desc.substr(0, 100);
+            }
+            
+            error_type_name = "ERROR_MISSING_TYPE_NAME_" + type_desc;
+        } else {
+            error_type_name = "ERROR_TYPE_REGISTRATION_FAILED";
+        }
+        
+        // Add a single named type export that points to a non-existent typespace index
+        // This will cause SpacetimeDB to error when it tries to resolve the type
+        RawTypeDefV9 error_type;
+        error_type.name.scope = {};
+        error_type.name.name = error_type_name;
+        error_type.ty = 999999; // Invalid typespace index - will cause an error
+        error_type.custom_ordering = false;
+        
+        v9_module.types.push_back(error_type);
+        
+        // Don't add anything to the typespace - this ensures the reference is invalid
+        // The server will fail with an error message that includes our error type name
+        
+        // Also log to stderr for debugging
+        fprintf(stderr, "\n[TYPE ERROR] Module cleared and replaced with error type: %s\n", error_type_name.c_str());
+        fprintf(stderr, "Original error: %s\n\n", error.c_str());
+        fflush(stderr);
+    }
+    
+    // Type validation passed - log statistics only in debug mode
+    #ifdef DEBUG_TYPE_REGISTRATION
+    else {
+        RawModuleDefV9& v9_module = GetV9Module();
+        fprintf(stderr, "[Type Validation] OK - %zu types, %zu tables, %zu reducers\n",
+                v9_module.typespace.types.size(),
+                v9_module.tables.size(), 
+                v9_module.reducers.size());
+    }
+    #endif
+}
+
+
+// FFI export - V9 serialization
+void Internal::Module::__describe_module__(BytesSink sink) {
+    // The preinit functions should have already been called by SpacetimeDB
+    // Including our validation preinit which checks for recursive types
+
+    // Get the global V9 module
+    RawModuleDefV9& v9_module = GetV9Module();
+    
+    
+    // Create a buffer and writer
+    std::vector<uint8_t> buffer;
+    bsatn::Writer writer(buffer); 
+    // Write version byte
+    writer.write_u8(1);
+    
+    // Serialize the V9 module with our manually added table
+    v9_module.bsatn_serialize(writer);
+    
+    // Now try to write using FFI directly
+    if (!buffer.empty()) {
+        size_t bytes_to_write = buffer.size();
+        FFI::bytes_sink_write(sink, buffer.data(), &bytes_to_write);
+    }
+}
+
+// Helper to consume all bytes from a BytesSource
+std::vector<uint8_t> ConsumeBytes(BytesSource source) {
+    if (source.inner == 0) {
+        return {};
+    }
+    
+    std::vector<uint8_t> buffer;
+    constexpr size_t CHUNK_SIZE = 1024;
+    buffer.reserve(CHUNK_SIZE);
+    
+    while (true) {
+        size_t chunk_size = CHUNK_SIZE;
+        size_t old_size = buffer.size();
+        buffer.resize(old_size + chunk_size);
+        
+        auto ret = FFI::bytes_source_read(source, buffer.data() + old_size, &chunk_size);
+        buffer.resize(old_size + chunk_size);  // Resize to actual bytes read
+        
+        if (ret == -1) {  // EXHAUSTED
+            break;
+        } else if (ret != 0) {  // Error
+            fprintf(stderr, "ERROR: Failed to read from BytesSource: %d\n", ret);
+            break;
+        }
+    }
+    
+    return buffer;
+}
+
+// Helper to write bytes to a BytesSink
+void WriteBytes(BytesSink sink, const std::vector<uint8_t>& bytes) {
+    if (sink.inner == 0 || bytes.empty()) {
+        return;
+    }
+    
+    size_t bytes_to_write = bytes.size();
+    FFI::bytes_sink_write(sink, bytes.data(), &bytes_to_write);
+}
+
+Status Module::__call_reducer__(
+    uint32_t id,
+    uint64_t sender_0, uint64_t sender_1, uint64_t sender_2, uint64_t sender_3,
+    uint64_t conn_id_0, uint64_t conn_id_1,
+    Timestamp timestamp,
+    BytesSource args_source,
+    BytesSink error_sink
+) {
+    // Clear any previous error state
+    SpacetimeDb::Internal::clear_reducer_error();
+
+    // Check if reducer ID is valid
+    if (id >= g_reducer_handlers.size()) {
+        fprintf(stderr, "ERROR: Invalid reducer ID %u (have %zu reducers)\n", 
+                id, g_reducer_handlers.size());
+        
+        // Write error message
+        std::string error = "Invalid reducer ID: " + std::to_string(id);
+        WriteBytes(error_sink, std::vector<uint8_t>(error.begin(), error.end()));
+        return StatusCode::NO_SUCH_REDUCER;
+    }
+    
+    // Create reducer context
+    std::array<uint8_t, 32> sender_bytes{};
+    // Pack the 4 uint64_t parts into 32 bytes
+    std::memcpy(sender_bytes.data(), &sender_0, 8);
+    std::memcpy(sender_bytes.data() + 8, &sender_1, 8);
+    std::memcpy(sender_bytes.data() + 16, &sender_2, 8);
+    std::memcpy(sender_bytes.data() + 24, &sender_3, 8);
+    
+    Identity sender_identity(sender_bytes);
+    
+    // Create connection ID if provided
+    std::optional<ConnectionId> connection_id;
+    if (conn_id_0 != 0 || conn_id_1 != 0) {
+        // ConnectionId is 128-bit (two 64-bit parts)
+        connection_id = ConnectionId(u128(conn_id_1, conn_id_0));
+    }
+    
+    ReducerContext ctx(sender_identity, connection_id, timestamp);
+    
+    // Get the handler
+    const auto& handler_info = g_reducer_handlers[id];
+    
+    // Call the reducer handler
+    handler_info.handler(ctx, args_source);
+    if (SpacetimeDb::Internal::has_reducer_error()) {
+        std::string error_msg = SpacetimeDb::Internal::get_reducer_error();
+        WriteBytes(error_sink, std::vector<uint8_t>(error_msg.begin(), error_msg.end()));
+        return StatusCode::HOST_CALL_FAILURE;
+    }    
+
+    return StatusCode::OK;
+}
+}
+}
+
+
+ 
\ No newline at end of file
diff --git a/crates/bindings-cpp/src/internal/v9_builder.cpp b/crates/bindings-cpp/src/internal/v9_builder.cpp
new file mode 100644
index 00000000000..0e883561e23
--- /dev/null
+++ b/crates/bindings-cpp/src/internal/v9_builder.cpp
@@ -0,0 +1,356 @@
+// Include autogen types first to ensure complete type definitions
+#include "spacetimedb/internal/autogen/SumType.g.h"
+#include "spacetimedb/internal/autogen/SumTypeVariant.g.h"
+#include "spacetimedb/internal/autogen/ProductType.g.h"
+#include "spacetimedb/internal/autogen/ProductTypeElement.g.h"
+#include "spacetimedb/internal/autogen/AlgebraicType.g.h"
+#include "spacetimedb/internal/autogen/TableType.g.h"
+#include "spacetimedb/internal/autogen/TableAccess.g.h"
+#include "spacetimedb/internal/autogen/RawIndexDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawTypeDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawConstraintDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawConstraintDataV9.g.h"
+#include "spacetimedb/internal/autogen/RawUniqueConstraintDataV9.g.h"
+#include "spacetimedb/internal/autogen/RawIndexAlgorithm.g.h"
+#include "spacetimedb/internal/autogen/RawTableDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawReducerDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawSequenceDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawScheduleDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawRowLevelSecurityDefV9.g.h"
+#include "spacetimedb/internal/autogen/Lifecycle.g.h"
+
+// Then include the main headers
+#include "spacetimedb/internal/v9_builder.h"
+#include "spacetimedb/internal/v9_type_registration.h"
+#include "spacetimedb/internal/debug.h"
+#include "spacetimedb/bsatn/bsatn.h"
+#include "spacetimedb/internal/Module_impl.h"
+#include <functional>
+#include <cstdio>
+#include <cxxabi.h>
+#include <memory>
+#include <algorithm>
+#include <set>
+
+namespace SpacetimeDb {
+namespace Internal {
+
+// Forward declaration of the global V9 module accessor
+RawModuleDefV9& GetV9Module();
+
+// demangle_cpp_type_name function removed - using global version from v9_type_registration.cpp
+
+// Global V9Builder instance
+std::unique_ptr<V9Builder> g_v9_builder;
+
+void initializeV9Builder() {
+    g_v9_builder = std::make_unique<V9Builder>();
+    // Also initialize the type registration system
+    initializeV9TypeRegistration();
+}
+
+V9Builder& getV9Builder() {
+    if (!g_v9_builder) {
+        STDB_DEBUG("Initializing V9Builder");
+        initializeV9Builder();
+    }
+    return *g_v9_builder;
+}
+
+// Constructor
+V9Builder::V9Builder() {
+    // No TypeRegistry anymore - everything goes through V9TypeRegistration
+}
+
+/**
+ * Register a type using the unified type registration system
+ * This is now just a thin wrapper around the V9TypeRegistration system
+ */
+AlgebraicType V9Builder::registerType(const bsatn::AlgebraicType& bsatn_type,
+                                      const std::string& explicit_name,
+                                      const std::type_info* cpp_type) {
+    return getV9TypeRegistration().registerType(bsatn_type, explicit_name, cpp_type);
+}
+
+void V9Builder::AddV9Table(const std::string& table_name,
+                                  const bsatn::AlgebraicType& table_type,
+                                  const std::type_info* cpp_type,
+                                  bool is_public,
+                                  const std::vector<uint16_t>& primary_key,
+                                  const std::vector<RawIndexDefV9>& indexes,
+                                  const std::vector<RawConstraintDefV9>& constraints,
+                                  const std::vector<RawSequenceDefV9>& sequences,
+                                  const std::optional<RawScheduleDefV9>& schedule) {
+    
+    // Register the table type using the unified system
+    // Use empty string to let the system extract the struct name from cpp_type
+    AlgebraicType registered_type = registerType(table_type, "", cpp_type);
+    
+    // Extract the typespace index from the registered type
+    uint32_t type_ref;
+    if (registered_type.get_tag() == AlgebraicType::Tag::Ref) {
+        type_ref = registered_type.get<0>();
+    } else {
+        // This shouldn't happen for a table type - tables should always be complex types
+        fprintf(stderr, "ERROR: Table '%s' did not register as a complex type\n", table_name.c_str());
+        type_ref = 0;
+    }
+    
+    // RegisterTable now handles all constraint and index generation,
+    // so we just use what was passed in directly
+    
+    // Create the table definition
+    RawTableDefV9 table_def;
+    table_def.name = table_name;
+    table_def.product_type_ref = type_ref;
+    table_def.primary_key = primary_key;
+    table_def.indexes = indexes;  // Use indexes passed from RegisterTable
+    table_def.constraints = constraints;  // Use constraints passed from RegisterTable
+    table_def.sequences = sequences;
+    table_def.schedule = schedule;
+    table_def.table_type = TableType::User;  // User-defined table
+    table_def.table_access = is_public ? TableAccess::Public : TableAccess::Private;
+    
+    // Check if table already exists to prevent duplicates
+    auto& module = GetV9Module();
+    for (const auto& existing_table : module.tables) {
+        if (existing_table.name == table_name) {
+            fprintf(stdout, "DEBUG: Table '%s' already registered, skipping duplicate registration\n", 
+                       table_name.c_str());
+            return;
+        }
+    }
+    
+    // Debug: Show all existing table names before adding new one
+    fprintf(stdout, "DEBUG: Adding table '%s'. Existing tables: [", table_name.c_str());
+    for (size_t i = 0; i < module.tables.size(); ++i) {
+        if (i > 0) fprintf(stdout, ", ");
+        fprintf(stdout, "'%s'", module.tables[i].name.c_str());
+    }
+    fprintf(stdout, "]\n");
+
+    // Add table to the global V9 module
+    module.tables.push_back(table_def);
+    fprintf(stdout, "DEBUG: Added table '%s' to V9 module (type_ref=%u) with %zu indexes, %zu constraints\n", 
+               table_name.c_str(), type_ref, indexes.size(), constraints.size());
+    
+    // Debug: Print index names
+    for (const auto& idx : indexes) {
+        if (idx.name.has_value()) {
+            fprintf(stdout, "  Index: %s\n", idx.name.value().c_str());
+        }
+    }
+    
+    // Debug: Print constraint names  
+    for (const auto& constraint : constraints) {
+        if (constraint.name.has_value()) {
+            fprintf(stdout, "  Constraint: %s\n", constraint.name.value().c_str());
+        }
+    }
+}
+
+void V9Builder::AddV9Reducer(const std::string& reducer_name,
+                                   const std::vector<bsatn::AlgebraicType>& param_types,
+                                   const std::vector<std::string>& param_names,
+                                   const std::vector<const std::type_info*>& param_cpp_types,
+                                   const std::vector<std::string>& param_type_names,
+                                   std::optional<Lifecycle> lifecycle) {
+    // Create the reducer definition
+    RawReducerDefV9 reducer_def;
+    reducer_def.name = reducer_name;
+    
+    // Build the params ProductType
+    ProductType params;
+    for (size_t i = 0; i < param_types.size(); ++i) {
+        ProductTypeElement elem;
+        elem.name = i < param_names.size() ? std::make_optional(param_names[i]) : std::nullopt;
+        
+        // Register the parameter type with proper C++ type info and name
+        const std::type_info* cpp_type = i < param_cpp_types.size() ? param_cpp_types[i] : nullptr;
+        const std::string& type_name = i < param_type_names.size() ? param_type_names[i] : "";
+        
+        // Register the parameter type using the unified system
+        elem.algebraic_type = registerType(param_types[i], type_name, cpp_type);
+        
+        params.elements.push_back(elem);
+    }
+    
+    reducer_def.params = params;
+    reducer_def.lifecycle = lifecycle;
+    
+    // Add directly to the global V9 module
+    GetV9Module().reducers.push_back(reducer_def);
+    fprintf(stdout, "DEBUG: Added reducer '%s' to V9 module\n", reducer_name.c_str());
+}
+
+// Helper function to get field name from Product type structure
+std::string V9Builder::getFieldName(const bsatn::AlgebraicType& table_type, uint16_t column_index) const {
+    if (table_type.tag() != bsatn::AlgebraicTypeTag::Product) {
+        return "column" + std::to_string(column_index);
+    }
+    
+    const auto& product = table_type.as_product();
+    if (column_index >= product.elements.size()) {
+        return "column" + std::to_string(column_index);
+    }
+    
+    const auto& element = product.elements[column_index];
+    if (element.name.has_value()) {
+        return element.name.value();
+    }
+    
+    return "column" + std::to_string(column_index);
+}
+
+// Helper function to generate constraints for primary key
+std::vector<RawConstraintDefV9> V9Builder::generateConstraintsForPrimaryKey(
+    const std::string& table_name,
+    const bsatn::AlgebraicType& table_type,
+    const std::vector<uint16_t>& primary_key) const {
+    
+    std::vector<RawConstraintDefV9> constraints;
+    
+    if (primary_key.empty()) {
+        return constraints;  // No primary key, no constraints
+    }
+    
+    // Create separate unique constraint for each primary key column
+    for (uint16_t col_idx : primary_key) {
+        // Generate field name for this primary key column
+        std::string field_name = getFieldName(table_type, col_idx);
+        std::string constraint_name = table_name + "_" + field_name + "_key";
+        
+        // Create unique constraint data for this single column
+        RawUniqueConstraintDataV9 unique_data;
+        unique_data.columns = {col_idx};  // Single column constraint
+        
+        // Create constraint data (tagged enum) and set the variant
+        RawConstraintDataV9 constraint_data;
+        constraint_data.set<0>(unique_data);
+        
+        // Create constraint definition
+        RawConstraintDefV9 constraint_def;
+        constraint_def.name = constraint_name;
+        constraint_def.data = constraint_data;
+        
+        constraints.push_back(constraint_def);
+    }
+    
+    return constraints;
+}
+
+// Helper function to generate indexes for primary key
+std::vector<RawIndexDefV9> V9Builder::generateIndexesForPrimaryKey(
+    const std::string& table_name,
+    const bsatn::AlgebraicType& table_type,
+    const std::vector<uint16_t>& primary_key) const {
+    
+    std::vector<RawIndexDefV9> indexes;
+    
+    if (primary_key.empty()) {
+        return indexes;  // No primary key, no indexes
+    }
+    
+    // Generate field name for the primary key column
+    std::string field_name = getFieldName(table_type, primary_key[0]);
+    std::string index_name = table_name + "_" + field_name + "_idx_btree";
+    
+    // Create BTree algorithm data
+    RawIndexAlgorithmBTreeData btree_data;
+    btree_data.columns = primary_key;
+    
+    // Create index algorithm (tagged enum) and set the BTree variant (index 0)
+    RawIndexAlgorithm algorithm;
+    algorithm.set<0>(btree_data);
+    
+    // Create index definition
+    RawIndexDefV9 index_def;
+    index_def.name = index_name;
+    index_def.accessor_name = field_name;
+    index_def.algorithm = algorithm;
+    
+    indexes.push_back(index_def);
+    
+    return indexes;
+}
+
+void V9Builder::RegisterSchedule(const std::string& table_name,
+                                 uint16_t scheduled_at_column,
+                                 const std::string& reducer_name) {
+    // Store the schedule to be applied when the table is registered
+    PendingSchedule schedule;
+    schedule.table_name = table_name;
+    schedule.scheduled_at_column = scheduled_at_column;
+    schedule.reducer_name = reducer_name;
+    
+    pending_schedules_[table_name] = schedule;
+    
+    fprintf(stdout, "DEBUG: Registered schedule for table '%s', column %u, reducer '%s'\n",
+            table_name.c_str(), scheduled_at_column, reducer_name.c_str());
+}
+
+void V9Builder::RegisterRowLevelSecurity(const std::string& sql_query) {
+    // Create an RLS definition and add it to the global module
+    RawRowLevelSecurityDefV9 rls_def;
+    rls_def.sql = sql_query;
+    
+    // Add directly to the global V9 module
+    GetV9Module().row_level_security.push_back(rls_def);
+    
+    fprintf(stdout, "DEBUG: Registered RLS policy: %s\n", sql_query.c_str());
+}
+
+// =============================================================================
+// End of V9Builder Implementation
+// =============================================================================
+
+
+// Helper to find existing table by name in the module
+RawTableDefV9* V9Builder::findTableByName(const std::string& table_name) {
+    auto& module = GetV9Module();
+    for (auto& table : module.tables) {
+        if (table.name == table_name) {
+            return &table;
+        }
+    }
+    return nullptr;
+}
+
+// Helper to create a BTree index for a field
+RawIndexDefV9 V9Builder::createBTreeIndex(const std::string& table_name,
+                                          const std::string& field_name,
+                                          uint16_t field_idx) const {
+    RawIndexAlgorithmBTreeData btree_data;
+    btree_data.columns = {field_idx};
+    
+    RawIndexAlgorithm algorithm;
+    algorithm.set<0>(btree_data);  // Set BTree variant
+    
+    RawIndexDefV9 index_def;
+    index_def.name = table_name + "_" + field_name + "_idx_btree";
+    index_def.accessor_name = field_name;
+    index_def.algorithm = algorithm;
+    
+    return index_def;
+}
+
+// Helper to create a unique constraint for a field
+RawConstraintDefV9 V9Builder::createUniqueConstraint(const std::string& table_name,
+                                                     const std::string& field_name,
+                                                     uint16_t field_idx) const {
+    RawUniqueConstraintDataV9 unique_data;
+    unique_data.columns = {field_idx};
+    
+    RawConstraintDataV9 constraint_data;
+    constraint_data.set<0>(unique_data);  // Set the Unique variant
+    
+    RawConstraintDefV9 constraint_def;
+    constraint_def.name = table_name + "_" + field_name + "_key";
+    constraint_def.data = std::move(constraint_data);
+    
+    return constraint_def;
+}
+
+
+} // namespace Internal
+} // namespace SpacetimeDb
\ No newline at end of file
diff --git a/crates/bindings-cpp/src/internal/v9_type_registration.cpp b/crates/bindings-cpp/src/internal/v9_type_registration.cpp
new file mode 100644
index 00000000000..9f1cc9b3fc1
--- /dev/null
+++ b/crates/bindings-cpp/src/internal/v9_type_registration.cpp
@@ -0,0 +1,748 @@
+#include "spacetimedb/internal/v9_type_registration.h"
+#include "spacetimedb/internal/v9_builder.h"
+#include "spacetimedb/internal/autogen/AlgebraicType.g.h"
+#include "spacetimedb/internal/autogen/RawModuleDefV9.g.h"
+#include "spacetimedb/internal/autogen/RawTypeDefV9.g.h"
+#include "spacetimedb/internal/autogen/ProductType.g.h"
+#include "spacetimedb/internal/autogen/SumType.g.h"
+#include "spacetimedb/logger.h"  // For LOG_ERROR, LOG_PANIC
+#include <cxxabi.h>
+#include <memory>
+#include <algorithm>
+#include <cstdio>
+#include <stdexcept>
+
+namespace SpacetimeDb {
+namespace Internal {
+
+// Use the correct namespaces - these types are already in the correct namespace
+
+// Forward declaration of the global V9 module accessor
+RawModuleDefV9& GetV9Module();
+
+// Global V9 type registration instance
+std::unique_ptr<V9TypeRegistration> g_v9_type_registration;
+
+// Thread-local storage for tracking the chain of types being registered
+thread_local std::vector<std::string> g_type_registration_chain;
+
+// Global flag to indicate circular reference error (set during type building)
+bool g_circular_ref_error = false;
+std::string g_circular_ref_type_name;
+
+void initializeV9TypeRegistration() {
+    g_v9_type_registration = std::make_unique<V9TypeRegistration>();
+    // Clear any previous error state
+    g_circular_ref_error = false;
+    g_circular_ref_type_name.clear();
+    g_type_registration_chain.clear();
+}
+
+V9TypeRegistration& getV9TypeRegistration() {
+    if (!g_v9_type_registration) {
+        initializeV9TypeRegistration();
+    }
+    return *g_v9_type_registration;
+}
+
+// Function moved outside Internal namespace - see end of file
+
+AlgebraicType V9TypeRegistration::registerType(const bsatn::AlgebraicType& bsatn_type,
+                                               const std::string& explicit_name,
+                                               const std::type_info* cpp_type) {
+    
+    // Debug: Log when we get a type with a namespace
+    if (!explicit_name.empty() && explicit_name.find("::") != std::string::npos) {
+        fprintf(stdout, "DEBUG: registerType called with namespaced name: '%s'\n", explicit_name.c_str());
+        // Check if this is ScheduleAt being registered incorrectly
+        if (explicit_name.find("ScheduleAt") != std::string::npos) {
+            fprintf(stdout, "DEBUG: ScheduleAt being registered with namespace! Should be inlined!\n");
+            fprintf(stdout, "  Type tag: %d\n", static_cast<int>(bsatn_type.tag()));
+            if (bsatn_type.tag() == bsatn::AlgebraicTypeTag::Sum) {
+                const auto& sum = bsatn_type.as_sum();
+                fprintf(stdout, "  Sum variants: %zu\n", sum.variants.size());
+                for (size_t i = 0; i < sum.variants.size(); ++i) {
+                    fprintf(stdout, "    Variant %zu: %s\n", i, sum.variants[i].name.c_str());
+                }
+            }
+        }
+    }
+    
+    // 1. PRIMITIVES - always inline, never registered
+    if (isPrimitive(bsatn_type)) {
+        return convertPrimitive(bsatn_type);
+    }
+    
+    // 2. REFS - already registered, convert and return
+    if (bsatn_type.tag() == bsatn::AlgebraicTypeTag::Ref) {
+        AlgebraicType result(AlgebraicType::Tag::Ref);
+        result.set<0>(bsatn_type.as_ref());
+        return result;
+    }
+    
+    // 3. ARRAYS - always inline with recursive element processing
+    if (bsatn_type.tag() == bsatn::AlgebraicTypeTag::Array) {
+        return convertArray(bsatn_type);
+    }
+    
+    // 4. UNIT TYPES - empty products should be inlined as Unit ONLY if unnamed
+    // Named unit structs (like UnitStruct) should be registered as named types
+    if (isUnitType(bsatn_type)) {
+        if (!explicit_name.empty()) {
+            // This is a named unit struct like UnitStruct - do NOT inline
+            fprintf(stdout, "DEBUG: Named unit struct '%s' detected - will register as named type\n", 
+                    explicit_name.c_str());
+            // Fall through to register as named type
+        } else {
+            // Unnamed unit type - inline it
+            return convertUnitType();
+        }
+    }
+    
+    // 5. SPECIAL TYPES - always inline
+    if (isSpecialType(bsatn_type)) {
+        return convertSpecialType(bsatn_type);
+    }
+    
+    // Check if this might be ScheduleAt being registered with wrong name
+    if (bsatn_type.tag() == bsatn::AlgebraicTypeTag::Sum) {
+        const auto& sum = bsatn_type.as_sum();
+        if (sum.variants.size() == 2 &&
+            sum.variants[0].name == "Interval" &&
+            sum.variants[1].name == "Time") {
+            // This is ScheduleAt - should have been caught above!
+            fprintf(stdout, "WARNING: ScheduleAt type detected but not inlined! explicit_name='%s'\n", 
+                    explicit_name.c_str());
+            // Force inline it
+            return convertInlineSum(bsatn_type);
+        }
+    }
+    
+    // 6. OPTIONS - always inline
+    if (isOptionType(bsatn_type)) {
+        return convertInlineSum(bsatn_type);
+    }
+    
+    // 7. SCHEDULE_AT - always inline
+    if (isScheduleAtType(bsatn_type)) {
+        fprintf(stdout, "DEBUG: ScheduleAt type detected and will be inlined\n");
+        return convertInlineSum(bsatn_type);
+    }
+    
+    // ============================================================
+    // ONLY USER-DEFINED STRUCTS AND ENUMS GET REGISTERED BELOW
+    // ============================================================
+    
+    // 7. DETERMINE TYPE NAME
+    std::string type_name = explicit_name;
+    if (type_name.empty() && cpp_type) {
+        type_name = extractTypeName(cpp_type);
+    } else if (!type_name.empty()) {
+        // Even if we have an explicit name, ensure it doesn't contain namespace separators
+        // This fixes issues with special types like SpacetimeDb::ScheduleAt
+        size_t last_colon = type_name.rfind("::");
+        if (last_colon != std::string::npos) {
+            type_name = type_name.substr(last_colon + 2);
+        }
+    }
+    
+    if (type_name.empty()) {
+        // Complex types MUST have proper names - this is a validation error
+        error_type_description_ = describeType(bsatn_type);
+        error_message_ = "Missing type name for complex type: " + error_type_description_;
+        has_error_ = true;
+        
+        // Return a dummy type to avoid crashing
+        return AlgebraicType(AlgebraicType::Tag::U8);
+    }
+    
+    // 8. DETECT RECURSIVE TYPE REGISTRATION (CYCLE DETECTION)
+    if (types_being_registered_.find(type_name) != types_being_registered_.end()) {
+        // Set error state for validation preinit to report
+        error_message_ = "Recursive type reference detected: '" + type_name + "' is referencing itself";
+        has_error_ = true;
+        
+        // Return a dummy type to break the infinite recursion
+        // This allows the validation preinit to run and report the error cleanly
+        return AlgebraicType(AlgebraicType::Tag::U8);
+    }
+    
+    // 9. CHECK IF ALREADY REGISTERED
+    // Check cache first
+    auto cache_it = type_name_cache_.find(type_name);
+    if (cache_it != type_name_cache_.end()) {
+        AlgebraicType result(AlgebraicType::Tag::Ref);
+        result.set<0>(cache_it->second);
+        return result;
+    }
+    
+    // Check module's types array
+    for (const auto& type_def : GetV9Module().types) {
+        if (type_def.name.name == type_name) {
+            uint32_t typespace_index = type_def.ty;
+            type_name_cache_[type_name] = typespace_index;
+            AlgebraicType result(AlgebraicType::Tag::Ref);
+            result.set<0>(typespace_index);
+            return result;
+        }
+    }
+    
+    // 10. REGISTER NEW COMPLEX TYPE
+    return registerComplexType(bsatn_type, type_name);
+}
+
+uint32_t V9TypeRegistration::registerAndGetIndex(const bsatn::AlgebraicType& bsatn_type,
+                                                 const std::string& type_name,
+                                                 const std::type_info* cpp_type) {
+    // Check if already registered in cache
+    auto cache_it = type_name_cache_.find(type_name);
+    if (cache_it != type_name_cache_.end()) {
+        return cache_it->second;
+    }
+    
+    // Register the type and get the Internal::AlgebraicType result
+    AlgebraicType result = registerType(bsatn_type, type_name, cpp_type);
+    
+    // If it's a Ref, return the index
+    if (result.get_tag() == AlgebraicType::Tag::Ref) {
+        uint32_t index = result.get<0>();
+        type_name_cache_[type_name] = index;
+        return index;
+    }
+    
+    // This shouldn't happen for enums - they should always register as complex types
+    fprintf(stderr, "ERROR: Enum '%s' did not register as a complex type\n", type_name.c_str());
+    return 0;
+}
+
+void V9TypeRegistration::registerTypeByName(const std::string& type_name, 
+                                            const bsatn::AlgebraicType& algebraic_type,
+                                            [[maybe_unused]] const std::type_info* cpp_type) {
+    // Check if already registered in cache
+    auto cache_it = type_name_cache_.find(type_name);
+    if (cache_it != type_name_cache_.end()) {
+        fprintf(stdout, "ENUM DEBUG: Type '%s' already registered at index %u\n", 
+                type_name.c_str(), cache_it->second);
+        return;
+    }
+    
+    // Check if already registered in module's types array
+    for (const auto& type_def : GetV9Module().types) {
+        if (type_def.name.name == type_name) {
+            uint32_t typespace_index = type_def.ty;
+            type_name_cache_[type_name] = typespace_index;
+            fprintf(stdout, "ENUM DEBUG: Type '%s' found in module at index %u\n", 
+                    type_name.c_str(), typespace_index);
+            return;
+        }
+    }
+    
+    // Register new type immediately
+    fprintf(stdout, "ENUM DEBUG: Registering new type '%s' immediately\n", type_name.c_str());
+    
+    // Mark this type as being registered (for cycle detection)
+    types_being_registered_.insert(type_name);
+    
+    // Reserve space in typespace
+    uint32_t typespace_index = GetV9Module().typespace.types.size();
+    
+    // For immediate registration, we process the type directly without recursive calls
+    // This avoids infinite loops when the enum's algebraic_type() calls registerTypeByName
+    AlgebraicType processed_type;
+    
+    if (algebraic_type.tag() == bsatn::AlgebraicTypeTag::Sum) {
+        // For enums, directly process the Sum type structure without recursive registerType calls
+        auto sum = std::make_unique<SumType>();
+        
+        for (const auto& variant : algebraic_type.as_sum().variants) {
+            SumTypeVariant v;
+            v.name = variant.name;
+            
+            // For simple enum variants, they should be Unit types (no payload)
+            // Check if it's a Unit type and convert appropriately
+            if (isUnitType(*variant.algebraic_type)) {
+                v.algebraic_type = convertUnitType();
+            } else if (isPrimitive(*variant.algebraic_type)) {
+                // For primitive variant types
+                v.algebraic_type = convertPrimitive(*variant.algebraic_type);
+            } else {
+                // For complex variant types, we need to recursively process them
+                // But we can't call registerType here as it would cause infinite recursion
+                // So we do a simple inline conversion
+                if (variant.algebraic_type->tag() == bsatn::AlgebraicTypeTag::Array) {
+                    v.algebraic_type = convertArray(*variant.algebraic_type);
+                } else if (variant.algebraic_type->tag() == bsatn::AlgebraicTypeTag::Product) {
+                    v.algebraic_type = convertSpecialType(*variant.algebraic_type);
+                } else {
+                    // Fallback to primitive conversion
+                    v.algebraic_type = convertPrimitive(*variant.algebraic_type);
+                }
+            }
+            sum->variants.push_back(std::move(v));
+        }
+        
+        processed_type = AlgebraicType(AlgebraicType::Tag::Sum);
+        processed_type.set<1>(std::move(sum));
+    } else if (algebraic_type.tag() == bsatn::AlgebraicTypeTag::Product) {
+        // For structs, process directly
+        auto product = std::make_unique<ProductType>();
+        
+        for (const auto& field : algebraic_type.as_product().elements) {
+            ProductTypeElement elem;
+            elem.name = field.name;
+            // Convert field type appropriately - handle different types
+            if (isPrimitive(*field.algebraic_type)) {
+                elem.algebraic_type = convertPrimitive(*field.algebraic_type);
+            } else if (isUnitType(*field.algebraic_type)) {
+                elem.algebraic_type = convertUnitType();
+            } else {
+                // For complex field types, just convert as primitive for now
+                elem.algebraic_type = convertPrimitive(*field.algebraic_type);
+            }
+            product->elements.push_back(std::move(elem));
+        }
+        
+        processed_type = AlgebraicType(AlgebraicType::Tag::Product);
+        processed_type.set<2>(std::move(product));
+    } else {
+        fprintf(stderr, "[Warning] Unexpected type tag %d for '%s'\n", 
+                static_cast<int>(algebraic_type.tag()), type_name.c_str());
+        processed_type = convertPrimitive(algebraic_type);
+    }
+    
+    // Add to typespace
+    GetV9Module().typespace.types.push_back(processed_type);
+    
+    // Create RawTypeDefV9 export with namespace support
+    RawTypeDefV9 type_def;
+    
+    // Parse namespace from type name
+    auto [scope, simple_name] = parseNamespaceAndName(type_name);
+    type_def.name.scope = scope;
+    type_def.name.name = simple_name;
+    type_def.ty = typespace_index;
+    type_def.custom_ordering = true; // Complex types need custom ordering
+    
+    // Add to module's types array
+    GetV9Module().types.push_back(type_def);
+    
+    // Update cache
+    type_name_cache_[type_name] = typespace_index;
+    
+    // Remove from types being registered (cycle detection cleanup)
+    types_being_registered_.erase(type_name);
+    
+    fprintf(stdout, "ENUM DEBUG: Successfully registered type '%s' at index %u\n", 
+            type_name.c_str(), typespace_index);
+}
+
+bool V9TypeRegistration::isPrimitive(const bsatn::AlgebraicType& type) const {
+    auto tag = static_cast<uint32_t>(type.tag());
+    // Use range check: String (4) to F64 (19) covers all primitive types
+    return tag >= static_cast<uint32_t>(bsatn::AlgebraicTypeTag::String) &&
+           tag <= static_cast<uint32_t>(bsatn::AlgebraicTypeTag::F64);
+}
+
+bool V9TypeRegistration::isSpecialType(const bsatn::AlgebraicType& type) const {
+    if (type.tag() != bsatn::AlgebraicTypeTag::Product) {
+        return false;
+    }
+    
+    const auto& product = type.as_product();
+    if (product.elements.size() != 1) {
+        return false;
+    }
+    
+    const auto& field_name = product.elements[0].name;
+    return field_name == "__identity__" ||
+           field_name == "__connection_id__" ||
+           field_name == "__timestamp_micros_since_unix_epoch__" ||
+           field_name == "__time_duration_micros__";
+}
+
+bool V9TypeRegistration::isOptionType(const bsatn::AlgebraicType& type) const {
+    if (type.tag() != bsatn::AlgebraicTypeTag::Sum) {
+        return false;
+    }
+    
+    const auto& sum = type.as_sum();
+    return sum.variants.size() == 2 &&
+           sum.variants[0].name == "some" &&
+           sum.variants[1].name == "none";
+}
+
+bool V9TypeRegistration::isScheduleAtType(const bsatn::AlgebraicType& type) const {
+    if (type.tag() != bsatn::AlgebraicTypeTag::Sum) {
+        return false;
+    }
+    
+    const auto& sum = type.as_sum();
+    return sum.variants.size() == 2 &&
+           sum.variants[0].name == "Interval" &&
+           sum.variants[1].name == "Time";
+}
+
+bool V9TypeRegistration::isUnitType(const bsatn::AlgebraicType& type) const {
+    if (type.tag() != bsatn::AlgebraicTypeTag::Product) {
+        return false;
+    }
+    
+    const auto& product = type.as_product();
+    // Unit type is an empty Product (no fields)
+    return product.elements.empty();
+}
+
+AlgebraicType V9TypeRegistration::convertUnitType() const {
+    // Create an empty Product type (Unit)
+    auto product = std::make_unique<ProductType>();
+    // No elements - empty Product
+    
+    AlgebraicType result(AlgebraicType::Tag::Product);
+    result.set<2>(std::move(product));
+    return result;
+}
+
+std::string V9TypeRegistration::extractTypeName(const std::type_info* cpp_type) const {
+    std::string demangled = demangle_cpp_type_name(cpp_type->name());
+    
+    // Extract simple name (last component after ::)
+    size_t last_colon = demangled.rfind("::");
+    if (last_colon != std::string::npos) {
+        demangled = demangled.substr(last_colon + 2);
+    }
+    
+    // Remove template parameters
+    size_t template_start = demangled.find('<');
+    if (template_start != std::string::npos) {
+        demangled = demangled.substr(0, template_start);
+    }
+    
+    return demangled;
+}
+
+std::pair<std::vector<std::string>, std::string> V9TypeRegistration::parseNamespaceAndName(const std::string& qualified_name) const {
+    std::vector<std::string> scope;
+    std::string name;
+    
+    // Look for namespace separator (dot)
+    size_t last_dot = qualified_name.rfind('.');
+    if (last_dot != std::string::npos) {
+        // Split into namespace and name
+        std::string namespace_part = qualified_name.substr(0, last_dot);
+        name = qualified_name.substr(last_dot + 1);
+        
+        // Split namespace into scope components (in case of nested namespaces like "A.B.C")
+        size_t start = 0;
+        size_t pos = 0;
+        while ((pos = namespace_part.find('.', start)) != std::string::npos) {
+            std::string component = namespace_part.substr(start, pos - start);
+            if (!component.empty()) {
+                scope.push_back(component);
+            }
+            start = pos + 1;
+        }
+        // Add the last component
+        std::string last_component = namespace_part.substr(start);
+        if (!last_component.empty()) {
+            scope.push_back(last_component);
+        }
+        
+        fprintf(stdout, "DEBUG: Parsed namespace '%s' -> scope=[", qualified_name.c_str());
+        for (size_t i = 0; i < scope.size(); ++i) {
+            if (i > 0) fprintf(stdout, ", ");
+            fprintf(stdout, "\"%s\"", scope[i].c_str());
+        }
+        fprintf(stdout, "], name=\"%s\"\n", name.c_str());
+    } else {
+        // No namespace, just use the full name
+        name = qualified_name;
+        // scope remains empty
+    }
+    
+    return std::make_pair(scope, name);
+}
+
+AlgebraicType V9TypeRegistration::convertPrimitive(const bsatn::AlgebraicType& type) const {
+    switch (type.tag()) {
+        case bsatn::AlgebraicTypeTag::Bool:
+            return AlgebraicType(AlgebraicType::Tag::Bool);
+        case bsatn::AlgebraicTypeTag::U8:
+            return AlgebraicType(AlgebraicType::Tag::U8);
+        case bsatn::AlgebraicTypeTag::U16:
+            return AlgebraicType(AlgebraicType::Tag::U16);
+        case bsatn::AlgebraicTypeTag::U32:
+            return AlgebraicType(AlgebraicType::Tag::U32);
+        case bsatn::AlgebraicTypeTag::U64:
+            return AlgebraicType(AlgebraicType::Tag::U64);
+        case bsatn::AlgebraicTypeTag::U128:
+            return AlgebraicType(AlgebraicType::Tag::U128);
+        case bsatn::AlgebraicTypeTag::U256:
+            return AlgebraicType(AlgebraicType::Tag::U256);
+        case bsatn::AlgebraicTypeTag::I8:
+            return AlgebraicType(AlgebraicType::Tag::I8);
+        case bsatn::AlgebraicTypeTag::I16:
+            return AlgebraicType(AlgebraicType::Tag::I16);
+        case bsatn::AlgebraicTypeTag::I32:
+            return AlgebraicType(AlgebraicType::Tag::I32);
+        case bsatn::AlgebraicTypeTag::I64:
+            return AlgebraicType(AlgebraicType::Tag::I64);
+        case bsatn::AlgebraicTypeTag::I128:
+            return AlgebraicType(AlgebraicType::Tag::I128);
+        case bsatn::AlgebraicTypeTag::I256:
+            return AlgebraicType(AlgebraicType::Tag::I256);
+        case bsatn::AlgebraicTypeTag::F32:
+            return AlgebraicType(AlgebraicType::Tag::F32);
+        case bsatn::AlgebraicTypeTag::F64:
+            return AlgebraicType(AlgebraicType::Tag::F64);
+        case bsatn::AlgebraicTypeTag::String:
+            return AlgebraicType(AlgebraicType::Tag::String);
+        default:
+            // Unknown primitive - use U8 as fallback
+            return AlgebraicType(AlgebraicType::Tag::U8);
+    }
+}
+
+AlgebraicType V9TypeRegistration::convertArray(const bsatn::AlgebraicType& type) {
+    const auto& array = type.as_array();
+    
+    // Recursively process element type
+    AlgebraicType elem_type = registerType(*array.element_type);
+    
+    // Create inline array
+    AlgebraicType result(AlgebraicType::Tag::Array);
+    result.set<3>(std::make_unique<AlgebraicType>(std::move(elem_type)));
+    return result;
+}
+
+AlgebraicType V9TypeRegistration::convertSpecialType(const bsatn::AlgebraicType& type) {
+    // Special types are inlined as Product structures
+    auto product = std::make_unique<ProductType>();
+    
+    for (const auto& field : type.as_product().elements) {
+        ProductTypeElement elem;
+        elem.name = field.name;
+        
+        // Recursively process field type (should be a primitive)
+        elem.algebraic_type = registerType(*field.algebraic_type);
+        product->elements.push_back(std::move(elem));
+    }
+    
+    AlgebraicType result(AlgebraicType::Tag::Product);
+    result.set<2>(std::move(product));
+    return result;
+}
+
+AlgebraicType V9TypeRegistration::convertInlineSum(const bsatn::AlgebraicType& type) {
+    // Options and ScheduleAt are inlined as Sum structures
+    auto sum = std::make_unique<SumType>();
+    
+    for (const auto& variant : type.as_sum().variants) {
+        SumTypeVariant v;
+        v.name = variant.name;
+        
+        // Recursively process variant type
+        v.algebraic_type = registerType(*variant.algebraic_type);
+        sum->variants.push_back(std::move(v));
+    }
+    
+    AlgebraicType result(AlgebraicType::Tag::Sum);
+    result.set<1>(std::move(sum));
+    return result;
+}
+
+AlgebraicType V9TypeRegistration::registerComplexType(const bsatn::AlgebraicType& type,
+                                                      const std::string& type_name) {
+    // Mark this type as being registered (for cycle detection)
+    types_being_registered_.insert(type_name);
+    
+    // Reserve space in typespace
+    uint32_t typespace_index = GetV9Module().typespace.types.size();
+    
+    // Debug logging (disabled in production)
+    #ifdef DEBUG_TYPE_REGISTRATION
+    fprintf(stdout, "[Type] Registering '%s' at index %u\n", type_name.c_str(), typespace_index);
+    #endif
+    
+    // Process the type based on its kind
+    AlgebraicType processed_type;
+    
+    if (type.tag() == bsatn::AlgebraicTypeTag::Product) {
+        processed_type = processProduct(type);
+    } else if (type.tag() == bsatn::AlgebraicTypeTag::Sum) {
+        processed_type = processSum(type);
+    } else {
+        // This shouldn't happen in normal usage
+        fprintf(stderr, "[Warning] Unexpected type tag %d for '%s'\n", 
+                static_cast<int>(type.tag()), type_name.c_str());
+        // Fallback
+        processed_type = convertPrimitive(type);
+    }
+    
+    // Add to typespace
+    GetV9Module().typespace.types.push_back(processed_type);
+    
+    // Create RawTypeDefV9 export with namespace support
+    RawTypeDefV9 type_def;
+    
+    // Parse namespace from type name
+    auto [scope, simple_name] = parseNamespaceAndName(type_name);
+    type_def.name.scope = scope;
+    type_def.name.name = simple_name;
+    type_def.ty = typespace_index;
+    type_def.custom_ordering = true; // Complex types need custom ordering
+    
+    // Add to module's types array
+    GetV9Module().types.push_back(type_def);
+    
+    // Update cache
+    type_name_cache_[type_name] = typespace_index;
+    
+    // Remove from types being registered (cycle detection cleanup)
+    types_being_registered_.erase(type_name);
+    
+    // Return Ref to the registered type
+    AlgebraicType result(AlgebraicType::Tag::Ref);
+    result.set<0>(typespace_index);
+    return result;
+}
+
+AlgebraicType V9TypeRegistration::processProduct(const bsatn::AlgebraicType& type) {
+    auto product = std::make_unique<ProductType>();
+    
+    for (const auto& field : type.as_product().elements) {
+        ProductTypeElement elem;
+        elem.name = field.name;
+        
+        // Recursively register/process field type
+        // For nested complex types, we need to ensure they're registered with proper names
+        // The registerType call will handle primitives, arrays, special types, and complex types
+        elem.algebraic_type = registerType(*field.algebraic_type);
+        product->elements.push_back(std::move(elem));
+    }
+    
+    AlgebraicType result(AlgebraicType::Tag::Product);
+    result.set<2>(std::move(product));
+    return result;
+}
+
+AlgebraicType V9TypeRegistration::processSum(const bsatn::AlgebraicType& type) {
+    auto sum = std::make_unique<SumType>();
+    
+    for (const auto& variant : type.as_sum().variants) {
+        SumTypeVariant v;
+        v.name = variant.name;
+        
+        // Recursively register/process variant type
+        v.algebraic_type = registerType(*variant.algebraic_type);
+        sum->variants.push_back(std::move(v));
+    }
+    
+    AlgebraicType result(AlgebraicType::Tag::Sum);
+    result.set<1>(std::move(sum));
+    return result;
+}
+
+std::string V9TypeRegistration::describeType(const bsatn::AlgebraicType& type) const {
+    switch (type.tag()) {
+        case bsatn::AlgebraicTypeTag::Bool: return "Bool";
+        case bsatn::AlgebraicTypeTag::U8: return "U8";
+        case bsatn::AlgebraicTypeTag::U16: return "U16";
+        case bsatn::AlgebraicTypeTag::U32: return "U32";
+        case bsatn::AlgebraicTypeTag::U64: return "U64";
+        case bsatn::AlgebraicTypeTag::U128: return "U128";
+        case bsatn::AlgebraicTypeTag::U256: return "U256";
+        case bsatn::AlgebraicTypeTag::I8: return "I8";
+        case bsatn::AlgebraicTypeTag::I16: return "I16";
+        case bsatn::AlgebraicTypeTag::I32: return "I32";
+        case bsatn::AlgebraicTypeTag::I64: return "I64";
+        case bsatn::AlgebraicTypeTag::I128: return "I128";
+        case bsatn::AlgebraicTypeTag::I256: return "I256";
+        case bsatn::AlgebraicTypeTag::F32: return "F32";
+        case bsatn::AlgebraicTypeTag::F64: return "F64";
+        case bsatn::AlgebraicTypeTag::String: return "String";
+        
+        case bsatn::AlgebraicTypeTag::Array: {
+            const auto& array = type.as_array();
+            return "Array<" + describeType(*array.element_type) + ">";
+        }
+        
+        case bsatn::AlgebraicTypeTag::Product: {
+            const auto& product = type.as_product();
+            if (product.elements.empty()) {
+                return "Product{}";
+            }
+            
+            std::string desc = "Product{";
+            bool first = true;
+            for (const auto& elem : product.elements) {
+                if (!first) desc += ", ";
+                first = false;
+                
+                if (elem.name.has_value()) {
+                    desc += elem.name.value() + ": ";
+                }
+                desc += describeType(*elem.algebraic_type);
+            }
+            desc += "}";
+            return desc;
+        }
+        
+        case bsatn::AlgebraicTypeTag::Sum: {
+            const auto& sum = type.as_sum();
+            if (sum.variants.empty()) {
+                return "Sum{}";
+            }
+            
+            // Check if it's an Option
+            if (isOptionType(type)) {
+                return "Option<" + describeType(*sum.variants[0].algebraic_type) + ">";
+            }
+            
+            std::string desc = "Sum{";
+            bool first = true;
+            for (const auto& variant : sum.variants) {
+                if (!first) desc += " | ";
+                first = false;
+                
+                desc += variant.name + ": " + describeType(*variant.algebraic_type);
+            }
+            desc += "}";
+            return desc;
+        }
+        
+        case bsatn::AlgebraicTypeTag::Ref:
+            return "Ref(" + std::to_string(type.as_ref()) + ")";
+            
+        default:
+            return "Unknown(tag=" + std::to_string(static_cast<int>(type.tag())) + ")";
+    }
+}
+
+void V9TypeRegistration::updateTypeNameInModule(uint32_t type_index, const std::string& new_name) {
+    // Get access to the global V9 module
+    RawModuleDefV9& v9_module = GetV9Module();
+    
+    // Check if the type index is valid
+    if (type_index >= v9_module.types.size()) {
+        fprintf(stderr, "ERROR: Invalid type index %u for namespace update (max: %zu)\n", 
+                type_index, v9_module.types.size());
+        return;
+    }
+    
+    // Parse the new name to extract namespace and name parts
+    auto [scope, name] = parseNamespaceAndName(new_name);
+    
+    // Update the type definition's scoped name
+    v9_module.types[type_index].name.scope = scope;
+    v9_module.types[type_index].name.name = name;
+    
+    fprintf(stdout, "DEBUG: Updated type index %u name to '%s' with %zu scope parts\n",
+            type_index, name.c_str(), scope.size());
+}
+
+// processOptionInnerType function removed - no longer needed
+// Options now use the same LazyTypeRegistrar pattern as other types
+
+} // namespace Internal
+
+} // namespace SpacetimeDb
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/client-comparison/README.md b/crates/bindings-cpp/tests/client-comparison/README.md
new file mode 100644
index 00000000000..d84e2ebbc69
--- /dev/null
+++ b/crates/bindings-cpp/tests/client-comparison/README.md
@@ -0,0 +1,86 @@
+# SpacetimeDB SDK Client Comparison Tool
+
+Compares client code generated from Rust and C++ SDK modules to validate type system equivalence and catch regressions.
+
+## Quick Start
+
+```bash
+./run_client_comparison.sh
+```
+
+This builds the C++ module, regenerates clients, and runs both client and module schema comparisons.
+
+## How It Works
+
+**3-Step Process:**
+1. **Build & Regenerate**: Compiles `lib.cpp` and generates fresh C++ client
+2. **Compare**: Runs client code and module schema comparisons in parallel  
+3. **Summarize**: Shows statistics and generates detailed analysis files
+
+**Prerequisites:**
+- SpacetimeDB CLI: `cargo build --release -p spacetimedb-cli`
+
+**Output:**
+- `client_diff_analysis.txt` - Detailed client code differences
+- `module_diff_analysis.txt` - Module schema comparison
+- Console summaries with key metrics
+
+## Scripts
+
+### `run_client_comparison.sh` (Main)
+Complete workflow: build → regenerate → compare → summarize
+
+### `scripts/compare_clients.sh`
+Client code comparison with intelligent filtering:
+- Ignores paths, version comments, whitespace
+- Shows only meaningful code differences
+- Provides accurate file statistics
+
+### `scripts/compare_modules.sh`
+Module schema comparison:
+- Publishes WASM to temporary databases
+- Extracts schemas via `spacetime describe --json`
+- Compares typespace, tables, reducers, named types
+
+### `scripts/regenerate_cpp_client.sh`
+Rebuilds C++ client only (no comparison)
+
+## Understanding Results
+
+**Client Comparison:**
+- **File counts**: Total files generated by each SDK
+- **Identical files**: Files with no meaningful differences (after filtering)
+- **Difference types**: Type representations, imports, structure flattening
+
+**Module Schema:**
+- **Typespace**: Core type definitions and relationships
+- **Common differences**: Registration order, duplicates, special type handling
+
+## Usage
+
+**Standard workflow:**
+```bash
+cd crates/bindings-cpp/tests/client-comparison
+./run_client_comparison.sh
+```
+
+**Update baselines:**
+```bash
+# Rust baseline
+cd rust-sdk-test
+spacetime generate --lang rust --out-dir . --project-path ../../../modules/sdk-test
+
+# Rust baseline
+./scripts/regenerate_rust_client.sh
+
+# C++ baseline  
+./scripts/regenerate_cpp_client.sh
+```
+
+## Troubleshooting
+
+- **"CLI not found"**: Build CLI with `cargo build --release -p spacetimedb-cli`
+- **"Client generation failed"**: Check if lib.cpp publishes successfully
+- **"No differences"**: Normal if no changes were made
+
+The tool validates C++ SDK functionality by comparing generated client code and module schemas against the Rust SDK baseline.
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/client-comparison/check_tables.py b/crates/bindings-cpp/tests/client-comparison/check_tables.py
new file mode 100644
index 00000000000..f77fb54bcab
--- /dev/null
+++ b/crates/bindings-cpp/tests/client-comparison/check_tables.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+import json
+from collections import Counter
+
+# Load both schemas
+with open('rust-module-schema.json', 'r') as f:
+    rust_schema = json.load(f)
+
+with open('cpp-module-schema.json', 'r') as f:
+    cpp_schema = json.load(f)
+
+# Count actual tables
+rust_tables = rust_schema.get('tables', [])
+cpp_tables = cpp_schema.get('tables', [])
+
+print(f'Actual table counts:')
+print(f'  Rust: {len(rust_tables)} tables')
+print(f'  C++: {len(cpp_tables)} tables')
+
+# Count all duplicate table entries (tables can appear multiple times for different accessors)
+rust_table_names = [t['name'] for t in rust_tables]
+cpp_table_names = [t['name'] for t in cpp_tables]
+
+rust_counts = Counter(rust_table_names)
+cpp_counts = Counter(cpp_table_names)
+
+print(f'\nTotal table entries (including duplicates):')
+print(f'  Rust: {sum(rust_counts.values())} entries')
+print(f'  C++: {sum(cpp_counts.values())} entries')
+
+# Check for tables that appear different number of times
+print(f'\nTables with different occurrence counts:')
+all_tables = set(rust_counts.keys()) | set(cpp_counts.keys())
+diff_found = False
+for table in sorted(all_tables):
+    rust_count = rust_counts.get(table, 0)
+    cpp_count = cpp_counts.get(table, 0)
+    if rust_count != cpp_count:
+        print(f'  {table}: Rust={rust_count}, C++={cpp_count}, diff={cpp_count-rust_count}')
+        diff_found = True
+
+if not diff_found:
+    print('  None - all tables appear the same number of times')
+
+# Check unique table names
+print(f'\nUnique table names:')
+print(f'  Rust: {len(set(rust_table_names))} unique tables')
+print(f'  C++: {len(set(cpp_table_names))} unique tables')
+
+# Check if table counts suggest duplicates
+print(f'\nTables appearing more than once:')
+for table, count in rust_counts.items():
+    if count > 1:
+        print(f'  Rust: {table} appears {count} times')
+        
+for table, count in cpp_counts.items():
+    if count > 1:
+        print(f'  C++: {table} appears {count} times')
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/client-comparison/run_client_comparison.sh b/crates/bindings-cpp/tests/client-comparison/run_client_comparison.sh
new file mode 100644
index 00000000000..03d4df237d4
--- /dev/null
+++ b/crates/bindings-cpp/tests/client-comparison/run_client_comparison.sh
@@ -0,0 +1,181 @@
+#!/bin/bash
+
+# Combined script to regenerate C++ SDK client and run comparison
+# This ensures we're always comparing against the most current C++ module
+#
+# Usage:
+#   ./run_client_comparison.sh          # Smart rebuild (only if sources changed)
+#   ./run_client_comparison.sh --force  # Force rebuild even if sources unchanged
+
+set -e  # Exit on any error
+
+# Check for force flag
+FORCE_REBUILD=false
+if [ "$1" = "--force" ] || [ "$1" = "-f" ]; then
+    FORCE_REBUILD=true
+    echo "Force rebuild requested..."
+fi
+
+echo "Regenerating SDK clients and running comparison..."
+echo "=================================================="
+
+# STEP 1a: Regenerate Rust client (with smart rebuild detection)
+echo ""
+echo "STEP 1a: Regenerating Rust SDK client..."
+echo "========================================"
+
+if [ ! -f scripts/regenerate_rust_client.sh ]; then
+    echo "ERROR: scripts/regenerate_rust_client.sh not found!"
+    echo "Make sure you're running this from the client-comparison directory."
+    exit 1
+fi
+
+# Pass force flag to regenerate script if needed
+if [ "$FORCE_REBUILD" = true ]; then
+    # Remove existing Rust client to force rebuild
+    RUST_DIR="rust-sdk-test"
+    if [ -d "$RUST_DIR" ]; then
+        echo "Removing existing Rust client to force rebuild..."
+        rm -rf "$RUST_DIR"
+    fi
+fi
+
+./scripts/regenerate_rust_client.sh
+
+# STEP 1b: Regenerate C++ client (with smart rebuild detection)
+echo ""
+echo "STEP 1b: Regenerating C++ SDK client..."
+echo "======================================="
+
+if [ ! -f scripts/regenerate_cpp_client.sh ]; then
+    echo "ERROR: scripts/regenerate_cpp_client.sh not found!"
+    echo "Make sure you're running this from the client-comparison directory."
+    exit 1
+fi
+
+# Pass force flag to regenerate script if needed
+if [ "$FORCE_REBUILD" = true ]; then
+    # Temporarily remove the WASM to force rebuild
+    WASM_PATH="../../../../modules/sdk-test-cpp/build/lib.wasm"
+    if [ -f "$WASM_PATH" ]; then
+        echo "Removing existing WASM to force rebuild..."
+        rm "$WASM_PATH"
+    fi
+fi
+
+./scripts/regenerate_cpp_client.sh
+
+# STEP 2: Run comparisons in parallel
+echo ""
+echo "STEP 2: Running comparisons..."
+echo "=============================="
+
+# Check if comparison scripts exist
+if [ ! -f scripts/compare_clients.sh ]; then
+    echo "ERROR: scripts/compare_clients.sh not found!"
+    echo "Make sure you're running this from the client-comparison directory."
+    exit 1
+fi
+
+if [ ! -f scripts/compare_modules.sh ]; then
+    echo "ERROR: scripts/compare_modules.sh not found!"
+    echo "Make sure you're running this from the client-comparison directory."
+    exit 1
+fi
+
+echo "Running client and module comparisons in parallel..."
+
+# Run both comparisons in parallel
+./scripts/compare_clients.sh &
+CLIENT_PID=$!
+
+./scripts/compare_modules.sh &
+MODULE_PID=$!
+
+# Wait for both to complete
+echo "Waiting for client comparison to complete..."
+wait $CLIENT_PID
+CLIENT_EXIT=$?
+
+echo "Waiting for module comparison to complete..."
+wait $MODULE_PID  
+MODULE_EXIT=$?
+
+# Check if both succeeded
+if [ $CLIENT_EXIT -ne 0 ]; then
+    echo "❌ Client comparison failed!"
+fi
+
+if [ $MODULE_EXIT -ne 0 ]; then
+    echo "❌ Module comparison failed!"
+fi
+
+if [ $CLIENT_EXIT -eq 0 ] && [ $MODULE_EXIT -eq 0 ]; then
+    echo "✅ Both comparisons completed successfully!"
+else
+    echo "⚠️  One or more comparisons failed - check output above"
+fi
+
+# STEP 3: Show results summary
+echo ""
+echo "STEP 3: Results Summary"
+echo "======================="
+
+# Client comparison results
+if [ -f client_diff_analysis.txt ]; then
+    echo ""
+    echo "📊 Client Comparison Summary:"
+    echo "$(grep "Total files compared:" client_diff_analysis.txt)"
+    echo "$(grep "Identical files (ignoring version):" client_diff_analysis.txt)"
+    echo "$(grep "Different files:" client_diff_analysis.txt)"
+    
+    # Extract file counts
+    RUST_COUNT=$(grep "Rust SDK files:" client_diff_analysis.txt | cut -d: -f2 | tr -d ' ')
+    CPP_COUNT=$(grep "C++ SDK files:" client_diff_analysis.txt | cut -d: -f2 | tr -d ' ')
+    
+    if [ "$RUST_COUNT" = "$CPP_COUNT" ]; then
+        echo "File count: ✅ Perfect match ($CPP_COUNT files each)"
+    else
+        echo "File count: ⚠️  Mismatch (Rust: $RUST_COUNT, C++: $CPP_COUNT)"
+    fi
+    
+    echo ""
+    echo "📁 Client analysis: client_diff_analysis.txt ($(du -h client_diff_analysis.txt | cut -f1))"
+else
+    echo "❌ Client analysis file not found!"
+fi
+
+# Module comparison results
+if [ -f module_diff_analysis.txt ]; then
+    echo ""
+    echo "🔧 Module Schema Summary:"
+    RUST_TYPES=$(grep "Rust SDK:" module_diff_analysis.txt | grep "named types" | cut -d: -f2 | cut -d' ' -f2)
+    CPP_TYPES=$(grep "C++ SDK:" module_diff_analysis.txt | grep "named types" | cut -d: -f2 | cut -d' ' -f3)
+    
+    echo "Rust schema: $RUST_TYPES named types"
+    echo "C++ schema: $CPP_TYPES named types"
+    
+    if [ "$RUST_TYPES" = "$CPP_TYPES" ]; then
+        echo "Schema types: ✅ Perfect match ($CPP_TYPES types each)"
+    else
+        echo "Schema types: ⚠️  Mismatch (difference: $((CPP_TYPES - RUST_TYPES)))"
+    fi
+    
+    echo ""
+    echo "📁 Module analysis: module_diff_analysis.txt ($(du -h module_diff_analysis.txt | cut -f1))"
+else
+    echo "❌ Module analysis file not found!"
+fi
+
+echo ""
+echo "🎉 Regeneration and comparison complete!"
+echo ""
+echo "Usage tips:"
+echo "  • ./run_client_comparison.sh          # Smart rebuild (only if sources changed)"
+echo "  • ./run_client_comparison.sh --force  # Force rebuild even if unchanged"
+echo ""
+echo "Next steps:"
+echo "  • Review client_diff_analysis.txt for client generation differences"
+echo "  • Review module_diff_analysis.txt for schema-level differences"
+echo "  • Focus on remaining type resolution issues if any"
+echo "  • Check for any new regressions or improvements"
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/client-comparison/scripts/compare_clients.sh b/crates/bindings-cpp/tests/client-comparison/scripts/compare_clients.sh
new file mode 100644
index 00000000000..710d4f75ae4
--- /dev/null
+++ b/crates/bindings-cpp/tests/client-comparison/scripts/compare_clients.sh
@@ -0,0 +1,110 @@
+#!/bin/bash
+
+# Script to compare Rust and C++ module library generated clients
+# Ignores version comment lines for cleaner comparison
+
+OUTPUT_FILE="client_diff_analysis.txt"
+RUST_DIR="rust-sdk-test"
+CPP_DIR="cpp-sdk-test"
+
+echo "SpacetimeDB Module Library Client Generation Comparison" > $OUTPUT_FILE
+echo "=======================================================" >> $OUTPUT_FILE
+echo "Generated on: $(date)" >> $OUTPUT_FILE
+echo "Comparing: $RUST_DIR vs $CPP_DIR" >> $OUTPUT_FILE
+echo "" >> $OUTPUT_FILE
+
+# File count comparison
+echo "FILE COUNT COMPARISON" >> $OUTPUT_FILE
+echo "--------------------" >> $OUTPUT_FILE
+RUST_COUNT=$(find $RUST_DIR -name "*.rs" | wc -l)
+CPP_COUNT=$(find $CPP_DIR -name "*.rs" | wc -l)
+echo "Rust module library files: $RUST_COUNT" >> $OUTPUT_FILE
+echo "C++ module library files:  $CPP_COUNT" >> $OUTPUT_FILE
+echo "Difference:     $((CPP_COUNT - RUST_COUNT))" >> $OUTPUT_FILE
+echo "" >> $OUTPUT_FILE
+
+# Files only in one directory
+echo "FILES UNIQUE TO EACH MODULE LIBRARY" >> $OUTPUT_FILE
+echo "-----------------------------------" >> $OUTPUT_FILE
+echo "Files only in Rust module library:" >> $OUTPUT_FILE
+comm -23 <(cd $RUST_DIR && find . -name "*.rs" | sort) <(cd $CPP_DIR && find . -name "*.rs" | sort) >> $OUTPUT_FILE
+echo "" >> $OUTPUT_FILE
+echo "Files only in C++ module library:" >> $OUTPUT_FILE
+comm -13 <(cd $RUST_DIR && find . -name "*.rs" | sort) <(cd $CPP_DIR && find . -name "*.rs" | sort) >> $OUTPUT_FILE
+echo "" >> $OUTPUT_FILE
+
+# Common files
+echo "COMMON FILES COMPARISON" >> $OUTPUT_FILE
+echo "----------------------" >> $OUTPUT_FILE
+COMMON_FILES=$(comm -12 <(cd $RUST_DIR && find . -name "*.rs" | sort) <(cd $CPP_DIR && find . -name "*.rs" | sort))
+echo "Number of common files: $(echo "$COMMON_FILES" | wc -l)" >> $OUTPUT_FILE
+echo "" >> $OUTPUT_FILE
+
+# Function to get meaningful diff content only
+get_meaningful_diff() {
+    local file1="$1"
+    local file2="$2"
+    
+    # Create temp files without version comment lines
+    local temp1=$(mktemp)
+    local temp2=$(mktemp)
+    
+    # Remove version comment line (line starting with "// This was generated using")
+    grep -v "^// This was generated using spacetimedb cli version" "$file1" > "$temp1"
+    grep -v "^// This was generated using spacetimedb cli version" "$file2" > "$temp2"
+    
+    # Check if files are identical after filtering version comments
+    if diff -q "$temp1" "$temp2" > /dev/null 2>&1; then
+        # Files are identical after filtering
+        rm "$temp1" "$temp2"
+        return 1  # No meaningful differences
+    else
+        # Files have differences - extract meaningful change lines
+        diff -u "$temp1" "$temp2" 2>/dev/null | grep -E '^[+-]' | grep -v -E '^[+-]{3}' | head -20
+        rm "$temp1" "$temp2"
+        return 0  # Has meaningful differences
+    fi
+}
+
+# Detailed diff of common files
+echo "DETAILED DIFFS OF COMMON FILES" >> $OUTPUT_FILE
+echo "==============================" >> $OUTPUT_FILE
+echo "(Version comment lines are ignored)" >> $OUTPUT_FILE
+echo "" >> $OUTPUT_FILE
+
+IDENTICAL_COUNT=0
+DIFFERENT_COUNT=0
+
+for file in $COMMON_FILES; do
+    # Get meaningful differences for this file
+    meaningful_diff=$(get_meaningful_diff "$RUST_DIR/$file" "$CPP_DIR/$file")
+    diff_result=$?
+    
+    if [ $diff_result -eq 0 ] && [ -n "$meaningful_diff" ]; then
+        # File has meaningful differences
+        ((DIFFERENT_COUNT++))
+        echo "" >> $OUTPUT_FILE
+        echo "DIFF: $file" >> $OUTPUT_FILE
+        echo "$(printf '=%.0s' {1..50})" >> $OUTPUT_FILE
+        echo "$meaningful_diff" >> $OUTPUT_FILE
+        echo "" >> $OUTPUT_FILE
+    else
+        # File is identical after filtering
+        ((IDENTICAL_COUNT++))
+    fi
+done
+
+# Statistics summary with accurate counts
+echo "STATISTICS SUMMARY" >> $OUTPUT_FILE
+echo "==================" >> $OUTPUT_FILE
+echo "Total files compared: $(echo "$COMMON_FILES" | wc -l)" >> $OUTPUT_FILE
+echo "Identical files (ignoring version): $IDENTICAL_COUNT" >> $OUTPUT_FILE
+echo "Different files: $DIFFERENT_COUNT" >> $OUTPUT_FILE
+echo "" >> $OUTPUT_FILE
+
+echo "Analysis complete. Results written to: $OUTPUT_FILE"
+echo "File size: $(du -h $OUTPUT_FILE | cut -f1)"
+echo ""
+echo "Summary:"
+echo "  - Identical files (ignoring version): $IDENTICAL_COUNT"
+echo "  - Different files: $DIFFERENT_COUNT"
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/client-comparison/scripts/compare_modules.sh b/crates/bindings-cpp/tests/client-comparison/scripts/compare_modules.sh
new file mode 100644
index 00000000000..ed459006707
--- /dev/null
+++ b/crates/bindings-cpp/tests/client-comparison/scripts/compare_modules.sh
@@ -0,0 +1,475 @@
+#!/bin/bash
+# compare_modules.sh - Compare module schemas between Rust and C++ SDKs
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &> /dev/null && pwd)"
+PARENT_DIR="$(dirname "$SCRIPT_DIR")"
+cd "$PARENT_DIR"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Detect available Python command (cross-platform)
+detect_python() {
+    local python_cmd=""
+    
+    # Try different Python commands in order of preference
+    for cmd in python3 python py; do
+        if command -v "$cmd" >/dev/null 2>&1; then
+            # Test if the command actually works and has json module
+            if "$cmd" -c "import json; import sys; print('OK')" >/dev/null 2>&1; then
+                python_cmd="$cmd"
+                break
+            fi
+        fi
+    done
+    
+    if [ -z "$python_cmd" ]; then
+        echo "❌ Error: No working Python installation found (tried: python3, python, py)" >&2
+        echo "   Please install Python 3.x with json module support" >&2
+        exit 1
+    fi
+    
+    echo "$python_cmd"
+}
+
+# Set the Python command to use
+PYTHON_CMD=$(detect_python)
+echo "Using Python command: $PYTHON_CMD"
+
+echo "Comparing module schemas between Rust and C++ SDKs..."
+echo "=================================================="
+
+# Function to get module schema from WASM
+get_module_schema() {
+    local sdk_name="$1"
+    local output_file="$2"
+    local wasm_path="$3"
+    
+    echo "Getting $sdk_name module schema from WASM..."
+    
+    # Use the same WASM file that client generation uses  
+    local temp_db
+    if [ "$sdk_name" = "Rust" ]; then
+        temp_db="rust-schema-temp"
+    else
+        temp_db="cpp-schema-temp"
+    fi
+    
+    echo "  Publishing WASM to temporary database: $temp_db from $wasm_path"
+    if spacetime publish --bin-path "$wasm_path" "$temp_db" -c -y >/dev/null 2>&1; then
+        echo "  Retrieving schema from published module..."
+        if spacetime describe --json "$temp_db" > "$output_file" 2>/dev/null; then
+            echo "✅ $sdk_name schema retrieved successfully from WASM"
+            # Pretty print the JSON for better comparison
+            $PYTHON_CMD -m json.tool "$output_file" > "${output_file}.tmp" 2>/dev/null && mv "${output_file}.tmp" "$output_file" || true
+        else
+            echo "❌ Failed to get $sdk_name schema from published module"
+            return 1
+        fi
+    else
+        echo "❌ Failed to publish $sdk_name WASM to temporary database"
+        return 1
+    fi
+}
+
+# Function to extract and analyze schema sections
+analyze_schema_section() {
+    local schema_file="$1"
+    local section_name="$2"
+    local output_prefix="$3"
+    
+    case "$section_name" in
+        "typespace")
+            # Extract first types array (line 3)
+            sed -n '3,/^    ],$/p' "$schema_file" > "${output_prefix}_typespace.json"
+            ;;
+        "tables")
+            # Extract tables section
+            sed -n '/"tables":/,/^    ],$/p' "$schema_file" > "${output_prefix}_tables.json"
+            ;;
+        "reducers")
+            # Extract reducers section
+            sed -n '/"reducers":/,/^    ],$/p' "$schema_file" > "${output_prefix}_reducers.json"
+            ;;
+        "named_types")
+            # Extract last types array (after reducers)
+            awk '/"types":/ && ++count==2,/^}$/' "$schema_file" > "${output_prefix}_named_types.json"
+            ;;
+    esac
+}
+
+# Function to count items in a section
+count_section_items() {
+    local file="$1"
+    local pattern="$2"
+    
+    if [ -f "$file" ]; then
+        grep -c "$pattern" "$file" 2>/dev/null || echo "0"
+    else
+        echo "0"
+    fi
+}
+
+# Function to get meaningful diff content only
+get_meaningful_diff() {
+    local file1="$1"
+    local file2="$2"
+    
+    # Create temporary files with version comments filtered out
+    local temp1=$(mktemp)
+    local temp2=$(mktemp)
+    
+    # Filter out version-specific content and normalize spacing
+    grep -v -E "(commit [a-f0-9]+|version [0-9]+\.[0-9]+\.[0-9]+)" "$file1" | sed 's/[[:space:]]*$//' > "$temp1" 2>/dev/null || true
+    grep -v -E "(commit [a-f0-9]+|version [0-9]+\.[0-9]+\.[0-9]+)" "$file2" | sed 's/[[:space:]]*$//' > "$temp2" 2>/dev/null || true
+    
+    # Get diff content, filter to only +/- lines, remove diff headers, limit output
+    diff -u "$temp1" "$temp2" 2>/dev/null | grep -E '^[+-]' | grep -v -E '^[+-]{3}' | head -50
+    
+    # Cleanup
+    rm -f "$temp1" "$temp2"
+}
+
+# Function to find differences in named items
+find_differences() {
+    local rust_file="$1"
+    local cpp_file="$2"
+    local item_pattern="$3"
+    
+    # Extract names from both files
+    local rust_names=$(mktemp)
+    local cpp_names=$(mktemp)
+    
+    grep -o "$item_pattern" "$rust_file" 2>/dev/null | sort | uniq > "$rust_names" || true
+    grep -o "$item_pattern" "$cpp_file" 2>/dev/null | sort | uniq > "$cpp_names" || true
+    
+    echo "Only in Rust:"
+    comm -23 "$rust_names" "$cpp_names" | head -10 | sed 's/^/  - /'
+    
+    echo "Only in C++:"
+    comm -13 "$rust_names" "$cpp_names" | head -10 | sed 's/^/  - /'
+    
+    # Cleanup
+    rm -f "$rust_names" "$cpp_names"
+}
+
+# Paths - use the same WASM files that client generation uses
+RUST_WASM_PATH=$(realpath "../../../../target/wasm32-unknown-unknown/release/sdk_test_module.wasm")
+CPP_WASM_PATH=$(realpath "../../../../modules/sdk-test-cpp/build/lib.wasm")
+
+RUST_SCHEMA="rust-module-schema.json"  
+CPP_SCHEMA="cpp-module-schema.json"
+ANALYSIS_FILE="module_diff_analysis.txt"
+
+# Get schemas from WASM files
+echo
+echo "Step 1: Retrieving module schemas from WASM..."
+echo "=============================================="
+
+# Check if WASM files exist and get schemas
+RUST_AVAILABLE=false
+CPP_AVAILABLE=false
+
+# Check if we have an existing Rust schema file or need to regenerate
+if [ -f "$RUST_SCHEMA" ]; then
+    echo "✅ Using existing Rust schema from $RUST_SCHEMA"
+    RUST_AVAILABLE=true
+elif [ ! -f "$RUST_WASM_PATH" ]; then
+    echo "❌ Rust WASM not found at: $RUST_WASM_PATH"
+    echo "   And no existing rust-module-schema.json found"
+    echo "   Build it with: cargo build --target wasm32-unknown-unknown --release -p sdk-test-module"
+else
+    if get_module_schema "Rust" "$RUST_SCHEMA" "$RUST_WASM_PATH"; then
+        RUST_AVAILABLE=true
+    else
+        echo "❌ Failed to get Rust module schema"
+    fi
+fi
+
+# Check if we have an existing C++ schema file or need to regenerate
+if [ -f "$CPP_SCHEMA" ]; then
+    echo "✅ Using existing C++ schema from $CPP_SCHEMA"
+    CPP_AVAILABLE=true
+elif [ ! -f "$CPP_WASM_PATH" ]; then
+    echo "❌ C++ WASM not found at: $CPP_WASM_PATH"
+    echo "   And no existing cpp-module-schema.json found"
+    echo "   Build it with: cmake --build build"
+else
+    if get_module_schema "C++" "$CPP_SCHEMA" "$CPP_WASM_PATH"; then
+        CPP_AVAILABLE=true
+    else
+        echo "❌ Failed to get C++ module schema"
+    fi
+fi
+
+# Exit only if neither schema is available
+if [ "$RUST_AVAILABLE" = false ] && [ "$CPP_AVAILABLE" = false ]; then
+    echo "❌ Cannot continue - no module schemas available"
+    exit 1
+fi
+
+echo
+echo "Step 2: Analyzing schemas..."
+echo "============================"
+
+# Extract sections for analysis
+for section in typespace tables reducers named_types; do
+    if [ "$RUST_AVAILABLE" = true ]; then
+        analyze_schema_section "$RUST_SCHEMA" "$section" "rust"
+    fi
+    if [ "$CPP_AVAILABLE" = true ]; then
+        analyze_schema_section "$CPP_SCHEMA" "$section" "cpp"
+    fi
+done
+
+# Start analysis file
+{
+    echo "SpacetimeDB Module Schema Comparison"
+    echo "===================================="
+    echo "Generated on: $(date)"
+    echo "Comparing: Rust SDK vs C++ SDK module schemas"
+    echo
+    
+    # Basic file info
+    echo "SCHEMA FILE SIZES"
+    echo "-----------------"
+    if [ "$RUST_AVAILABLE" = true ]; then
+        echo "Rust schema: $(wc -c < "$RUST_SCHEMA" 2>/dev/null || echo "N/A") bytes"
+    else
+        echo "Rust schema: Not available"
+    fi
+    if [ "$CPP_AVAILABLE" = true ] && [ -f "$CPP_SCHEMA" ]; then
+        echo "C++ schema:  $(wc -c < "$CPP_SCHEMA" 2>/dev/null || echo "N/A") bytes"
+    else
+        echo "C++ schema:  Not available"
+    fi
+    if [ "$RUST_AVAILABLE" = true ] && [ "$CPP_AVAILABLE" = true ]; then
+        echo "Difference:  $(($(wc -c < "$CPP_SCHEMA") - $(wc -c < "$RUST_SCHEMA"))) bytes"
+    fi
+    echo
+    
+    echo "=================================================================="
+    echo "SECTION 1: TYPESPACE (Anonymous types used internally)"
+    echo "=================================================================="
+    echo
+    
+    rust_typespace=0
+    cpp_typespace=0
+    
+    # Count types in the typespace.types array
+    if [ "$RUST_AVAILABLE" = true ] && [ -f "$RUST_SCHEMA" ]; then
+        rust_typespace=$($PYTHON_CMD -c "import json; data=json.load(open('$RUST_SCHEMA')); ts=data.get('typespace', {}); types=ts.get('types', []); print(len(types))" 2>/dev/null || echo "0")
+        echo "- Rust SDK: $rust_typespace types"
+    else
+        echo "- Rust SDK: Not available"
+    fi
+    
+    if [ "$CPP_AVAILABLE" = true ] && [ -f "$CPP_SCHEMA" ]; then
+        cpp_typespace=$($PYTHON_CMD -c "import json; data=json.load(open('$CPP_SCHEMA')); ts=data.get('typespace', {}); types=ts.get('types', []); print(len(types))" 2>/dev/null || echo "0")
+        echo "- C++ SDK:  $cpp_typespace types"
+    else
+        echo "- C++ SDK:  Not available"
+    fi
+    
+    if [ "$RUST_AVAILABLE" = true ] && [ "$CPP_AVAILABLE" = true ]; then
+        echo "- Difference: $((cpp_typespace - rust_typespace))"
+    fi
+    echo
+    
+    # Analyze type patterns in typespace
+    if [ "$CPP_AVAILABLE" = true ] || [ "$RUST_AVAILABLE" = true ]; then
+        echo "Type patterns in typespace:"
+        
+        if [ -f "rust_typespace.json" ]; then
+            rust_products=$(grep -c '"Product":' rust_typespace.json 2>/dev/null || echo "0")
+            rust_sums=$(grep -c '"Sum":' rust_typespace.json 2>/dev/null || echo "0")
+        else
+            rust_products="N/A"
+            rust_sums="N/A"
+        fi
+        
+        if [ -f "cpp_typespace.json" ]; then
+            cpp_products=$(grep -c '"Product":' cpp_typespace.json 2>/dev/null || echo "0")
+            cpp_sums=$(grep -c '"Sum":' cpp_typespace.json 2>/dev/null || echo "0")
+        else
+            cpp_products="N/A"
+            cpp_sums="N/A"
+        fi
+        
+        echo "- Product types: Rust=$rust_products, C++=$cpp_products"
+        echo "- Sum types: Rust=$rust_sums, C++=$cpp_sums"
+        echo
+    fi
+    
+    echo "=================================================================="
+    echo "SECTION 2: TABLES"
+    echo "=================================================================="
+    echo
+    # Count tables by counting table objects (look for '"name":' at the table level, not field level)
+    # Each table starts with {"name": so count those
+    rust_tables=$($PYTHON_CMD -c "import json; data=json.load(open('$RUST_SCHEMA')); print(len(data.get('tables', [])))" 2>/dev/null || echo "0")
+    cpp_tables=$($PYTHON_CMD -c "import json; data=json.load(open('$CPP_SCHEMA')); print(len(data.get('tables', [])))" 2>/dev/null || echo "0")
+    echo "Table counts:"
+    echo "- Rust SDK: $rust_tables tables"
+    echo "- C++ SDK:  $cpp_tables tables"
+    echo "- Difference: $((cpp_tables - rust_tables))"
+    
+    if [ "$rust_tables" -eq "$cpp_tables" ] && [ "$rust_tables" -gt "0" ]; then
+        echo "✅ Table count matches!"
+    elif [ "$rust_tables" -ne "$cpp_tables" ]; then
+        echo "⚠️  Table count mismatch!"
+        echo
+        echo "Table differences:"
+        find_differences "$RUST_SCHEMA" "$CPP_SCHEMA" '"name": "[^"]*"'
+    fi
+    echo
+    
+    echo "=================================================================="
+    echo "SECTION 3: REDUCERS"
+    echo "=================================================================="
+    echo
+    # Count reducers properly using Python
+    rust_reducers=$($PYTHON_CMD -c "import json; data=json.load(open('$RUST_SCHEMA')); print(len(data.get('reducers', [])))" 2>/dev/null || echo "0")
+    cpp_reducers=$($PYTHON_CMD -c "import json; data=json.load(open('$CPP_SCHEMA')); print(len(data.get('reducers', [])))" 2>/dev/null || echo "0")
+    echo "Reducer counts:"
+    echo "- Rust SDK: $rust_reducers reducers"
+    echo "- C++ SDK:  $cpp_reducers reducers"
+    echo "- Difference: $((cpp_reducers - rust_reducers))"
+    
+    if [ "$rust_reducers" -eq "$cpp_reducers" ] && [ "$rust_reducers" -gt "0" ]; then
+        echo "✅ Reducer count matches!"
+    elif [ "$rust_reducers" -ne "$cpp_reducers" ]; then
+        echo "⚠️  Reducer count mismatch!"
+        echo
+        echo "Reducer differences:"
+        # Extract reducer names from both schemas
+        sed -n '/"reducers":/,/^    ],$/p' "$RUST_SCHEMA" > rust_reducers_section.tmp
+        sed -n '/"reducers":/,/^    ],$/p' "$CPP_SCHEMA" > cpp_reducers_section.tmp
+        find_differences "rust_reducers_section.tmp" "cpp_reducers_section.tmp" '"name": "[^"]*"'
+        rm -f rust_reducers_section.tmp cpp_reducers_section.tmp
+    fi
+    echo
+    
+    echo "=================================================================="
+    echo "SECTION 4: NAMED TYPES (User-defined types)"
+    echo "=================================================================="
+    echo
+    
+    # Count named types in the typespace.types array (these are the actual named/anonymous types)
+    rust_named_types=$($PYTHON_CMD -c "import json; data=json.load(open('$RUST_SCHEMA')); ts=data.get('typespace', {}); types=ts.get('types', []); print(len(types))" 2>/dev/null || echo "0")
+    cpp_named_types=$($PYTHON_CMD -c "import json; data=json.load(open('$CPP_SCHEMA')); ts=data.get('typespace', {}); types=ts.get('types', []); print(len(types))" 2>/dev/null || echo "0")
+    
+    echo "Named type counts:"
+    echo "- Rust SDK: $rust_named_types named types"
+    echo "- C++ SDK:  $cpp_named_types named types"
+    echo "- Difference: $((cpp_named_types - rust_named_types))"
+    
+    if [ "$rust_named_types" -ne "$cpp_named_types" ]; then
+        echo
+        echo "Named type differences:"
+        # Extract just the type names for comparison
+        grep -A2 '"name":' rust_named_types.json | grep '"name":' | grep -o '"[^"]*"$' | sort > rust_type_names.tmp
+        grep -A2 '"name":' cpp_named_types.json | grep '"name":' | grep -o '"[^"]*"$' | sort > cpp_type_names.tmp
+        
+        echo "Only in Rust:"
+        comm -23 rust_type_names.tmp cpp_type_names.tmp | head -10 | sed 's/^/  - /'
+        
+        echo "Only in C++:"
+        comm -13 rust_type_names.tmp cpp_type_names.tmp | head -10 | sed 's/^/  - /'
+        
+        rm -f rust_type_names.tmp cpp_type_names.tmp
+    fi
+    echo
+    
+    # Analyze specific types
+    echo "CRITICAL TYPE ANALYSIS"
+    echo "====================="
+    echo
+    
+    # Look for specific patterns that might indicate issues
+    echo "Type index examples (showing potential misalignment):"
+    echo "Rust:"
+    grep -A3 '"ByteStruct"\|"EnumWithPayload"\|"UnitStruct"' rust_named_types.json 2>/dev/null | grep -E '"name":|"ty":' | head -6
+    echo
+    echo "C++:"
+    grep -A3 '"ByteStruct"\|"EnumWithPayload"\|"UnitStruct"' cpp_named_types.json 2>/dev/null | grep -E '"name":|"ty":' | head -6
+    echo
+    
+    # Check for potential duplicate registrations
+    echo "Checking for duplicate type names:"
+    echo "Rust duplicates:"
+    grep '"name":' rust_named_types.json | grep -o '"[^"]*"$' | sort | uniq -c | grep -v '^ *1 ' | head -5
+    echo "C++ duplicates:"
+    grep '"name":' cpp_named_types.json | grep -o '"[^"]*"$' | sort | uniq -c | grep -v '^ *1 ' | head -5
+    echo
+    
+    echo "=================================================================="
+    echo "SUMMARY"
+    echo "=================================================================="
+    echo
+    
+    # Overall summary
+    total_rust=$((rust_typespace + rust_tables + rust_reducers + rust_named_types))
+    total_cpp=$((cpp_typespace + cpp_tables + cpp_reducers + cpp_named_types))
+    
+    echo "Total counts across all sections:"
+    echo "- Rust SDK: $total_rust items"
+    echo "- C++ SDK:  $total_cpp items"
+    echo "- Difference: $((total_cpp - total_rust))"
+    echo
+    
+    echo "Key findings:"
+    if [ "$((cpp_typespace - rust_typespace))" -gt 0 ]; then
+        echo "⚠️  C++ has $((cpp_typespace - rust_typespace)) extra anonymous types in typespace"
+    fi
+    
+    if [ "$rust_tables" -ne "$cpp_tables" ]; then
+        echo "⚠️  Table count differs by $((cpp_tables - rust_tables))"
+    fi
+    
+    if [ "$rust_reducers" -ne "$cpp_reducers" ]; then
+        echo "⚠️  Reducer count differs by $((cpp_reducers - rust_reducers))"
+    fi
+    
+    if [ "$((cpp_named_types - rust_named_types))" -ne 0 ]; then
+        echo "⚠️  Named type count differs by $((cpp_named_types - rust_named_types))"
+    fi
+    
+    if [ "$rust_tables" -eq "$cpp_tables" ] && [ "$rust_reducers" -eq "$cpp_reducers" ]; then
+        echo "✅ Table and reducer counts match perfectly"
+    fi
+    
+} > "$ANALYSIS_FILE"
+
+# Clean up temporary files
+rm -f rust_*.json cpp_*.json 2>/dev/null
+
+echo "✅ Module schema analysis complete!"
+echo 
+echo -e "${GREEN}📊 Summary:${NC}"
+
+# Quick summary from the analysis
+rust_named=$(grep "Rust SDK:.*named types" "$ANALYSIS_FILE" | tail -1 | grep -o '[0-9]\+' | head -1)
+cpp_named=$(grep "C\+\+ SDK:.*named types" "$ANALYSIS_FILE" | tail -1 | grep -o '[0-9]\+' | head -1)
+
+if [ -n "$rust_named" ] && [ -n "$cpp_named" ]; then
+    echo "  • Rust schema: $rust_named named types"
+    echo "  • C++ schema: $cpp_named named types"
+    
+    if [ "$rust_named" -eq "$cpp_named" ]; then
+        echo -e "  • ${GREEN}✅ Named type count matches${NC}"
+    else
+        echo -e "  • ${YELLOW}⚠️  Named type count differs by $((cpp_named - rust_named))${NC}"  
+    fi
+fi
+
+echo
+echo -e "${BLUE}📁 Detailed analysis: $ANALYSIS_FILE${NC}"
+echo -e "   File size: $(ls -lh "$ANALYSIS_FILE" | awk '{print $5}')"
+echo
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/client-comparison/scripts/regenerate_cpp_client.sh b/crates/bindings-cpp/tests/client-comparison/scripts/regenerate_cpp_client.sh
new file mode 100644
index 00000000000..d31d1292225
--- /dev/null
+++ b/crates/bindings-cpp/tests/client-comparison/scripts/regenerate_cpp_client.sh
@@ -0,0 +1,134 @@
+#!/bin/bash
+
+# Script to regenerate C++ SDK client from latest lib.cpp build
+# This ensures we're always comparing against the most current C++ module
+
+set -e  # Exit on any error
+# Detect the correct emcmake command for cross-platform compatibility
+detect_emcmake_command() {
+    if command -v emcmake >/dev/null 2>&1; then
+        echo "emcmake"
+    elif command -v emcmake.bat >/dev/null 2>&1; then
+        echo "emcmake.bat"
+    elif [ -n "$EMSDK" ] && [ -f "$EMSDK/emcmake.bat" ]; then
+        echo "$EMSDK/emcmake.bat"
+    else
+        echo "emcmake"  # fallback, will fail with clear error
+    fi
+}
+
+EMCMAKE_CMD=$(detect_emcmake_command)
+echo "Using emcmake command: $EMCMAKE_CMD"
+
+CPP_DIR="cpp-sdk-test"
+SDK_TEST_DIR=$(realpath "../../../../modules/sdk-test-cpp")
+WASM_PATH="$SDK_TEST_DIR/build/lib.wasm"
+CLI_PATH=$(realpath "../../../../target/release/spacetimedb-cli")
+NUM_CORES=16
+
+# Check if rebuild is needed
+check_needs_rebuild() {
+    local wasm_file="$1"
+    local source_dir="$2"
+    local lib_dir="../.." # Path to bindings-cpp
+    
+    # If WASM doesn't exist, we need to build
+    if [ ! -f "$wasm_file" ]; then
+        return 0  # true - needs rebuild
+    fi
+    
+    # Find the newest source file in sdk-test-cpp
+    local newest_src=$(find "$source_dir/src" "$source_dir/include" -type f \( -name "*.cpp" -o -name "*.h" \) -printf '%T@\n' 2>/dev/null | sort -n | tail -1)
+    
+    # Find the newest library file in bindings-cpp
+    local newest_lib=$(find "$lib_dir/include" "$lib_dir/src" -type f \( -name "*.cpp" -o -name "*.h" \) -printf '%T@\n' 2>/dev/null | sort -n | tail -1)
+    
+    # Get WASM modification time
+    local wasm_time=$(stat -c %Y "$wasm_file" 2>/dev/null || echo 0)
+    
+    # Check if any source is newer than WASM
+    if [ -n "$newest_src" ] && [ $(echo "$newest_src" | cut -d. -f1) -gt $wasm_time ]; then
+        return 0  # true - needs rebuild
+    fi
+    
+    # Check if any library file is newer than WASM
+    if [ -n "$newest_lib" ] && [ $(echo "$newest_lib" | cut -d. -f1) -gt $wasm_time ]; then
+        return 0  # true - needs rebuild
+    fi
+    
+    return 1  # false - no rebuild needed
+}
+
+echo "Regenerating C++ SDK client from latest lib.cpp build..."
+echo "========================================================="
+
+# Check if lib.cpp needs rebuilding
+if check_needs_rebuild "$WASM_PATH" "$SDK_TEST_DIR"; then
+    echo "Source files changed - rebuilding lib.cpp with $NUM_CORES cores..."
+    echo "-----------------------------------------"
+    cd "$SDK_TEST_DIR"
+    
+    # Check if build directory exists, if not configure it
+    if [ ! -d "build" ]; then
+        echo "Configuring build directory..."
+        $EMCMAKE_CMD cmake -B build -DMODULE_SOURCE=src/lib.cpp -DOUTPUT_NAME=lib
+    fi
+    
+    # Build with parallel compilation
+    echo "Building lib.wasm..."
+    cmake --build build -j$NUM_CORES
+    
+    if [ ! -f "$WASM_PATH" ]; then
+        echo "ERROR: Build succeeded but lib.wasm not found at $WASM_PATH"
+        echo "Build may have produced a different output file."
+        exit 1
+    fi
+    
+    echo "✅ lib.cpp built successfully!"
+    echo "WASM size: $(du -h "$WASM_PATH" | cut -f1)"
+    echo ""
+    
+    # Return to the client-comparison directory
+    cd - > /dev/null
+else
+    echo "✅ No source changes detected - using existing lib.wasm"
+    echo "WASM size: $(du -h "$WASM_PATH" | cut -f1)"
+    echo ""
+fi
+
+if [ ! -f "$CLI_PATH" ]; then
+    echo "ERROR: SpacetimeDB CLI not found at $CLI_PATH"
+    echo "Please build the CLI first, from the project root:"
+    echo "  cargo build --release -p spacetimedb-cli"
+    exit 1
+fi
+
+# Clear existing C++ client directory
+echo "Clearing existing C++ client directory..."
+if [ -d "$CPP_DIR" ]; then
+    rm -rf "$CPP_DIR"/*
+    echo "Cleared $CPP_DIR/"
+else
+    mkdir -p "$CPP_DIR"
+    echo "Created $CPP_DIR/"
+fi
+
+# Generate new C++ client
+echo "Generating new C++ client from lib.wasm..."
+cd "$CPP_DIR"
+"$CLI_PATH" generate --lang rust --out-dir . --bin-path "$WASM_PATH" >/dev/null 2>&1
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo "✅ C++ SDK client regenerated successfully!"
+    echo "Files generated: $(find . -name "*.rs" | wc -l)"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Run ./compare_clients.sh to generate new comparison"
+    echo "  2. Review client_diff_analysis.txt for updated differences"
+else
+    echo ""
+    echo "❌ Client generation failed!"
+    echo "Check the error messages above for details."
+    exit 1
+fi
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/client-comparison/scripts/regenerate_rust_client.sh b/crates/bindings-cpp/tests/client-comparison/scripts/regenerate_rust_client.sh
new file mode 100644
index 00000000000..3eed2cad3c4
--- /dev/null
+++ b/crates/bindings-cpp/tests/client-comparison/scripts/regenerate_rust_client.sh
@@ -0,0 +1,93 @@
+#!/bin/bash
+
+# Script to regenerate Rust SDK client from latest sdk-test module
+# This ensures we're always comparing against the most current Rust module
+
+set -e  # Exit on any error
+
+RUST_DIR="rust-sdk-test"
+SDK_TEST_DIR=$(realpath "../../../../modules/sdk-test")
+CLI_PATH=$(realpath "../../../../target/release/spacetimedb-cli")
+
+# Check if rebuild is needed
+check_needs_rebuild() {
+    local source_dir="$1"
+    local target_dir="$2"
+    
+    # If target directory doesn't exist or is empty, we need to build
+    if [ ! -d "$target_dir" ] || [ -z "$(ls -A "$target_dir" 2>/dev/null)" ]; then
+        return 0  # true - needs rebuild
+    fi
+    
+    # Find the newest source file in sdk-test
+    local newest_src=$(find "$source_dir/src" -type f \( -name "*.rs" -o -name "*.toml" \) -printf '%T@\n' 2>/dev/null | sort -n | tail -1)
+    
+    # Find the oldest generated file in rust-sdk-test
+    local oldest_gen=$(find "$target_dir" -type f -name "*.rs" -printf '%T@\n' 2>/dev/null | sort -n | head -1)
+    
+    # Check if any source is newer than generated files
+    if [ -n "$newest_src" ] && [ -n "$oldest_gen" ] && [ $(echo "$newest_src" | cut -d. -f1) -gt $(echo "$oldest_gen" | cut -d. -f1) ]; then
+        return 0  # true - needs rebuild
+    fi
+    
+    return 1  # false - no rebuild needed
+}
+
+echo "Regenerating Rust SDK client from latest sdk-test module..."
+echo "=========================================================="
+
+# Check if sdk-test needs rebuilding
+if check_needs_rebuild "$SDK_TEST_DIR" "$RUST_DIR"; then
+    echo "Source files changed - regenerating Rust client..."
+    echo "--------------------------------------------------"
+else
+    echo "✅ No source changes detected - using existing Rust client"
+    if [ -d "$RUST_DIR" ]; then
+        echo "Files present: $(find "$RUST_DIR" -name "*.rs" | wc -l)"
+    fi
+    echo ""
+    exit 0
+fi
+
+if [ ! -f "$CLI_PATH" ]; then
+    echo "ERROR: SpacetimeDB CLI not found at $CLI_PATH"
+    echo "Please build the CLI first, from the project root:"
+    echo "  cargo build --release -p spacetimedb-cli"
+    exit 1
+fi
+
+if [ ! -d "$SDK_TEST_DIR" ]; then
+    echo "ERROR: SDK test module not found at $SDK_TEST_DIR"
+    echo "Please ensure the sdk-test module exists."
+    exit 1
+fi
+
+# Clear existing Rust client directory
+echo "Clearing existing Rust client directory..."
+if [ -d "$RUST_DIR" ]; then
+    rm -rf "$RUST_DIR"/*
+    echo "Cleared $RUST_DIR/"
+else
+    mkdir -p "$RUST_DIR"
+    echo "Created $RUST_DIR/"
+fi
+
+# Generate new Rust client
+echo "Generating new Rust client from sdk-test module..."
+cd "$RUST_DIR"
+"$CLI_PATH" generate --lang rust --out-dir . --project-path "$SDK_TEST_DIR" >/dev/null 2>&1
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo "✅ Rust SDK client regenerated successfully!"
+    echo "Files generated: $(find . -name "*.rs" | wc -l)"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Run ./compare_clients.sh to generate new comparison"
+    echo "  2. Review client_diff_analysis.txt for updated differences"
+else
+    echo ""
+    echo "❌ Client generation failed!"
+    echo "Check the error messages above for details."
+    exit 1
+fi
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/.gitignore b/crates/bindings-cpp/tests/type-isolation-test/.gitignore
new file mode 100644
index 00000000000..c81f926d0c2
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/.gitignore
@@ -0,0 +1,11 @@
+# Build directories
+library_build/
+test_modules/build_*/
+
+# Test output files
+test_log.txt
+test_summary_live.txt
+test_summary.txt
+
+# Results directory
+results/
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/CMakeLists.module.txt b/crates/bindings-cpp/tests/type-isolation-test/CMakeLists.module.txt
new file mode 100644
index 00000000000..243fcc5b902
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/CMakeLists.module.txt
@@ -0,0 +1,64 @@
+cmake_minimum_required(VERSION 3.16)
+project(module)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Module source file
+if(NOT DEFINED MODULE_SOURCE)
+    message(FATAL_ERROR "MODULE_SOURCE must be defined")
+endif()
+
+# Output name
+if(NOT DEFINED OUTPUT_NAME)
+    set(OUTPUT_NAME "module")
+endif()
+
+# Library directory must be provided
+if(NOT DEFINED SPACETIMEDB_LIBRARY_DIR)
+    message(FATAL_ERROR "SPACETIMEDB_LIBRARY_DIR must be defined")
+endif()
+
+if(NOT DEFINED SPACETIMEDB_INCLUDE_DIR)
+    message(FATAL_ERROR "SPACETIMEDB_INCLUDE_DIR must be defined")
+endif()
+
+# Create the module executable
+add_executable(${OUTPUT_NAME} ${MODULE_SOURCE})
+
+# Include directories
+target_include_directories(${OUTPUT_NAME} PRIVATE ${SPACETIMEDB_INCLUDE_DIR})
+
+# Link the pre-built library
+target_link_directories(${OUTPUT_NAME} PRIVATE ${SPACETIMEDB_LIBRARY_DIR})
+target_link_libraries(${OUTPUT_NAME} PRIVATE spacetimedb_cpp_library)
+
+# Emscripten specific settings
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  # Export list as a single variable (no extra quoting per-platform)
+  set(EXPORTED_FUNCS "['_malloc','_free','___describe_module__','___call_reducer__']")
+
+  # Produce a standalone .wasm (no JS harness) with no entry point
+  target_link_options(${OUTPUT_NAME} PRIVATE
+    "SHELL:-sSTANDALONE_WASM=1"
+    "SHELL:-sWASM=1"
+    "SHELL:--no-entry"
+    # Exports
+    "SHELL:-sEXPORTED_FUNCTIONS=${EXPORTED_FUNCS}"
+    # Keep this ON for correctness; you can flip to 0 temporarily to probe
+    "SHELL:-sERROR_ON_UNDEFINED_SYMBOLS=1"
+    # Trim runtime
+    "SHELL:-sFILESYSTEM=0"
+    "SHELL:-sDISABLE_EXCEPTION_CATCHING=1"
+    "SHELL:-sALLOW_MEMORY_GROWTH=0"
+    "SHELL:-sINITIAL_MEMORY=16MB"
+    "SHELL:-sSUPPORT_LONGJMP=0"
+    "SHELL:-sSUPPORT_ERRNO=0"
+    # C++20 and O2 at link step (Emscripten accepts them here too)
+    "SHELL:-std=c++20"
+    "SHELL:-O2"
+  )
+
+  # Name the output lib.wasm
+  set_target_properties(${OUTPUT_NAME} PROPERTIES OUTPUT_NAME "lib" SUFFIX ".wasm")
+endif()
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/CMakeLists.txt b/crates/bindings-cpp/tests/type-isolation-test/CMakeLists.txt
new file mode 100644
index 00000000000..0aaee03ac0b
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.16)
+project(type-isolation-tests)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Build the SpacetimeDB library once
+set(SPACETIMEDB_CPP_LIBRARY_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../..")
+
+# Build the library as a static library
+add_subdirectory(${SPACETIMEDB_CPP_LIBRARY_PATH} ${CMAKE_CURRENT_BINARY_DIR}/spacetimedb_lib)
+
+# Export the library path for modules to use
+set(SPACETIMEDB_LIBRARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/spacetimedb_lib CACHE PATH "Path to built SpacetimeDB library")
+set(SPACETIMEDB_INCLUDE_DIR ${SPACETIMEDB_CPP_LIBRARY_PATH}/include CACHE PATH "Path to SpacetimeDB includes")
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/CMakeLists_module.txt b/crates/bindings-cpp/tests/type-isolation-test/CMakeLists_module.txt
new file mode 100644
index 00000000000..6b101206f6a
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/CMakeLists_module.txt
@@ -0,0 +1,64 @@
+cmake_minimum_required(VERSION 3.16)
+project(module)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Module source file
+if(NOT DEFINED MODULE_SOURCE)
+    message(FATAL_ERROR "MODULE_SOURCE must be defined")
+endif()
+
+# Output name
+if(NOT DEFINED OUTPUT_NAME)
+    set(OUTPUT_NAME "module")
+endif()
+
+# Library directory must be provided
+if(NOT DEFINED SPACETIMEDB_LIBRARY_DIR)
+    message(FATAL_ERROR "SPACETIMEDB_LIBRARY_DIR must be defined")
+endif()
+
+if(NOT DEFINED SPACETIMEDB_INCLUDE_DIR)
+    message(FATAL_ERROR "SPACETIMEDB_INCLUDE_DIR must be defined")
+endif()
+
+# Create the module executable
+add_executable(${OUTPUT_NAME} ${MODULE_SOURCE})
+
+# Include directories
+target_include_directories(${OUTPUT_NAME} PRIVATE ${SPACETIMEDB_INCLUDE_DIR})
+
+# Link the pre-built library
+target_link_directories(${OUTPUT_NAME} PRIVATE ${SPACETIMEDB_LIBRARY_DIR})
+target_link_libraries(${OUTPUT_NAME} PRIVATE spacetimedb_cpp_library)
+
+# Emscripten specific settings
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  # Export list as a single variable (no extra quoting per-platform)
+  set(EXPORTED_FUNCS "['_malloc','_free','___describe_module__','___call_reducer__']")
+
+  # Produce a standalone .wasm (no JS harness) with no entry point
+  target_link_options(lib PRIVATE
+    "SHELL:-sSTANDALONE_WASM=1"
+    "SHELL:-sWASM=1"
+    "SHELL:--no-entry"
+    # Exports
+    "SHELL:-sEXPORTED_FUNCTIONS=${EXPORTED_FUNCS}"
+    # Keep this ON for correctness; you can flip to 0 temporarily to probe
+    "SHELL:-sERROR_ON_UNDEFINED_SYMBOLS=1"
+    # Trim runtime
+    "SHELL:-sFILESYSTEM=0"
+    "SHELL:-sDISABLE_EXCEPTION_CATCHING=1"
+    "SHELL:-sALLOW_MEMORY_GROWTH=0"
+    "SHELL:-sINITIAL_MEMORY=16MB"
+    "SHELL:-sSUPPORT_LONGJMP=0"
+    "SHELL:-sSUPPORT_ERRNO=0"
+    # C++20 and O2 at link step (Emscripten accepts them here too)
+    "SHELL:-std=c++20"
+    "SHELL:-O2"
+  )
+
+  # Name the output lib.wasm
+  set_target_properties(lib PROPERTIES OUTPUT_NAME "lib" SUFFIX ".wasm")
+endif()
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/README.md b/crates/bindings-cpp/tests/type-isolation-test/README.md
new file mode 100644
index 00000000000..2f5da071b3a
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/README.md
@@ -0,0 +1,148 @@
+# SpacetimeDB C++ Type Isolation Test Suite
+
+Comprehensive test framework for systematically testing individual C++ types with the SpacetimeDB C++ library. Features parallel builds, real-time progress monitoring, and automated constraint validation testing.
+
+## Quick Start
+
+```bash
+# Run all tests with default parallelism (16 builds)
+./run_type_isolation_test.sh
+
+# Run with custom parallelism
+./run_type_isolation_test.sh 8
+
+# Monitor progress in real-time (separate terminal)
+watch -n 1 cat test_summary_live.txt
+```
+
+## Features
+
+- **Parallel Execution**: Configurable parallelism (default: 16 concurrent builds)
+- **Live Progress Monitoring**: Real-time status table with build/publish progress
+- **Optimized Builds**: Pre-builds library once, 2-3x faster than individual builds
+- **Smart Error Capture**: Clean error messages (up to 250 characters) in status table
+- **Auto-discovery**: Automatically tests all `.cpp` files in `test_modules/`
+- **State Recovery**: Resumes from previous state if interrupted
+
+## Test Categories
+
+### Basic Types (module01-12)
+- **Primitives**: U8-U256, I8-I256, F32/F64, Bool, String
+- **Special Types**: Identity, Timestamp, ConnectionId
+- **Complex Types**: Enums, structs, vectors, optionals
+- **Constraints**: Unique constraints and indexes
+
+### Constraint Validation (error_*)
+Tests that **intentionally fail** to validate error detection:
+- `error_autoinc_non_integer`: Compile-time error for AutoIncrement on non-integers
+- `error_invalid_index`: Compile-time error for Index on non-filterable types  
+- `error_multiple_pk`: Runtime error for multiple primary keys
+- `error_non_spacetimedb_type`: Compile-time error for unsupported types
+- `error_circular_ref`: Runtime error for circular type references
+- `error_scheduled_id_pk`: Runtime error for invalid scheduled tables
+
+### Debug & Edge Cases (debug_*, test_*)
+- Type combinations and interactions
+- Reducer and table scenarios
+- Specific debugging modules
+
+## Output
+
+- **`test_summary_live.txt`**: Live status table
+- **`test_log.txt`**: Detailed build/publish log with timestamps
+- **`test_modules/build_*/`**: Individual build directories
+- **`library_build/`**: Pre-built shared library
+
+## Status Table Format
+
+```
+Module                    | Build | Publish | WASM Size | Error
+--------------------------|-------|---------|-----------|------------------
+debug_large_struct        | ✅    | ✅      | 299KB     | 
+error_multiple_pk         | ✅    | ❌      | 306KB     | Multiple primary keys
+module01_basic_unsigned   | 🔨    | ⏳      | -         | 
+```
+
+**Status Indicators:** ⏳ Pending, 🔨 Building, 📤 Publishing, ✅ Passed, ❌ Failed, ⏭️ Skipped
+
+## Performance
+
+- **Total time**: ~1 minute for 57 modules
+- **Library pre-build**: ~10 seconds  
+- **Module builds**: 5-13 seconds each (vs 20-30 without optimization)
+- **Current success rate**: 89% (51/57 passing, 6 intentional failures)
+
+## Requirements
+
+- SpacetimeDB CLI and server
+- Emscripten (emcc, emcmake)
+- CMake 3.16+, C++20 compiler
+- Bash 4.0+ with associative arrays
+
+## Usage
+
+**Standard workflow:**
+```bash
+cd crates/bindings-cpp/tests/type-isolation-test
+./run_type_isolation_test.sh
+```
+
+**Monitor progress:**
+```bash
+watch -n 1 cat test_summary_live.txt
+```
+
+**Check detailed errors:**
+```bash
+grep "error" test_log.txt
+```
+
+## Troubleshooting
+
+**Server issues:**
+```bash
+curl -s http://127.0.0.1:3000/health  # Check server
+spacetime start                        # Start if needed
+```
+
+**Build failures:**
+- Check error messages in live table (250 char limit)
+- Review `test_log.txt` for full details
+- Build artifacts in `test_modules/build_<module>/`
+
+**Stuck updates:**
+```bash
+pkill -f update_table_from_log  # Kill orphaned processes
+./run_type_isolation_test.sh    # Restart
+```
+
+## Adding Tests
+
+1. Create `.cpp` file in `test_modules/` following naming: `test_<category>_<specific>.cpp`
+2. Include minimal code isolating the type being tested
+3. Run test suite to verify
+
+**Basic template:**
+```cpp
+#include <spacetimedb.h>
+using namespace SpacetimeDb;
+
+struct TestTable { /* fields */ };
+SPACETIMEDB_STRUCT(TestTable, /* field list */)
+SPACETIMEDB_TABLE(TestTable, test_table, Public)
+
+SPACETIMEDB_INIT(init) {
+    LOG_INFO("Test module initialized");
+}
+```
+
+## Integration
+
+**CI/CD example:**
+```bash
+./run_type_isolation_test.sh
+SUCCESS_RATE=$(grep "Success rate:" test_summary_live.txt | grep -o '[0-9]*%')
+[[ "${SUCCESS_RATE}" == "89%" ]] || exit 1  # Expected rate with intentional failures
+```
+
+The test suite validates the C++ SDK type system by testing individual types in isolation, ensuring reliable constraint validation and error detection.
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/run_type_isolation_test.sh b/crates/bindings-cpp/tests/type-isolation-test/run_type_isolation_test.sh
new file mode 100644
index 00000000000..942b63783bd
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/run_type_isolation_test.sh
@@ -0,0 +1,343 @@
+#!/bin/bash
+
+# Main test runner with live table updates
+# Uses test_log.txt for events and test_summary_live.txt for the table
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TMP_DIR="$SCRIPT_DIR/tmp"
+cd "$SCRIPT_DIR"
+
+# Detect the correct emcmake command for cross-platform compatibility
+detect_emcmake_command() {
+    if command -v emcmake >/dev/null 2>&1; then
+        echo "emcmake"
+    elif command -v emcmake.bat >/dev/null 2>&1; then
+        echo "emcmake.bat"
+    elif [ -n "$EMSDK" ] && [ -f "$EMSDK/emcmake.bat" ]; then
+        echo "$EMSDK/emcmake.bat"
+    else
+        echo "emcmake"  # fallback, will fail with clear error
+    fi
+}
+
+EMCMAKE_CMD=$(detect_emcmake_command)
+echo "Using emcmake command: $EMCMAKE_CMD"
+
+# Clear previous state
+echo "Starting fresh test run..."
+rm -f test_log.txt test_summary_live.txt
+touch test_log.txt
+
+# Ensure spacetime is running
+check_server_running() {
+    curl -s http://127.0.0.1:3000/health >/dev/null 2>&1
+}
+
+if ! check_server_running; then
+    echo "Starting SpacetimeDB server..."
+    nohup spacetime start > "$TMP_DIR/spacetime.log" 2>&1 &
+    
+    echo "Waiting for server to start..."
+    for i in {1..30}; do
+        if check_server_running; then
+            echo "Server started successfully!"
+            break
+        fi
+        sleep 1
+        if [ $i -eq 30 ]; then
+            echo "Error: Server failed to start after 30 seconds"
+            exit 1
+        fi
+    done
+else
+    echo "SpacetimeDB server already running"
+fi
+
+# Discover modules
+declare -a MODULES
+for cpp_file in test_modules/*.cpp; do
+    if [ -f "$cpp_file" ]; then
+        module_name=$(basename "${cpp_file%.cpp}")
+        MODULES+=("$module_name")
+    fi
+done
+
+# Sort modules
+IFS=$'\n' MODULES=($(sort <<<"${MODULES[*]}"))
+unset IFS
+
+echo "========================================="
+echo "Testing ${#MODULES[@]} modules"
+echo "Parallelism: ${1:-16} (use ./run_type_isolation_test.sh <num> to change)"
+echo "========================================="
+echo "Monitor table with: watch -n 1 cat test_summary_live.txt"
+echo "Monitor log with: tail -f test_log.txt"
+echo "========================================="
+
+# Create results directory
+mkdir -p results
+mkdir -p "$TMP_DIR"
+
+# Function to write log entry (always write to script dir)
+write_log() {
+    echo "$(date +%s)|$1|$2|$3" >> "$SCRIPT_DIR/test_log.txt"
+}
+
+# Start the table updater in background
+echo "Starting table updater..."
+./update_table_from_log.sh &
+TABLE_UPDATER_PID=$!
+
+# Array to track build job PIDs
+declare -a BUILD_PIDS=()
+
+# Give it a second to start
+sleep 1
+
+# Pre-build the SpacetimeDB library once
+NUM_CORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4)
+echo "========================================="
+echo "Pre-building SpacetimeDB library (using $NUM_CORES cores)..."
+echo "========================================="
+
+write_log "LIBRARY" "build" "start"
+
+LIBRARY_BUILD_DIR="library_build"
+rm -rf "$LIBRARY_BUILD_DIR"
+mkdir -p "$LIBRARY_BUILD_DIR"
+cd "$LIBRARY_BUILD_DIR"
+
+LIBRARY_ERROR_FILE="$TMP_DIR/library_build_error.txt"
+if ! $EMCMAKE_CMD cmake ../../../ > "$LIBRARY_ERROR_FILE" 2>&1; then
+    write_log "LIBRARY" "build" "fail"
+    ERROR_MSG=$(grep -E "(error:|Error:|ERROR:)" "$LIBRARY_ERROR_FILE" 2>/dev/null | head -5 | tr '\n' ' ')
+    if [ -z "$ERROR_MSG" ]; then
+        ERROR_MSG=$(tail -20 "$LIBRARY_ERROR_FILE" 2>/dev/null | tr '\n' ' ')
+    fi
+    ERROR_MSG="${ERROR_MSG:0:500}"
+    write_log "LIBRARY" "error" "${ERROR_MSG:-Failed to configure library build}"
+    echo "❌ Failed to configure library build"
+    echo "Error details:"
+    tail -30 "$LIBRARY_ERROR_FILE"
+    echo "========================================="
+    echo "Library build failed. Updating table with error details..."
+    # Force table updater to process the error
+    sleep 3  # Give more time for table updater to process
+    # Send SIGUSR1 to force immediate update (if the script supports it)
+    kill -USR1 $TABLE_UPDATER_PID 2>/dev/null || true
+    sleep 1  # Wait for final update
+    echo "Check test_summary_live.txt for error details."
+    kill $TABLE_UPDATER_PID 2>/dev/null
+    exit 1
+fi
+
+# Use all available cores for parallel compilation (already set above)
+if ! cmake --build . -j$NUM_CORES > "$LIBRARY_ERROR_FILE" 2>&1; then
+    # Extract more comprehensive error messages FIRST
+    ERROR_MSG=$(grep -E "(error:|Error:|ERROR:|undefined reference|fatal error)" "$LIBRARY_ERROR_FILE" 2>/dev/null | head -10 | tr '\n' ' ')
+    if [ -z "$ERROR_MSG" ]; then
+        ERROR_MSG=$(tail -50 "$LIBRARY_ERROR_FILE" 2>/dev/null | tr '\n' ' ')
+    fi
+    ERROR_MSG="${ERROR_MSG:0:800}"  # Allow more space for library errors
+    
+    # Write to log BEFORE any output
+    write_log "LIBRARY" "build" "fail"
+    write_log "LIBRARY" "error" "${ERROR_MSG:-Failed to build library}"
+    
+    # Force flush the log file
+    sync
+    
+    echo "❌ Failed to build library"
+    echo "Error details:"
+    tail -50 "$LIBRARY_ERROR_FILE"
+    echo "========================================="
+    echo "Library build failed. Updating table with error details..."
+    
+    # Give table updater more time to read the log and update
+    sleep 4  # Increased sleep time
+    
+    echo "Check test_summary_live.txt for error details."
+    
+    # Gracefully terminate table updater
+    kill -TERM $TABLE_UPDATER_PID 2>/dev/null
+    wait $TABLE_UPDATER_PID 2>/dev/null
+    
+    exit 1
+fi
+rm -f "$LIBRARY_ERROR_FILE"
+
+cd ..
+write_log "LIBRARY" "build" "pass"
+echo "✅ Library built successfully"
+
+# Create the expected directory structure and copy the library
+mkdir -p "$LIBRARY_BUILD_DIR/spacetimedb_lib"
+cp "$LIBRARY_BUILD_DIR/libspacetimedb_cpp_library.a" "$LIBRARY_BUILD_DIR/spacetimedb_lib/"
+
+echo "========================================="
+
+# Export library paths for module builds
+export SPACETIMEDB_LIBRARY_DIR="$(pwd)/$LIBRARY_BUILD_DIR/spacetimedb_lib"
+export SPACETIMEDB_INCLUDE_DIR="$(pwd)/../../include"
+
+# Function to publish module in background
+publish_module() {
+    local module=$1
+    local wasm="test_modules/build_${module}/lib.wasm"
+    
+    if [ ! -f "$wasm" ]; then
+        write_log "$module" "publish" "skip"
+        return
+    fi
+    
+    # Get size
+    local size=$(stat -c%s "$wasm" 2>/dev/null || echo "0")
+    local size_kb=$((size / 1024))
+    write_log "$module" "size" "${size_kb}KB"
+    
+    # Update to publishing
+    write_log "$module" "publish" "start"
+    
+    local db_name=$(echo "testmod-${module}" | sed 's/_/-/g')
+    echo "  📤 Publishing $module as $db_name..."
+    local PUBLISH_ERROR_FILE="$TMP_DIR/publish_error_${module}.txt"
+    if timeout 60 spacetime publish --bin-path "$wasm" -c "$db_name" -y > /dev/null 2>"$PUBLISH_ERROR_FILE"; then
+        write_log "$module" "publish" "pass"
+        echo "  ✅ Published $module"
+        rm -f "$PUBLISH_ERROR_FILE"
+    else
+        write_log "$module" "publish" "fail"
+        # Capture more comprehensive error message
+        # Get the full error starting from "Error:" line and including several lines after
+        ERROR_MSG=$(sed -n '/Error:/,+10p' "$PUBLISH_ERROR_FILE" 2>/dev/null | tr '\n' ' ')
+        if [ -z "$ERROR_MSG" ]; then
+            # Try getting the last 15 lines which usually contain the actual error
+            ERROR_MSG=$(tail -n 15 "$PUBLISH_ERROR_FILE" 2>/dev/null | tr '\n' ' ')
+        fi
+        if [ -z "$ERROR_MSG" ]; then
+            # Last resort - get the whole file if it's small
+            ERROR_MSG=$(cat "$PUBLISH_ERROR_FILE" 2>/dev/null | tr '\n' ' ')
+        fi
+        # Truncate to 500 chars (much more than before)
+        ERROR_MSG="${ERROR_MSG:0:500}"
+        write_log "$module" "error" "${ERROR_MSG:-Publish failed}"
+        echo "  ❌ Publish failed: $module"
+        rm -f "$PUBLISH_ERROR_FILE"
+    fi
+}
+
+# Function to build a module
+build_module() {
+    local module=$1
+    local count=$2
+    local total=$3
+    
+    echo "[$count/$total] Building $module..."
+    
+    # Log build start
+    write_log "$module" "build" "start"
+    
+    # Create build directory under test_modules
+    BUILD_DIR="test_modules/build_${module}"
+    rm -rf "$BUILD_DIR"
+    mkdir -p "$BUILD_DIR"
+    
+    cd "$BUILD_DIR"
+    
+    # Try to build - use the module-specific CMake with pre-built library
+    BUILD_ERROR_FILE="$TMP_DIR/build_error_${module}.txt"
+    
+    # Copy the module CMakeLists
+    cp ../../CMakeLists.module.txt CMakeLists.txt
+    
+    if $EMCMAKE_CMD cmake . \
+        -DMODULE_SOURCE="../../test_modules/${module}.cpp" \
+        -DOUTPUT_NAME="${module}" \
+        -DSPACETIMEDB_LIBRARY_DIR="$SPACETIMEDB_LIBRARY_DIR" \
+        -DSPACETIMEDB_INCLUDE_DIR="$SPACETIMEDB_INCLUDE_DIR" > /dev/null 2>"$BUILD_ERROR_FILE"; then
+        
+        if cmake --build . > /dev/null 2>"$BUILD_ERROR_FILE"; then
+            cd ../..
+            write_log "$module" "build" "pass"
+            echo "  ✅ Build successful: $module"
+            rm -f "$BUILD_ERROR_FILE"
+            # Start publish in background
+            publish_module "$module" &
+        else
+            cd ../..
+            write_log "$module" "build" "fail"
+            # Capture first 1000 chars of error
+            ERROR_MSG=$(head -n 10 "$BUILD_ERROR_FILE" 2>/dev/null | tr '\n' ' ' | cut -c1-1000)
+            write_log "$module" "error" "${ERROR_MSG:-Build failed}"
+            echo "  ❌ Build failed: $module"
+            rm -f "$BUILD_ERROR_FILE"
+        fi
+    else
+        cd ../..
+        write_log "$module" "build" "fail"
+        # Capture first 1000 chars of error
+        ERROR_MSG=$(head -n 10 "$BUILD_ERROR_FILE" 2>/dev/null | tr '\n' ' ' | cut -c1-1000)
+        write_log "$module" "error" "${ERROR_MSG:-CMake failed}"
+        echo "  ❌ CMake configuration failed: $module"
+        rm -f "$BUILD_ERROR_FILE"
+    fi
+}
+
+# Parallel build management with configurable parallelism
+MAX_PARALLEL=16  # Default to 16, or use first argument
+echo "Building modules with parallelism of $MAX_PARALLEL..."
+
+# Build modules maintaining constant parallelism
+COUNT=0
+TOTAL=${#MODULES[@]}
+for module in "${MODULES[@]}"; do
+    ((COUNT++))
+    
+    # Wait if we have max parallel jobs running
+    while (( $(jobs -r | wc -l) >= MAX_PARALLEL )); do
+        sleep 0.2
+    done
+    
+    # Start new build job
+    build_module "$module" "$COUNT" "$TOTAL" &
+    BUILD_PIDS+=($!)
+    
+    # Small delay to avoid race conditions
+    sleep 0.05
+done
+
+# Wait for all remaining builds to complete (excluding table updater)
+for pid in "${BUILD_PIDS[@]}"; do
+    wait $pid 2>/dev/null
+done
+
+echo ""
+echo "Waiting for any remaining background jobs..."
+# Give a moment for any publish jobs to complete
+sleep 2
+
+# Check if there are any publish jobs still running (excluding table updater)
+for i in {1..10}; do
+    # Count background jobs excluding the table updater
+    JOB_COUNT=$(jobs -p | grep -v "^$TABLE_UPDATER_PID$" | wc -l)
+    if [ $JOB_COUNT -eq 0 ]; then
+        break
+    fi
+    sleep 1
+done
+
+# Signal completion
+write_log "COMPLETE" "COMPLETE" "COMPLETE"
+
+# Wait a bit for table updater to finish
+sleep 2
+
+# Kill table updater
+kill $TABLE_UPDATER_PID 2>/dev/null
+
+echo
+echo "========================================="
+echo "Test Complete!"
+echo "========================================="
+echo "Final table in: test_summary_live.txt"
+echo "Log file: test_log.txt"
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_constraint_simple.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_constraint_simple.cpp
new file mode 100644
index 00000000000..341ce25951d
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_constraint_simple.cpp
@@ -0,0 +1,22 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Simple test with just one primary key constraint
+struct SimpleConstraintTest {
+    uint32_t id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(SimpleConstraintTest, id, data)
+SPACETIMEDB_TABLE(SimpleConstraintTest, simple_constraint_test, SpacetimeDb::Public)
+FIELD_PrimaryKey(simple_constraint_test, id);
+
+SPACETIMEDB_INIT(init) {
+    LOG_INFO("Simple constraint test initialized");
+}
+
+SPACETIMEDB_REDUCER(test_simple_constraint, SpacetimeDb::ReducerContext ctx) {
+    LOG_INFO("Testing simple constraint");
+    SimpleConstraintTest test{1, "Test data"};
+    ctx.db[simple_constraint_test].insert(test);
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_large_struct.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_large_struct.cpp
new file mode 100644
index 00000000000..d5fc14a1389
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_large_struct.cpp
@@ -0,0 +1,46 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+// ISOLATION TEST: Large struct causing client codegen issues
+// Test if EveryPrimitiveStruct alone causes the "non-special product or sum type" error
+
+// Recreate the problematic large struct
+struct EveryPrimitiveStruct {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    Identity q;
+    ConnectionId r;
+    Timestamp s;
+    TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// Simple table using the large struct
+struct TestTable { 
+    EveryPrimitiveStruct s; 
+    int32_t id;
+};
+SPACETIMEDB_STRUCT(TestTable, s, id)
+SPACETIMEDB_TABLE(TestTable, test_table, Public)
+
+// Simple reducer without problematic parameters
+SPACETIMEDB_REDUCER(test_basic, ReducerContext ctx)
+{
+    LOG_INFO("Basic reducer called");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_minimal_fail.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_minimal_fail.cpp
new file mode 100644
index 00000000000..f0b0cddc2be
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_minimal_fail.cpp
@@ -0,0 +1,14 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+
+// The problematic pattern: SimpleEnum used in multiple contexts using new unified syntax
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+
+// Direct table using SimpleEnum
+struct DirectTable { SimpleEnum e; };
+SPACETIMEDB_STRUCT(DirectTable, e)
+SPACETIMEDB_TABLE(DirectTable, direct_table, Public)
+
+// NO reducers - just the table registration conflict
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_optional_large_struct.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_optional_large_struct.cpp
new file mode 100644
index 00000000000..68d41cdb9b1
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_optional_large_struct.cpp
@@ -0,0 +1,45 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+// ISOLATION TEST: std::optional<LargeStruct> causing client codegen issues
+// Testing if optional wrapper around large struct causes the error
+
+// The large struct (we know this alone works)
+struct EveryPrimitiveStruct {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    Identity q;
+    ConnectionId r;
+    Timestamp s;
+    TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// TEST: Optional wrapper around large struct - does this cause client codegen error?
+struct OptionLargeStruct { 
+    std::optional<EveryPrimitiveStruct> s; 
+};
+SPACETIMEDB_STRUCT(OptionLargeStruct, s)
+SPACETIMEDB_TABLE(OptionLargeStruct, option_large_struct, Public)
+
+// Simple reducer without problematic parameters
+SPACETIMEDB_REDUCER(test_basic, ReducerContext ctx)
+{
+    LOG_INFO("Basic reducer called");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_simple_enum.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_simple_enum.cpp
new file mode 100644
index 00000000000..25d4254cb74
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_simple_enum.cpp
@@ -0,0 +1,34 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+
+// Simple enum using new unified syntax
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+
+// Complex enum using new unified syntax
+SPACETIMEDB_ENUM(TestEnum,
+    (SimpleEnums, std::vector<SimpleEnum>)
+)
+
+// Table that uses SimpleEnum directly
+struct SimpleEnumTable { 
+    SimpleEnum e; 
+    int32_t id;
+};
+SPACETIMEDB_STRUCT(SimpleEnumTable, e, id)
+SPACETIMEDB_TABLE(SimpleEnumTable, simple_enum_table, Public)
+
+// Table that uses TestEnum (containing vector<SimpleEnum>)
+struct TestEnumTable { 
+    TestEnum te;
+    int32_t id;
+};
+SPACETIMEDB_STRUCT(TestEnumTable, te, id)
+SPACETIMEDB_TABLE(TestEnumTable, test_enum_table, Public)
+
+// Reducer that uses SimpleEnum as parameter - this might be the trigger
+SPACETIMEDB_REDUCER(insert_enum, ReducerContext ctx, SimpleEnum e, int32_t id)
+{
+    ctx.db.table<SimpleEnumTable>("simple_enum_table").insert(SimpleEnumTable{e, id});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special.cpp
new file mode 100644
index 00000000000..e77922597ce
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special.cpp
@@ -0,0 +1,13 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Minimal test for debugging special type vectors
+
+
+// Single table with vector of Identity
+struct DebugIdentityVec { 
+    std::vector<Identity> ids; 
+};
+SPACETIMEDB_STRUCT(DebugIdentityVec, ids)
+SPACETIMEDB_TABLE(DebugIdentityVec, debug_identity_vec, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special_constraints.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special_constraints.cpp
new file mode 100644
index 00000000000..533c759ec9b
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special_constraints.cpp
@@ -0,0 +1,29 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// ISOLATION TEST: Test constraints on special types
+// Based on working test_special_minimal, add constraints to see if they cause WASM traps
+
+// Working baseline: Simple special type table
+struct TestIdentity { Identity i; };
+SPACETIMEDB_STRUCT(TestIdentity, i)
+SPACETIMEDB_TABLE(TestIdentity, test_identity, Public)
+
+// TEST: Add Unique constraint on Identity - does this cause WASM trap?
+struct UniqueIdentity { Identity i; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueIdentity, i, data)
+SPACETIMEDB_TABLE(UniqueIdentity, unique_identity, Public)
+FIELD_Unique(unique_identity, i)
+
+// TEST: Add PrimaryKey constraint on Identity - does this cause WASM trap?
+struct PkIdentity { Identity i; int32_t data; };
+SPACETIMEDB_STRUCT(PkIdentity, i, data)  
+SPACETIMEDB_TABLE(PkIdentity, pk_identity, Public)
+FIELD_PrimaryKey(pk_identity, i)
+
+// Simple reducer without special type parameters
+SPACETIMEDB_REDUCER(test_basic, ReducerContext ctx)
+{
+    LOG_INFO("Basic reducer called");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special_reducers.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special_reducers.cpp
new file mode 100644
index 00000000000..77ed5e229ad
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_special_reducers.cpp
@@ -0,0 +1,60 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// ISOLATION TEST: Test direct special type reducer parameters
+// Based on working debug_special_constraints, add direct special type parameters
+
+// Working baseline: Simple special type tables (we know these work)
+struct TestIdentity { Identity i; };
+SPACETIMEDB_STRUCT(TestIdentity, i)
+SPACETIMEDB_TABLE(TestIdentity, test_identity, Public)
+
+struct TestConnectionId { ConnectionId c; };
+SPACETIMEDB_STRUCT(TestConnectionId, c)  
+SPACETIMEDB_TABLE(TestConnectionId, test_connection_id, Public)
+
+// Parameter wrappers to avoid direct special type parameters (causes WASM traps)
+struct IdentityParam { Identity i; };
+SPACETIMEDB_STRUCT(IdentityParam, i)
+
+struct ConnectionIdParam { ConnectionId c; };
+SPACETIMEDB_STRUCT(ConnectionIdParam, c)
+
+// TEST: Use wrapped special type parameters to avoid WASM trap
+SPACETIMEDB_REDUCER(insert_identity, ReducerContext ctx, IdentityParam param)
+{
+    ctx.db.table<TestIdentity>("test_identity").insert(TestIdentity{param.i});
+}
+
+SPACETIMEDB_REDUCER(insert_connection_id, ReducerContext ctx, ConnectionIdParam param)
+{
+    ctx.db.table<TestConnectionId>("test_connection_id").insert(TestConnectionId{param.c});
+}
+
+// Control: basic reducer without special type parameters (known to work)
+SPACETIMEDB_REDUCER(test_basic, ReducerContext ctx)
+{
+    LOG_INFO("Basic reducer called");
+}
+
+// TEST: Direct special type parameters (expected to cause WASM trap)
+SPACETIMEDB_REDUCER(insert_direct_identity, ReducerContext ctx, Identity i)
+{
+    ctx.db.table<TestIdentity>("test_identity").insert(TestIdentity{i});
+}
+
+SPACETIMEDB_REDUCER(insert_direct_connection_id, ReducerContext ctx, ConnectionId c)
+{
+    ctx.db.table<TestConnectionId>("test_connection_id").insert(TestConnectionId{c});
+}
+
+SPACETIMEDB_REDUCER(insert_direct_timestamp, ReducerContext ctx, Timestamp t)
+{
+    LOG_INFO("Received timestamp parameter");
+}
+
+SPACETIMEDB_REDUCER(insert_direct_time_duration, ReducerContext ctx, TimeDuration d)
+{
+    LOG_INFO("Received duration parameter");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_trace.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_trace.cpp
new file mode 100644
index 00000000000..9f03bb2690e
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_trace.cpp
@@ -0,0 +1,14 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+// Simple table with optional field
+struct DebugTable {
+    uint32_t id;
+    std::optional<int32_t> maybe_value;
+};
+
+SPACETIMEDB_STRUCT(DebugTable, id, maybe_value)
+SPACETIMEDB_TABLE(DebugTable, debug_table, Public)
+
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_vector_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_vector_only.cpp
new file mode 100644
index 00000000000..4f79c558304
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_vector_only.cpp
@@ -0,0 +1,23 @@
+#include <spacetimedb.h>
+#include <vector>
+
+using namespace SpacetimeDb;
+
+// Minimal test - just one vector variant to see how it's serialized
+
+SPACETIMEDB_ENUM(SimpleVectorEnum,
+    (Bytes, std::vector<uint8_t>)
+)
+
+struct VectorTable { 
+    SimpleVectorEnum e; 
+};
+SPACETIMEDB_STRUCT(VectorTable, e)
+SPACETIMEDB_TABLE(VectorTable, vector_table, Public)
+
+SPACETIMEDB_REDUCER(insert_test, ReducerContext ctx)
+{
+    std::vector<uint8_t> bytes = {1, 2, 3};
+    SimpleVectorEnum e = bytes;
+    ctx.db.table<VectorTable>("vector_table").insert(VectorTable{e});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_vector_only_simple.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_vector_only_simple.cpp
new file mode 100644
index 00000000000..4af1c128033
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/debug_vector_only_simple.cpp
@@ -0,0 +1,19 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+
+// SimpleEnum defined but ONLY used in vector context using new unified syntax
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+
+// Variant enum with vector<SimpleEnum> - this triggers the problem using new unified syntax
+SPACETIMEDB_ENUM(VectorEnum,
+    (SimpleEnums, std::vector<SimpleEnum>)
+)
+
+// Table using VectorEnum (which contains vector<SimpleEnum>)
+struct VectorTable { VectorEnum ve; };
+SPACETIMEDB_STRUCT(VectorTable, ve)
+SPACETIMEDB_TABLE(VectorTable, vector_table, Public)
+
+// NO direct SimpleEnum usage - only through vector
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_autoinc_non_integer.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_autoinc_non_integer.cpp
new file mode 100644
index 00000000000..f9f0fc10212
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_autoinc_non_integer.cpp
@@ -0,0 +1,144 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test auto-increment on non-integer column types
+// AutoInc should only work on integer types (uint32_t, uint64_t, etc.)
+
+// AutoInc on string field - INVALID
+struct StringAutoInc {
+    std::string id;  // Strings can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(StringAutoInc, id, data)
+SPACETIMEDB_TABLE(StringAutoInc, string_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(string_autoinc_table, id);  // ERROR: AutoInc on string!
+
+// AutoInc on float field - INVALID
+struct FloatAutoInc {
+    float id;  // Floats can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(FloatAutoInc, id, data)
+SPACETIMEDB_TABLE(FloatAutoInc, float_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(float_autoinc_table, id);  // ERROR: AutoInc on float!
+
+// AutoInc on double field - INVALID
+struct DoubleAutoInc {
+    double id;  // Doubles can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(DoubleAutoInc, id, data)
+SPACETIMEDB_TABLE(DoubleAutoInc, double_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(double_autoinc_table, id);  // ERROR: AutoInc on double!
+
+// AutoInc on bool field - INVALID
+struct BoolAutoInc {
+    bool id;  // Bools can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(BoolAutoInc, id, data)
+SPACETIMEDB_TABLE(BoolAutoInc, bool_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(bool_autoinc_table, id);  // ERROR: AutoInc on bool!
+
+// AutoInc on Identity field - INVALID (Identity is not an integer)
+struct IdentityAutoInc {
+    Identity id;  // Identity can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(IdentityAutoInc, id, data)
+SPACETIMEDB_TABLE(IdentityAutoInc, identity_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(identity_autoinc_table, id);  // ERROR: AutoInc on Identity!
+
+// AutoInc on struct field - INVALID
+struct NestedStruct {
+    uint32_t x;
+    uint32_t y;
+};
+SPACETIMEDB_STRUCT(NestedStruct, x, y)
+
+struct StructAutoInc {
+    NestedStruct id;  // Structs can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(StructAutoInc, id, data)
+SPACETIMEDB_TABLE(StructAutoInc, struct_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(struct_autoinc_table, id);  // ERROR: AutoInc on struct!
+
+// AutoInc on vector field - INVALID
+struct VectorAutoInc {
+    std::vector<uint32_t> id;  // Vectors can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(VectorAutoInc, id, data)
+SPACETIMEDB_TABLE(VectorAutoInc, vector_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(vector_autoinc_table, id);  // ERROR: AutoInc on vector!
+
+// AutoInc on optional field - INVALID
+struct OptionalAutoInc {
+    std::optional<uint32_t> id;  // Optionals can't auto-increment!
+    std::string data;
+};
+SPACETIMEDB_STRUCT(OptionalAutoInc, id, data)
+SPACETIMEDB_TABLE(OptionalAutoInc, optional_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(optional_autoinc_table, id);  // ERROR: AutoInc on optional!
+
+// Valid AutoInc tables for comparison
+struct ValidU32AutoInc {
+    uint32_t id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(ValidU32AutoInc, id, data)
+SPACETIMEDB_TABLE(ValidU32AutoInc, valid_u32_autoinc, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(valid_u32_autoinc, id);  // Correct: AutoInc on uint32_t
+
+struct ValidU64AutoInc {
+    uint64_t id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(ValidU64AutoInc, id, data)
+SPACETIMEDB_TABLE(ValidU64AutoInc, valid_u64_autoinc, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(valid_u64_autoinc, id);  // Correct: AutoInc on uint64_t
+
+struct ValidI32AutoInc {
+    int32_t id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(ValidI32AutoInc, id, data)
+SPACETIMEDB_TABLE(ValidI32AutoInc, valid_i32_autoinc, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(valid_i32_autoinc, id);  // Correct: AutoInc on int32_t
+
+struct ValidI64AutoInc {
+    int64_t id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(ValidI64AutoInc, id, data)
+SPACETIMEDB_TABLE(ValidI64AutoInc, valid_i64_autoinc, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(valid_i64_autoinc, id);  // Correct: AutoInc on int64_t
+
+// Test reducer
+SPACETIMEDB_REDUCER(test_autoinc_types, SpacetimeDb::ReducerContext ctx)
+{
+    LOG_INFO("Testing auto-increment on non-integer types - should fail validation");
+    
+    // These should all fail if validation works
+    StringAutoInc string_ai{"", "String AutoInc"};
+    ctx.db[string_autoinc_table].insert(string_ai);
+    
+    FloatAutoInc float_ai{0.0f, "Float AutoInc"};
+    ctx.db[float_autoinc_table].insert(float_ai);
+    
+    // Valid inserts
+    ValidU32AutoInc valid_u32{0, "Valid U32"};
+    ctx.db[valid_u32_autoinc].insert(valid_u32);
+    
+    ValidU64AutoInc valid_u64{0, "Valid U64"};
+    ctx.db[valid_u64_autoinc].insert(valid_u64);
+}
+
+// Init reducer
+SPACETIMEDB_INIT(init)
+{
+    LOG_INFO("Auto-increment on non-integer types test");
+    LOG_INFO("AutoInc should only work on integer types");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_circular_ref.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_circular_ref.cpp
new file mode 100644
index 00000000000..b02a95069ca
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_circular_ref.cpp
@@ -0,0 +1,26 @@
+#include <spacetimedb.h>
+#include <vector>
+#include <optional>
+// Test circular references: A → B → C → A
+// This should be caught by the type system
+
+
+
+
+// StructC references StructA (completing the circle)
+struct StructA {
+    uint32_t id;
+    std::vector<StructA> a_ref; //(circular!)
+};
+
+// Register the structs
+SPACETIMEDB_STRUCT(StructA, id, a_ref)
+
+// Try to use them as tables
+SPACETIMEDB_TABLE(StructA, struct_a, SpacetimeDb::Public)
+
+// Test reducer
+SPACETIMEDB_REDUCER(test_circular_ref, SpacetimeDb::ReducerContext ctx)
+{
+    LOG_INFO("This should never execute - circular references should be detected");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_invalid_index.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_invalid_index.cpp
new file mode 100644
index 00000000000..90aa4157223
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_invalid_index.cpp
@@ -0,0 +1,184 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test FIELD_ macro validation for index constraints on non-filterable types
+
+// Complex struct that can't be indexed
+struct ComplexData {
+    uint32_t x;
+    uint32_t y;
+    std::string label;
+};
+SPACETIMEDB_STRUCT(ComplexData, x, y, label)
+
+// Table with struct field - define without constraints in SPACETIMEDB_TABLE
+struct UniqueOnStruct {
+    uint32_t id;
+    ComplexData data;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(UniqueOnStruct, id, data, name)
+
+// Register table without any constraints
+SPACETIMEDB_TABLE(UniqueOnStruct, unique_struct_table, SpacetimeDb::Public)
+
+// Now add constraints using FIELD_ macros - this should fail at compile time!
+FIELD_PrimaryKey(unique_struct_table, id)           // OK: Any type can be primary key
+FIELD_Unique(unique_struct_table, data)             // ERROR: ComplexData is not filterable!
+FIELD_Index(unique_struct_table, name)              // OK: String is filterable
+
+// Table with vector field
+struct UniqueOnVector {
+    uint32_t id;
+    std::vector<uint32_t> items;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(UniqueOnVector, id, items, name)
+SPACETIMEDB_TABLE(UniqueOnVector, unique_vector_table, SpacetimeDb::Public)
+
+// Add field constraints
+FIELD_PrimaryKey(unique_vector_table, id)
+FIELD_Unique(unique_vector_table, items)            // ERROR: Vector is not filterable!
+
+// Table with optional field
+struct UniqueOnOptional {
+    uint32_t id;
+    std::optional<uint32_t> maybe_value;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(UniqueOnOptional, id, maybe_value, name)
+SPACETIMEDB_TABLE(UniqueOnOptional, unique_optional_table, SpacetimeDb::Public)
+
+// Add field constraints
+FIELD_PrimaryKey(unique_optional_table, id)
+FIELD_Unique(unique_optional_table, maybe_value)    // ERROR: Optional is not filterable!
+
+// Table with float field
+struct UniqueOnFloat {
+    uint32_t id;
+    float value;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(UniqueOnFloat, id, value, name)
+SPACETIMEDB_TABLE(UniqueOnFloat, unique_float_table, SpacetimeDb::Public)
+
+// Add field constraints
+FIELD_PrimaryKey(unique_float_table, id)
+FIELD_Unique(unique_float_table, value)             // ERROR: Float is not filterable!
+
+// Table with double field
+struct IndexOnDouble {
+    uint32_t id;
+    double value;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(IndexOnDouble, id, value, name)
+SPACETIMEDB_TABLE(IndexOnDouble, index_double_table, SpacetimeDb::Public)
+
+// Add field constraints
+FIELD_PrimaryKey(index_double_table, id)
+FIELD_Index(index_double_table, value)              // ERROR: Double is not filterable!
+
+// Table with ScheduleAt field
+struct UniqueOnScheduleAt {
+    uint32_t id;
+    ScheduleAt schedule;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(UniqueOnScheduleAt, id, schedule, name)
+SPACETIMEDB_TABLE(UniqueOnScheduleAt, unique_schedule_table, SpacetimeDb::Public)
+
+// Add field constraints
+FIELD_PrimaryKey(unique_schedule_table, id)
+FIELD_Unique(unique_schedule_table, schedule)       // ERROR: ScheduleAt is not filterable!
+
+// Valid indexed tables for comparison
+struct ValidUniqueInt {
+    uint32_t id;
+    uint32_t unique_code;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(ValidUniqueInt, id, unique_code, name)
+SPACETIMEDB_TABLE(ValidUniqueInt, valid_unique_int_table, SpacetimeDb::Public)
+
+// These should all work fine
+FIELD_PrimaryKey(valid_unique_int_table, id)
+FIELD_Unique(valid_unique_int_table, unique_code)   // OK: Integer is filterable
+
+struct ValidIndexString {
+    uint32_t id;
+    std::string indexed_name;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(ValidIndexString, id, indexed_name, data)
+SPACETIMEDB_TABLE(ValidIndexString, valid_index_string_table, SpacetimeDb::Public)
+
+FIELD_PrimaryKey(valid_index_string_table, id)
+FIELD_Index(valid_index_string_table, indexed_name) // OK: String is filterable
+
+struct ValidUniqueIdentity {
+    uint32_t id;
+    Identity user_id;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(ValidUniqueIdentity, id, user_id, name)
+SPACETIMEDB_TABLE(ValidUniqueIdentity, valid_unique_identity_table, SpacetimeDb::Public)
+
+FIELD_PrimaryKey(valid_unique_identity_table, id)
+FIELD_Unique(valid_unique_identity_table, user_id)  // OK: Identity is filterable
+
+struct ValidIndexTimestamp {
+    uint32_t id;
+    Timestamp created_at;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(ValidIndexTimestamp, id, created_at, data)
+SPACETIMEDB_TABLE(ValidIndexTimestamp, valid_index_timestamp_table, SpacetimeDb::Public)
+
+FIELD_PrimaryKey(valid_index_timestamp_table, id)
+FIELD_Index(valid_index_timestamp_table, created_at) // OK: Timestamp is filterable
+
+struct ValidUniqueBool {
+    uint32_t id;
+    bool is_active;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(ValidUniqueBool, id, is_active, data)
+SPACETIMEDB_TABLE(ValidUniqueBool, valid_unique_bool_table, SpacetimeDb::Public)
+
+FIELD_PrimaryKey(valid_unique_bool_table, id)
+FIELD_Unique(valid_unique_bool_table, is_active)    // OK: Bool is filterable (though unusual)
+
+// Test reducer
+SPACETIMEDB_REDUCER(test_field_macro_validation, SpacetimeDb::ReducerContext ctx)
+{
+    LOG_INFO("Testing FIELD_ macro validation");
+    
+    // If this code runs, it means validation failed!
+    // The module should fail to compile due to FIELD_ macro validation
+    
+    ComplexData complex{1, 2, "Complex"};
+    UniqueOnStruct bad_unique{1, complex, "Bad unique"};
+    ctx.db[unique_struct_table].insert(bad_unique);
+    
+    ValidUniqueInt valid_int{1, 100, "Valid unique int"};
+    ctx.db[valid_unique_int_table].insert(valid_int);
+    
+    ValidIndexString valid_string{1, "indexed", "Valid index string"};
+    ctx.db[valid_index_string_table].insert(valid_string);
+}
+
+// Init reducer
+SPACETIMEDB_INIT(init)
+{
+    LOG_INFO("FIELD_ macro validation test");
+    LOG_INFO("This module should FAIL to compile if validation is working");
+    LOG_INFO("Errors expected for:");
+    LOG_INFO("- FIELD_Unique on ComplexData");
+    LOG_INFO("- FIELD_Unique on vector");
+    LOG_INFO("- FIELD_Unique on optional");
+    LOG_INFO("- FIELD_Unique on float");
+    LOG_INFO("- FIELD_Index on double");
+    LOG_INFO("- FIELD_Unique on ScheduleAt");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_multiple_pk.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_multiple_pk.cpp
new file mode 100644
index 00000000000..7b3bae24f82
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_multiple_pk.cpp
@@ -0,0 +1,98 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test multiple primary keys in a single table
+// SpacetimeDB should only allow ONE primary key per table
+
+// Table with two PrimaryKey fields - INVALID
+struct DoublePrimaryKey {
+    uint32_t id1;
+    uint32_t id2;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(DoublePrimaryKey, id1, id2, data)
+SPACETIMEDB_TABLE(DoublePrimaryKey, double_pk_table, SpacetimeDb::Public)
+FIELD_PrimaryKey(double_pk_table, id1);
+FIELD_PrimaryKey(double_pk_table, id2);  // ERROR: Two primary keys!
+
+// Table with PrimaryKey and PrimaryKeyAutoInc - INVALID
+struct MixedPrimaryKey {
+    uint32_t manual_id;
+    uint64_t auto_id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(MixedPrimaryKey, manual_id, auto_id, data)
+SPACETIMEDB_TABLE(MixedPrimaryKey, mixed_pk_table, SpacetimeDb::Public)
+FIELD_PrimaryKey(mixed_pk_table, manual_id);
+FIELD_PrimaryKeyAutoInc(mixed_pk_table, auto_id);  // ERROR: Two primary keys of different types!
+
+// Table with multiple PrimaryKeyAutoInc - INVALID
+struct DoubleAutoInc {
+    uint64_t id1;
+    uint64_t id2;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(DoubleAutoInc, id1, id2, data)
+SPACETIMEDB_TABLE(DoubleAutoInc, double_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(double_autoinc_table, id1);
+FIELD_PrimaryKeyAutoInc(double_autoinc_table, id2);  // ERROR: Two auto-increment primary keys!
+
+// Table with three primary keys - VERY INVALID
+struct TriplePrimaryKey {
+    uint32_t id1;
+    uint32_t id2;
+    uint32_t id3;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(TriplePrimaryKey, id1, id2, id3, data)
+SPACETIMEDB_TABLE(TriplePrimaryKey, triple_pk_table, SpacetimeDb::Public)
+FIELD_PrimaryKey(triple_pk_table, id1);
+FIELD_PrimaryKey(triple_pk_table, id2);
+FIELD_PrimaryKey(triple_pk_table, id3);  // ERROR: Three primary keys!
+
+// Valid table for comparison - single primary key
+struct SinglePrimaryKey {
+    uint32_t id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(SinglePrimaryKey, id, data)
+SPACETIMEDB_TABLE(SinglePrimaryKey, single_pk_table, SpacetimeDb::Public)
+FIELD_PrimaryKey(single_pk_table, id);  // Correct: Single primary key
+
+// Valid table with auto-increment
+struct SingleAutoInc {
+    uint64_t id;
+    std::string data;
+};
+SPACETIMEDB_STRUCT(SingleAutoInc, id, data)
+SPACETIMEDB_TABLE(SingleAutoInc, single_autoinc_table, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(single_autoinc_table, id);  // Correct: Single auto-increment primary key
+
+// Test reducer
+SPACETIMEDB_REDUCER(test_multiple_pks, SpacetimeDb::ReducerContext ctx)
+{
+    LOG_INFO("Testing multiple primary keys - should fail validation");
+    
+    // Try to insert into double PK table
+    DoublePrimaryKey double_pk{1, 2, "Double PK"};
+    ctx.db[double_pk_table].insert(double_pk);
+    
+    // Try to insert into mixed PK table
+    MixedPrimaryKey mixed_pk{1, 0, "Mixed PK"};
+    ctx.db[mixed_pk_table].insert(mixed_pk);
+    
+    // Insert into valid tables
+    SinglePrimaryKey single_pk{1, "Valid single PK"};
+    ctx.db[single_pk_table].insert(single_pk);
+    
+    SingleAutoInc single_auto{0, "Valid auto-inc"};
+    ctx.db[single_autoinc_table].insert(single_auto);
+}
+
+// Init reducer
+SPACETIMEDB_INIT(init)
+{
+    LOG_INFO("Multiple primary keys test - should fail validation");
+    LOG_INFO("SpacetimeDB allows only ONE primary key per table");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_non_spacetimedb_type.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_non_spacetimedb_type.cpp
new file mode 100644
index 00000000000..6fb80b4b1df
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_non_spacetimedb_type.cpp
@@ -0,0 +1,78 @@
+#include <spacetimedb.h>
+#include <memory>
+#include <thread>
+#include <atomic>
+
+// Test types that don't have BSATN serialization support
+// These should be caught as compilation errors
+
+// Custom type without SPACETIMEDB_STRUCT macro
+struct UnsupportedType {
+    int x;
+    int y;
+};
+// Intentionally NOT adding: SPACETIMEDB_STRUCT(UnsupportedType, x, y)
+
+// Type with unsupported member (std::thread)
+struct ThreadContainingType {
+    uint32_t id;
+    std::thread worker;  // std::thread cannot be serialized
+};
+// This would fail even with SPACETIMEDB_STRUCT
+
+// Type with raw pointer (not serializable)
+struct RawPointerType {
+    uint32_t id;
+    int* data;  // Raw pointers cannot be serialized
+};
+// SPACETIMEDB_STRUCT(RawPointerType, id, data) // Would fail
+
+// Type with std::unique_ptr (not serializable)
+struct SmartPointerType {
+    uint32_t id;
+    std::unique_ptr<int> value;  // Smart pointers cannot be serialized
+};
+// SPACETIMEDB_STRUCT(SmartPointerType, id, value) // Would fail
+
+// Type with std::atomic (not serializable)
+struct AtomicType {
+    uint32_t id;
+    std::atomic<int> counter;  // Atomics cannot be serialized
+};
+// SPACETIMEDB_STRUCT(AtomicType, id, counter) // Would fail
+
+// Valid type for comparison
+struct ValidType {
+    uint32_t id;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(ValidType, id, name)
+
+// Try to use unsupported type as table - should fail
+SPACETIMEDB_TABLE(UnsupportedType, unsupported_table, SpacetimeDb::Public)
+
+// Try to use unsupported type as reducer argument - should fail
+SPACETIMEDB_REDUCER(test_unsupported_arg, SpacetimeDb::ReducerContext ctx, UnsupportedType arg)
+{
+    LOG_INFO("This should never compile - UnsupportedType lacks BSATN traits");
+}
+
+// Valid reducer for comparison
+SPACETIMEDB_REDUCER(test_valid_arg, SpacetimeDb::ReducerContext ctx, ValidType arg)
+{
+    LOG_INFO("Valid type works fine: " + arg.name);
+}
+
+// Try to use type with unsupported members in a struct
+struct ComplexBadType {
+    uint32_t id;
+    UnsupportedType unsupported;  // Contains type without BSATN
+};
+SPACETIMEDB_STRUCT(ComplexBadType, id, unsupported)  // Should fail - nested type lacks traits
+SPACETIMEDB_TABLE(ComplexBadType, complex_bad_table, SpacetimeDb::Public)
+
+// Init reducer
+SPACETIMEDB_INIT(init)
+{
+    LOG_INFO("Non-SpacetimeDB type test - should fail compilation");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_scheduled_id_pk.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_scheduled_id_pk.cpp
new file mode 100644
index 00000000000..603b5b1f69f
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/error_scheduled_id_pk.cpp
@@ -0,0 +1,100 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test scheduled table without primary key on scheduled_id
+// This should be caught as an error
+
+// Incorrect scheduled table - scheduled_id is NOT a primary key
+struct BadScheduledTable {
+    uint64_t scheduled_id;  // Should be PrimaryKeyAutoInc but isn't
+    SpacetimeDb::ScheduleAt scheduled_at;
+    std::string message;
+};
+SPACETIMEDB_STRUCT(BadScheduledTable, scheduled_id, scheduled_at, message)
+SPACETIMEDB_TABLE(BadScheduledTable, bad_scheduled, SpacetimeDb::Public)  // Missing PrimaryKeyAutoInc(scheduled_id)
+SPACETIMEDB_SCHEDULE(bad_scheduled, 1, process_bad_schedule)  // This should fail!
+
+// Another incorrect variant - has primary key but on wrong field
+struct WrongPkScheduledTable {
+    uint64_t scheduled_id;
+    SpacetimeDb::ScheduleAt scheduled_at;
+    std::string message;
+};
+SPACETIMEDB_STRUCT(WrongPkScheduledTable, scheduled_id, scheduled_at, message)
+SPACETIMEDB_TABLE(WrongPkScheduledTable, wrong_pk_scheduled, SpacetimeDb::Public)
+FIELD_PrimaryKey(wrong_pk_scheduled, message)  // Primary key on wrong field!
+SPACETIMEDB_SCHEDULE(wrong_pk_scheduled, 1, process_wrong_pk_schedule)
+
+// Yet another incorrect variant - has unique constraint instead of primary key
+struct UniqueScheduledTable {
+    uint64_t scheduled_id;
+    SpacetimeDb::ScheduleAt scheduled_at;
+    std::string message;
+};
+SPACETIMEDB_STRUCT(UniqueScheduledTable, scheduled_id, scheduled_at, message)
+SPACETIMEDB_TABLE(UniqueScheduledTable, unique_scheduled, SpacetimeDb::Public)
+FIELD_Unique(unique_scheduled, scheduled_id)  // Unique instead of PrimaryKey!
+SPACETIMEDB_SCHEDULE(unique_scheduled, 1, process_unique_schedule)
+
+// Correct scheduled table for comparison
+struct GoodScheduledTable {
+    uint64_t scheduled_id;
+    SpacetimeDb::ScheduleAt scheduled_at;
+    std::string message;
+};
+SPACETIMEDB_STRUCT(GoodScheduledTable, scheduled_id, scheduled_at, message)
+SPACETIMEDB_TABLE(GoodScheduledTable, good_scheduled, SpacetimeDb::Public)
+FIELD_PrimaryKeyAutoInc(good_scheduled, scheduled_id)  // Correct!
+SPACETIMEDB_SCHEDULE(good_scheduled, 1, process_good_schedule)
+
+// Scheduled reducers
+SPACETIMEDB_REDUCER(process_bad_schedule, SpacetimeDb::ReducerContext ctx, BadScheduledTable arg)
+{
+    LOG_INFO("Bad schedule executed: " + arg.message);
+}
+
+SPACETIMEDB_REDUCER(process_wrong_pk_schedule, SpacetimeDb::ReducerContext ctx, WrongPkScheduledTable arg)
+{
+    LOG_INFO("Wrong PK schedule executed: " + arg.message);
+}
+
+SPACETIMEDB_REDUCER(process_unique_schedule, SpacetimeDb::ReducerContext ctx, UniqueScheduledTable arg)
+{
+    LOG_INFO("Unique schedule executed: " + arg.message);
+}
+
+SPACETIMEDB_REDUCER(process_good_schedule, SpacetimeDb::ReducerContext ctx, GoodScheduledTable arg)
+{
+    LOG_INFO("Good schedule executed: " + arg.message);
+}
+
+// Test reducer to schedule tasks
+SPACETIMEDB_REDUCER(test_schedule_tables, SpacetimeDb::ReducerContext ctx)
+{
+    LOG_INFO("Testing scheduled tables - this should fail if validation works");
+    
+    // Try to insert into bad scheduled table
+    BadScheduledTable bad{0, ScheduleAt::time(ctx.timestamp + TimeDuration(1000000)), "Bad schedule"};
+    ctx.db[bad_scheduled].insert(bad);
+    
+    // Try to insert into wrong PK scheduled table
+    WrongPkScheduledTable wrong{0, ScheduleAt::time(ctx.timestamp + TimeDuration(1000000)), "Wrong PK"};
+    ctx.db[wrong_pk_scheduled].insert(wrong);
+    
+    // Try to insert into unique scheduled table
+    UniqueScheduledTable unique{0, ScheduleAt::time(ctx.timestamp + TimeDuration(1000000)), "Unique instead of PK"};
+    ctx.db[unique_scheduled].insert(unique);
+    
+    // Insert into good scheduled table (should work)
+    GoodScheduledTable good{0, ScheduleAt::time(ctx.timestamp + TimeDuration(1000000)), "Good schedule"};
+    ctx.db[good_scheduled].insert(good);
+}
+
+// Init reducer
+SPACETIMEDB_INIT(init)
+{
+    LOG_INFO("Scheduled table PK test module initialized");
+    LOG_INFO("This tests that scheduled_id must be a primary key");
+    LOG_INFO("Should fail if scheduled_id is not PrimaryKeyAutoInc");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module01_basic_unsigned.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module01_basic_unsigned.cpp
new file mode 100644
index 00000000000..42be67ec079
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module01_basic_unsigned.cpp
@@ -0,0 +1,90 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 1: Basic unsigned integers (U8, U16, U32)
+// Testing if basic unsigned integer types cause WASM issues
+
+
+// OneU8 table
+struct OneU8 { uint8_t n; };
+SPACETIMEDB_STRUCT(OneU8, n)
+SPACETIMEDB_TABLE(OneU8, one_u8, Public)
+
+// OneU16 table  
+struct OneU16 { uint16_t n; };
+SPACETIMEDB_STRUCT(OneU16, n)
+SPACETIMEDB_TABLE(OneU16, one_u16, Public)
+
+// OneU32 table
+struct OneU32 { uint32_t n; };
+SPACETIMEDB_STRUCT(OneU32, n)
+SPACETIMEDB_TABLE(OneU32, one_u32, Public)
+
+// VecU8 table
+struct VecU8 { std::vector<uint8_t> n; };
+SPACETIMEDB_STRUCT(VecU8, n)
+SPACETIMEDB_TABLE(VecU8, vec_u8, Public)
+
+// VecU16 table
+struct VecU16 { std::vector<uint16_t> n; };
+SPACETIMEDB_STRUCT(VecU16, n)
+SPACETIMEDB_TABLE(VecU16, vec_u16, Public)
+
+// VecU32 table
+struct VecU32 { std::vector<uint32_t> n; };
+SPACETIMEDB_STRUCT(VecU32, n)
+SPACETIMEDB_TABLE(VecU32, vec_u32, Public)
+
+// UniqueU8 table
+struct UniqueU8 { uint8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU8, n, data)
+SPACETIMEDB_TABLE(UniqueU8, unique_u8, Public)
+FIELD_Unique(unique_u8, n)
+
+// UniqueU16 table
+struct UniqueU16 { uint16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU16, n, data)
+SPACETIMEDB_TABLE(UniqueU16, unique_u16, Public)
+FIELD_Unique(unique_u16, n)
+
+// UniqueU32 table
+struct UniqueU32 { uint32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU32, n, data)
+SPACETIMEDB_TABLE(UniqueU32, unique_u32, Public)
+FIELD_Unique(unique_u32, n)
+
+// PkU8 table
+struct PkU8 { uint8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU8, n, data)
+SPACETIMEDB_TABLE(PkU8, pk_u8, Public)
+FIELD_PrimaryKey(pk_u8, n)
+
+// PkU16 table
+struct PkU16 { uint16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU16, n, data)
+SPACETIMEDB_TABLE(PkU16, pk_u16, Public)
+FIELD_PrimaryKey(pk_u16, n)
+
+// PkU32 table
+struct PkU32 { uint32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU32, n, data)
+SPACETIMEDB_TABLE(PkU32, pk_u32, Public)
+FIELD_PrimaryKey(pk_u32, n)
+
+// Reducers for basic unsigned integers
+SPACETIMEDB_REDUCER(insert_one_u8, ReducerContext ctx, uint8_t n)
+{
+    ctx.db.table<OneU8>("one_u8").insert(OneU8{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u16, ReducerContext ctx, uint16_t n)
+{
+    ctx.db.table<OneU16>("one_u16").insert(OneU16{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u32, ReducerContext ctx, uint32_t n)
+{
+    ctx.db.table<OneU32>("one_u32").insert(OneU32{n});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module02_large_unsigned.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module02_large_unsigned.cpp
new file mode 100644
index 00000000000..5b574c8dc8c
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module02_large_unsigned.cpp
@@ -0,0 +1,90 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 2: Large unsigned integers (U64, U128, U256)
+// Testing if large unsigned integer types cause WASM issues
+
+
+// OneU64 table
+struct OneU64 { uint64_t n; };
+SPACETIMEDB_STRUCT(OneU64, n)
+SPACETIMEDB_TABLE(OneU64, one_u64, Public)
+
+// OneU128 table
+struct OneU128 { u128 n; };
+SPACETIMEDB_STRUCT(OneU128, n)
+SPACETIMEDB_TABLE(OneU128, one_u128, Public)
+
+// OneU256 table
+struct OneU256 { u256 n; };
+SPACETIMEDB_STRUCT(OneU256, n)
+SPACETIMEDB_TABLE(OneU256, one_u256, Public)
+
+// VecU64 table
+struct VecU64 { std::vector<uint64_t> n; };
+SPACETIMEDB_STRUCT(VecU64, n)
+SPACETIMEDB_TABLE(VecU64, vec_u64, Public)
+
+// VecU128 table
+struct VecU128 { std::vector<u128> n; };
+SPACETIMEDB_STRUCT(VecU128, n)
+SPACETIMEDB_TABLE(VecU128, vec_u128, Public)
+
+// VecU256 table
+struct VecU256 { std::vector<u256> n; };
+SPACETIMEDB_STRUCT(VecU256, n)
+SPACETIMEDB_TABLE(VecU256, vec_u256, Public)
+
+// UniqueU64 table
+struct UniqueU64 { uint64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU64, n, data)
+SPACETIMEDB_TABLE(UniqueU64, unique_u64, Public)
+FIELD_Unique(unique_u64, n)
+
+// UniqueU128 table
+struct UniqueU128 { u128 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU128, n, data)
+SPACETIMEDB_TABLE(UniqueU128, unique_u128, Public)
+FIELD_Unique(unique_u128, n)
+
+// UniqueU256 table
+struct UniqueU256 { u256 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU256, n, data)
+SPACETIMEDB_TABLE(UniqueU256, unique_u256, Public)
+FIELD_Unique(unique_u256, n)
+
+// PkU64 table
+struct PkU64 { uint64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU64, n, data)
+SPACETIMEDB_TABLE(PkU64, pk_u64, Public)
+FIELD_PrimaryKey(pk_u64, n)
+
+// PkU128 table
+struct PkU128 { u128 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU128, n, data)
+SPACETIMEDB_TABLE(PkU128, pk_u128, Public)
+FIELD_PrimaryKey(pk_u128, n)
+
+// PkU256 table
+struct PkU256 { u256 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU256, n, data)
+SPACETIMEDB_TABLE(PkU256, pk_u256, Public)
+FIELD_PrimaryKey(pk_u256, n)
+
+// Reducers for large unsigned integers
+SPACETIMEDB_REDUCER(insert_one_u64, ReducerContext ctx, uint64_t n)
+{
+    ctx.db.table<OneU64>("one_u64").insert(OneU64{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u128, ReducerContext ctx, u128 n)
+{
+    ctx.db.table<OneU128>("one_u128").insert(OneU128{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u256, ReducerContext ctx, u256 n)
+{
+    ctx.db.table<OneU256>("one_u256").insert(OneU256{n});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module03_basic_signed.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module03_basic_signed.cpp
new file mode 100644
index 00000000000..7b62b004441
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module03_basic_signed.cpp
@@ -0,0 +1,90 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 3: Basic signed integers (I8, I16, I32)
+// Testing if basic signed integer types cause WASM issues
+
+
+// OneI8 table
+struct OneI8 { int8_t n; };
+SPACETIMEDB_STRUCT(OneI8, n)
+SPACETIMEDB_TABLE(OneI8, one_i8, Public)
+
+// OneI16 table
+struct OneI16 { int16_t n; };
+SPACETIMEDB_STRUCT(OneI16, n)
+SPACETIMEDB_TABLE(OneI16, one_i16, Public)
+
+// OneI32 table
+struct OneI32 { int32_t n; };
+SPACETIMEDB_STRUCT(OneI32, n)
+SPACETIMEDB_TABLE(OneI32, one_i32, Public)
+
+// VecI8 table
+struct VecI8 { std::vector<int8_t> n; };
+SPACETIMEDB_STRUCT(VecI8, n)
+SPACETIMEDB_TABLE(VecI8, vec_i8, Public)
+
+// VecI16 table
+struct VecI16 { std::vector<int16_t> n; };
+SPACETIMEDB_STRUCT(VecI16, n)
+SPACETIMEDB_TABLE(VecI16, vec_i16, Public)
+
+// VecI32 table
+struct VecI32 { std::vector<int32_t> n; };
+SPACETIMEDB_STRUCT(VecI32, n)
+SPACETIMEDB_TABLE(VecI32, vec_i32, Public)
+
+// UniqueI8 table
+struct UniqueI8 { int8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI8, n, data)
+SPACETIMEDB_TABLE(UniqueI8, unique_i8, Public)
+FIELD_Unique(unique_i8, n)
+
+// UniqueI16 table
+struct UniqueI16 { int16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI16, n, data)
+SPACETIMEDB_TABLE(UniqueI16, unique_i16, Public)
+FIELD_Unique(unique_i16, n)
+
+// UniqueI32 table
+struct UniqueI32 { int32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI32, n, data)
+SPACETIMEDB_TABLE(UniqueI32, unique_i32, Public)
+FIELD_Unique(unique_i32, n)
+
+// PkI8 table
+struct PkI8 { int8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI8, n, data)
+SPACETIMEDB_TABLE(PkI8, pk_i8, Public)
+FIELD_PrimaryKey(pk_i8, n)
+
+// PkI16 table
+struct PkI16 { int16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI16, n, data)
+SPACETIMEDB_TABLE(PkI16, pk_i16, Public)
+FIELD_PrimaryKey(pk_i16, n)
+
+// PkI32 table
+struct PkI32 { int32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI32, n, data)
+SPACETIMEDB_TABLE(PkI32, pk_i32, Public)
+FIELD_PrimaryKey(pk_i32, n)
+
+// Reducers for basic signed integers
+SPACETIMEDB_REDUCER(insert_one_i8, ReducerContext ctx, int8_t n)
+{
+    ctx.db.table<OneI8>("one_i8").insert(OneI8{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i16, ReducerContext ctx, int16_t n)
+{
+    ctx.db.table<OneI16>("one_i16").insert(OneI16{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i32, ReducerContext ctx, int32_t n)
+{
+    ctx.db.table<OneI32>("one_i32").insert(OneI32{n});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module04_large_signed.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module04_large_signed.cpp
new file mode 100644
index 00000000000..0f314999807
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module04_large_signed.cpp
@@ -0,0 +1,90 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 4: Large signed integers (I64, I128, I256)
+// Testing if large signed integer types cause WASM issues
+
+
+// OneI64 table
+struct OneI64 { int64_t n; };
+SPACETIMEDB_STRUCT(OneI64, n)
+SPACETIMEDB_TABLE(OneI64, one_i64, Public)
+
+// OneI128 table
+struct OneI128 { i128 n; };
+SPACETIMEDB_STRUCT(OneI128, n)
+SPACETIMEDB_TABLE(OneI128, one_i128, Public)
+
+// OneI256 table
+struct OneI256 { i256 n; };
+SPACETIMEDB_STRUCT(OneI256, n)
+SPACETIMEDB_TABLE(OneI256, one_i256, Public)
+
+// VecI64 table
+struct VecI64 { std::vector<int64_t> n; };
+SPACETIMEDB_STRUCT(VecI64, n)
+SPACETIMEDB_TABLE(VecI64, vec_i64, Public)
+
+// VecI128 table
+struct VecI128 { std::vector<i128> n; };
+SPACETIMEDB_STRUCT(VecI128, n)
+SPACETIMEDB_TABLE(VecI128, vec_i128, Public)
+
+// VecI256 table
+struct VecI256 { std::vector<i256> n; };
+SPACETIMEDB_STRUCT(VecI256, n)
+SPACETIMEDB_TABLE(VecI256, vec_i256, Public)
+
+// UniqueI64 table
+struct UniqueI64 { int64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI64, n, data)
+SPACETIMEDB_TABLE(UniqueI64, unique_i64, Public)
+FIELD_Unique(unique_i64, n)
+
+// UniqueI128 table
+struct UniqueI128 { i128 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI128, n, data)
+SPACETIMEDB_TABLE(UniqueI128, unique_i128, Public)
+FIELD_Unique(unique_i128, n)
+
+// UniqueI256 table
+struct UniqueI256 { i256 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI256, n, data)
+SPACETIMEDB_TABLE(UniqueI256, unique_i256, Public)
+FIELD_Unique(unique_i256, n)
+
+// PkI64 table
+struct PkI64 { int64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI64, n, data)
+SPACETIMEDB_TABLE(PkI64, pk_i64, Public)
+FIELD_PrimaryKey(pk_i64, n)
+
+// PkI128 table
+struct PkI128 { i128 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI128, n, data)
+SPACETIMEDB_TABLE(PkI128, pk_i128, Public)
+FIELD_PrimaryKey(pk_i128, n)
+
+// PkI256 table
+struct PkI256 { i256 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI256, n, data)
+SPACETIMEDB_TABLE(PkI256, pk_i256, Public)
+FIELD_PrimaryKey(pk_i256, n)
+
+// Reducers for large signed integers
+SPACETIMEDB_REDUCER(insert_one_i64, ReducerContext ctx, int64_t n)
+{
+    ctx.db.table<OneI64>("one_i64").insert(OneI64{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i128, ReducerContext ctx, i128 n)
+{
+    ctx.db.table<OneI128>("one_i128").insert(OneI128{n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i256, ReducerContext ctx, i256 n)
+{
+    ctx.db.table<OneI256>("one_i256").insert(OneI256{n});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module05_float_bool.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module05_float_bool.cpp
new file mode 100644
index 00000000000..b20f7e78e99
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module05_float_bool.cpp
@@ -0,0 +1,66 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 5: Floating point and boolean types
+// Testing if float/bool types cause WASM issues
+
+
+// OneBool table
+struct OneBool { bool b; };
+SPACETIMEDB_STRUCT(OneBool, b)
+SPACETIMEDB_TABLE(OneBool, one_bool, Public)
+
+// OneF32 table
+struct OneF32 { float f; };
+SPACETIMEDB_STRUCT(OneF32, f)
+SPACETIMEDB_TABLE(OneF32, one_f32, Public)
+
+// OneF64 table
+struct OneF64 { double f; };
+SPACETIMEDB_STRUCT(OneF64, f)
+SPACETIMEDB_TABLE(OneF64, one_f64, Public)
+
+// VecBool table
+struct VecBool { std::vector<bool> b; };
+SPACETIMEDB_STRUCT(VecBool, b)
+SPACETIMEDB_TABLE(VecBool, vec_bool, Public)
+
+// VecF32 table
+struct VecF32 { std::vector<float> f; };
+SPACETIMEDB_STRUCT(VecF32, f)
+SPACETIMEDB_TABLE(VecF32, vec_f32, Public)
+
+// VecF64 table
+struct VecF64 { std::vector<double> f; };
+SPACETIMEDB_STRUCT(VecF64, f)
+SPACETIMEDB_TABLE(VecF64, vec_f64, Public)
+
+// UniqueBool table
+struct UniqueBool { bool b; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueBool, b, data)
+SPACETIMEDB_TABLE(UniqueBool, unique_bool, Public)
+FIELD_Unique(unique_bool, b)
+
+// PkBool table
+struct PkBool { bool b; int32_t data; };
+SPACETIMEDB_STRUCT(PkBool, b, data)
+SPACETIMEDB_TABLE(PkBool, pk_bool, Public)
+FIELD_PrimaryKey(pk_bool, b)
+
+// Reducers for float and bool types
+SPACETIMEDB_REDUCER(insert_one_bool, ReducerContext ctx, bool b)
+{
+    ctx.db.table<OneBool>("one_bool").insert(OneBool{b});
+}
+
+SPACETIMEDB_REDUCER(insert_one_f32, ReducerContext ctx, float f)
+{
+    ctx.db.table<OneF32>("one_f32").insert(OneF32{f});
+}
+
+SPACETIMEDB_REDUCER(insert_one_f64, ReducerContext ctx, double f)
+{
+    ctx.db.table<OneF64>("one_f64").insert(OneF64{f});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module06_string.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module06_string.cpp
new file mode 100644
index 00000000000..1bf2c3af746
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module06_string.cpp
@@ -0,0 +1,35 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Module 6: String and text types
+// Testing if string types cause WASM issues
+
+
+// OneString table
+struct OneString { std::string s; };
+SPACETIMEDB_STRUCT(OneString, s)
+SPACETIMEDB_TABLE(OneString, one_string, Public)
+
+// VecString table
+struct VecString { std::vector<std::string> s; };
+SPACETIMEDB_STRUCT(VecString, s)
+SPACETIMEDB_TABLE(VecString, vec_string, Public)
+
+// UniqueString table
+struct UniqueString { std::string s; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueString, s, data)
+SPACETIMEDB_TABLE(UniqueString, unique_string, Public)
+FIELD_Unique(unique_string, s)
+
+// PkString table
+struct PkString { std::string s; int32_t data; };
+SPACETIMEDB_STRUCT(PkString, s, data)
+SPACETIMEDB_TABLE(PkString, pk_string, Public)
+FIELD_PrimaryKey(pk_string, s)
+
+// Reducer for string types
+SPACETIMEDB_REDUCER(insert_one_string, ReducerContext ctx, std::string s)
+{
+    ctx.db.table<OneString>("one_string").insert(OneString{s});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module07_special_types.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module07_special_types.cpp
new file mode 100644
index 00000000000..c3c97d18bb7
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module07_special_types.cpp
@@ -0,0 +1,113 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 7: Special types (Identity, ConnectionId, Timestamp)
+// Testing if special SpacetimeDB types cause WASM issues
+
+
+// OneIdentity table
+struct OneIdentity { Identity i; };
+SPACETIMEDB_STRUCT(OneIdentity, i)
+SPACETIMEDB_TABLE(OneIdentity, one_identity, Public)
+
+// OneConnectionId table
+struct OneConnectionId { ConnectionId a; };
+SPACETIMEDB_STRUCT(OneConnectionId, a)
+SPACETIMEDB_TABLE(OneConnectionId, one_connection_id, Public)
+
+// OneTimestamp table
+struct OneTimestamp { Timestamp t; };
+SPACETIMEDB_STRUCT(OneTimestamp, t)
+SPACETIMEDB_TABLE(OneTimestamp, one_timestamp, Public)
+
+// VecIdentity table
+struct VecIdentity { std::vector<Identity> i; };
+SPACETIMEDB_STRUCT(VecIdentity, i)
+SPACETIMEDB_TABLE(VecIdentity, vec_identity, Public)
+
+// VecConnectionId table
+struct VecConnectionId { std::vector<ConnectionId> a; };
+SPACETIMEDB_STRUCT(VecConnectionId, a)
+SPACETIMEDB_TABLE(VecConnectionId, vec_connection_id, Public)
+
+// VecTimestamp table
+struct VecTimestamp { std::vector<Timestamp> t; };
+SPACETIMEDB_STRUCT(VecTimestamp, t)
+SPACETIMEDB_TABLE(VecTimestamp, vec_timestamp, Public)
+
+// UniqueIdentity table
+struct UniqueIdentity { Identity i; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueIdentity, i, data)
+SPACETIMEDB_TABLE(UniqueIdentity, unique_identity, Public)
+FIELD_Unique(unique_identity, i)
+
+// UniqueConnectionId table
+struct UniqueConnectionId { ConnectionId a; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueConnectionId, a, data)
+SPACETIMEDB_TABLE(UniqueConnectionId, unique_connection_id, Public)
+FIELD_Unique(unique_connection_id, a)
+
+// PkIdentity table
+struct PkIdentity { Identity i; int32_t data; };
+SPACETIMEDB_STRUCT(PkIdentity, i, data)
+SPACETIMEDB_TABLE(PkIdentity, pk_identity, Public)
+FIELD_PrimaryKey(pk_identity, i)
+
+// PkConnectionId table
+struct PkConnectionId { ConnectionId a; int32_t data; };
+SPACETIMEDB_STRUCT(PkConnectionId, a, data)
+SPACETIMEDB_TABLE(PkConnectionId, pk_connection_id, Public)
+FIELD_PrimaryKey(pk_connection_id, a)
+
+// Users table
+struct Users {
+    Identity identity;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(Users, identity, name)
+SPACETIMEDB_TABLE(Users, users, Public)
+FIELD_PrimaryKey(users, identity)
+
+// Parameter wrappers to avoid direct special type parameters (causes WASM traps)
+struct IdentityParam { Identity i; };
+SPACETIMEDB_STRUCT(IdentityParam, i)
+
+struct ConnectionIdParam { ConnectionId a; };
+SPACETIMEDB_STRUCT(ConnectionIdParam, a)
+
+struct TimestampParam { Timestamp t; };
+SPACETIMEDB_STRUCT(TimestampParam, t)
+
+// Reducers for special types (using wrapped parameters)
+SPACETIMEDB_REDUCER(insert_one_identity, ReducerContext ctx, IdentityParam param)
+{
+    ctx.db.table<OneIdentity>("one_identity").insert(OneIdentity{param.i});
+}
+
+SPACETIMEDB_REDUCER(insert_one_connection_id, ReducerContext ctx, ConnectionIdParam param)
+{
+    ctx.db.table<OneConnectionId>("one_connection_id").insert(OneConnectionId{param.a});
+}
+
+SPACETIMEDB_REDUCER(insert_one_timestamp, ReducerContext ctx, TimestampParam param)
+{
+    ctx.db.table<OneTimestamp>("one_timestamp").insert(OneTimestamp{param.t});
+}
+
+// TEST: Direct special type parameters (should cause WASM trap when published)
+SPACETIMEDB_REDUCER(insert_direct_identity, ReducerContext ctx, Identity i)
+{
+    ctx.db.table<OneIdentity>("one_identity").insert(OneIdentity{i});
+}
+
+SPACETIMEDB_REDUCER(insert_direct_connection_id, ReducerContext ctx, ConnectionId c)
+{
+    ctx.db.table<OneConnectionId>("one_connection_id").insert(OneConnectionId{c});
+}
+
+SPACETIMEDB_REDUCER(insert_direct_timestamp, ReducerContext ctx, Timestamp t)
+{
+    LOG_INFO("Direct timestamp reducer called");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module08_enums.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module08_enums.cpp
new file mode 100644
index 00000000000..31872d7d582
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module08_enums.cpp
@@ -0,0 +1,84 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+#include <variant>
+
+using namespace SpacetimeDb;
+
+// Module 8: Enums and enum tables
+// Testing if enum types cause WASM issues
+
+
+// SimpleEnum - basic enum using new unified syntax
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+
+// EnumWithPayload - variant enum with payloads using new unified syntax
+SPACETIMEDB_ENUM(EnumWithPayload,
+    (U8, uint8_t),
+    (U16, uint16_t),
+    (U32, uint32_t),
+    (U64, uint64_t),
+    (U128, SpacetimeDb::u128),
+    (U256, SpacetimeDb::u256),
+    (I8, int8_t),
+    (I16, int16_t),
+    (I32, int32_t),
+    (I64, int64_t),
+    (I128, SpacetimeDb::i128),
+    (I256, SpacetimeDb::i256),
+    (Bool, bool),
+    (F32, float),
+    (F64, double),
+    (Str, std::string),
+    (Identity, SpacetimeDb::Identity),
+    (ConnectionId, SpacetimeDb::ConnectionId),
+    (Timestamp, SpacetimeDb::Timestamp),
+    (Bytes, std::vector<uint8_t>),
+    (Ints, std::vector<int32_t>),
+    (Strings, std::vector<std::string>),
+    (SimpleEnums, std::vector<SimpleEnum>)
+)
+
+// OneSimpleEnum table
+struct OneSimpleEnum { SimpleEnum e; };
+SPACETIMEDB_STRUCT(OneSimpleEnum, e)
+SPACETIMEDB_TABLE(OneSimpleEnum, one_simple_enum, Public)
+
+// OneEnumWithPayload table
+struct OneEnumWithPayload { EnumWithPayload e; };
+SPACETIMEDB_STRUCT(OneEnumWithPayload, e)
+SPACETIMEDB_TABLE(OneEnumWithPayload, one_enum_with_payload, Public)
+
+// VecSimpleEnum table
+struct VecSimpleEnum { std::vector<SimpleEnum> e; };
+SPACETIMEDB_STRUCT(VecSimpleEnum, e)
+SPACETIMEDB_TABLE(VecSimpleEnum, vec_simple_enum, Public)
+
+// VecEnumWithPayload table
+struct VecEnumWithPayload { std::vector<EnumWithPayload> e; };
+SPACETIMEDB_STRUCT(VecEnumWithPayload, e)
+SPACETIMEDB_TABLE(VecEnumWithPayload, vec_enum_with_payload, Public)
+
+// PkSimpleEnum table
+struct PkSimpleEnum { SimpleEnum a; int32_t data; };
+SPACETIMEDB_STRUCT(PkSimpleEnum, a, data)
+SPACETIMEDB_TABLE(PkSimpleEnum, pk_simple_enum, Public)
+FIELD_PrimaryKey(pk_simple_enum, a)
+
+// IndexedSimpleEnum table
+struct IndexedSimpleEnum {
+    SimpleEnum n;
+};
+SPACETIMEDB_STRUCT(IndexedSimpleEnum, n)
+SPACETIMEDB_TABLE(IndexedSimpleEnum, indexed_simple_enum, Public)
+FIELD_Index(indexed_simple_enum, n)
+
+// Reducers for enum types
+SPACETIMEDB_REDUCER(insert_one_simple_enum, ReducerContext ctx, SimpleEnum e)
+{
+    ctx.db.table<OneSimpleEnum>("one_simple_enum").insert(OneSimpleEnum{e});
+}
+
+SPACETIMEDB_REDUCER(insert_one_enum_with_payload, ReducerContext ctx, EnumWithPayload e)
+{
+    ctx.db.table<OneEnumWithPayload>("one_enum_with_payload").insert(OneEnumWithPayload{e});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module09_structs.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module09_structs.cpp
new file mode 100644
index 00000000000..ab959291b27
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module09_structs.cpp
@@ -0,0 +1,189 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+#include <variant>
+
+using namespace SpacetimeDb;
+
+// Module 9: Structs and complex types
+// Testing if struct types cause WASM issues
+
+
+// Need enums for struct fields using new unified syntax
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+SPACETIMEDB_ENUM(EnumWithPayload,
+    (U8, uint8_t),
+    (U16, uint16_t),
+    (U32, uint32_t),
+    (U64, uint64_t),
+    (U128, SpacetimeDb::u128),
+    (U256, SpacetimeDb::u256),
+    (I8, int8_t),
+    (I16, int16_t),
+    (I32, int32_t),
+    (I64, int64_t),
+    (I128, SpacetimeDb::i128),
+    (I256, SpacetimeDb::i256),
+    (Bool, bool),
+    (F32, float),
+    (F64, double),
+    (Str, std::string),
+    (Identity, SpacetimeDb::Identity),
+    (ConnectionId, SpacetimeDb::ConnectionId),
+    (Timestamp, SpacetimeDb::Timestamp),
+    (Bytes, std::vector<uint8_t>),
+    (Ints, std::vector<int32_t>),
+    (Strings, std::vector<std::string>),
+    (SimpleEnums, std::vector<SimpleEnum>)
+)
+
+// UnitStruct
+struct UnitStruct {
+    uint8_t dummy = 0;
+};
+SPACETIMEDB_STRUCT(UnitStruct, dummy)
+
+// ByteStruct
+struct ByteStruct {
+    uint8_t b;
+};
+SPACETIMEDB_STRUCT(ByteStruct, b)
+
+// EveryPrimitiveStruct
+struct EveryPrimitiveStruct {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    Identity q;
+    ConnectionId r;
+    Timestamp s;
+    TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// EveryVecStruct
+struct EveryVecStruct {
+    std::vector<uint8_t> a;
+    std::vector<uint16_t> b;
+    std::vector<uint32_t> c;
+    std::vector<uint64_t> d;
+    std::vector<u128> e;
+    std::vector<u256> f;
+    std::vector<int8_t> g;
+    std::vector<int16_t> h;
+    std::vector<int32_t> i;
+    std::vector<int64_t> j;
+    std::vector<i128> k;
+    std::vector<i256> l;
+    std::vector<bool> m;
+    std::vector<float> n;
+    std::vector<double> o;
+    std::vector<std::string> p;
+    std::vector<Identity> q;
+    std::vector<ConnectionId> r;
+    std::vector<Timestamp> s;
+    std::vector<TimeDuration> t;
+    std::vector<SimpleEnum> u;
+};
+SPACETIMEDB_STRUCT(EveryVecStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)
+
+// OneUnitStruct table
+struct OneUnitStruct { UnitStruct s; };
+SPACETIMEDB_STRUCT(OneUnitStruct, s)
+SPACETIMEDB_TABLE(OneUnitStruct, one_unit_struct, Public)
+
+// OneByteStruct table
+struct OneByteStruct { ByteStruct s; };
+SPACETIMEDB_STRUCT(OneByteStruct, s)
+SPACETIMEDB_TABLE(OneByteStruct, one_byte_struct, Public)
+
+// OneEveryPrimitiveStruct table
+struct OneEveryPrimitiveStruct { EveryPrimitiveStruct s; };
+SPACETIMEDB_STRUCT(OneEveryPrimitiveStruct, s)
+SPACETIMEDB_TABLE(OneEveryPrimitiveStruct, one_every_primitive_struct, Public)
+
+// OneEveryVecStruct table
+struct OneEveryVecStruct { EveryVecStruct s; };
+SPACETIMEDB_STRUCT(OneEveryVecStruct, s)
+SPACETIMEDB_TABLE(OneEveryVecStruct, one_every_vec_struct, Public)
+
+// VecUnitStruct table
+struct VecUnitStruct { std::vector<UnitStruct> s; };
+SPACETIMEDB_STRUCT(VecUnitStruct, s)
+SPACETIMEDB_TABLE(VecUnitStruct, vec_unit_struct, Public)
+
+// VecByteStruct table
+struct VecByteStruct { std::vector<ByteStruct> s; };
+SPACETIMEDB_STRUCT(VecByteStruct, s)
+SPACETIMEDB_TABLE(VecByteStruct, vec_byte_struct, Public)
+
+// VecEveryPrimitiveStruct table
+struct VecEveryPrimitiveStruct { std::vector<EveryPrimitiveStruct> s; };
+SPACETIMEDB_STRUCT(VecEveryPrimitiveStruct, s)
+SPACETIMEDB_TABLE(VecEveryPrimitiveStruct, vec_every_primitive_struct, Public)
+
+// VecEveryVecStruct table
+struct VecEveryVecStruct { std::vector<EveryVecStruct> s; };
+SPACETIMEDB_STRUCT(VecEveryVecStruct, s)
+SPACETIMEDB_TABLE(VecEveryVecStruct, vec_every_vec_struct, Public)
+
+// LargeTable
+struct LargeTable {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    SimpleEnum q;
+    EnumWithPayload r;
+    UnitStruct s;
+    ByteStruct t;
+    EveryPrimitiveStruct u;
+    EveryVecStruct v;
+};
+SPACETIMEDB_STRUCT(LargeTable, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)
+SPACETIMEDB_TABLE(LargeTable, large_table, Public)
+
+// Reducers for struct types
+SPACETIMEDB_REDUCER(insert_one_unit_struct, ReducerContext ctx, UnitStruct s)
+{
+    ctx.db.table<OneUnitStruct>("one_unit_struct").insert(OneUnitStruct{s});
+}
+
+SPACETIMEDB_REDUCER(insert_one_byte_struct, ReducerContext ctx, ByteStruct s)
+{
+    ctx.db.table<OneByteStruct>("one_byte_struct").insert(OneByteStruct{s});
+}
+
+SPACETIMEDB_REDUCER(insert_one_every_primitive_struct, ReducerContext ctx, EveryPrimitiveStruct s)
+{
+    ctx.db.table<OneEveryPrimitiveStruct>("one_every_primitive_struct").insert(OneEveryPrimitiveStruct{s});
+}
+
+SPACETIMEDB_REDUCER(insert_one_every_vec_struct, ReducerContext ctx, EveryVecStruct s)
+{
+    ctx.db.table<OneEveryVecStruct>("one_every_vec_struct").insert(OneEveryVecStruct{s});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module10_vectors.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module10_vectors.cpp
new file mode 100644
index 00000000000..f7732c5bd18
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module10_vectors.cpp
@@ -0,0 +1,54 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 10: Vector/array types (already covered in other modules, adding nested)
+// Testing if nested vector types cause WASM issues
+
+
+// Tables that hold other table structs  
+struct OneU8 { uint8_t n; };
+SPACETIMEDB_STRUCT(OneU8, n)
+
+struct VecU8 { std::vector<uint8_t> n; };
+SPACETIMEDB_STRUCT(VecU8, n)
+
+// TableHoldsTable - nested table structures
+struct TableHoldsTable {
+    OneU8 a;
+    VecU8 b;
+};
+SPACETIMEDB_STRUCT(TableHoldsTable, a, b)
+SPACETIMEDB_TABLE(TableHoldsTable, table_holds_table, Public)
+
+// Test some additional vector types not covered elsewhere
+struct VecVecU8 { std::vector<std::vector<uint8_t>> n; };
+SPACETIMEDB_STRUCT(VecVecU8, n)
+SPACETIMEDB_TABLE(VecVecU8, vec_vec_u8, Public)
+
+struct VecVecString { std::vector<std::vector<std::string>> s; };
+SPACETIMEDB_STRUCT(VecVecString, s)
+SPACETIMEDB_TABLE(VecVecString, vec_vec_string, Public)
+
+// Reducers for nested vector types
+SPACETIMEDB_REDUCER(insert_table_holds_table, ReducerContext ctx, OneU8 a, VecU8 b)
+{
+    ctx.db.table<TableHoldsTable>("table_holds_table").insert(TableHoldsTable{a, b});
+}
+
+// Direct vector parameter reducers
+SPACETIMEDB_REDUCER(insert_vec_u8, ReducerContext ctx, std::vector<uint8_t> n)
+{
+    LOG_INFO("Received vector<uint8_t> parameter");
+}
+
+SPACETIMEDB_REDUCER(insert_vec_vec_u8, ReducerContext ctx, std::vector<std::vector<uint8_t>> n)
+{
+    ctx.db.table<VecVecU8>("vec_vec_u8").insert(VecVecU8{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_vec_string, ReducerContext ctx, std::vector<std::vector<std::string>> s)
+{
+    ctx.db.table<VecVecString>("vec_vec_string").insert(VecVecString{s});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module11_optional.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module11_optional.cpp
new file mode 100644
index 00000000000..7f2992773f2
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module11_optional.cpp
@@ -0,0 +1,114 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+#include <optional>
+#include <variant>
+
+using namespace SpacetimeDb;
+
+// Module 11: Optional types
+// Testing if optional types cause WASM issues
+
+
+// Need enums for optional enum test using new unified syntax
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+
+// Need struct for optional struct test
+struct EveryPrimitiveStruct {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    Identity q;
+    ConnectionId r;
+    Timestamp s;
+    TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// CRITICAL FIX: Add a direct table using EveryPrimitiveStruct to ensure it gets registered by name
+// This prevents it from being inlined when used in Options
+SPACETIMEDB_TABLE(EveryPrimitiveStruct, every_primitive_direct, Public)
+
+// OptionI32 table
+struct OptionI32 { std::optional<int32_t> n; };
+SPACETIMEDB_STRUCT(OptionI32, n)
+SPACETIMEDB_TABLE(OptionI32, option_i32, Public)
+
+// OptionString table
+struct OptionString { std::optional<std::string> s; };
+SPACETIMEDB_STRUCT(OptionString, s)
+SPACETIMEDB_TABLE(OptionString, option_string, Public)
+
+// OptionIdentity table
+struct OptionIdentity { std::optional<Identity> i; };
+SPACETIMEDB_STRUCT(OptionIdentity, i)
+SPACETIMEDB_TABLE(OptionIdentity, option_identity, Public)
+
+// OptionSimpleEnum table
+struct OptionSimpleEnum { std::optional<SimpleEnum> e; };
+SPACETIMEDB_STRUCT(OptionSimpleEnum, e)
+SPACETIMEDB_TABLE(OptionSimpleEnum, option_simple_enum, Public)
+
+// OptionEveryPrimitiveStruct table
+struct OptionEveryPrimitiveStruct { std::optional<EveryPrimitiveStruct> s; };
+SPACETIMEDB_STRUCT(OptionEveryPrimitiveStruct, s)
+SPACETIMEDB_TABLE(OptionEveryPrimitiveStruct, option_every_primitive_struct, Public)
+
+// Complex nested optional type
+struct OptionVecOptionI32 { std::optional<std::vector<std::optional<int32_t>>> v; };
+SPACETIMEDB_STRUCT(OptionVecOptionI32, v)
+SPACETIMEDB_TABLE(OptionVecOptionI32, option_vec_option_i32, Public)
+
+// Parameter wrappers to avoid direct std::optional parameters (causes WASM traps)
+struct OptionalI32Param { std::optional<int32_t> n; };
+SPACETIMEDB_STRUCT(OptionalI32Param, n)
+
+struct OptionalStringParam { std::optional<std::string> s; };
+SPACETIMEDB_STRUCT(OptionalStringParam, s)
+
+struct OptionalIdentityParam { std::optional<Identity> i; };
+SPACETIMEDB_STRUCT(OptionalIdentityParam, i)
+
+// Reducers for optional types (using wrapped parameters)
+SPACETIMEDB_REDUCER(insert_option_i32, ReducerContext ctx, OptionalI32Param param)
+{
+    ctx.db.table<OptionI32>("option_i32").insert(OptionI32{param.n});
+}
+
+SPACETIMEDB_REDUCER(insert_option_string, ReducerContext ctx, OptionalStringParam param)
+{
+    ctx.db.table<OptionString>("option_string").insert(OptionString{param.s});
+}
+
+SPACETIMEDB_REDUCER(insert_option_identity, ReducerContext ctx, OptionalIdentityParam param)
+{
+    ctx.db.table<OptionIdentity>("option_identity").insert(OptionIdentity{param.i});
+}
+
+// TEST: Direct optional parameters (should cause WASM trap when published)
+SPACETIMEDB_REDUCER(insert_direct_option_i32, ReducerContext ctx, std::optional<int32_t> n)
+{
+    ctx.db.table<OptionI32>("option_i32").insert(OptionI32{n});
+}
+
+SPACETIMEDB_REDUCER(insert_direct_option_string, ReducerContext ctx, std::optional<std::string> s)
+{
+    ctx.db.table<OptionString>("option_string").insert(OptionString{s});
+}
+
+SPACETIMEDB_REDUCER(insert_direct_option_every_primitive_struct, ReducerContext ctx, std::optional<EveryPrimitiveStruct> s)
+{
+    ctx.db.table<OptionEveryPrimitiveStruct>("option_every_primitive_struct").insert(OptionEveryPrimitiveStruct{s});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/module12_constraints.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module12_constraints.cpp
new file mode 100644
index 00000000000..46beebaeaf7
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/module12_constraints.cpp
@@ -0,0 +1,58 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+// Module 12: Constraint tables (Indexes, etc.)
+// Testing if constraint-based tables cause WASM issues
+
+
+// IndexedTable
+struct IndexedTable {
+    uint32_t player_id;
+};
+SPACETIMEDB_STRUCT(IndexedTable, player_id)
+SPACETIMEDB_TABLE(IndexedTable, indexed_table, Private)
+FIELD_Index(indexed_table, player_id)
+
+// IndexedTable2 with multiple indexes
+struct IndexedTable2 {
+    uint32_t player_id;
+    float player_snazz;
+};
+SPACETIMEDB_STRUCT(IndexedTable2, player_id, player_snazz)
+SPACETIMEDB_TABLE(IndexedTable2, indexed_table_2, Private)
+FIELD_Index(indexed_table_2, player_id)
+// Note: float fields cannot be indexed - removing this constraint
+// FIELD_Index(indexed_table_2, player_snazz)  // Would fail compile-time validation
+
+// BTreeU32 table with index
+struct BTreeU32 {
+    uint32_t n;
+    int32_t data;
+};
+SPACETIMEDB_STRUCT(BTreeU32, n, data)
+SPACETIMEDB_TABLE(BTreeU32, btree_u32, Public)
+FIELD_Index(btree_u32, n)
+
+// PkU32Two - additional primary key table
+struct PkU32Two { uint32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU32Two, n, data)
+SPACETIMEDB_TABLE(PkU32Two, pk_u32_two, Public)
+FIELD_PrimaryKey(pk_u32_two, n)
+
+// Reducers for constraint tables
+SPACETIMEDB_REDUCER(insert_indexed_table, ReducerContext ctx, uint32_t player_id)
+{
+    ctx.db.table<IndexedTable>("indexed_table").insert(IndexedTable{player_id});
+}
+
+SPACETIMEDB_REDUCER(insert_indexed_table_2, ReducerContext ctx, uint32_t player_id, float player_snazz)
+{
+    ctx.db.table<IndexedTable2>("indexed_table_2").insert(IndexedTable2{player_id, player_snazz});
+}
+
+SPACETIMEDB_REDUCER(insert_btree_u32, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    ctx.db.table<BTreeU32>("btree_u32").insert(BTreeU32{n, data});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test.o b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test.o
new file mode 100644
index 00000000000..e552055a4f6
Binary files /dev/null and b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test.o differ
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_complex_reducer_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_complex_reducer_only.cpp
new file mode 100644
index 00000000000..5aa0575ac8e
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_complex_reducer_only.cpp
@@ -0,0 +1,56 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+
+// Complex struct with special types
+struct EveryPrimitiveStruct {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    Identity q;
+    ConnectionId r;
+    Timestamp s;
+    TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// Simple table without the complex struct
+struct SimpleTable {
+    int32_t id;
+    std::string value;
+};
+SPACETIMEDB_STRUCT(SimpleTable, id, value)
+SPACETIMEDB_TABLE(SimpleTable, simple_table, Public)
+
+// Reducer that uses the complex struct as parameter
+SPACETIMEDB_REDUCER(insert_with_complex, ReducerContext ctx, EveryPrimitiveStruct data)
+{
+    SimpleTable row;
+    row.id = data.i;  // Use the int32_t field as id
+    row.value = data.p;  // Use the string field as value
+    ctx.db.table<SimpleTable>("simple_table").insert(row);
+}
+
+// Another reducer without complex struct
+SPACETIMEDB_REDUCER(insert_simple, ReducerContext ctx, int32_t id, std::string value)
+{
+    SimpleTable row;
+    row.id = id;
+    row.value = value;
+    ctx.db.table<SimpleTable>("simple_table").insert(row);
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_complex_table_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_complex_table_only.cpp
new file mode 100644
index 00000000000..4bef88d165c
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_complex_table_only.cpp
@@ -0,0 +1,67 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+
+// Complex struct with special types
+struct EveryPrimitiveStruct {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    Identity q;
+    ConnectionId r;
+    Timestamp s;
+    TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// Table with the complex struct as a field
+struct ComplexTable {
+    int32_t id;
+    EveryPrimitiveStruct data;
+};
+SPACETIMEDB_STRUCT(ComplexTable, id, data)
+SPACETIMEDB_TABLE(ComplexTable, complex_table, Public)
+
+// Reducer that doesn't use the complex struct as parameter
+SPACETIMEDB_REDUCER(insert_default, ReducerContext ctx, int32_t id)
+{
+    ComplexTable row;
+    row.id = id;
+    // Initialize struct fields explicitly
+    row.data.a = 1;
+    row.data.b = 2;
+    row.data.c = 3;
+    row.data.d = 4;
+    row.data.e = u128{5};
+    row.data.f = u256();  // Default constructor
+    row.data.g = 7;
+    row.data.h = 8;
+    row.data.i = 9;
+    row.data.j = 10;
+    row.data.k = i128{11};
+    row.data.l = i256();  // Default constructor
+    row.data.m = true;
+    row.data.n = 14.0f;
+    row.data.o = 15.0;
+    row.data.p = "test";
+    row.data.q = Identity();  // Default constructor
+    row.data.r = ConnectionId{u128{17}};
+    row.data.s = Timestamp::now();
+    row.data.t = TimeDuration{100};
+    ctx.db.table<ComplexTable>("complex_table").insert(row);
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_connectionid_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_connectionid_only.cpp
new file mode 100644
index 00000000000..6ec6fa2bbda
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_connectionid_only.cpp
@@ -0,0 +1,13 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+
+// Simple table with just ConnectionId
+struct TestConnectionId {
+    uint32_t id;
+    ConnectionId conn_id;
+};
+SPACETIMEDB_STRUCT(TestConnectionId, id, conn_id)
+SPACETIMEDB_TABLE(TestConnectionId, test_connection_id, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_debug_optional.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_debug_optional.cpp
new file mode 100644
index 00000000000..6a12f5988a8
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_debug_optional.cpp
@@ -0,0 +1,43 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+#include <optional>
+#include <cstdio>
+
+using namespace SpacetimeDb;
+
+// Global constructor to run before __preinit__
+struct DebugInit {
+    DebugInit() {
+        fprintf(stdout, "DEBUG: DebugInit constructor called\n");
+    }
+};
+static DebugInit debug_init;
+
+
+// Table with optional field - will this trigger the crash?
+struct OptionalTable {
+    uint32_t id;
+    std::optional<int32_t> maybe_value;
+};
+
+// First register the BSATN struct
+SPACETIMEDB_STRUCT(OptionalTable, id, maybe_value)
+
+// Global constructor after BSATN registration
+struct AfterBsatn {
+    AfterBsatn() {
+        fprintf(stdout, "DEBUG: AfterBsatn constructor called\n");
+    }
+};
+static AfterBsatn after_bsatn;
+
+// Then register the table
+SPACETIMEDB_TABLE(OptionalTable, optional_table, Public)
+
+// Global constructor after TABLE registration
+struct AfterTable {
+    AfterTable() {
+        fprintf(stdout, "DEBUG: AfterTable constructor called\n");
+    }
+};
+static AfterTable after_table;
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_enum_table_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_enum_table_only.cpp
new file mode 100644
index 00000000000..68d7e96b95f
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_enum_table_only.cpp
@@ -0,0 +1,74 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+#include <variant>
+
+using namespace SpacetimeDb;
+
+// Test: EnumWithPayload in table but NOT as reducer parameter
+// This isolates whether the issue is with table storage or reducer params
+
+
+// SimpleEnum - basic enum using new unified syntax
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+
+// EnumWithPayload - with all the problematic vector types using new unified syntax
+SPACETIMEDB_ENUM(EnumWithPayload,
+    (U8, uint8_t),
+    (U16, uint16_t),
+    (U32, uint32_t),
+    (U64, uint64_t),
+    (U128, SpacetimeDb::u128),
+    (U256, SpacetimeDb::u256),
+    (I8, int8_t),
+    (I16, int16_t),
+    (I32, int32_t),
+    (I64, int64_t),
+    (I128, SpacetimeDb::i128),
+    (I256, SpacetimeDb::i256),
+    (Bool, bool),
+    (F32, float),
+    (F64, double),
+    (Str, std::string),
+    (Identity, SpacetimeDb::Identity),
+    (ConnectionId, SpacetimeDb::ConnectionId),
+    (Timestamp, SpacetimeDb::Timestamp),
+    (Bytes, std::vector<uint8_t>),
+    (Ints, std::vector<int32_t>),
+    (Strings, std::vector<std::string>),
+    (SimpleEnums, std::vector<SimpleEnum>)
+)
+
+// Table with EnumWithPayload - this should work fine
+struct EnumTable { 
+    EnumWithPayload e; 
+    int32_t id;
+};
+SPACETIMEDB_STRUCT(EnumTable, e, id)
+SPACETIMEDB_TABLE(EnumTable, enum_table, Public)
+
+// Reducers that DON'T use EnumWithPayload as parameters
+// Instead use simple types only
+
+SPACETIMEDB_REDUCER(insert_simple, ReducerContext ctx, int32_t id)
+{
+    // Create an EnumWithPayload and insert it
+    EnumWithPayload e = uint8_t{42}; // U8 variant
+    ctx.db.table<EnumTable>("enum_table").insert(EnumTable{e, id});
+}
+
+SPACETIMEDB_REDUCER(insert_bytes, ReducerContext ctx, int32_t id)
+{
+    // Create Bytes variant and insert
+    std::vector<uint8_t> bytes = {1, 2, 3, 4};
+    EnumWithPayload e = bytes; // Bytes variant  
+    ctx.db.table<EnumTable>("enum_table").insert(EnumTable{e, id});
+}
+
+SPACETIMEDB_REDUCER(query_all, ReducerContext ctx)
+{
+    auto table = ctx.db.table<EnumTable>("enum_table");
+    for (auto& row : table) {
+        // Process the EnumWithPayload in table storage
+        LOG_INFO("Found enum table row");
+    }
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_enum_vector_payloads.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_enum_vector_payloads.cpp
new file mode 100644
index 00000000000..a939b08ff13
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_enum_vector_payloads.cpp
@@ -0,0 +1,39 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test enum variants containing vectors - the missing pattern from lib.cpp
+SPACETIMEDB_ENUM(SimpleEnum, A, B, C)
+
+// Critical test: Enum with vector payloads (especially vector of enums)
+SPACETIMEDB_ENUM(EnumWithVectorPayloads,
+    (Bytes, std::vector<uint8_t>),
+    (Ints, std::vector<int32_t>),
+    (Strings, std::vector<std::string>),
+    (SimpleEnums, std::vector<SimpleEnum>)  // Vector of enums in enum variant!
+)
+
+// Table using the complex enum
+struct TableWithComplexEnum {
+    EnumWithVectorPayloads complex_enum;
+};
+SPACETIMEDB_STRUCT(TableWithComplexEnum, complex_enum)
+SPACETIMEDB_TABLE(TableWithComplexEnum, table_with_complex_enum, Public)
+
+// Even more complex: Vector of enums that contain vectors
+struct TableWithVectorOfComplexEnums {
+    std::vector<EnumWithVectorPayloads> vec_of_complex_enums;
+};
+SPACETIMEDB_STRUCT(TableWithVectorOfComplexEnums, vec_of_complex_enums)
+SPACETIMEDB_TABLE(TableWithVectorOfComplexEnums, table_with_vector_of_complex_enums, Public)
+
+// Test reducers
+SPACETIMEDB_REDUCER(test_complex_enum, ReducerContext ctx, EnumWithVectorPayloads e)
+{
+    ctx.db[table_with_complex_enum].insert(TableWithComplexEnum{e});
+}
+
+SPACETIMEDB_REDUCER(test_vector_complex_enum, ReducerContext ctx, std::vector<EnumWithVectorPayloads> vec)
+{
+    ctx.db[table_with_vector_of_complex_enums].insert(TableWithVectorOfComplexEnums{vec});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_identity_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_identity_only.cpp
new file mode 100644
index 00000000000..44d660a27d3
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_identity_only.cpp
@@ -0,0 +1,13 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+
+// Simple table with just Identity
+struct TestIdentity {
+    uint32_t id;
+    Identity identity;
+};
+SPACETIMEDB_STRUCT(TestIdentity, id, identity)
+SPACETIMEDB_TABLE(TestIdentity, test_identity, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_massive_reducer.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_massive_reducer.cpp
new file mode 100644
index 00000000000..c79b9d1c6db
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_massive_reducer.cpp
@@ -0,0 +1,78 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Recreate the problematic pattern from lib.cpp
+SPACETIMEDB_ENUM(SimpleEnum, A, B, C)
+
+SPACETIMEDB_ENUM(EnumWithPayload,
+    (U8, uint8_t),
+    (U16, uint16_t),
+    (U32, uint32_t),
+    (U64, uint64_t),
+    (U128, SpacetimeDb::u128),
+    (U256, SpacetimeDb::u256),
+    (I8, int8_t),
+    (I16, int16_t),
+    (I32, int32_t),
+    (I64, int64_t),
+    (I128, SpacetimeDb::i128),
+    (I256, SpacetimeDb::i256),
+    (Bool, bool),
+    (F32, float),
+    (F64, double),
+    (Str, std::string),
+    (Identity, SpacetimeDb::Identity),
+    (ConnectionId, SpacetimeDb::ConnectionId),
+    (Timestamp, SpacetimeDb::Timestamp),
+    (Bytes, std::vector<uint8_t>),
+    (Ints, std::vector<int32_t>),
+    (Strings, std::vector<std::string>),
+    (SimpleEnums, std::vector<SimpleEnum>)
+)
+
+SPACETIMEDB_UNIT_STRUCT(UnitStruct)
+
+struct ByteStruct { uint8_t b; };
+SPACETIMEDB_STRUCT(ByteStruct, b)
+
+struct EveryPrimitiveStruct {
+    uint8_t a; uint16_t b; uint32_t c; uint64_t d; u128 e; u256 f;
+    int8_t g; int16_t h; int32_t i; int64_t j; i128 k; i256 l;
+    bool m; float n; double o; std::string p;
+    Identity q; ConnectionId r; Timestamp s; TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+struct EveryVecStruct {
+    std::vector<uint8_t> a; std::vector<uint16_t> b; std::vector<uint32_t> c; std::vector<uint64_t> d;
+    std::vector<u128> e; std::vector<u256> f; std::vector<int8_t> g; std::vector<int16_t> h;
+    std::vector<int32_t> i; std::vector<int64_t> j; std::vector<i128> k; std::vector<i256> l;
+    std::vector<bool> m; std::vector<float> n; std::vector<double> o; std::vector<std::string> p;
+    std::vector<Identity> q; std::vector<ConnectionId> r; std::vector<Timestamp> s; std::vector<TimeDuration> t;
+};
+SPACETIMEDB_STRUCT(EveryVecStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// The monster struct that combines everything
+struct LargeTable {
+    uint8_t a; uint16_t b; uint32_t c; uint64_t d; u128 e; u256 f;
+    int8_t g; int16_t h; int32_t i; int64_t j; i128 k; i256 l;
+    bool m; float n; double o; std::string p;
+    SimpleEnum q; EnumWithPayload r; UnitStruct s; ByteStruct t;
+    EveryPrimitiveStruct u; EveryVecStruct v;
+};
+SPACETIMEDB_STRUCT(LargeTable, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)
+SPACETIMEDB_TABLE(LargeTable, large_table, Public)
+
+// The problematic reducer with 22 parameters including complex nested structures
+SPACETIMEDB_REDUCER(insert_large_table, ReducerContext ctx,
+    uint8_t a, uint16_t b, uint32_t c, uint64_t d, u128 e, u256 f,
+    int8_t g, int16_t h, int32_t i, int64_t j, i128 k, i256 l,
+    bool m, float n, double o, std::string p,
+    SimpleEnum q, EnumWithPayload r, UnitStruct s, ByteStruct t,
+    EveryPrimitiveStruct u, EveryVecStruct v)
+{
+    ctx.db[large_table].insert(LargeTable{
+        a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v
+    });
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_minimal_special.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_minimal_special.cpp
new file mode 100644
index 00000000000..a1b17b46981
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_minimal_special.cpp
@@ -0,0 +1,16 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Minimal test - just one table with Identity and one reducer with Identity parameter
+
+// Simple Identity table
+struct SimpleIdentityTable { Identity id; };
+SPACETIMEDB_STRUCT(SimpleIdentityTable, id)
+SPACETIMEDB_TABLE(SimpleIdentityTable, simple_identity_table, Public)
+
+// Single reducer with direct Identity parameter
+SPACETIMEDB_REDUCER(test_identity_reducer, ReducerContext ctx, Identity i)
+{
+    ctx.db.table<SimpleIdentityTable>("simple_identity_table").insert(SimpleIdentityTable{i});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_mixed_types.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_mixed_types.cpp
new file mode 100644
index 00000000000..e57082dce94
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_mixed_types.cpp
@@ -0,0 +1,21 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+
+// Table with working type (Identity)
+struct TestIdentity {
+    uint32_t id;
+    Identity identity;
+};
+SPACETIMEDB_STRUCT(TestIdentity, id, identity)
+SPACETIMEDB_TABLE(TestIdentity, test_identity, Public)
+
+// Table with failing type (u128)  
+struct TestU128 {
+    uint32_t id;
+    u128 value;
+};
+SPACETIMEDB_STRUCT(TestU128, id, value)
+SPACETIMEDB_TABLE(TestU128, test_u128, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_nested_optionals.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_nested_optionals.cpp
new file mode 100644
index 00000000000..2c1281b46ad
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_nested_optionals.cpp
@@ -0,0 +1,39 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test the problematic nested optional patterns from lib.cpp
+
+// Large struct to use in optional
+struct EveryPrimitiveStruct {
+    uint8_t a; uint16_t b; uint32_t c; uint64_t d; u128 e; u256 f;
+    int8_t g; int16_t h; int32_t i; int64_t j; i128 k; i256 l;
+    bool m; float n; double o; std::string p;
+    Identity q; ConnectionId r; Timestamp s; TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// The problematic nested optional: optional vector of optional integers
+struct OptionVecOptionI32 { 
+    std::optional<std::vector<std::optional<int32_t>>> v; 
+};
+SPACETIMEDB_STRUCT(OptionVecOptionI32, v)
+SPACETIMEDB_TABLE(OptionVecOptionI32, option_vec_option_i32, Public)
+
+// Optional complex struct
+struct OptionEveryPrimitiveStruct { 
+    std::optional<EveryPrimitiveStruct> s; 
+};
+SPACETIMEDB_STRUCT(OptionEveryPrimitiveStruct, s)
+SPACETIMEDB_TABLE(OptionEveryPrimitiveStruct, option_every_primitive_struct, Public)
+
+// Test reducers with nested optional parameters
+SPACETIMEDB_REDUCER(insert_option_vec_option_i32, ReducerContext ctx, std::optional<std::vector<std::optional<int32_t>>> v)
+{
+    ctx.db[option_vec_option_i32].insert(OptionVecOptionI32{v});
+}
+
+SPACETIMEDB_REDUCER(insert_option_every_primitive_struct, ReducerContext ctx, std::optional<EveryPrimitiveStruct> s)
+{
+    ctx.db[option_every_primitive_struct].insert(OptionEveryPrimitiveStruct{s});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_debug.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_debug.cpp
new file mode 100644
index 00000000000..1e81332cfd9
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_debug.cpp
@@ -0,0 +1,19 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+// MINIMAL TEST: Just optional in table field, NO reducer parameters
+// This isolates whether issue is in table registration vs reducer parameter processing
+
+struct OptionalTable {
+    std::optional<int32_t> maybe_value;
+};
+SPACETIMEDB_STRUCT(OptionalTable, maybe_value)
+SPACETIMEDB_TABLE(OptionalTable, optional_table, Public)
+
+// Simple reducer that doesn't use optional as parameter
+SPACETIMEDB_REDUCER(test_basic, ReducerContext ctx)
+{
+    LOG_INFO("Basic reducer called");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_reducer_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_reducer_only.cpp
new file mode 100644
index 00000000000..2d5932dfa18
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_reducer_only.cpp
@@ -0,0 +1,41 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+// Test: Optional in reducer only (no table fields)
+
+
+// Struct with optional field (used as reducer parameter)
+struct OptionalParam {
+    int32_t id;
+    std::optional<int32_t> opt_value;
+};
+SPACETIMEDB_STRUCT(OptionalParam, id, opt_value)
+
+// Simple non-optional table
+struct SimpleTable {
+    int32_t id;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(SimpleTable, id, value)
+SPACETIMEDB_TABLE(SimpleTable, simple_table, Public)
+
+// Reducer that uses struct with optional as parameter
+SPACETIMEDB_REDUCER(insert_with_optional, ReducerContext ctx, OptionalParam param)
+{
+    SimpleTable row;
+    row.id = param.id;
+    // Use the optional value or default to 0
+    row.value = param.opt_value.value_or(0);
+    ctx.db.table<SimpleTable>("simple_table").insert(row);
+}
+
+// Another reducer without optional
+SPACETIMEDB_REDUCER(insert_direct, ReducerContext ctx, int32_t id, int32_t value)
+{
+    SimpleTable row;
+    row.id = id;
+    row.value = value;
+    ctx.db.table<SimpleTable>("simple_table").insert(row);
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_simple.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_simple.cpp
new file mode 100644
index 00000000000..dbe61be1ee3
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_simple.cpp
@@ -0,0 +1,28 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+#include <optional>
+
+using namespace SpacetimeDb;
+
+
+// Simple table with optional field
+struct SimpleOptional {
+    uint32_t id;
+    std::optional<int32_t> maybe_value;
+};
+
+SPACETIMEDB_STRUCT(SimpleOptional, id, maybe_value)
+SPACETIMEDB_TABLE(SimpleOptional, simple_optional, Public)
+
+// Parameter wrapper to avoid direct optional parameter
+struct OptionalParam {
+    uint32_t id;
+    std::optional<int32_t> value;
+};
+SPACETIMEDB_STRUCT(OptionalParam, id, value)
+
+// Reducer to insert optional value (using struct wrapper instead of direct optional parameter)
+SPACETIMEDB_REDUCER(insert_optional, ReducerContext ctx, OptionalParam param)
+{
+    ctx.db.table<SimpleOptional>("simple_optional").insert(SimpleOptional{param.id, param.value});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_table_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_table_only.cpp
new file mode 100644
index 00000000000..511ccf8fbdb
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_optional_table_only.cpp
@@ -0,0 +1,29 @@
+#include <spacetimedb.h>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+// Test: Optional in table only (no reducer parameters)
+
+
+// Simple optional table
+struct OptionalI32Table {
+    std::optional<int32_t> value;
+};
+SPACETIMEDB_STRUCT(OptionalI32Table, value)
+SPACETIMEDB_TABLE(OptionalI32Table, optional_i32_table, Public)
+
+// Reducer that doesn't use optional as parameter
+SPACETIMEDB_REDUCER(insert_value, ReducerContext ctx, int32_t v)
+{
+    OptionalI32Table row;
+    row.value = v;  // Convert to optional
+    ctx.db.table<OptionalI32Table>("optional_i32_table").insert(row);
+}
+
+SPACETIMEDB_REDUCER(insert_none, ReducerContext ctx)
+{
+    OptionalI32Table row;
+    row.value = std::nullopt;
+    ctx.db.table<OptionalI32Table>("optional_i32_table").insert(row);
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_simple_table.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_simple_table.cpp
new file mode 100644
index 00000000000..2c67ce11158
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_simple_table.cpp
@@ -0,0 +1,16 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+SPACETIMEDB_INIT(init) {
+    LOG_INFO("Test simple table initialized");
+}
+
+// Simplest possible table - no optional fields
+struct SimpleTable {
+    uint32_t id;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(SimpleTable, id, value)
+SPACETIMEDB_TABLE(SimpleTable, simple_table, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_single_special_vector.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_single_special_vector.cpp
new file mode 100644
index 00000000000..4465f4887a1
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_single_special_vector.cpp
@@ -0,0 +1,12 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test: Single vector of special type to isolate the exact error
+// Start with just std::vector<Identity> to pinpoint the issue
+
+
+// Test just one vector of Identity
+struct TestVecIdentity { std::vector<Identity> identities; };
+SPACETIMEDB_STRUCT(TestVecIdentity, identities)
+SPACETIMEDB_TABLE(TestVecIdentity, test_vec_identity, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_special_minimal.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_special_minimal.cpp
new file mode 100644
index 00000000000..dffcb9783de
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_special_minimal.cpp
@@ -0,0 +1,20 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Minimal test: Just the three basic special types together
+// Testing if combination of Identity + ConnectionId + Timestamp causes issues
+
+
+// Test 1: Individual tables (should work based on isolated tests)
+struct TestIdentity { Identity i; };
+SPACETIMEDB_STRUCT(TestIdentity, i)
+SPACETIMEDB_TABLE(TestIdentity, test_identity, Public)
+
+struct TestConnectionId { ConnectionId c; };  
+SPACETIMEDB_STRUCT(TestConnectionId, c)
+SPACETIMEDB_TABLE(TestConnectionId, test_connection_id, Public)
+
+struct TestTimestamp { Timestamp t; };
+SPACETIMEDB_STRUCT(TestTimestamp, t)  
+SPACETIMEDB_TABLE(TestTimestamp, test_timestamp, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_special_vectors.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_special_vectors.cpp
new file mode 100644
index 00000000000..0f44601808f
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_special_vectors.cpp
@@ -0,0 +1,20 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Test: Vectors of special types
+// Testing if std::vector<Identity>, std::vector<ConnectionId>, std::vector<Timestamp> cause issues
+
+
+// Test vectors of special types
+struct VecIdentity { std::vector<Identity> identities; };
+SPACETIMEDB_STRUCT(VecIdentity, identities)
+SPACETIMEDB_TABLE(VecIdentity, vec_identity, Public)
+
+struct VecConnectionId { std::vector<ConnectionId> connections; };
+SPACETIMEDB_STRUCT(VecConnectionId, connections)
+SPACETIMEDB_TABLE(VecConnectionId, vec_connection_id, Public)
+
+struct VecTimestamp { std::vector<Timestamp> timestamps; };
+SPACETIMEDB_STRUCT(VecTimestamp, timestamps)
+SPACETIMEDB_TABLE(VecTimestamp, vec_timestamp, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_timeduration_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_timeduration_only.cpp
new file mode 100644
index 00000000000..e4b9f3b46da
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_timeduration_only.cpp
@@ -0,0 +1,13 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+
+// Simple table with just TimeDuration
+struct TestTimeDuration {
+    uint32_t id;
+    TimeDuration duration;
+};
+SPACETIMEDB_STRUCT(TestTimeDuration, id, duration)
+SPACETIMEDB_TABLE(TestTimeDuration, test_time_duration, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_timestamp_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_timestamp_only.cpp
new file mode 100644
index 00000000000..90961b3eddb
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_timestamp_only.cpp
@@ -0,0 +1,13 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+
+// Simple table with just Timestamp
+struct TestTimestamp {
+    uint32_t id;
+    Timestamp timestamp;
+};
+SPACETIMEDB_STRUCT(TestTimestamp, id, timestamp)
+SPACETIMEDB_TABLE(TestTimestamp, test_timestamp, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_u128_only.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_u128_only.cpp
new file mode 100644
index 00000000000..d4bd7c1238f
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_u128_only.cpp
@@ -0,0 +1,13 @@
+#include <spacetimedb.h>
+// Removed: enhanced_database.h (unused functionality)
+
+using namespace SpacetimeDb;
+
+
+// Simple table with just u128
+struct TestU128 {
+    uint32_t id;
+    u128 value;
+};
+SPACETIMEDB_STRUCT(TestU128, id, value)
+SPACETIMEDB_TABLE(TestU128, test_u128, Public)
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unified_enum.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unified_enum.cpp
new file mode 100644
index 00000000000..5ab9ec82caa
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unified_enum.cpp
@@ -0,0 +1,23 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+
+// Test 1: Simple enum (should route to SPACETIMEDB_ENUM_SIMPLE)
+SPACETIMEDB_ENUM(SimpleTestEnum, Red, Green, Blue)
+
+// Test 2: Complex enum using unified syntax
+SPACETIMEDB_ENUM(ComplexTestEnum, (Number, uint32_t), (Text, std::string))
+
+// Test table with simple enum
+struct TestTable {
+    uint32_t id;
+    SimpleTestEnum color;
+};
+SPACETIMEDB_STRUCT(TestTable, id, color)
+SPACETIMEDB_TABLE(TestTable, test_table, Public)
+
+// Test reducer with complex enum parameter
+SPACETIMEDB_REDUCER(test_complex_enum, ReducerContext ctx, ComplexTestEnum value) {
+    LOG_INFO("Complex enum test completed");
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_isolation.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_isolation.cpp
new file mode 100644
index 00000000000..34cb577c374
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_isolation.cpp
@@ -0,0 +1,67 @@
+// Isolate the exact unit type serialization issue
+#include "spacetimedb.h"
+#include <cstdint>
+
+using namespace SpacetimeDb;
+
+SPACETIMEDB_UNIT_STRUCT(TestUnit)
+
+// Test 1: Just unit + primitive in struct (this should work)
+struct UnitPlusInt {
+    TestUnit unit;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(UnitPlusInt, unit, value)
+SPACETIMEDB_TABLE(UnitPlusInt, unit_plus_int, Public)
+
+// Test 2: Two units + primitive (this might fail)
+SPACETIMEDB_UNIT_STRUCT(SecondUnit)
+struct TwoUnits {
+    TestUnit unit1;
+    SecondUnit unit2;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(TwoUnits, unit1, unit2, value)
+SPACETIMEDB_TABLE(TwoUnits, two_units, Public)
+
+// Test 3: Nested struct with unit (this is where we expect failure)
+struct NestedUnitTest {
+    UnitPlusInt nested;
+    TestUnit another_unit;
+};
+SPACETIMEDB_STRUCT(NestedUnitTest, nested, another_unit)
+SPACETIMEDB_TABLE(NestedUnitTest, nested_unit_test, Public)
+
+// Test different insertion patterns
+SPACETIMEDB_REDUCER(test_step1_simple, ReducerContext ctx) {
+    TestUnit unit{};
+    ctx.db[unit_plus_int].insert({unit, 100});
+}
+
+SPACETIMEDB_REDUCER(test_step2_two_units, ReducerContext ctx) {
+    TestUnit unit1{};
+    SecondUnit unit2{};
+    ctx.db[two_units].insert({unit1, unit2, 200});
+}
+
+SPACETIMEDB_REDUCER(test_step3_nested_fail, ReducerContext ctx) {
+    TestUnit unit{};
+    UnitPlusInt simple{unit, 300};
+    NestedUnitTest nested{simple, unit};
+    // This should fail with size mismatch
+    ctx.db[nested_unit_test].insert(nested);
+}
+
+SPACETIMEDB_INIT(init) {
+    // Start with simple cases that should work
+    TestUnit unit{};
+    ctx.db[unit_plus_int].insert({unit, 100});
+    
+    SecondUnit unit2{};
+    ctx.db[two_units].insert({unit, unit2, 200});
+    
+    // This line should cause the failure:
+    UnitPlusInt simple{unit, 300};
+    NestedUnitTest nested{simple, unit};
+    ctx.db[nested_unit_test].insert(nested);
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_progression.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_progression.cpp
new file mode 100644
index 00000000000..36423d4d587
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_progression.cpp
@@ -0,0 +1,83 @@
+// Progressive unit type testing to isolate the exact failure
+#include "spacetimedb.h"
+#include <cstdint>
+
+using namespace SpacetimeDb;
+
+// Test 1: Single unit (we know this works)
+SPACETIMEDB_UNIT_STRUCT(TestUnit)
+
+// Test 2: Multiple units
+SPACETIMEDB_UNIT_STRUCT(Unit1)
+SPACETIMEDB_UNIT_STRUCT(Unit2)
+
+// Test 3: Unit in simple struct
+struct SimpleStructWithUnit {
+    TestUnit unit;
+    int32_t data;
+};
+SPACETIMEDB_STRUCT(SimpleStructWithUnit, unit, data)
+
+// Test 4: Multiple units in struct
+struct StructWithMultipleUnits {
+    Unit1 unit1;
+    Unit2 unit2;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(StructWithMultipleUnits, unit1, unit2, value)
+
+// Test 5: Table with unit field
+struct TableWithUnit {
+    TestUnit unit;
+    int32_t id;
+};
+SPACETIMEDB_STRUCT(TableWithUnit, unit, id)
+SPACETIMEDB_TABLE(TableWithUnit, table_with_unit, Public)
+
+// Test 6: Table with multiple units  
+struct TableWithMultipleUnits {
+    Unit1 unit1;
+    Unit2 unit2;
+    int32_t id;
+};
+SPACETIMEDB_STRUCT(TableWithMultipleUnits, unit1, unit2, id)
+SPACETIMEDB_TABLE(TableWithMultipleUnits, table_with_multiple_units, Public)
+
+// Test 7: Nested struct with units
+struct NestedUnit {
+    SimpleStructWithUnit nested;
+    TestUnit unit;
+};
+SPACETIMEDB_STRUCT(NestedUnit, nested, unit)
+SPACETIMEDB_TABLE(NestedUnit, nested_unit_table, Public)
+
+// Reducers to test each step
+SPACETIMEDB_REDUCER(test_single_unit, ReducerContext ctx, TestUnit unit) {
+    ctx.db[table_with_unit].insert({unit, 1});
+}
+
+SPACETIMEDB_REDUCER(test_multiple_units, ReducerContext ctx, Unit1 u1, Unit2 u2) {
+    ctx.db[table_with_multiple_units].insert({u1, u2, 2});
+}
+
+SPACETIMEDB_REDUCER(test_struct_with_unit, ReducerContext ctx, SimpleStructWithUnit s) {
+    ctx.db[table_with_unit].insert({s.unit, s.data});
+}
+
+SPACETIMEDB_REDUCER(test_nested_units, ReducerContext ctx, NestedUnit nested) {
+    ctx.db[nested_unit_table].insert(nested);
+}
+
+SPACETIMEDB_INIT(init) {
+    TestUnit test_unit{};
+    Unit1 unit1{};
+    Unit2 unit2{};
+    
+    // Test basic operations
+    ctx.db[table_with_unit].insert({test_unit, 100});
+    ctx.db[table_with_multiple_units].insert({unit1, unit2, 200});
+    
+    SimpleStructWithUnit simple{test_unit, 300};
+    NestedUnit nested{simple, test_unit};
+    ctx.db[nested_unit_table].insert(nested);
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_simple.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_simple.cpp
new file mode 100644
index 00000000000..76de63877dc
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_simple.cpp
@@ -0,0 +1,23 @@
+// Simplified test module for unit struct types
+#include "spacetimedb.h"
+#include <cstdint>
+
+using namespace SpacetimeDb;
+
+// Define a single unit struct
+SPACETIMEDB_UNIT_STRUCT(BasicUnit)
+
+// Simple table with unit field
+struct SimpleTable {
+    uint32_t id;
+    BasicUnit unit;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(SimpleTable, id, unit, value)
+SPACETIMEDB_TABLE(SimpleTable, simple_table, Public)
+
+// Init reducer
+SPACETIMEDB_INIT(init) {
+    BasicUnit unit{};
+    ctx.db[simple_table].insert({1, unit, 100});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_struct.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_struct.cpp
new file mode 100644
index 00000000000..da4620d9af1
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_unit_struct.cpp
@@ -0,0 +1,113 @@
+// Test module for unit struct types
+#include "spacetimedb.h"
+#include <cstdint>
+
+using namespace SpacetimeDb;
+
+// Define various unit structs using the macro
+SPACETIMEDB_UNIT_STRUCT(BasicUnit)
+SPACETIMEDB_UNIT_STRUCT(AnotherUnit)
+SPACETIMEDB_UNIT_STRUCT(ThirdUnit)
+
+// Removed monostate struct - causes issues
+
+// Regular struct that contains unit types
+struct StructWithUnits {
+    int32_t id;
+    BasicUnit basic;
+    AnotherUnit another;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(StructWithUnits, id, basic, another, name)
+
+// Nested struct with units
+struct NestedWithUnits {
+    StructWithUnits nested;
+    ThirdUnit third;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(NestedWithUnits, nested, third, value)
+
+// Table with unit fields
+struct TableWithUnits {
+    uint32_t id_field;
+    BasicUnit unit_field;
+    int32_t data;
+};
+SPACETIMEDB_STRUCT(TableWithUnits, id_field, unit_field, data)
+SPACETIMEDB_TABLE(TableWithUnits, table_with_units, Public)
+
+// Another table with nested units
+struct ComplexTable {
+    uint32_t key_field;
+    StructWithUnits complex_field;
+    std::string description;
+};
+SPACETIMEDB_STRUCT(ComplexTable, key_field, complex_field, description)
+SPACETIMEDB_TABLE(ComplexTable, complex_table, Public)
+
+// Table that is just units and primitives
+struct SimpleUnitTable {
+    BasicUnit unit1;
+    AnotherUnit unit2;
+    int32_t value;
+};
+SPACETIMEDB_STRUCT(SimpleUnitTable, unit1, unit2, value)
+SPACETIMEDB_TABLE(SimpleUnitTable, simple_unit_table, Public)
+
+// Reducers that use unit types
+
+// Reducer with unit parameter
+SPACETIMEDB_REDUCER(reducer_with_unit_param, ReducerContext ctx, BasicUnit unit_param, int32_t value) {
+    // Insert into table
+    ctx.db[table_with_units].insert({
+        static_cast<uint32_t>(value),
+        unit_param,
+        value * 2
+    });
+}
+
+// Reducer with struct containing units
+SPACETIMEDB_REDUCER(reducer_with_struct_param, ReducerContext ctx, StructWithUnits struct_param) {
+    // Insert into complex table
+    ctx.db[complex_table].insert({
+        static_cast<uint32_t>(struct_param.id),
+        struct_param,
+        "From reducer"
+    });
+}
+
+// Reducer with multiple unit parameters
+SPACETIMEDB_REDUCER(reducer_multiple_units, ReducerContext ctx, 
+                    BasicUnit unit1, AnotherUnit unit2, ThirdUnit unit3, int32_t id) {
+    // Insert simple unit table
+    ctx.db[simple_unit_table].insert({
+        unit1,
+        unit2,
+        id
+    });
+}
+
+// Reducer returning unit type in struct
+SPACETIMEDB_REDUCER(reducer_nested_units, ReducerContext ctx, NestedWithUnits nested) {
+    // Access nested units
+    ctx.db[complex_table].insert({
+        static_cast<uint32_t>(nested.value),
+        nested.nested,
+        "Nested units"
+    });
+}
+
+// Init reducer
+SPACETIMEDB_INIT(init) {
+    // Create some initial data with units
+    BasicUnit basic{};
+    AnotherUnit another{};
+    
+    ctx.db[table_with_units].insert({1, basic, 100});
+    
+    StructWithUnits s{42, basic, another, "initial"};
+    ctx.db[complex_table].insert({1, s, "Initial entry"});
+    
+    ctx.db[simple_unit_table].insert({basic, another, 999});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_wrapped_special.cpp b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_wrapped_special.cpp
new file mode 100644
index 00000000000..1256d2c6a3f
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/test_modules/test_wrapped_special.cpp
@@ -0,0 +1,20 @@
+#include <spacetimedb.h>
+
+using namespace SpacetimeDb;
+
+// Control test - same functionality but with wrapped parameters (should work)
+
+// Simple Identity table
+struct SimpleIdentityTable { Identity id; };
+SPACETIMEDB_STRUCT(SimpleIdentityTable, id)
+SPACETIMEDB_TABLE(SimpleIdentityTable, simple_identity_table, Public)
+
+// Parameter wrapper struct
+struct IdentityParam { Identity id; };
+SPACETIMEDB_STRUCT(IdentityParam, id)
+
+// Reducer with wrapped Identity parameter (should work)
+SPACETIMEDB_REDUCER(test_identity_reducer, ReducerContext ctx, IdentityParam param)
+{
+    ctx.db.table<SimpleIdentityTable>("simple_identity_table").insert(SimpleIdentityTable{param.id});
+}
\ No newline at end of file
diff --git a/crates/bindings-cpp/tests/type-isolation-test/update_table_from_log.sh b/crates/bindings-cpp/tests/type-isolation-test/update_table_from_log.sh
new file mode 100644
index 00000000000..9b4edf991fa
--- /dev/null
+++ b/crates/bindings-cpp/tests/type-isolation-test/update_table_from_log.sh
@@ -0,0 +1,296 @@
+#!/bin/bash
+
+# Table updater - reads from test_log.txt and updates test_summary_live.txt
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+# Initialize module arrays
+declare -a MODULES
+declare -A BUILD_STATUS
+declare -A PUBLISH_STATUS
+declare -A WASM_SIZE
+declare -A ERROR_MSG
+
+# Initialize library status
+LIBRARY_STATUS="⏳"
+LIBRARY_ERROR=""
+
+# Discover all modules
+for cpp_file in test_modules/*.cpp; do
+    if [ -f "$cpp_file" ]; then
+        module=$(basename "${cpp_file%.cpp}")
+        MODULES+=("$module")
+        BUILD_STATUS["$module"]="⏳"
+        PUBLISH_STATUS["$module"]="⏳"
+        WASM_SIZE["$module"]="-"
+        ERROR_MSG["$module"]=""
+    fi
+done
+
+# Process existing log to reconstruct current state (if log exists)
+if [ -f test_log.txt ]; then
+    while IFS='|' read -r timestamp module field value; do
+        # Skip empty lines
+        [ -z "$module" ] && continue
+        
+        # Handle library status
+        if [ "$module" = "LIBRARY" ]; then
+            case "$field" in
+                "build")
+                    case "$value" in
+                        "start") LIBRARY_STATUS="🔨" ;;
+                        "pass") LIBRARY_STATUS="✅" ;;
+                        "fail") LIBRARY_STATUS="❌" ;;
+                    esac
+                    ;;
+                "error")
+                    LIBRARY_ERROR="$value"
+                    ;;
+            esac
+            continue
+        fi
+        
+        # Update status based on field
+        case "$field" in
+            "build")
+                case "$value" in
+                    "start") BUILD_STATUS["$module"]="🔨" ;;
+                    "pass") BUILD_STATUS["$module"]="✅" ;;
+                    "fail") BUILD_STATUS["$module"]="❌" ;;
+                esac
+                ;;
+            "publish")
+                case "$value" in
+                    "start") PUBLISH_STATUS["$module"]="📤" ;;
+                    "pass") PUBLISH_STATUS["$module"]="✅" ;;
+                    "fail") PUBLISH_STATUS["$module"]="❌" ;;
+                    "skip") PUBLISH_STATUS["$module"]="⏭️" ;;
+                esac
+                ;;
+            "size")
+                WASM_SIZE["$module"]="$value"
+                ;;
+            "error")
+                ERROR_MSG["$module"]="$value"
+                ;;
+        esac
+    done < test_log.txt
+fi
+
+# Sort modules
+IFS=$'\n' MODULES=($(sort <<<"${MODULES[*]}"))
+unset IFS
+
+# Function to render table
+render_table() {
+    {
+        echo "============================================================"
+        echo "SpacetimeDB C++ Library Type Isolation Test - Live Progress"
+        echo "Generated: $(date)"
+        echo "Last Update: $(date +%H:%M:%S)"
+        echo "============================================================"
+        echo
+        echo "Test Environment:"
+        echo "  Directory: $SCRIPT_DIR"
+        echo "  Total Modules: ${#MODULES[@]}"
+        echo
+        echo "============================================================"
+        echo "Live Test Status Table:"
+        echo "============================================================"
+        echo
+        printf "%-27s | %-10s | %-12s | %-10s | %s\n" "Module" "Build" "Publish" "WASM Size" "Error"
+        echo "----------------------------|-----------|-------------|-----------|------------------------------------"
+        
+        # Show library build status first
+        # Truncate library error if too long (for table display)
+        local lib_error_display="$LIBRARY_ERROR"
+        if [ ${#lib_error_display} -gt 200 ]; then
+            lib_error_display="${lib_error_display:0:197}..."
+        fi
+        printf "%-27s | %-10s | %-12s | %-10s | %s\n" "📚 Library" "$LIBRARY_STATUS" "-" "-" "$lib_error_display"
+        echo "----------------------------|-----------|-------------|-----------|------------------------------------"
+        
+        for module in "${MODULES[@]}"; do
+            build="${BUILD_STATUS[$module]}"
+            publish="${PUBLISH_STATUS[$module]}"
+            size="${WASM_SIZE[$module]}"
+            error="${ERROR_MSG[$module]}"
+            
+            # Truncate error if too long (but show more context for table display)
+            if [ ${#error} -gt 250 ]; then
+                error="${error:0:247}..."
+            fi
+            
+            printf "%-27s | %-10s | %-12s | %-10s | %s\n" "$module" "$build" "$publish" "$size" "$error"
+        done
+        
+        echo
+        echo "============================================================"
+        echo "Legend:"
+        echo "  ⏳ = Pending    🔨 = Building    📤 = Publishing"
+        echo "  ✅ = Passed     ❌ = Failed      ⏭️  = Skipped"
+        echo "============================================================"
+        
+        # Progress counter
+        local completed=0
+        local building=0
+        local publishing=0
+        local total=${#MODULES[@]}
+        
+        for module in "${MODULES[@]}"; do
+            case "${BUILD_STATUS[$module]}" in
+                "✅"|"❌") ((completed++)) ;;
+                "🔨") ((building++)) ;;
+            esac
+            case "${PUBLISH_STATUS[$module]}" in
+                "📤") ((publishing++)) ;;
+            esac
+        done
+        
+        echo
+        echo "Progress: $completed/$total builds complete, $building building, $publishing publishing"
+        
+        # Add statistics if all complete
+        if [ $completed -eq $total ]; then
+            echo
+            echo "============================================================"
+            echo "Final Statistics:"
+            echo "============================================================"
+            
+            local passed=0
+            local build_fail=0
+            local publish_fail=0
+            
+            for module in "${MODULES[@]}"; do
+                if [ "${BUILD_STATUS[$module]}" = "✅" ] && [ "${PUBLISH_STATUS[$module]}" = "✅" ]; then
+                    ((passed++))
+                elif [ "${BUILD_STATUS[$module]}" = "❌" ]; then
+                    ((build_fail++))
+                elif [ "${PUBLISH_STATUS[$module]}" = "❌" ]; then
+                    ((publish_fail++))
+                fi
+            done
+            
+            echo "Total modules: $total"
+            echo "Fully passed: $passed"
+            echo "Build failures: $build_fail"
+            echo "Publish failures: $publish_fail"
+            echo "Success rate: $(( passed * 100 / total ))%"
+            echo "============================================================"
+        fi
+    } > test_summary_live.txt
+}
+
+# Track last processed line - count lines already in log
+if [ -f test_log.txt ]; then
+    LAST_LINE=$(wc -l < test_log.txt)
+else
+    LAST_LINE=0
+fi
+
+# Initial render
+render_table
+
+# Continuously read log and update table
+while true; do
+    # Check if log file exists
+    if [ ! -f test_log.txt ]; then
+        sleep 0.5
+        continue
+    fi
+    
+    # Read new lines from log
+    CURRENT_LINES=$(wc -l < test_log.txt)
+    
+    if [ $CURRENT_LINES -gt $LAST_LINE ]; then
+        # Process new lines - use process substitution to avoid subshell
+        while IFS='|' read -r timestamp module field value; do
+            # Skip empty lines
+            [ -z "$module" ] && continue
+            
+            # Check for completion signal
+            if [ "$module" = "COMPLETE" ]; then
+                render_table
+                exit 0
+            fi
+            
+            # Handle library status
+            if [ "$module" = "LIBRARY" ]; then
+                case "$field" in
+                    "build")
+                        case "$value" in
+                            "start") LIBRARY_STATUS="🔨" ;;
+                            "pass") LIBRARY_STATUS="✅" ;;
+                            "fail") LIBRARY_STATUS="❌" ;;
+                        esac
+                        ;;
+                    "error")
+                        LIBRARY_ERROR="$value"
+                        ;;
+                esac
+            else
+                # Update status based on field
+                case "$field" in
+                    "build")
+                        case "$value" in
+                            "start") BUILD_STATUS["$module"]="🔨" ;;
+                            "pass") BUILD_STATUS["$module"]="✅" ;;
+                            "fail") BUILD_STATUS["$module"]="❌" ;;
+                        esac
+                        ;;
+                    "publish")
+                        case "$value" in
+                            "start") PUBLISH_STATUS["$module"]="📤" ;;
+                            "pass") PUBLISH_STATUS["$module"]="✅" ;;
+                            "fail") PUBLISH_STATUS["$module"]="❌" ;;
+                            "skip") PUBLISH_STATUS["$module"]="⏭️" ;;
+                        esac
+                        ;;
+                    "size")
+                        WASM_SIZE["$module"]="$value"
+                        ;;
+                    "error")
+                        # Store full error for log
+                        ERROR_MSG["$module"]="$value"
+                        
+                        # Extract cleaner error for table display
+                        # Look for key error patterns and extract the important part
+                        clean_error=""
+                        if [[ "$value" =~ "Error: Errors occurred:" ]]; then
+                            # Extract the main error message after "Error: Errors occurred:"
+                            # Get the part between "Error: Errors occurred:" and "Caused by:"
+                            clean_error=$(echo "$value" | sed 's/.*Error: Errors occurred: //' | sed 's/Caused by:.*//' | sed 's/[[:space:]]*$//' | head -1)
+                            if [ -n "$clean_error" ]; then
+                                clean_error="Error: $clean_error"
+                            fi
+                        elif [[ "$value" =~ "error: static assertion failed:" ]]; then
+                            # Extract the assertion message with more context
+                            clean_error=$(echo "$value" | grep -o 'error: static assertion failed: [^.]*' | head -1)
+                        elif [[ "$value" =~ "error:" ]]; then
+                            # Generic error - try to extract first error line with more context
+                            clean_error=$(echo "$value" | grep -o "error:[^|]*" | head -1 | sed 's/[[:space:]]*$//')
+                        elif [[ "$value" =~ "Error:" ]]; then
+                            # Spacetime error - extract the main message with more context
+                            clean_error=$(echo "$value" | sed 's/.*\(Error:[^|]*\).*/\1/' | sed 's/[[:space:]]*$//' | head -1)
+                        fi
+                        
+                        # Use clean error if we extracted one
+                        if [ -n "$clean_error" ]; then
+                            ERROR_MSG["$module"]="$clean_error"
+                        fi
+                        ;;
+                esac
+            fi
+        done < <(tail -n +$((LAST_LINE + 1)) test_log.txt)
+        
+        # Update last processed line
+        LAST_LINE=$CURRENT_LINES
+        
+        # Render updated table
+        render_table
+    fi
+    
+    # Small delay to avoid CPU spinning
+    sleep 0.2
+done
\ No newline at end of file
diff --git a/crates/cli/src/subcommands/dev.rs b/crates/cli/src/subcommands/dev.rs
index 868df9c8fe8..222b4f03f54 100644
--- a/crates/cli/src/subcommands/dev.rs
+++ b/crates/cli/src/subcommands/dev.rs
@@ -353,6 +353,7 @@ async fn generate_build_and_publish(
         crate::util::ModuleLanguage::Rust => &Language::Rust,
         crate::util::ModuleLanguage::Csharp => &Language::Csharp,
         crate::util::ModuleLanguage::Javascript => &Language::TypeScript,
+        crate::util::ModuleLanguage::Cpp => &Language::UnrealCpp,
     });
     let client_language_str = match client_language {
         Language::Rust => "rust",
diff --git a/crates/cli/src/subcommands/init.rs b/crates/cli/src/subcommands/init.rs
index 19cec472996..3e7d0aea2a4 100644
--- a/crates/cli/src/subcommands/init.rs
+++ b/crates/cli/src/subcommands/init.rs
@@ -57,6 +57,7 @@ pub enum ServerLanguage {
     Rust,
     Csharp,
     TypeScript,
+    Cpp,
 }
 
 impl ServerLanguage {
@@ -65,6 +66,7 @@ impl ServerLanguage {
             ServerLanguage::Rust => "rust",
             ServerLanguage::Csharp => "csharp",
             ServerLanguage::TypeScript => "typescript",
+            ServerLanguage::Cpp => "cpp",
         }
     }
 
@@ -73,6 +75,7 @@ impl ServerLanguage {
             "rust" => Ok(Some(ServerLanguage::Rust)),
             "csharp" | "c#" => Ok(Some(ServerLanguage::Csharp)),
             "typescript" => Ok(Some(ServerLanguage::TypeScript)),
+            "cpp" | "c++" => Ok(Some(ServerLanguage::Cpp)),
             _ => Err(anyhow!("Unknown server language: {}", s)),
         }
     }
@@ -132,11 +135,9 @@ pub fn cli() -> clap::Command {
                 .help("Initialize server only from the template (no client)")
                 .action(clap::ArgAction::SetTrue),
         )
-        .arg(
-            Arg::new("lang").long("lang").value_name("LANG").help(
-                "Server language: rust, csharp, typescript (it can only be used when --template is not specified)",
-            ),
-        )
+        .arg(Arg::new("lang").long("lang").value_name("LANG").help(
+            "Server language: rust, csharp, typescript, cpp (it can only be used when --template is not specified)",
+        ))
         .arg(
             Arg::new("template")
                 .short('t')
@@ -1213,6 +1214,9 @@ fn init_builtin(config: &TemplateConfig, project_path: &Path, is_server_only: bo
         Some(ServerLanguage::Csharp) => {
             update_csproj_server_to_nuget(&server_dir)?;
         }
+        Some(ServerLanguage::Cpp) => {
+            // No name update needed for C++ at the moment
+        }
         None => {}
     }
 
@@ -1265,6 +1269,11 @@ fn init_empty(config: &TemplateConfig, project_path: &Path) -> anyhow::Result<()
             let server_dir = project_path.join("spacetimedb");
             init_empty_typescript_server(&server_dir, &config.project_name)?;
         }
+        Some(ServerLanguage::Cpp) => {
+            println!("Setting up C++ server...");
+            let server_dir = project_path.join("spacetimedb");
+            init_empty_cpp_server(&server_dir, &config.project_name)?;
+        }
         None => {}
     }
 
@@ -1287,6 +1296,10 @@ fn init_empty_typescript_server(server_dir: &Path, project_name: &str) -> anyhow
     Ok(())
 }
 
+fn init_empty_cpp_server(server_dir: &Path, _project_name: &str) -> anyhow::Result<()> {
+    init_cpp_project(server_dir)
+}
+
 fn print_next_steps(config: &TemplateConfig, _project_path: &Path) -> anyhow::Result<()> {
     println!();
     println!("{}", "Next steps:".bold());
@@ -1570,6 +1583,83 @@ pub fn init_typescript_project(project_path: &Path) -> anyhow::Result<()> {
     Ok(())
 }
 
+pub fn init_cpp_project(project_path: &Path) -> anyhow::Result<()> {
+    let export_files = vec![
+        (
+            include_str!("../../templates/basic-cpp/server/CMakeLists._txt"),
+            "CMakeLists.txt",
+        ),
+        (include_str!("../../templates/basic-cpp/server/lib._cpp"), "src/lib.cpp"),
+        (
+            include_str!("../../templates/basic-cpp/server/_gitignore"),
+            ".gitignore",
+        ),
+    ];
+
+    for data_file in export_files {
+        let path = project_path.join(data_file.1);
+        create_directory(path.parent().unwrap())?;
+        std::fs::write(path, data_file.0)?;
+    }
+
+    // Copy the SpacetimeDB C++ SDK
+    let sdk_dest = project_path.join("spacetimedb-cpp-sdk");
+    create_directory(&sdk_dest)?;
+
+    // Try to find and copy the SDK from the development environment
+    let current_dir = std::env::current_dir().context("Failed to get current directory")?;
+    let mut found_sdk = false;
+
+    // Look for bindings-cpp in current directory and parent directories
+    let mut search_dir = current_dir.clone();
+    for _ in 0..10 {
+        let bindings_cpp_path = search_dir.join("crates").join("bindings-cpp");
+        if bindings_cpp_path.exists() {
+            // Copy include directory
+            let src_include = bindings_cpp_path.join("include");
+            let dest_include = sdk_dest.join("include");
+            if src_include.exists() {
+                copy_dir_recursive(&src_include, &dest_include).context("Failed to copy SDK include directory")?;
+                println!("✓ Copied SpacetimeDB C++ SDK include files");
+            }
+
+            // Copy src directory
+            let src_src = bindings_cpp_path.join("src");
+            let dest_src = sdk_dest.join("src");
+            if src_src.exists() {
+                copy_dir_recursive(&src_src, &dest_src).context("Failed to copy SDK src directory")?;
+                println!("✓ Copied SpacetimeDB C++ SDK source files");
+            }
+            found_sdk = true;
+            break;
+        }
+
+        if let Some(parent) = search_dir.parent() {
+            search_dir = parent.to_path_buf();
+        } else {
+            break;
+        }
+    }
+
+    if !found_sdk {
+        println!("{}", "Note: Could not automatically find SpacetimeDB C++ SDK.".yellow());
+        println!("To complete setup, copy the SDK files manually:");
+        println!(
+            "  cp -r <spacetimedb-repo>/crates/bindings-cpp/include {}/spacetimedb-cpp-sdk/",
+            project_path.display()
+        );
+        println!(
+            "  cp -r <spacetimedb-repo>/crates/bindings-cpp/src {}/spacetimedb-cpp-sdk/",
+            project_path.display()
+        );
+    }
+
+    check_for_emscripten();
+    check_for_git();
+
+    Ok(())
+}
+
 pub async fn exec_init_rust(args: &ArgMatches) -> anyhow::Result<()> {
     let project_path = args.get_one::<PathBuf>("project-path").unwrap();
     init_rust_project(project_path)?;
@@ -1672,3 +1762,36 @@ fn set_dependency_version(item: &mut Item, version: &str, remove_path: bool) {
 
     *item = value(version.to_string());
 }
+
+fn check_for_emscripten() -> bool {
+    if find_executable("emcc").is_some() && find_executable("cmake").is_some() {
+        return true;
+    }
+    println!(
+        "{}",
+        "Warning: You have created a C++ project, but you are missing emcc (Emscripten) or cmake.".yellow()
+    );
+    println!(
+        "{}",
+        "Install Emscripten from: https://emscripten.org/docs/getting_started/downloads.html".yellow()
+    );
+    println!("{}", "Install CMake from: https://cmake.org/download/".yellow());
+    false
+}
+
+fn copy_dir_recursive(src: &Path, dest: &Path) -> Result<(), anyhow::Error> {
+    create_directory(dest)?;
+
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        let src_path = entry.path();
+        let dest_path = dest.join(entry.file_name());
+
+        if src_path.is_dir() {
+            copy_dir_recursive(&src_path, &dest_path)?;
+        } else {
+            std::fs::copy(&src_path, &dest_path)?;
+        }
+    }
+    Ok(())
+}
diff --git a/crates/cli/src/tasks/cpp.rs b/crates/cli/src/tasks/cpp.rs
new file mode 100644
index 00000000000..09933e5742f
--- /dev/null
+++ b/crates/cli/src/tasks/cpp.rs
@@ -0,0 +1,100 @@
+use anyhow::{anyhow, Context};
+use std::path::{Path, PathBuf};
+use walkdir::WalkDir;
+
+/// Run a program cross-platform. On Windows, go via `cmd /C` so .bat/.cmd work.
+fn run_status<S: AsRef<str>>(prog: &str, args: &[S], cwd: &Path) -> anyhow::Result<()> {
+    #[cfg(windows)]
+    {
+        let mut pieces: Vec<String> = Vec::with_capacity(1 + args.len());
+        pieces.push(prog.to_string());
+        pieces.extend(args.iter().map(|s| s.as_ref().to_string()));
+        duct::cmd("cmd", std::iter::once("/C").chain(pieces.iter().map(String::as_str)))
+            .dir(cwd)
+            .run()
+            .with_context(|| format!("failed running `{prog}`"))?;
+    }
+    #[cfg(not(windows))]
+    {
+        duct::cmd(prog, args.iter().map(|s| s.as_ref()))
+            .dir(cwd)
+            .run()
+            .with_context(|| format!("failed running `{prog}`"))?;
+    }
+    Ok(())
+}
+
+fn run_read<S: AsRef<str>>(prog: &str, args: &[S]) -> std::io::Result<String> {
+    #[cfg(windows)]
+    {
+        let mut pieces: Vec<String> = Vec::with_capacity(1 + args.len());
+        pieces.push(prog.to_string());
+        pieces.extend(args.iter().map(|s| s.as_ref().to_string()));
+        duct::cmd("cmd", std::iter::once("/C").chain(pieces.iter().map(String::as_str)))
+            .stderr_capture()
+            .stdout_capture()
+            .read()
+    }
+    #[cfg(not(windows))]
+    {
+        duct::cmd(prog, args.iter().map(|s| s.as_ref()))
+            .stderr_capture()
+            .stdout_capture()
+            .read()
+    }
+}
+
+pub(crate) fn build_cpp(project_path: &Path, build_debug: bool) -> anyhow::Result<PathBuf> {
+    // Tool sanity checks (shell-wrapped so .bat shims work on Windows)
+    run_read("emcc", &["--version"])
+        .map_err(|_| anyhow!("`emcc` not found/runnable. Activate Emscripten (emsdk_env)."))?;
+    run_read("cmake", &["--version"]).map_err(|_| anyhow!("`cmake` not found in PATH."))?;
+    // Just ensure emcmake runs; some versions lack `--version`.
+    if run_read("emcmake", &["cmake", "--version"]).is_err() {
+        return Err(anyhow!("`emcmake` not found/runnable. Is Emscripten env active?"));
+    }
+
+    let build_type = if build_debug { "Debug" } else { "Release" };
+    let build_dir = project_path.join("build");
+
+    // === Configure (no generator flags; let emcmake/cmake decide or reuse existing) ===
+    // This matches: emcmake cmake -B build .
+    // We keep -S/-B so `project_path` can be anywhere, and pass CMAKE_BUILD_TYPE (ignored by multi-config).
+    let cfg_args = [
+        "cmake",
+        "-S",
+        &project_path.to_string_lossy(),
+        "-B",
+        &build_dir.to_string_lossy(),
+        &format!("-DCMAKE_BUILD_TYPE={}", build_type),
+    ];
+    run_status("emcmake", &cfg_args, project_path).context("Failed to configure C++ project with emcmake/cmake")?;
+
+    // === Build (matches: cmake --build build) ===
+    // Always pass --config; it’s required for multi-config and ignored for single-config.
+    let build_args = [
+        "--build",
+        &build_dir.to_string_lossy(),
+        "--config",
+        build_type,
+        "--parallel",
+    ];
+    run_status("cmake", &build_args, project_path).context("Failed to build C++ project")?;
+
+    // Find the first .wasm under build/ (covers Debug/Release or target subdirs)
+    let wasm = WalkDir::new(&build_dir)
+        .into_iter()
+        .filter_map(Result::ok)
+        .find_map(|e| {
+            let p = e.path();
+            (p.extension().and_then(|s| s.to_str()) == Some("wasm")).then(|| p.to_path_buf())
+        })
+        .ok_or_else(|| {
+            anyhow!(
+                "Built successfully but couldn't find a .wasm under {}",
+                build_dir.display()
+            )
+        })?;
+
+    Ok(wasm)
+}
diff --git a/crates/cli/src/tasks/mod.rs b/crates/cli/src/tasks/mod.rs
index a88f10a9b0b..1444e79f5c4 100644
--- a/crates/cli/src/tasks/mod.rs
+++ b/crates/cli/src/tasks/mod.rs
@@ -2,6 +2,7 @@ use std::path::{Path, PathBuf};
 
 use crate::util::{self, ModuleLanguage};
 
+use self::cpp::build_cpp;
 use self::csharp::build_csharp;
 use self::javascript::build_javascript;
 use self::rust::build_rust;
@@ -19,6 +20,7 @@ pub fn build(
         ModuleLanguage::Rust => build_rust(project_path, lint_dir, build_debug),
         ModuleLanguage::Csharp => build_csharp(project_path, build_debug),
         ModuleLanguage::Javascript => build_javascript(project_path, build_debug),
+        ModuleLanguage::Cpp => build_cpp(project_path, build_debug),
     }?;
 
     if lang == ModuleLanguage::Javascript {
@@ -51,6 +53,7 @@ pub fn build(
     }
 }
 
+pub mod cpp;
 pub mod csharp;
 pub mod javascript;
 pub mod rust;
diff --git a/crates/cli/src/util.rs b/crates/cli/src/util.rs
index 74b483c54e6..f0889c590ee 100644
--- a/crates/cli/src/util.rs
+++ b/crates/cli/src/util.rs
@@ -196,10 +196,11 @@ pub enum ModuleLanguage {
     Csharp,
     Rust,
     Javascript,
+    Cpp,
 }
 impl clap::ValueEnum for ModuleLanguage {
     fn value_variants<'a>() -> &'a [Self] {
-        &[Self::Csharp, Self::Rust, Self::Javascript]
+        &[Self::Csharp, Self::Rust, Self::Javascript, Self::Cpp]
     }
     fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
         match self {
@@ -215,6 +216,7 @@ impl clap::ValueEnum for ModuleLanguage {
                 "ecmascript",
                 "es",
             ])),
+            Self::Cpp => Some(clap::builder::PossibleValue::new("cpp").aliases(["c++", "cxx", "C++", "Cpp"])),
         }
     }
 }
@@ -232,6 +234,8 @@ pub fn detect_module_language(path_to_project: &Path) -> anyhow::Result<ModuleLa
         Ok(ModuleLanguage::Csharp)
     } else if path_to_project.join("package.json").exists() {
         Ok(ModuleLanguage::Javascript)
+    } else if path_to_project.join("CMakeLists.txt").exists() {
+        Ok(ModuleLanguage::Cpp)
     } else {
         anyhow::bail!("Could not detect the language of the module. Are you in a SpacetimeDB project directory?")
     }
diff --git a/crates/cli/templates/basic-cpp/server/CMakeLists._txt b/crates/cli/templates/basic-cpp/server/CMakeLists._txt
new file mode 100644
index 00000000000..a16309d2d5f
--- /dev/null
+++ b/crates/cli/templates/basic-cpp/server/CMakeLists._txt
@@ -0,0 +1,62 @@
+cmake_minimum_required(VERSION 3.20)
+project(spacetime_cpp_module)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Set the module source file
+set(MODULE_SOURCE "src/lib.cpp" CACHE STRING "Source file for the SpacetimeDB module")
+
+# Set optimization level for Release builds
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(CMAKE_CXX_FLAGS_RELEASE "-O2")
+endif()
+
+# Include the SpacetimeDB C++ SDK
+set(SPACETIMEDB_SDK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/spacetimedb-cpp-sdk")
+include_directories(${SPACETIMEDB_SDK_DIR}/include)
+
+# Collect all source files for the SpacetimeDB library
+file(GLOB_RECURSE SPACETIMEDB_SOURCES
+    "${SPACETIMEDB_SDK_DIR}/src/*.cpp"
+    "${SPACETIMEDB_SDK_DIR}/src/*.c"
+)
+
+# Create SpacetimeDB library
+add_library(spacetimedb_cpp_library STATIC ${SPACETIMEDB_SOURCES})
+target_include_directories(spacetimedb_cpp_library PUBLIC ${SPACETIMEDB_SDK_DIR}/include)
+
+# Create the main module executable
+add_executable(lib ${MODULE_SOURCE})
+target_link_libraries(lib spacetimedb_cpp_library)
+
+# Configure Emscripten-specific settings for WASM output
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  # Export list as a single variable (no extra quoting per-platform)
+  set(EXPORTED_FUNCS "['_malloc','_free','___describe_module__','___call_reducer__']")
+
+  # Produce a standalone .wasm (no JS harness) with no entry point
+  target_link_options(lib PRIVATE
+    "SHELL:-sSTANDALONE_WASM=1"
+    "SHELL:-sWASM=1"
+    "SHELL:--no-entry"
+    # Exports
+    "SHELL:-sEXPORTED_FUNCTIONS=${EXPORTED_FUNCS}"
+    # Keep this ON for correctness; you can flip to 0 temporarily to probe
+    "SHELL:-sERROR_ON_UNDEFINED_SYMBOLS=1"
+    # Trim runtime
+    "SHELL:-sFILESYSTEM=0"
+    "SHELL:-sDISABLE_EXCEPTION_CATCHING=1"
+    "SHELL:-sALLOW_MEMORY_GROWTH=0"
+    "SHELL:-sINITIAL_MEMORY=16MB"
+    "SHELL:-sSUPPORT_LONGJMP=0"
+    "SHELL:-sSUPPORT_ERRNO=0"
+    # C++20 and O2 at link step (Emscripten accepts them here too)
+    "SHELL:-std=c++20"
+    "SHELL:-O2"
+  )
+
+  # Name the output lib.wasm
+  set_target_properties(lib PROPERTIES OUTPUT_NAME "lib" SUFFIX ".wasm")
+endif()
\ No newline at end of file
diff --git a/crates/cli/templates/basic-cpp/server/_gitignore b/crates/cli/templates/basic-cpp/server/_gitignore
new file mode 100644
index 00000000000..68eb119c532
--- /dev/null
+++ b/crates/cli/templates/basic-cpp/server/_gitignore
@@ -0,0 +1,21 @@
+# Build directories
+/build/
+/build_*/
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store
+Thumbs.db
+
+# CMake cache
+CMakeCache.txt
+CMakeFiles/
+
+# Compiled WASM files
+*.wasm
+*.opt.wasm
\ No newline at end of file
diff --git a/crates/cli/templates/basic-cpp/server/lib._cpp b/crates/cli/templates/basic-cpp/server/lib._cpp
new file mode 100644
index 00000000000..d65e393d5b0
--- /dev/null
+++ b/crates/cli/templates/basic-cpp/server/lib._cpp
@@ -0,0 +1,44 @@
+#include "spacetimedb.h"
+
+using namespace SpacetimeDb;
+
+// Define a simple table
+struct Person {
+    std::string name;
+};
+SPACETIMEDB_STRUCT(Person, name)
+SPACETIMEDB_TABLE(Person, person, Public)
+
+// Called when the module is initially published
+SPACETIMEDB_INIT(init)
+{
+    // Module initialization logic goes here
+}
+
+// Called every time a new client connects
+SPACETIMEDB_CLIENT_CONNECTED(identity_connected)
+{
+    // Client connection logic goes here
+}
+
+// Called every time a client disconnects  
+SPACETIMEDB_CLIENT_DISCONNECTED(identity_disconnected)
+{
+    // Client disconnection logic goes here
+}
+
+// Add a person to the table
+SPACETIMEDB_REDUCER(add, ReducerContext ctx, std::string name)
+{
+    ctx.db[person].insert(Person{name});
+}
+
+// Say hello to everyone in the table
+SPACETIMEDB_REDUCER(say_hello, ReducerContext ctx)
+{
+    auto table = ctx.db[person];
+    for (const auto& person : table) {
+        LOG_INFO("Hello, " + person.name + "!");
+    }
+    LOG_INFO("Hello, World!");
+}
\ No newline at end of file
diff --git a/crates/cli/templates/templates-list.json b/crates/cli/templates/templates-list.json
index ab6602744b2..609ac59caf9 100644
--- a/crates/cli/templates/templates-list.json
+++ b/crates/cli/templates/templates-list.json
@@ -27,6 +27,14 @@
       "server_lang": "rust",
       "client_lang": "rust"
     },
+    {
+      "id": "basic-cpp",
+      "description": "A basic C++ server template with only stubs for code",
+      "server_source": "templates/basic-rust/server",
+      "client_source": "",
+      "server_lang": "rust",
+      "client_lang": ""
+    },
     {
       "id": "basic-react",
       "description": "React web app with TypeScript server",
diff --git a/crates/codegen/examples/regen-cpp-moduledef.rs b/crates/codegen/examples/regen-cpp-moduledef.rs
new file mode 100644
index 00000000000..5f2211054dc
--- /dev/null
+++ b/crates/codegen/examples/regen-cpp-moduledef.rs
@@ -0,0 +1,52 @@
+//! This script is used to generate the C++ bindings for the `RawModuleDef` type.
+//! Run `cargo run --example regen-cpp-moduledef` to update C++ bindings whenever the module definition changes.
+
+use fs_err as fs;
+use spacetimedb_codegen::{cpp, generate, OutputFile};
+use spacetimedb_lib::db::raw_def::v9::{RawModuleDefV9, RawModuleDefV9Builder};
+use spacetimedb_schema::def::ModuleDef;
+use std::path::Path;
+
+fn main() -> anyhow::Result<()> {
+    let mut builder = RawModuleDefV9Builder::new();
+    builder.add_type::<RawModuleDefV9>();
+    let module = builder.finish();
+
+    // Build relative path from the codegen crate to the C++ Module Library autogen directory
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    let dir = Path::new(manifest_dir)
+        .parent()
+        .unwrap()
+        .join("bindings-cpp/include/spacetimedb/internal/autogen");
+
+    println!("Target directory path: {}", dir.display());
+
+    // Create the autogen directory if it doesn't exist
+    if dir.exists() {
+        fs::remove_dir_all(&dir)?;
+    }
+    fs::create_dir_all(&dir)?;
+
+    let module: ModuleDef = module.try_into()?;
+    generate(
+        &module,
+        &cpp::Cpp {
+            namespace: "SpacetimeDb::Internal",
+        },
+    )
+    .into_iter()
+    .try_for_each(|OutputFile { filename, code }| {
+        // Remove any prefix and just use the filename
+        let filename = if let Some(name) = filename.strip_prefix("Types/") {
+            name
+        } else {
+            &filename
+        };
+
+        println!("Generating {}", filename);
+        fs::write(dir.join(filename), code)
+    })?;
+
+    println!("C++ autogen files written to: {}", dir.display());
+    Ok(())
+}
diff --git a/crates/codegen/src/cpp.rs b/crates/codegen/src/cpp.rs
new file mode 100644
index 00000000000..e79697160a3
--- /dev/null
+++ b/crates/codegen/src/cpp.rs
@@ -0,0 +1,525 @@
+//! Minimal C++ code generation for SpacetimeDB module definitions.
+//! Generates only schema definitions - framework provides all functionality.
+
+use crate::Lang;
+use crate::OutputFile;
+use spacetimedb_lib::sats::layout::PrimitiveType;
+use spacetimedb_schema::def::{ModuleDef, ReducerDef, TableDef, TypeDef};
+use spacetimedb_schema::type_for_generate::{
+    AlgebraicTypeDef, AlgebraicTypeUse, PlainEnumTypeDef, ProductTypeDef, SumTypeDef,
+};
+// Removed unused import
+use std::collections::HashSet;
+use std::fmt::{self, Write};
+
+pub struct Cpp<'opts> {
+    pub namespace: &'opts str,
+}
+
+impl<'opts> Cpp<'opts> {
+    fn write_header_comment(&self, output: &mut String) {
+        writeln!(
+            output,
+            "// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE"
+        )
+        .unwrap();
+        writeln!(
+            output,
+            "// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD."
+        )
+        .unwrap();
+        writeln!(output).unwrap();
+        writeln!(output, "// This was generated using spacetimedb codegen.").unwrap();
+        writeln!(output).unwrap();
+    }
+
+    fn write_standard_includes(&self, output: &mut String) {
+        writeln!(output, "#pragma once").unwrap();
+        writeln!(output).unwrap();
+        writeln!(output, "#include <cstdint>").unwrap();
+        writeln!(output, "#include <string>").unwrap();
+        writeln!(output, "#include <vector>").unwrap();
+        writeln!(output, "#include <optional>").unwrap();
+        writeln!(output, "#include <memory>").unwrap();
+        writeln!(output, "#include \"../autogen_base.h\"").unwrap();
+        writeln!(output, "#include \"spacetimedb/bsatn/bsatn.h\"").unwrap();
+    }
+
+    fn cpp_primitive_type(&self, p: &PrimitiveType) -> &'static str {
+        match p {
+            PrimitiveType::Bool => "bool",
+            PrimitiveType::I8 => "int8_t",
+            PrimitiveType::U8 => "uint8_t",
+            PrimitiveType::I16 => "int16_t",
+            PrimitiveType::U16 => "uint16_t",
+            PrimitiveType::I32 => "int32_t",
+            PrimitiveType::U32 => "uint32_t",
+            PrimitiveType::I64 => "int64_t",
+            PrimitiveType::U64 => "uint64_t",
+            PrimitiveType::I128 => "SpacetimeDb::I128",
+            PrimitiveType::U128 => "SpacetimeDb::U128",
+            PrimitiveType::I256 => "I256Placeholder", // TODO: proper 256-bit support
+            PrimitiveType::U256 => "U256Placeholder", // TODO: proper 256-bit support
+            PrimitiveType::F32 => "float",
+            PrimitiveType::F64 => "double",
+        }
+    }
+
+    fn write_algebraic_type(&self, output: &mut String, module: &ModuleDef, typ: &AlgebraicTypeUse) -> fmt::Result {
+        match typ {
+            AlgebraicTypeUse::Primitive(p) => write!(output, "{}", self.cpp_primitive_type(p)),
+            AlgebraicTypeUse::Array(elem_type) => {
+                write!(output, "std::vector<")?;
+                self.write_algebraic_type(output, module, elem_type)?;
+                write!(output, ">")
+            }
+            AlgebraicTypeUse::Option(inner_type) => {
+                write!(output, "std::optional<")?;
+                self.write_algebraic_type(output, module, inner_type)?;
+                write!(output, ">")
+            }
+            AlgebraicTypeUse::String => write!(output, "std::string"),
+            AlgebraicTypeUse::Identity => write!(output, "__sdk::Identity"),
+            AlgebraicTypeUse::ConnectionId => write!(output, "__sdk::ConnectionId"),
+            AlgebraicTypeUse::Timestamp => write!(output, "__sdk::Timestamp"),
+            AlgebraicTypeUse::TimeDuration => write!(output, "__sdk::TimeDuration"),
+            AlgebraicTypeUse::ScheduleAt => write!(output, "__sdk::ScheduleAt"),
+            AlgebraicTypeUse::Unit => write!(output, "std::monostate"),
+            AlgebraicTypeUse::Never => write!(output, "std::monostate"),
+            AlgebraicTypeUse::Ref(type_ref) => {
+                if let Some((type_name, _type_def)) = module.type_def_from_ref(*type_ref) {
+                    let name = type_name.name().to_string();
+                    write!(output, "{}::{}", self.namespace, name)
+                } else {
+                    write!(output, "UnknownType /* ref {} */", type_ref.idx())
+                }
+            }
+        }
+    }
+
+    fn collect_dependencies(module: &ModuleDef, typ: &AlgebraicTypeUse) -> HashSet<String> {
+        let mut deps = HashSet::new();
+        match typ {
+            AlgebraicTypeUse::Array(elem_type) | AlgebraicTypeUse::Option(elem_type) => {
+                deps.extend(Self::collect_dependencies(module, elem_type));
+            }
+            AlgebraicTypeUse::Ref(type_ref) => {
+                if let Some((type_name, _)) = module.type_def_from_ref(*type_ref) {
+                    deps.insert(type_name.name().to_string());
+                }
+            }
+            _ => {}
+        }
+        deps
+    }
+
+    fn collect_product_dependencies(&self, module: &ModuleDef, product: &ProductTypeDef) -> HashSet<String> {
+        let mut deps = HashSet::new();
+        for (_, field_type) in &product.elements {
+            deps.extend(Self::collect_dependencies(module, field_type));
+        }
+        deps
+    }
+
+    fn collect_sum_dependencies(&self, module: &ModuleDef, sum: &SumTypeDef) -> HashSet<String> {
+        let mut deps = HashSet::new();
+        for (_, variant_type) in &sum.variants {
+            deps.extend(Self::collect_dependencies(module, variant_type));
+        }
+        deps
+    }
+
+    // Generate minimal product type (struct with fields only)
+    fn write_product_type(&self, output: &mut String, module: &ModuleDef, type_name: &str, product: &ProductTypeDef) {
+        // Use INTERNAL macro for Internal namespace
+        let macro_name = if self.namespace == "SpacetimeDb::Internal" {
+            "SPACETIMEDB_INTERNAL_PRODUCT_TYPE"
+        } else {
+            "SPACETIMEDB_PRODUCT_TYPE"
+        };
+        writeln!(output, "{}({}) {{", macro_name, type_name).unwrap();
+
+        // Write fields only
+        for (field_name, field_type) in &product.elements {
+            write!(output, "    ").unwrap();
+            self.write_algebraic_type(output, module, field_type).unwrap();
+            writeln!(output, " {};", field_name).unwrap();
+        }
+
+        writeln!(output).unwrap();
+
+        // Only generate serialization for Internal types (no deserialization needed)
+        writeln!(
+            output,
+            "    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {{"
+        )
+        .unwrap();
+        for (field_name, _) in &product.elements {
+            writeln!(
+                output,
+                "        ::SpacetimeDb::bsatn::serialize(writer, {});",
+                field_name
+            )
+            .unwrap();
+        }
+        writeln!(output, "    }}").unwrap();
+
+        // Generate equality method
+        if !product.elements.is_empty() {
+            write!(output, "    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(").unwrap();
+            for (i, (field_name, _)) in product.elements.iter().enumerate() {
+                if i > 0 {
+                    write!(output, ", ").unwrap();
+                }
+                write!(output, "{}", field_name).unwrap();
+            }
+            writeln!(output, ")").unwrap();
+        }
+
+        writeln!(output, "}};").unwrap();
+    }
+
+    // Generate minimal sum type (TaggedEnum only)
+    fn write_sum_type(&self, output: &mut String, module: &ModuleDef, type_name: &str, sum: &SumTypeDef) {
+        // Special case: Generate proper tagged enum for RawIndexAlgorithm with data variants
+        if type_name == "RawIndexAlgorithm" {
+            // Generate data structures for each algorithm variant
+            writeln!(output, "// BTree algorithm data").unwrap();
+            writeln!(
+                output,
+                "SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawIndexAlgorithmBTreeData) {{"
+            )
+            .unwrap();
+            writeln!(output, "    std::vector<uint16_t> columns;").unwrap();
+            writeln!(
+                output,
+                "    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {{"
+            )
+            .unwrap();
+            writeln!(output, "        ::SpacetimeDb::bsatn::serialize(writer, columns);").unwrap();
+            writeln!(output, "    }}").unwrap();
+            writeln!(output, "    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(columns)").unwrap();
+            writeln!(output, "}};").unwrap();
+            writeln!(output).unwrap();
+
+            // Generate Hash data structure (for future use)
+            writeln!(output, "// Hash algorithm data (not currently used)").unwrap();
+            writeln!(
+                output,
+                "SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawIndexAlgorithmHashData) {{"
+            )
+            .unwrap();
+            writeln!(output, "    std::vector<uint16_t> columns;").unwrap();
+            writeln!(
+                output,
+                "    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {{"
+            )
+            .unwrap();
+            writeln!(output, "        ::SpacetimeDb::bsatn::serialize(writer, columns);").unwrap();
+            writeln!(output, "    }}").unwrap();
+            writeln!(output, "    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(columns)").unwrap();
+            writeln!(output, "}};").unwrap();
+            writeln!(output).unwrap();
+
+            // Generate Direct data structure (not currently used)
+            writeln!(output, "// Direct algorithm data (not currently used)").unwrap();
+            writeln!(
+                output,
+                "SPACETIMEDB_INTERNAL_PRODUCT_TYPE(RawIndexAlgorithmDirectData) {{"
+            )
+            .unwrap();
+            writeln!(output, "    uint16_t column;").unwrap();
+            writeln!(
+                output,
+                "    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const {{"
+            )
+            .unwrap();
+            writeln!(output, "        ::SpacetimeDb::bsatn::serialize(writer, column);").unwrap();
+            writeln!(output, "    }}").unwrap();
+            writeln!(output, "    SPACETIMEDB_PRODUCT_TYPE_EQUALITY(column)").unwrap();
+            writeln!(output, "}};").unwrap();
+            writeln!(output).unwrap();
+
+            // Generate the tagged enum
+            writeln!(output, "// RawIndexAlgorithm tagged enum with data variants").unwrap();
+            writeln!(output, "SPACETIMEDB_INTERNAL_TAGGED_ENUM({}, ", type_name).unwrap();
+            writeln!(output, "    SpacetimeDb::Internal::RawIndexAlgorithmBTreeData,").unwrap();
+            writeln!(output, "    SpacetimeDb::Internal::RawIndexAlgorithmHashData,").unwrap();
+            writeln!(output, "    SpacetimeDb::Internal::RawIndexAlgorithmDirectData").unwrap();
+            writeln!(output, ")").unwrap();
+            return;
+        }
+
+        // Use INTERNAL macro for Internal namespace
+        let macro_name = if self.namespace == "SpacetimeDb::Internal" {
+            "SPACETIMEDB_INTERNAL_TAGGED_ENUM"
+        } else {
+            "SPACETIMEDB_TAGGED_ENUM"
+        };
+
+        // Collect variant types and check for duplicates
+        let mut variant_types = Vec::new();
+        let mut type_strings = Vec::new();
+
+        for (variant_name, variant_type) in &sum.variants {
+            let mut type_str = String::new();
+            self.write_algebraic_type(&mut type_str, module, variant_type).unwrap();
+
+            // Check if this type already exists
+            let duplicate_index = type_strings.iter().position(|s| s == &type_str);
+
+            if let Some(_idx) = duplicate_index {
+                // Found duplicate - create a wrapper struct to make it unique
+                let wrapper_name = format!("{}_{}_Wrapper", type_name, variant_name);
+                writeln!(output, "struct {} {{ {} value; }};", wrapper_name, type_str).unwrap();
+                variant_types.push(wrapper_name);
+            } else {
+                // No duplicate, use the type directly
+                type_strings.push(type_str.clone());
+                variant_types.push(type_str);
+            }
+        }
+
+        // Generate the tagged enum with (potentially wrapped) variant types
+        write!(output, "{}({}", macro_name, type_name).unwrap();
+
+        if !variant_types.is_empty() {
+            write!(output, ", ").unwrap();
+            for (i, variant_type) in variant_types.iter().enumerate() {
+                if i > 0 {
+                    write!(output, ", ").unwrap();
+                }
+                write!(output, "{}", variant_type).unwrap();
+            }
+        }
+
+        writeln!(output, ")").unwrap();
+    }
+
+    // Generate minimal plain enum
+    fn write_plain_enum(&self, output: &mut String, type_name: &str, plain_enum: &PlainEnumTypeDef) {
+        writeln!(output, "enum class {} : uint8_t {{", type_name).unwrap();
+
+        for (i, variant) in plain_enum.variants.iter().enumerate() {
+            writeln!(output, "    {} = {},", variant, i).unwrap();
+        }
+
+        writeln!(output, "}};").unwrap();
+    }
+
+    // Special generation for AlgebraicType to handle circular dependencies
+    fn generate_algebraic_type_special(&self) -> String {
+        r#"// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+// This was generated using spacetimedb codegen.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <optional>
+#include <memory>
+#include <variant>
+#include "spacetimedb/bsatn/bsatn.h"
+#include "../forward_declarations.h"
+
+namespace SpacetimeDb::Internal {
+
+// AlgebraicType is special - it uses pointers to break circular dependencies
+// This is a custom implementation due to circular references between:
+// AlgebraicType -> SumType -> SumTypeVariant -> AlgebraicType
+// AlgebraicType -> ProductType -> ProductTypeElement -> AlgebraicType
+class AlgebraicType {
+public:
+    enum class Tag : uint8_t {
+        Ref = 0,
+        Sum = 1, 
+        Product = 2,
+        Array = 3,
+        String = 4,
+        Bool = 5,
+        I8 = 6,
+        U8 = 7,
+        I16 = 8,
+        U16 = 9,
+        I32 = 10,
+        U32 = 11,
+        I64 = 12,
+        U64 = 13,
+        I128 = 14,
+        U128 = 15,
+        I256 = 16,
+        U256 = 17,
+        F32 = 18,
+        F64 = 19
+    };
+
+    using DataType = std::variant<
+        uint32_t,                                          // Ref
+        std::unique_ptr<SpacetimeDb::Internal::SumType>,   // Sum
+        std::unique_ptr<SpacetimeDb::Internal::ProductType>, // Product 
+        std::unique_ptr<SpacetimeDb::Internal::AlgebraicType>, // Array element type
+        std::monostate  // All primitive types (String, Bool, I8, U8, etc.)
+    >;
+
+private:
+    Tag tag_;
+    DataType data_;
+
+public:
+    AlgebraicType();
+    AlgebraicType(Tag primitive_tag);
+    AlgebraicType(const AlgebraicType& other);
+    AlgebraicType& operator=(const AlgebraicType& other);
+    
+    Tag get_tag() const { return tag_; }
+    
+    template<size_t Index>
+    const auto& get() const { return std::get<Index>(data_); }
+
+    template<size_t Index>
+    auto& get() { return std::get<Index>(data_); }
+
+    template<size_t Index, typename T>
+    void set(T&& value);
+
+    template<size_t Index>
+    bool is() const { return tag_ == static_cast<Tag>(Index); }
+
+    template<typename Visitor>
+    auto visit(Visitor&& visitor) const -> decltype(auto) {
+        return std::visit(std::forward<Visitor>(visitor), data_);
+    }
+
+    template<typename Visitor>  
+    auto visit(Visitor&& visitor) -> decltype(auto) {
+        return std::visit(std::forward<Visitor>(visitor), data_);
+    }
+
+    void bsatn_serialize(::SpacetimeDb::bsatn::Writer& writer) const;
+
+    bool operator==(const AlgebraicType& other) const;
+    bool operator!=(const AlgebraicType& other) const { return !(*this == other); }
+};
+
+} // namespace SpacetimeDb::Internal
+"#
+        .to_string()
+    }
+}
+
+impl Lang for Cpp<'_> {
+    fn generate_table_file(&self, module: &ModuleDef, table: &TableDef) -> OutputFile {
+        let mut output = String::new();
+        self.write_header_comment(&mut output);
+        self.write_standard_includes(&mut output);
+
+        // Add includes for dependencies
+        if let Some(AlgebraicTypeDef::Product(product)) = module.typespace_for_generate().get(table.product_type_ref) {
+            let deps = self.collect_product_dependencies(module, product);
+            for dep in deps {
+                if dep != table.name.to_string() {
+                    writeln!(output, "#include \"{}.g.h\"", dep).unwrap();
+                }
+            }
+        }
+
+        writeln!(output).unwrap();
+        writeln!(output, "namespace {} {{", self.namespace).unwrap();
+        writeln!(output).unwrap();
+
+        // Generate table as a product type
+        if let Some(AlgebraicTypeDef::Product(product)) = module.typespace_for_generate().get(table.product_type_ref) {
+            self.write_product_type(&mut output, module, &table.name, product);
+        }
+
+        writeln!(output, "}} // namespace {}", self.namespace).unwrap();
+
+        OutputFile {
+            filename: format!("{}.g.h", table.name),
+            code: output,
+        }
+    }
+
+    fn generate_type_files(&self, module: &ModuleDef, type_def: &TypeDef) -> Vec<OutputFile> {
+        let mut output = String::new();
+        self.write_header_comment(&mut output);
+
+        let name = type_def.name.name();
+
+        // Special handling for AlgebraicType due to circular dependencies
+        if name.to_string() == "AlgebraicType" {
+            return vec![OutputFile {
+                filename: format!("{name}.g.h"),
+                code: self.generate_algebraic_type_special(),
+            }];
+        }
+
+        self.write_standard_includes(&mut output);
+
+        // Add includes for dependencies
+        let deps = match module.typespace_for_generate().get(type_def.ty) {
+            Some(AlgebraicTypeDef::Product(product)) => self.collect_product_dependencies(module, product),
+            Some(AlgebraicTypeDef::Sum(sum)) => self.collect_sum_dependencies(module, sum),
+            Some(AlgebraicTypeDef::PlainEnum(_)) => HashSet::new(),
+            None => HashSet::new(),
+        };
+
+        for dep in deps {
+            if dep != name.to_string() {
+                writeln!(output, "#include \"{}.g.h\"", dep).unwrap();
+            }
+        }
+
+        writeln!(output).unwrap();
+        writeln!(output, "namespace {} {{", self.namespace).unwrap();
+        writeln!(output).unwrap();
+
+        match module.typespace_for_generate().get(type_def.ty) {
+            Some(AlgebraicTypeDef::Product(product)) => {
+                self.write_product_type(&mut output, module, name, product);
+            }
+            Some(AlgebraicTypeDef::Sum(sum)) => {
+                self.write_sum_type(&mut output, module, name, sum);
+            }
+            Some(AlgebraicTypeDef::PlainEnum(plain_enum)) => {
+                self.write_plain_enum(&mut output, name, plain_enum);
+            }
+            None => {
+                writeln!(output, "// ERROR: Could not resolve type definition for {}", name).unwrap();
+            }
+        }
+
+        writeln!(output, "}} // namespace {}", self.namespace).unwrap();
+        vec![OutputFile {
+            filename: format!("{name}.g.h"),
+            code: output,
+        }]
+    }
+
+    fn generate_reducer_file(&self, _module: &ModuleDef, reducer: &ReducerDef) -> OutputFile {
+        let mut output = String::new();
+        self.write_header_comment(&mut output);
+        self.write_standard_includes(&mut output);
+
+        writeln!(output).unwrap();
+        writeln!(output, "namespace {} {{", self.namespace).unwrap();
+        writeln!(output).unwrap();
+
+        writeln!(output, "// Reducer: {}", reducer.name).unwrap();
+        writeln!(output, "// This file is intentionally minimal - reducer implementation").unwrap();
+        writeln!(output, "// is handled by the SpacetimeDB framework.").unwrap();
+
+        writeln!(output, "}} // namespace {}", self.namespace).unwrap();
+        OutputFile {
+            filename: format!("{}.g.h", reducer.name),
+            code: output,
+        }
+    }
+
+    fn generate_global_files(&self, _module: &ModuleDef) -> Vec<OutputFile> {
+        vec![]
+    }
+}
diff --git a/crates/codegen/src/lib.rs b/crates/codegen/src/lib.rs
index f9493329402..ffa9682e9e3 100644
--- a/crates/codegen/src/lib.rs
+++ b/crates/codegen/src/lib.rs
@@ -1,6 +1,7 @@
 use spacetimedb_schema::def::{ModuleDef, ReducerDef, TableDef, TypeDef};
 
 mod code_indenter;
+pub mod cpp;
 pub mod csharp;
 pub mod rust;
 pub mod typescript;
diff --git a/crates/testing/src/modules.rs b/crates/testing/src/modules.rs
index 7dbcd442b06..8d0fc54d471 100644
--- a/crates/testing/src/modules.rs
+++ b/crates/testing/src/modules.rs
@@ -325,3 +325,17 @@ impl ModuleLanguage for TypeScript {
         &MODULE
     }
 }
+
+pub struct Cpp;
+
+impl ModuleLanguage for Cpp {
+    const NAME: &'static str = "cpp";
+
+    fn get_module() -> &'static CompiledModule {
+        lazy_static::lazy_static! {
+            pub static ref MODULE: CompiledModule = CompiledModule::compile("benchmarks-cpp", COMPILATION_MODE);
+        }
+
+        &MODULE
+    }
+}
diff --git a/crates/testing/tests/standalone_integration_test.rs b/crates/testing/tests/standalone_integration_test.rs
index 7f19bd185ce..faffb85320d 100644
--- a/crates/testing/tests/standalone_integration_test.rs
+++ b/crates/testing/tests/standalone_integration_test.rs
@@ -1,8 +1,8 @@
 use serial_test::serial;
 use spacetimedb_lib::sats::{product, AlgebraicValue};
 use spacetimedb_testing::modules::{
-    CompilationMode, CompiledModule, Csharp, LogLevel, LoggerRecord, ModuleHandle, ModuleLanguage, Rust, TypeScript,
-    DEFAULT_CONFIG, IN_MEMORY_CONFIG,
+    CompilationMode, CompiledModule, Cpp, Csharp, LogLevel, LoggerRecord, ModuleHandle, ModuleLanguage, Rust,
+    TypeScript, DEFAULT_CONFIG, IN_MEMORY_CONFIG,
 };
 use std::{
     future::Future,
@@ -105,6 +105,12 @@ fn test_calling_a_reducer_typescript() {
     test_calling_a_reducer_in_module("module-test-ts");
 }
 
+#[test]
+#[serial]
+fn test_calling_a_reducer_cpp() {
+    test_calling_a_reducer_in_module("module-test-cpp");
+}
+
 #[test]
 #[serial]
 fn test_calling_a_reducer_with_private_table() {
@@ -372,6 +378,11 @@ fn test_calling_bench_db_circles_csharp() {
 fn test_calling_bench_db_circles_typescript() {
     test_calling_bench_db_circles::<TypeScript>();
 }
+#[test]
+#[serial]
+fn test_calling_bench_db_circles_cpp() {
+    test_calling_bench_db_circles::<Cpp>();
+}
 
 fn test_calling_bench_db_ia_loop<L: ModuleLanguage>() {
     L::get_module().with_module_async(DEFAULT_CONFIG, |module| async move {
@@ -408,3 +419,8 @@ fn test_calling_bench_db_ia_loop_csharp() {
 fn test_calling_bench_db_ia_loop_typescript() {
     test_calling_bench_db_ia_loop::<TypeScript>();
 }
+#[test]
+#[serial]
+fn test_calling_bench_db_ia_loop_cpp() {
+    test_calling_bench_db_ia_loop::<Cpp>();
+}
diff --git a/modules/benchmarks-cpp/CMakeLists.txt b/modules/benchmarks-cpp/CMakeLists.txt
new file mode 100644
index 00000000000..9aa9d02d3da
--- /dev/null
+++ b/modules/benchmarks-cpp/CMakeLists.txt
@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.16)
+project(benchmarks-cpp)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Module source files
+set(MODULE_SOURCES
+    src/lib.cpp
+    src/circles.cpp
+    src/ia_loop.cpp
+    src/synthetic.cpp
+)
+
+# Output name
+if(NOT DEFINED OUTPUT_NAME)
+    set(OUTPUT_NAME "lib")
+endif()
+
+# Set the path to the SpacetimeDB C++ library
+set(SPACETIMEDB_CPP_LIBRARY_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../crates/bindings-cpp")
+
+# Create the module executable
+add_executable(${OUTPUT_NAME} ${MODULE_SOURCES})
+
+# Include directories
+target_include_directories(${OUTPUT_NAME} PRIVATE
+    ${SPACETIMEDB_CPP_LIBRARY_PATH}/include
+)
+
+# Link the SpacetimeDB library
+add_subdirectory(${SPACETIMEDB_CPP_LIBRARY_PATH} ${CMAKE_CURRENT_BINARY_DIR}/spacetimedb_cpp_library)
+target_link_libraries(${OUTPUT_NAME} PRIVATE spacetimedb_cpp_library)
+
+# Emscripten specific settings
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  # Export list as a single variable (no extra quoting per-platform)
+  set(EXPORTED_FUNCS "['_malloc','_free','___describe_module__','___call_reducer__']")
+
+  # Produce a standalone .wasm (no JS harness) with no entry point
+  target_link_options(lib PRIVATE
+    "SHELL:-sSTANDALONE_WASM=1"
+    "SHELL:-sWASM=1"
+    "SHELL:--no-entry"
+    # Exports
+    "SHELL:-sEXPORTED_FUNCTIONS=${EXPORTED_FUNCS}"
+    # Keep this ON for correctness; you can flip to 0 temporarily to probe
+    "SHELL:-sERROR_ON_UNDEFINED_SYMBOLS=1"
+    # Trim runtime
+    "SHELL:-sFILESYSTEM=0"
+    "SHELL:-sDISABLE_EXCEPTION_CATCHING=1"
+    "SHELL:-sALLOW_MEMORY_GROWTH=0"
+    "SHELL:-sINITIAL_MEMORY=16MB"
+    "SHELL:-sSUPPORT_LONGJMP=0"
+    "SHELL:-sSUPPORT_ERRNO=0"
+    # C++20 and O2 at link step (Emscripten accepts them here too)
+    "SHELL:-std=c++20"
+    "SHELL:-O2"
+  )
+
+  # Name the output lib.wasm
+  set_target_properties(lib PROPERTIES OUTPUT_NAME "lib" SUFFIX ".wasm")
+endif()
\ No newline at end of file
diff --git a/modules/benchmarks-cpp/build.bat b/modules/benchmarks-cpp/build.bat
new file mode 100644
index 00000000000..00bfa95eddd
--- /dev/null
+++ b/modules/benchmarks-cpp/build.bat
@@ -0,0 +1,2 @@
+call emcmake cmake -B build .
+call cmake --build build
\ No newline at end of file
diff --git a/modules/benchmarks-cpp/src/circles.cpp b/modules/benchmarks-cpp/src/circles.cpp
new file mode 100644
index 00000000000..c27bbddb09e
--- /dev/null
+++ b/modules/benchmarks-cpp/src/circles.cpp
@@ -0,0 +1,180 @@
+//! STDB module used for benchmarks based on "realistic" workloads we are focusing in improving.
+//! Circles benchmark - Game-like entities with spatial queries
+
+#include "common.h"
+#include <cmath>
+#include <algorithm>
+
+// =============================================================================
+// CIRCLES BENCHMARK - DATA STRUCTURES
+// =============================================================================
+
+// Vector2 - 2D coordinate structure
+struct Vector2 {
+    float x;
+    float y;
+};
+SPACETIMEDB_STRUCT(Vector2, x, y)
+
+// Entity table - represents game objects with position and mass
+struct Entity {
+    uint32_t id;
+    Vector2 position;
+    uint32_t mass;
+};
+SPACETIMEDB_STRUCT(Entity, id, position, mass)
+SPACETIMEDB_TABLE(Entity, entity, Public)
+FIELD_PrimaryKeyAutoInc(entity, id)
+
+// Circle table - represents player-controlled entities
+struct Circle {
+    uint32_t entity_id;
+    uint32_t player_id;
+    Vector2 direction;
+    float magnitude;
+    Timestamp last_split_time;
+};
+SPACETIMEDB_STRUCT(Circle, entity_id, player_id, direction, magnitude, last_split_time)
+SPACETIMEDB_TABLE(Circle, circle, Public)
+FIELD_PrimaryKey(circle, entity_id)
+FIELD_Index(circle, player_id)
+
+// Food table - represents consumable game objects
+struct Food {
+    uint32_t entity_id;
+};
+SPACETIMEDB_STRUCT(Food, entity_id)
+SPACETIMEDB_TABLE(Food, food, Public)
+FIELD_PrimaryKey(food, entity_id)
+
+// =============================================================================
+// CIRCLES BENCHMARK - HELPER FUNCTIONS
+// =============================================================================
+
+// Convert mass to radius for collision detection
+inline float mass_to_radius(uint32_t mass) {
+    return std::sqrt(static_cast<float>(mass));
+}
+
+// Check if two entities are overlapping based on their positions and masses
+inline bool is_overlapping(const Entity& entity1, const Entity& entity2) {
+    float entity1_radius = mass_to_radius(entity1.mass);
+    float entity2_radius = mass_to_radius(entity2.mass);
+    float dx = entity1.position.x - entity2.position.x;
+    float dy = entity1.position.y - entity2.position.y;
+    float distance = std::sqrt(dx * dx + dy * dy);
+    return distance < std::max(entity1_radius, entity2_radius);
+}
+
+// =============================================================================
+// CIRCLES BENCHMARK - BULK INSERT OPERATIONS
+// =============================================================================
+
+// Bulk insert entities with auto-incremented IDs
+SPACETIMEDB_REDUCER(insert_bulk_entity, ReducerContext& ctx, uint32_t count) {
+    for (uint32_t id = 0; id < count; ++id) {
+        Entity new_entity = {
+            0, // Auto-incremented by database
+            {static_cast<float>(id), static_cast<float>(id + 5)}, // position
+            id * 5 // mass
+        };
+        ctx.db[entity].insert(new_entity);
+    }
+    LOG_INFO("INSERT ENTITY: " + std::to_string(count));
+}
+
+// Bulk insert circles with specified entity and player IDs
+SPACETIMEDB_REDUCER(insert_bulk_circle, ReducerContext& ctx, uint32_t count) {
+    for (uint32_t id = 0; id < count; ++id) {
+        Circle new_circle = {
+            id, // entity_id
+            id, // player_id
+            {static_cast<float>(id), static_cast<float>(id + 5)}, // direction
+            static_cast<float>(id * 5), // magnitude
+            ctx.timestamp // last_split_time
+        };
+        ctx.db[circle].insert(new_circle);
+    }
+    LOG_INFO("INSERT CIRCLE: " + std::to_string(count));
+}
+
+// Bulk insert food entities
+SPACETIMEDB_REDUCER(insert_bulk_food, ReducerContext& ctx, uint32_t count) {
+    for (uint32_t id = 1; id <= count; ++id) {
+        Food new_food = {id};
+        ctx.db[food].insert(new_food);
+    }
+    LOG_INFO("INSERT FOOD: " + std::to_string(count));
+}
+
+// =============================================================================
+// CIRCLES BENCHMARK - CROSS JOIN OPERATIONS
+// =============================================================================
+
+// Simulate: SELECT * FROM Circle, Entity, Food
+// This creates a Cartesian product of all three tables
+SPACETIMEDB_REDUCER(cross_join_all, ReducerContext& ctx, uint32_t expected) {
+    uint32_t count = 0;
+    for (const auto& _circle : ctx.db[circle]) {
+        for (const auto& _entity : ctx.db[entity]) {
+            for (const auto& _food : ctx.db[food]) {
+                ++count;
+            }
+        }
+    }
+    LOG_INFO("CROSS JOIN ALL: " + std::to_string(expected) + ", processed: " + std::to_string(count));
+}
+
+// Simulate: SELECT * FROM Circle JOIN Entity USING(entity_id), Food JOIN Entity USING(entity_id)
+// This joins circles with their entities, then cross-joins with food entities to check overlaps
+SPACETIMEDB_REDUCER(cross_join_circle_food, ReducerContext& ctx, uint32_t expected) {
+    uint32_t count = 0;
+    for (const auto& circle_elem : ctx.db[circle]) {
+        // Find the entity for this circle
+        auto circle_entity_opt = ctx.db[entity_id].find(circle_elem.entity_id);
+        if (!circle_entity_opt) {
+            continue; // Skip if entity not found
+        }
+        const auto& circle_entity = *circle_entity_opt;
+        
+        // Cross join with all food entities
+        for (const auto& food_elem : ctx.db[food]) {
+            ++count;
+            // Find the entity for this food
+            auto food_entity_opt = ctx.db[entity_id].find(food_elem.entity_id);
+            if (!food_entity_opt) {
+                LOG_PANIC("Entity not found: " + std::to_string(food_elem.entity_id));
+                return;
+            }
+            const auto& food_entity = *food_entity_opt;
+            
+            // Check overlap and use black_box to prevent optimization
+            black_box(is_overlapping(circle_entity, food_entity));
+        }
+    }
+    LOG_INFO("CROSS JOIN CIRCLE FOOD: " + std::to_string(expected) + ", processed: " + std::to_string(count));
+}
+
+// =============================================================================
+// CIRCLES BENCHMARK - GAME SIMULATION ENTRY POINTS
+// =============================================================================
+
+// Initialize the circles game simulation with test data
+SPACETIMEDB_REDUCER(init_game_circles, ReducerContext& ctx, uint32_t initial_load) {
+    Load load(initial_load);
+    
+    // Set up the game world with food, entities, and circles
+    insert_bulk_food(ctx, load.initial_load);
+    insert_bulk_entity(ctx, load.initial_load);
+    insert_bulk_circle(ctx, load.small_table);
+}
+
+// Run the circles game simulation benchmark
+SPACETIMEDB_REDUCER(run_game_circles, ReducerContext& ctx, uint32_t initial_load) {
+    Load load(initial_load);
+    
+    // Perform the main benchmark operations
+    cross_join_circle_food(ctx, initial_load * load.small_table);
+    cross_join_all(ctx, initial_load * initial_load * load.small_table);
+}
+
diff --git a/modules/benchmarks-cpp/src/common.h b/modules/benchmarks-cpp/src/common.h
new file mode 100644
index 00000000000..0d5f1855b6e
--- /dev/null
+++ b/modules/benchmarks-cpp/src/common.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <spacetimedb.h>
+#include <cstdint>
+
+using namespace SpacetimeDb;
+
+// Black box function to prevent compiler optimizations during benchmarking
+template<typename T>
+inline void black_box(const T& value) {
+    // Use volatile to prevent the compiler from optimizing away the value
+    volatile const void* ptr = &value;
+    (void)ptr;
+}
+
+// Load configuration struct - defines test data sizes for benchmarks
+struct Load {
+    uint32_t initial_load;
+    uint32_t small_table;
+    uint32_t num_players;
+    uint32_t big_table;
+    uint32_t biggest_table;
+
+    // Default constructor required by SPACETIMEDB_STRUCT
+    Load() = default;
+
+    Load(uint32_t initial_load_param)
+        : initial_load(initial_load_param)
+        , small_table(initial_load_param)
+        , num_players(initial_load_param)
+        , big_table(initial_load_param * 50)
+        , biggest_table(initial_load_param * 100)
+    {}
+};
+SPACETIMEDB_STRUCT(Load, initial_load, small_table, num_players, big_table, biggest_table)
\ No newline at end of file
diff --git a/modules/benchmarks-cpp/src/ia_loop.cpp b/modules/benchmarks-cpp/src/ia_loop.cpp
new file mode 100644
index 00000000000..59f9c1d1d2e
--- /dev/null
+++ b/modules/benchmarks-cpp/src/ia_loop.cpp
@@ -0,0 +1,419 @@
+//! STDB module used for benchmarks based on "realistic" workloads we are focusing in improving.
+//! IA Loop benchmark - AI agent simulation with complex state management
+
+#include "common.h"
+#include <cmath>
+#include <algorithm>
+#include <functional>
+#include <vector>
+
+// =============================================================================
+// IA_LOOP BENCHMARK - DATA STRUCTURES
+// =============================================================================
+
+// Velocity table for entity movement
+struct Velocity {
+    uint32_t entity_id;
+    float x;
+    float y;
+    float z;
+};
+SPACETIMEDB_STRUCT(Velocity, entity_id, x, y, z)
+SPACETIMEDB_TABLE(Velocity, velocity, Public)
+FIELD_PrimaryKey(velocity, entity_id)
+
+// Position table with extended velocity fields
+struct Position {
+    uint32_t entity_id;
+    float x;
+    float y;
+    float z;
+    float vx;
+    float vy;
+    float vz;
+};
+SPACETIMEDB_STRUCT(Position, entity_id, x, y, z, vx, vy, vz)
+SPACETIMEDB_TABLE(Position, position, Public)
+FIELD_PrimaryKey(position, entity_id)
+
+// Agent action enumeration
+SPACETIMEDB_ENUM(AgentAction, Inactive, Idle, Evading, Investigating, Retreating, Fighting)
+
+// AI agent state management
+struct GameEnemyAiAgentState {
+    uint64_t entity_id;
+    std::vector<uint64_t> last_move_timestamps;
+    uint64_t next_action_timestamp;
+    AgentAction action;
+};
+SPACETIMEDB_STRUCT(GameEnemyAiAgentState, entity_id, last_move_timestamps, next_action_timestamp, action)
+SPACETIMEDB_TABLE(GameEnemyAiAgentState, game_enemy_ai_agent_state, Public)
+FIELD_PrimaryKey(game_enemy_ai_agent_state, entity_id)
+
+// Targetable state for spatial queries
+struct GameTargetableState {
+    uint64_t entity_id;
+    int64_t quad;
+};
+SPACETIMEDB_STRUCT(GameTargetableState, entity_id, quad)
+SPACETIMEDB_TABLE(GameTargetableState, game_targetable_state, Public)
+FIELD_PrimaryKey(game_targetable_state, entity_id)
+
+// Live targetable state with quad indexing
+struct GameLiveTargetableState {
+    uint64_t entity_id;
+    int64_t quad;
+};
+SPACETIMEDB_STRUCT(GameLiveTargetableState, entity_id, quad)
+SPACETIMEDB_TABLE(GameLiveTargetableState, game_live_targetable_state, Public)
+FIELD_Unique(game_live_targetable_state, entity_id)
+FIELD_Index(game_live_targetable_state, quad)
+
+// Mobile entity state with spatial indexing
+struct GameMobileEntityState {
+    uint64_t entity_id;
+    int32_t location_x;
+    int32_t location_y;
+    uint64_t timestamp;
+};
+SPACETIMEDB_STRUCT(GameMobileEntityState, entity_id, location_x, location_y, timestamp)
+SPACETIMEDB_TABLE(GameMobileEntityState, game_mobile_entity_state, Public)
+FIELD_PrimaryKey(game_mobile_entity_state, entity_id)
+FIELD_Index(game_mobile_entity_state, location_x)
+
+// Enemy state for herd management
+struct GameEnemyState {
+    uint64_t entity_id;
+    int32_t herd_id;
+};
+SPACETIMEDB_STRUCT(GameEnemyState, entity_id, herd_id)
+SPACETIMEDB_TABLE(GameEnemyState, game_enemy_state, Public)
+FIELD_PrimaryKey(game_enemy_state, entity_id)
+
+// Small hex tile coordinate structure
+struct SmallHexTile {
+    int32_t x;
+    int32_t z;
+    uint32_t dimension;
+};
+SPACETIMEDB_STRUCT(SmallHexTile, x, z, dimension)
+
+// Herd cache for AI behavior
+struct GameHerdCache {
+    int32_t id;
+    uint32_t dimension_id;
+    int32_t current_population;
+    SmallHexTile location;
+    int32_t max_population;
+    float spawn_eagerness;
+    int32_t roaming_distance;
+};
+SPACETIMEDB_STRUCT(GameHerdCache, id, dimension_id, current_population, location, max_population, spawn_eagerness, roaming_distance)
+SPACETIMEDB_TABLE(GameHerdCache, game_herd_cache, Public)
+FIELD_PrimaryKey(game_herd_cache, id)
+
+// =============================================================================
+// IA_LOOP BENCHMARK - HELPER FUNCTIONS
+// =============================================================================
+
+// Simplified moment calculation - always returns 1 as per original implementations
+inline uint64_t moment_milliseconds() {
+    return 1;
+}
+
+// Simple hash calculation for quad values
+inline uint64_t calculate_hash(int64_t value) {
+    return static_cast<uint64_t>(std::hash<int64_t>{}(value));
+}
+
+// =============================================================================
+// IA_LOOP BENCHMARK - POSITION AND VELOCITY OPERATIONS
+// =============================================================================
+
+// Bulk insert position entries
+SPACETIMEDB_REDUCER(insert_bulk_position, ReducerContext& ctx, uint32_t count) {
+    for (uint32_t id = 0; id < count; ++id) {
+        float x = static_cast<float>(id);
+        float y = static_cast<float>(id + 5);
+        float z = static_cast<float>(id * 5);
+        Position new_position = {
+            id, x, y, z,
+            x + 10.0f, y + 20.0f, z + 30.0f // vx, vy, vz
+        };
+        ctx.db[position].insert(new_position);
+    }
+    LOG_INFO("INSERT POSITION: " + std::to_string(count));
+}
+
+// Bulk insert velocity entries
+SPACETIMEDB_REDUCER(insert_bulk_velocity, ReducerContext& ctx, uint32_t count) {
+    for (uint32_t id = 0; id < count; ++id) {
+        Velocity new_velocity = {
+            id,
+            static_cast<float>(id),
+            static_cast<float>(id + 5),
+            static_cast<float>(id * 5)
+        };
+        ctx.db[velocity].insert(new_velocity);
+    }
+    LOG_INFO("INSERT VELOCITY: " + std::to_string(count));
+}
+
+// Update all positions using their internal velocity
+SPACETIMEDB_REDUCER(update_position_all, ReducerContext& ctx, uint32_t expected) {
+    uint32_t count = 0;
+    for (auto pos : ctx.db[position]) {
+        pos.x += pos.vx;
+        pos.y += pos.vy;
+        pos.z += pos.vz;
+        
+        auto _updated = ctx.db[position_entity_id].update(pos);
+        ++count;
+    }
+    LOG_INFO("UPDATE POSITION ALL: " + std::to_string(expected) + ", processed: " + std::to_string(count));
+}
+
+// Update positions using separate velocity table
+SPACETIMEDB_REDUCER(update_position_with_velocity, ReducerContext& ctx, uint32_t expected) {
+    uint32_t count = 0;
+    for (const auto& vel : ctx.db[velocity]) {
+        auto pos_opt = ctx.db[position_entity_id].find(vel.entity_id);
+        if (!pos_opt) {
+            continue;
+        }
+        auto pos = *pos_opt;
+        
+        pos.x += vel.x;
+        pos.y += vel.y;
+        pos.z += vel.z;
+
+        auto _updated = ctx.db[position_entity_id].update(pos);
+        ++count;
+    }
+    LOG_INFO("UPDATE POSITION BY VELOCITY: " + std::to_string(expected) + ", processed: " + std::to_string(count));
+}
+
+// =============================================================================
+// IA_LOOP BENCHMARK - WORLD SETUP
+// =============================================================================
+
+// Insert complete game world state for specified number of players
+SPACETIMEDB_REDUCER(insert_world, ReducerContext& ctx, uint64_t players) {
+    for (uint64_t i = 0; i < players; ++i) {
+        uint64_t next_action_timestamp = (i & 2) == 2 ? 
+            moment_milliseconds() + 2000 : moment_milliseconds();
+        
+        // Insert AI agent state
+        std::vector<uint64_t> move_timestamps = {i, 0, i * 2};
+        GameEnemyAiAgentState agent_state = {
+            i, move_timestamps, next_action_timestamp, AgentAction::Idle
+        };
+        ctx.db[game_enemy_ai_agent_state].insert(agent_state);
+        
+        // Insert live targetable state
+        GameLiveTargetableState live_targetable = {
+            i, static_cast<int64_t>(i)
+        };
+        ctx.db[game_live_targetable_state].insert(live_targetable);
+        
+        // Insert targetable state
+        GameTargetableState targetable = {
+            i, static_cast<int64_t>(i)
+        };
+        ctx.db[game_targetable_state].insert(targetable);
+        
+        // Insert mobile entity state
+        GameMobileEntityState mobile_entity = {
+            i, static_cast<int32_t>(i), static_cast<int32_t>(i), next_action_timestamp
+        };
+        ctx.db[game_mobile_entity_state].insert(mobile_entity);
+        
+        // Insert enemy state
+        GameEnemyState enemy = {
+            i, static_cast<int32_t>(i)
+        };
+        ctx.db[game_enemy_state].insert(enemy);
+        
+        // Insert herd cache
+        SmallHexTile tile = {
+            static_cast<int32_t>(i),
+            static_cast<int32_t>(i),
+            static_cast<uint32_t>(i * 2)
+        };
+        GameHerdCache herd = {
+            static_cast<int32_t>(i),
+            static_cast<uint32_t>(i),
+            static_cast<int32_t>(i * 2),
+            tile,
+            static_cast<int32_t>(i * 4),
+            static_cast<float>(i),
+            static_cast<int32_t>(i)
+        };
+        ctx.db[game_herd_cache].insert(herd);
+    }
+    LOG_INFO("INSERT WORLD PLAYERS: " + std::to_string(players));
+}
+
+// =============================================================================
+// IA_LOOP BENCHMARK - GAME LOGIC
+// =============================================================================
+
+// Get targetable entities near a specific quad
+std::vector<GameTargetableState> get_targetables_near_quad(
+    ReducerContext& ctx, uint64_t entity_id, uint64_t num_players) {
+    std::vector<GameTargetableState> result;
+    result.reserve(4);
+    
+    for (uint64_t id = entity_id; id < num_players; ++id) {
+        int64_t quad = static_cast<int64_t>(id);
+        for (const auto& t : ctx.db[game_live_targetable_state_quad].filter(quad)) {
+            auto targetable_opt = ctx.db[game_targetable_state_entity_id].find(t.entity_id);
+            if (!targetable_opt) {
+                LOG_PANIC("Identity not found");
+                return result;
+            }
+            result.push_back(*targetable_opt);
+        }
+    }
+    
+    return result;
+}
+
+const std::size_t MAX_MOVE_TIMESTAMPS = 20;
+
+// Move agent logic - updates agent state and related entities
+void move_agent(ReducerContext& ctx, GameEnemyAiAgentState& agent, 
+                const SmallHexTile& agent_coord, uint64_t current_time_ms) {
+    uint64_t entity_id = agent.entity_id;
+    
+    // Update enemy state
+    auto enemy_opt = ctx.db[game_enemy_state_entity_id].find(entity_id);
+    if (!enemy_opt) {
+        LOG_PANIC("GameEnemyState Entity ID not found");
+        return;
+    }
+    auto enemy = *enemy_opt;
+    auto _updated = ctx.db[game_enemy_state_entity_id].update(enemy);
+    
+    // Update agent timestamp
+    agent.next_action_timestamp = current_time_ms + 2000;
+    
+    // Track movement timestamps
+    agent.last_move_timestamps.push_back(current_time_ms);
+    if (agent.last_move_timestamps.size() > MAX_MOVE_TIMESTAMPS) {
+        agent.last_move_timestamps.erase(agent.last_move_timestamps.begin());
+    }
+    
+    // Update targetable state
+    auto targetable_opt = ctx.db[game_targetable_state_entity_id].find(entity_id);
+    if (!targetable_opt) {
+        LOG_PANIC("GameTargetableState Entity ID not found");
+        return;
+    }
+    auto targetable = *targetable_opt;
+    int64_t new_hash = static_cast<int64_t>(calculate_hash(targetable.quad));
+    targetable.quad = new_hash;
+    _updated = ctx.db[game_targetable_state_entity_id].update(targetable);
+    
+    // Update live targetable state if exists
+    auto live_targetable_opt = ctx.db[game_live_targetable_state_entity_id].find(entity_id);
+    if (live_targetable_opt) {
+        GameLiveTargetableState live_targetable = {entity_id, new_hash};
+        ctx.db[game_live_targetable_state_entity_id].update(live_targetable);
+    }
+    
+    // Update mobile entity state
+    auto mobile_entity_opt = ctx.db[game_mobile_entity_state_entity_id].find(entity_id);
+    if (!mobile_entity_opt) {
+        LOG_PANIC("GameMobileEntityState Entity ID not found");
+        return;
+    }
+    auto mobile_entity = *mobile_entity_opt;
+    mobile_entity.location_x += 1;
+    mobile_entity.location_y += 1;
+    mobile_entity.timestamp = agent.next_action_timestamp;
+    
+    // Update agent state and mobile entity
+    _updated = ctx.db[game_enemy_ai_agent_state_entity_id].update(agent);
+    _updated = ctx.db[game_mobile_entity_state_entity_id].update(mobile_entity);
+}
+
+// Main agent loop processing
+void agent_loop(ReducerContext& ctx, GameEnemyAiAgentState& agent,
+                const GameTargetableState& agent_targetable,
+                const std::vector<GameTargetableState>& surrounding_agents,
+                uint64_t current_time_ms) {
+    uint64_t entity_id = agent.entity_id;
+    
+    auto coordinates_opt = ctx.db[game_mobile_entity_state_entity_id].find(entity_id);
+    if (!coordinates_opt) {
+        LOG_PANIC("GameMobileEntityState Entity ID not found");
+        return;
+    }
+    
+    auto agent_entity_opt = ctx.db[game_enemy_state_entity_id].find(entity_id);
+    if (!agent_entity_opt) {
+        LOG_PANIC("GameEnemyState Entity ID not found");
+        return;
+    }
+    const auto& agent_entity = *agent_entity_opt;
+    
+    auto agent_herd_opt = ctx.db[game_herd_cache_id].find(agent_entity.herd_id);
+    if (!agent_herd_opt) {
+        LOG_PANIC("GameHerdCache Entity ID not found");
+        return;
+    }
+    const auto& agent_herd = *agent_herd_opt;
+    
+    SmallHexTile agent_herd_coordinates = agent_herd.location;
+    
+    move_agent(ctx, agent, agent_herd_coordinates, current_time_ms);
+}
+
+// Main game loop for enemy AI processing
+SPACETIMEDB_REDUCER(game_loop_enemy_ia, ReducerContext& ctx, uint64_t players) {
+    uint32_t count = 0;
+    uint64_t current_time_ms = moment_milliseconds();
+    
+    for (auto agent : ctx.db[game_enemy_ai_agent_state]) {
+        auto agent_targetable_opt = ctx.db[game_targetable_state_entity_id].find(agent.entity_id);
+        if (!agent_targetable_opt) {
+            LOG_PANIC("No TargetableState for AgentState entity");
+            return;
+        }
+        const auto& agent_targetable = *agent_targetable_opt;
+        
+        auto surrounding_agents = get_targetables_near_quad(ctx, agent_targetable.entity_id, players);
+        
+        agent.action = AgentAction::Fighting;
+        
+        agent_loop(ctx, agent, agent_targetable, surrounding_agents, current_time_ms);
+        
+        ++count;
+    }
+    
+    LOG_INFO("ENEMY IA LOOP PLAYERS: " + std::to_string(players) + ", processed: " + std::to_string(count));
+}
+
+// =============================================================================
+// IA_LOOP BENCHMARK - GAME SIMULATION ENTRY POINTS
+// =============================================================================
+
+// Initialize the IA loop game simulation with test data
+SPACETIMEDB_REDUCER(init_game_ia_loop, ReducerContext& ctx, uint32_t initial_load) {
+    Load load(initial_load);
+    
+    insert_bulk_position(ctx, load.biggest_table);
+    insert_bulk_velocity(ctx, load.big_table);
+    update_position_all(ctx, load.biggest_table);
+    update_position_with_velocity(ctx, load.big_table);
+    
+    insert_world(ctx, static_cast<uint64_t>(load.num_players));
+}
+
+// Run the IA loop game simulation benchmark
+SPACETIMEDB_REDUCER(run_game_ia_loop, ReducerContext& ctx, uint32_t initial_load) {
+    Load load(initial_load);
+    
+    game_loop_enemy_ia(ctx, static_cast<uint64_t>(load.num_players));
+}
\ No newline at end of file
diff --git a/modules/benchmarks-cpp/src/lib.cpp b/modules/benchmarks-cpp/src/lib.cpp
new file mode 100644
index 00000000000..3820b27a059
--- /dev/null
+++ b/modules/benchmarks-cpp/src/lib.cpp
@@ -0,0 +1,14 @@
+//! STDB module used for benchmarks based on "realistic" workloads.
+//!
+//! This C++ module provides equivalence with the Rust and C# benchmark modules:
+//! - Various table definitions with different indexing strategies
+//! - Realistic game workload simulations (circles, ia_loop)
+//! - Synthetic benchmarking operations
+//! - Cross-joins, bulk operations, and performance testing
+//!
+//! The module is organized into three main benchmark categories:
+//! - circles: Game-like entities with spatial queries
+//! - ia_loop: AI agent simulation with complex state management
+//! - synthetic: Pure database operations with various indexing strategies
+
+#include "common.h"
diff --git a/modules/benchmarks-cpp/src/synthetic.cpp b/modules/benchmarks-cpp/src/synthetic.cpp
new file mode 100644
index 00000000000..9b75a48cae2
--- /dev/null
+++ b/modules/benchmarks-cpp/src/synthetic.cpp
@@ -0,0 +1,437 @@
+//! STDB module used for benchmarks.
+//! 
+//! This file provides pure database operations with various indexing strategies for performance testing.
+//! 
+//! We instantiate multiple copies of each table with different indexing:
+//! - unique_0_*: single unique key on first field  
+//! - no_index_*: no indexes at all
+//! - btree_each_column_*: btree index on every column
+
+#include "common.h"
+#include <string>
+#include <vector>
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - TABLE VARIANTS FOR u32_u64_str (id, age, name)
+// =============================================================================
+
+// Unique indexed version
+struct unique_0_u32_u64_str_t {
+    uint32_t id;
+    uint64_t age;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(unique_0_u32_u64_str_t, id, age, name)
+SPACETIMEDB_TABLE(unique_0_u32_u64_str_t, unique_0_u32_u64_str, Public)
+FIELD_Unique(unique_0_u32_u64_str, id)
+
+// No index version
+struct no_index_u32_u64_str_t {
+    uint32_t id;
+    uint64_t age;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(no_index_u32_u64_str_t, id, age, name)
+SPACETIMEDB_TABLE(no_index_u32_u64_str_t, no_index_u32_u64_str, Public)
+
+// BTree index on each column version
+struct btree_each_column_u32_u64_str_t {
+    uint32_t id;
+    uint64_t age;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(btree_each_column_u32_u64_str_t, id, age, name)
+SPACETIMEDB_TABLE(btree_each_column_u32_u64_str_t, btree_each_column_u32_u64_str, Public)
+FIELD_Index(btree_each_column_u32_u64_str, id)
+FIELD_Index(btree_each_column_u32_u64_str, age)
+FIELD_Index(btree_each_column_u32_u64_str, name)
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - TABLE VARIANTS FOR u32_u64_u64 (id, x, y)
+// =============================================================================
+
+// Unique indexed version
+struct unique_0_u32_u64_u64_t {
+    uint32_t id;
+    uint64_t x;
+    uint64_t y;
+};
+SPACETIMEDB_STRUCT(unique_0_u32_u64_u64_t, id, x, y)
+SPACETIMEDB_TABLE(unique_0_u32_u64_u64_t, unique_0_u32_u64_u64, Public)
+FIELD_Unique(unique_0_u32_u64_u64, id)
+
+// No index version
+struct no_index_u32_u64_u64_t {
+    uint32_t id;
+    uint64_t x;
+    uint64_t y;
+};
+SPACETIMEDB_STRUCT(no_index_u32_u64_u64_t, id, x, y)
+SPACETIMEDB_TABLE(no_index_u32_u64_u64_t, no_index_u32_u64_u64, Public)
+
+// BTree index on each column version
+struct btree_each_column_u32_u64_u64_t {
+    uint32_t id;
+    uint64_t x;
+    uint64_t y;
+};
+SPACETIMEDB_STRUCT(btree_each_column_u32_u64_u64_t, id, x, y)
+SPACETIMEDB_TABLE(btree_each_column_u32_u64_u64_t, btree_each_column_u32_u64_u64, Public)
+FIELD_Index(btree_each_column_u32_u64_u64, id)
+FIELD_Index(btree_each_column_u32_u64_u64, x)
+FIELD_Index(btree_each_column_u32_u64_u64, y)
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - EMPTY REDUCER FOR BASELINE
+// =============================================================================
+
+// Empty reducer for baseline measurement
+SPACETIMEDB_REDUCER(empty, ReducerContext& ctx) {}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - SINGLE INSERT OPERATIONS FOR STRING TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_unique_0_u32_u64_str, ReducerContext& ctx, uint32_t id, uint64_t age, std::string name) {
+    unique_0_u32_u64_str_t record = {id, age, name};
+    ctx.db[unique_0_u32_u64_str].insert(record);
+}
+
+SPACETIMEDB_REDUCER(insert_no_index_u32_u64_str, ReducerContext& ctx, uint32_t id, uint64_t age, std::string name) {
+    no_index_u32_u64_str_t record = {id, age, name};
+    ctx.db[no_index_u32_u64_str].insert(record);
+}
+
+SPACETIMEDB_REDUCER(insert_btree_each_column_u32_u64_str, ReducerContext& ctx, uint32_t id, uint64_t age, std::string name) {
+    btree_each_column_u32_u64_str_t record = {id, age, name};
+    ctx.db[btree_each_column_u32_u64_str].insert(record);
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - SINGLE INSERT OPERATIONS FOR NUMERIC TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_unique_0_u32_u64_u64, ReducerContext& ctx, uint32_t id, uint64_t x, uint64_t y) {
+    unique_0_u32_u64_u64_t record = {id, x, y};
+    ctx.db[unique_0_u32_u64_u64].insert(record);
+}
+
+SPACETIMEDB_REDUCER(insert_no_index_u32_u64_u64, ReducerContext& ctx, uint32_t id, uint64_t x, uint64_t y) {
+    no_index_u32_u64_u64_t record = {id, x, y};
+    ctx.db[no_index_u32_u64_u64].insert(record);
+}
+
+SPACETIMEDB_REDUCER(insert_btree_each_column_u32_u64_u64, ReducerContext& ctx, uint32_t id, uint64_t x, uint64_t y) {
+    btree_each_column_u32_u64_u64_t record = {id, x, y};
+    ctx.db[btree_each_column_u32_u64_u64].insert(record);
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - BULK INSERT OPERATIONS FOR NUMERIC TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_bulk_unique_0_u32_u64_u64, ReducerContext& ctx, std::vector<unique_0_u32_u64_u64_t> locs) {
+    for (const auto& loc : locs) {
+        ctx.db[unique_0_u32_u64_u64].insert(loc);
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_bulk_no_index_u32_u64_u64, ReducerContext& ctx, std::vector<no_index_u32_u64_u64_t> locs) {
+    for (const auto& loc : locs) {
+        ctx.db[no_index_u32_u64_u64].insert(loc);
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_bulk_btree_each_column_u32_u64_u64, ReducerContext& ctx, std::vector<btree_each_column_u32_u64_u64_t> locs) {
+    for (const auto& loc : locs) {
+        ctx.db[btree_each_column_u32_u64_u64].insert(loc);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - BULK INSERT OPERATIONS FOR STRING TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_bulk_unique_0_u32_u64_str, ReducerContext& ctx, std::vector<unique_0_u32_u64_str_t> people) {
+    for (const auto& person : people) {
+        ctx.db[unique_0_u32_u64_str].insert(person);
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_bulk_no_index_u32_u64_str, ReducerContext& ctx, std::vector<no_index_u32_u64_str_t> people) {
+    for (const auto& person : people) {
+        ctx.db[no_index_u32_u64_str].insert(person);
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_bulk_btree_each_column_u32_u64_str, ReducerContext& ctx, std::vector<btree_each_column_u32_u64_str_t> people) {
+    for (const auto& person : people) {
+        ctx.db[btree_each_column_u32_u64_str].insert(person);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - UPDATE OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(update_bulk_unique_0_u32_u64_u64, ReducerContext& ctx, uint32_t row_count) {
+    uint32_t hit = 0;
+    for (const auto& u32_u64_u64 : ctx.db[unique_0_u32_u64_u64]) {
+        if (hit >= row_count) break;
+        ++hit;
+        unique_0_u32_u64_u64_t updated_loc = {u32_u64_u64.id, u32_u64_u64.x + 1, u32_u64_u64.y};
+        ctx.db[unique_0_u32_u64_u64_id].update(updated_loc);
+    }
+    if (hit != row_count) {
+        LOG_PANIC("Not enough rows to perform requested amount of updates");
+        return;
+    }
+}
+
+SPACETIMEDB_REDUCER(update_bulk_unique_0_u32_u64_str, ReducerContext& ctx, uint32_t row_count) {
+    uint32_t hit = 0;
+    for (const auto& u32_u64_str : ctx.db[unique_0_u32_u64_str]) {
+        if (hit >= row_count) break;
+        ++hit;
+        unique_0_u32_u64_str_t updated = {u32_u64_str.id, u32_u64_str.age + 1, u32_u64_str.name};
+        ctx.db[unique_0_u32_u64_str_id].update(updated);
+    }
+    if (hit != row_count) {
+        LOG_PANIC("Not enough rows to perform requested amount of updates");
+        return;
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - ITERATION OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(iterate_unique_0_u32_u64_str, ReducerContext& ctx) {
+    for (const auto& u32_u64_str : ctx.db[unique_0_u32_u64_str]) {
+        black_box(u32_u64_str);
+    }
+}
+
+SPACETIMEDB_REDUCER(iterate_unique_0_u32_u64_u64, ReducerContext& ctx) {
+    for (const auto& u32_u64_u64 : ctx.db[unique_0_u32_u64_u64]) {
+        black_box(u32_u64_u64);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - FILTERING BY ID OPERATIONS FOR STRING TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(filter_unique_0_u32_u64_str_by_id, ReducerContext& ctx, uint32_t id) {
+    auto result = ctx.db[unique_0_u32_u64_str_id].find(id);
+    if (result) {
+        black_box(*result);
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_no_index_u32_u64_str_by_id, ReducerContext& ctx, uint32_t id) {
+    for (const auto& r : ctx.db[no_index_u32_u64_str]) {
+        if (r.id == id) {
+            black_box(r);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_btree_each_column_u32_u64_str_by_id, ReducerContext& ctx, uint32_t id) {
+    for (const auto& r : ctx.db[btree_each_column_u32_u64_str_id].filter(id)) {
+        black_box(r);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - FILTERING BY NAME OPERATIONS FOR STRING TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(filter_unique_0_u32_u64_str_by_name, ReducerContext& ctx, std::string name) {
+    for (const auto& p : ctx.db[unique_0_u32_u64_str]) {
+        if (p.name == name) {
+            black_box(p);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_no_index_u32_u64_str_by_name, ReducerContext& ctx, std::string name) {
+    for (const auto& p : ctx.db[no_index_u32_u64_str]) {
+        if (p.name == name) {
+            black_box(p);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_btree_each_column_u32_u64_str_by_name, ReducerContext& ctx, std::string name) {
+    for (const auto& p : ctx.db[btree_each_column_u32_u64_str_name].filter(name)) {
+        black_box(p);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - FILTERING BY ID OPERATIONS FOR NUMERIC TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(filter_unique_0_u32_u64_u64_by_id, ReducerContext& ctx, uint32_t id) {
+    auto result = ctx.db[unique_0_u32_u64_u64_id].find(id);
+    if (result) {
+        black_box(*result);
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_no_index_u32_u64_u64_by_id, ReducerContext& ctx, uint32_t id) {
+    for (const auto& loc : ctx.db[no_index_u32_u64_u64]) {
+        if (loc.id == id) {
+            black_box(loc);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_btree_each_column_u32_u64_u64_by_id, ReducerContext& ctx, uint32_t id) {
+    for (const auto& loc : ctx.db[btree_each_column_u32_u64_u64_id].filter(id)) {
+        black_box(loc);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - FILTERING BY X COORDINATE FOR NUMERIC TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(filter_unique_0_u32_u64_u64_by_x, ReducerContext& ctx, uint64_t x) {
+    for (const auto& loc : ctx.db[unique_0_u32_u64_u64]) {
+        if (loc.x == x) {
+            black_box(loc);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_no_index_u32_u64_u64_by_x, ReducerContext& ctx, uint64_t x) {
+    for (const auto& loc : ctx.db[no_index_u32_u64_u64]) {
+        if (loc.x == x) {
+            black_box(loc);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_btree_each_column_u32_u64_u64_by_x, ReducerContext& ctx, uint64_t x) {
+    for (const auto& loc : ctx.db[btree_each_column_u32_u64_u64_x].filter(x)) {
+        black_box(loc);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - FILTERING BY Y COORDINATE FOR NUMERIC TABLES
+// =============================================================================
+
+SPACETIMEDB_REDUCER(filter_unique_0_u32_u64_u64_by_y, ReducerContext& ctx, uint64_t y) {
+    for (const auto& loc : ctx.db[unique_0_u32_u64_u64]) {
+        if (loc.y == y) {
+            black_box(loc);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_no_index_u32_u64_u64_by_y, ReducerContext& ctx, uint64_t y) {
+    for (const auto& loc : ctx.db[no_index_u32_u64_u64]) {
+        if (loc.y == y) {
+            black_box(loc);
+        }
+    }
+}
+
+SPACETIMEDB_REDUCER(filter_btree_each_column_u32_u64_u64_by_y, ReducerContext& ctx, uint64_t y) {
+    for (const auto& loc : ctx.db[btree_each_column_u32_u64_u64_y].filter(y)) {
+        black_box(loc);
+    }
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - DELETE OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(delete_unique_0_u32_u64_str_by_id, ReducerContext& ctx, uint32_t id) {
+    ctx.db[unique_0_u32_u64_str_id].delete_by_value(id);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_0_u32_u64_u64_by_id, ReducerContext& ctx, uint32_t id) {
+    ctx.db[unique_0_u32_u64_u64_id].delete_by_value(id);
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - CLEAR TABLE OPERATIONS (UNIMPLEMENTED)
+// =============================================================================
+
+SPACETIMEDB_REDUCER(clear_table_unique_0_u32_u64_str, ReducerContext& ctx) {
+    LOG_PANIC("Modules currently have no interface to clear a table");
+}
+
+SPACETIMEDB_REDUCER(clear_table_no_index_u32_u64_str, ReducerContext& ctx) {
+    LOG_PANIC("Modules currently have no interface to clear a table");
+}
+
+SPACETIMEDB_REDUCER(clear_table_btree_each_column_u32_u64_str, ReducerContext& ctx) {
+    LOG_PANIC("Modules currently have no interface to clear a table");
+}
+
+SPACETIMEDB_REDUCER(clear_table_unique_0_u32_u64_u64, ReducerContext& ctx) {
+    LOG_PANIC("Modules currently have no interface to clear a table");
+}
+
+SPACETIMEDB_REDUCER(clear_table_no_index_u32_u64_u64, ReducerContext& ctx) {
+    LOG_PANIC("Modules currently have no interface to clear a table");
+}
+
+SPACETIMEDB_REDUCER(clear_table_btree_each_column_u32_u64_u64, ReducerContext& ctx) {
+    LOG_PANIC("Modules currently have no interface to clear a table");
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - COUNT OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(count_unique_0_u32_u64_str, ReducerContext& ctx) {
+    LOG_INFO("COUNT: " + std::to_string(ctx.db[unique_0_u32_u64_str].count()));
+}
+
+SPACETIMEDB_REDUCER(count_no_index_u32_u64_str, ReducerContext& ctx) {
+    LOG_INFO("COUNT: " + std::to_string(ctx.db[no_index_u32_u64_str].count()));
+}
+
+SPACETIMEDB_REDUCER(count_btree_each_column_u32_u64_str, ReducerContext& ctx) {
+    LOG_INFO("COUNT: " + std::to_string(ctx.db[btree_each_column_u32_u64_str].count()));
+}
+
+SPACETIMEDB_REDUCER(count_unique_0_u32_u64_u64, ReducerContext& ctx) {
+    LOG_INFO("COUNT: " + std::to_string(ctx.db[unique_0_u32_u64_u64].count()));
+}
+
+SPACETIMEDB_REDUCER(count_no_index_u32_u64_u64, ReducerContext& ctx) {
+    LOG_INFO("COUNT: " + std::to_string(ctx.db[no_index_u32_u64_u64].count()));
+}
+
+SPACETIMEDB_REDUCER(count_btree_each_column_u32_u64_u64, ReducerContext& ctx) {
+    LOG_INFO("COUNT: " + std::to_string(ctx.db[btree_each_column_u32_u64_u64].count()));
+}
+
+// =============================================================================
+// SYNTHETIC BENCHMARK - MODULE-SPECIFIC STRESS TESTING
+// =============================================================================
+
+SPACETIMEDB_REDUCER(fn_with_1_args, ReducerContext& ctx, std::string arg) {}
+
+SPACETIMEDB_REDUCER(fn_with_32_args, ReducerContext& ctx,
+    std::string arg1, std::string arg2, std::string arg3, std::string arg4,
+    std::string arg5, std::string arg6, std::string arg7, std::string arg8,
+    std::string arg9, std::string arg10, std::string arg11, std::string arg12,
+    std::string arg13, std::string arg14, std::string arg15, std::string arg16,
+    std::string arg17, std::string arg18, std::string arg19, std::string arg20,
+    std::string arg21, std::string arg22, std::string arg23, std::string arg24,
+    std::string arg25, std::string arg26, std::string arg27, std::string arg28,
+    std::string arg29, std::string arg30, std::string arg31, std::string arg32) {}
+
+SPACETIMEDB_REDUCER(print_many_things, ReducerContext& ctx, uint32_t n) {
+    for (uint32_t i = 0; i < n; ++i) {
+        LOG_INFO("hello again!");
+    }
+}
\ No newline at end of file
diff --git a/modules/module-test-cpp/CMakeLists.txt b/modules/module-test-cpp/CMakeLists.txt
new file mode 100644
index 00000000000..22ceef3342c
--- /dev/null
+++ b/modules/module-test-cpp/CMakeLists.txt
@@ -0,0 +1,60 @@
+cmake_minimum_required(VERSION 3.16)
+project(module-test-cpp)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Module source file
+if(NOT DEFINED MODULE_SOURCE)
+    set(MODULE_SOURCE "src/lib.cpp")
+endif()
+
+# Output name
+if(NOT DEFINED OUTPUT_NAME)
+    set(OUTPUT_NAME "lib")
+endif()
+
+# Set the path to the SpacetimeDB C++ library
+set(SPACETIMEDB_CPP_LIBRARY_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../crates/bindings-cpp")
+
+# Create the module executable
+add_executable(${OUTPUT_NAME} ${MODULE_SOURCE})
+
+# Include directories
+target_include_directories(${OUTPUT_NAME} PRIVATE
+    ${SPACETIMEDB_CPP_LIBRARY_PATH}/include
+)
+
+# Link the SpacetimeDB library
+add_subdirectory(${SPACETIMEDB_CPP_LIBRARY_PATH} ${CMAKE_CURRENT_BINARY_DIR}/spacetimedb_cpp_library)
+target_link_libraries(${OUTPUT_NAME} PRIVATE spacetimedb_cpp_library)
+
+# Emscripten specific settings
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  # Export list as a single variable (no extra quoting per-platform)
+  set(EXPORTED_FUNCS "['_malloc','_free','___describe_module__','___call_reducer__']")
+
+  # Produce a standalone .wasm (no JS harness) with no entry point
+  target_link_options(lib PRIVATE
+    "SHELL:-sSTANDALONE_WASM=1"
+    "SHELL:-sWASM=1"
+    "SHELL:--no-entry"
+    # Exports
+    "SHELL:-sEXPORTED_FUNCTIONS=${EXPORTED_FUNCS}"
+    # Keep this ON for correctness; you can flip to 0 temporarily to probe
+    "SHELL:-sERROR_ON_UNDEFINED_SYMBOLS=1"
+    # Trim runtime
+    "SHELL:-sFILESYSTEM=0"
+    "SHELL:-sDISABLE_EXCEPTION_CATCHING=1"
+    "SHELL:-sALLOW_MEMORY_GROWTH=0"
+    "SHELL:-sINITIAL_MEMORY=16MB"
+    "SHELL:-sSUPPORT_LONGJMP=0"
+    "SHELL:-sSUPPORT_ERRNO=0"
+    # C++20 and O2 at link step (Emscripten accepts them here too)
+    "SHELL:-std=c++20"
+    "SHELL:-O2"
+  )
+
+  # Name the output lib.wasm
+  set_target_properties(lib PROPERTIES OUTPUT_NAME "lib" SUFFIX ".wasm")
+endif()
\ No newline at end of file
diff --git a/modules/module-test-cpp/compare_module_schemas.py b/modules/module-test-cpp/compare_module_schemas.py
new file mode 100644
index 00000000000..8d040722f10
--- /dev/null
+++ b/modules/module-test-cpp/compare_module_schemas.py
@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+Compare SpacetimeDB module schemas between Rust and C++ implementations.
+
+This script compares the JSON schema outputs from:
+- Rust module: rust-module-schema.json
+- C++ module: cpp-module-schema.json or cpp-module-schema-latest.json
+
+Usage:
+    python3 compare_module_schemas.py
+    
+To regenerate schema files:
+    spacetime describe module-test --json > rust-module-schema.json
+    spacetime describe module-test-cpp --json > cpp-module-schema.json
+"""
+
+import json
+import sys
+import os
+
+def load_schemas():
+    """Load the schema files, trying both cpp-module-schema.json and cpp-module-schema-latest.json"""
+    try:
+        with open('rust-module-schema.json', 'r') as f:
+            rust = json.load(f)
+    except FileNotFoundError:
+        print("Error: rust-module-schema.json not found")
+        print("Generate it with: spacetime describe module-test --json > rust-module-schema.json")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error parsing rust-module-schema.json: {e}")
+        print("The file may be corrupted or incomplete. Try regenerating it.")
+        sys.exit(1)
+        
+    # Try to load C++ schema, checking both possible filenames
+    cpp = None
+    for filename in ['cpp-module-schema-latest.json', 'cpp-module-schema.json']:
+        if os.path.exists(filename):
+            with open(filename, 'r') as f:
+                cpp = json.load(f)
+                print(f"Loaded C++ schema from {filename}")
+                break
+    
+    if cpp is None:
+        print("Error: No C++ schema file found")
+        print("Generate it with: spacetime describe module-test-cpp --json > cpp-module-schema.json")
+        sys.exit(1)
+    
+    return rust, cpp
+
+def normalize_index(idx):
+    """Normalize index representation for comparison"""
+    name = idx.get('name', {})
+    if isinstance(name, dict):
+        name = name.get('some', None)
+    
+    accessor = idx.get('accessor_name', {})
+    if isinstance(accessor, dict):
+        accessor = accessor.get('some', None)
+    
+    algo = idx.get('algorithm', {})
+    cols = []
+    if isinstance(algo, dict) and 'BTree' in algo:
+        cols = algo['BTree']
+    
+    return {'name': name, 'accessor': accessor, 'columns': cols}
+
+def compare_tables(rust_tables, cpp_tables):
+    """Compare table definitions between Rust and C++"""
+    print("\n=== TABLE COMPARISON ===")
+    print(f"Rust tables: {len(rust_tables)}")
+    print(f"C++ tables: {len(cpp_tables)}")
+    
+    rust_names = set(rust_tables.keys())
+    cpp_names = set(cpp_tables.keys())
+    
+    if rust_names != cpp_names:
+        missing = rust_names - cpp_names
+        extra = cpp_names - rust_names
+        if missing:
+            print(f"❌ Missing in C++: {missing}")
+        if extra:
+            print(f"❌ Extra in C++: {extra}")
+    else:
+        print("✅ All table names match!")
+    
+    return rust_names & cpp_names
+
+def compare_indexes(rust_tables, cpp_tables, common_tables):
+    """Compare index definitions for common tables"""
+    print("\n=== INDEX COMPARISON ===")
+    
+    differences = []
+    for table_name in sorted(common_tables):
+        rust_table = rust_tables[table_name]
+        cpp_table = cpp_tables[table_name]
+        
+        rust_indexes = [normalize_index(idx) for idx in rust_table.get('indexes', [])]
+        cpp_indexes = [normalize_index(idx) for idx in cpp_table.get('indexes', [])]
+        
+        if rust_indexes != cpp_indexes:
+            differences.append((table_name, rust_indexes, cpp_indexes))
+    
+    if not differences:
+        print("✅ All table indexes match perfectly!")
+    else:
+        print(f"Found index differences in {len(differences)} table(s):")
+        for table_name, rust_idx, cpp_idx in differences:
+            print(f"\n{table_name}:")
+            for r in rust_idx:
+                name_str = str(r['name']) if r['name'] is not None else "None"
+                accessor_str = str(r['accessor']) if r['accessor'] is not None else "None"
+                print(f"  Rust:  name={name_str:<30} accessor={accessor_str:<20} cols={r['columns']}")
+            for c in cpp_idx:
+                name_str = str(c['name']) if c['name'] is not None else "None"
+                accessor_str = str(c['accessor']) if c['accessor'] is not None else "None"
+                print(f"  C++:   name={name_str:<30} accessor={accessor_str:<20} cols={c['columns']}")
+
+def compare_reducers(rust_reducers, cpp_reducers):
+    """Compare reducer definitions between Rust and C++"""
+    print("\n=== REDUCER COMPARISON ===")
+    
+    rust_names = {r['name'] for r in rust_reducers}
+    cpp_names = {r['name'] for r in cpp_reducers}
+    
+    print(f"Rust reducers: {len(rust_names)}")
+    print(f"C++ reducers: {len(cpp_names)}")
+    
+    if rust_names != cpp_names:
+        missing = rust_names - cpp_names
+        extra = cpp_names - rust_names
+        if missing:
+            print(f"❌ Missing in C++: {missing}")
+        if extra:
+            print(f"❌ Extra in C++: {extra}")
+    else:
+        print("✅ All reducer names match!")
+
+def check_testf_enum(rust, cpp):
+    """Check the TestF enum specifically since it's known to have issues"""
+    print("\n=== TESTF ENUM COMPARISON ===")
+    
+    for schema, lang in [(rust, 'Rust'), (cpp, 'C++')]:
+        for reducer in schema['reducers']:
+            if reducer['name'] == 'test':
+                params = reducer.get('params', [])
+                if len(params) >= 4:
+                    param_type = params[3].get('algebraic_type', {})
+                    if 'Sum' in param_type:
+                        variants = param_type['Sum'].get('variants', [])
+                        print(f"\n{lang} TestF enum:")
+                        for v in variants:
+                            name = v.get('name', 'unnamed')
+                            alg_type = v.get('algebraic_type', {})
+                            if 'Product' in alg_type and alg_type['Product'].get('fields'):
+                                fields = alg_type['Product']['fields']
+                                field_info = []
+                                for f in fields:
+                                    field_name = f.get('name', 'unnamed')
+                                    field_info.append(field_name)
+                                print(f"  - {name}: has payload with fields {field_info}")
+                            else:
+                                print(f"  - {name}: unit variant (no payload)")
+                break
+
+def main():
+    print("=" * 60)
+    print("SpacetimeDB Module Schema Comparison")
+    print("Comparing Rust vs C++ module implementations")
+    print("=" * 60)
+    
+    # Load schemas
+    rust, cpp = load_schemas()
+    
+    # Extract tables and reducers
+    rust_tables = {t['name']: t for t in rust['tables']}
+    cpp_tables = {t['name']: t for t in cpp['tables']}
+    rust_reducers = rust['reducers']
+    cpp_reducers = cpp['reducers']
+    
+    # Run comparisons
+    common_tables = compare_tables(rust_tables, cpp_tables)
+    compare_indexes(rust_tables, cpp_tables, common_tables)
+    compare_reducers(rust_reducers, cpp_reducers)
+    check_testf_enum(rust, cpp)
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("SUMMARY")
+    print("=" * 60)
+    
+    perfect_match = (
+        len(rust_tables) == len(cpp_tables) and
+        len(rust_reducers) == len(cpp_reducers) and
+        set(rust_tables.keys()) == set(cpp_tables.keys()) and
+        {r['name'] for r in rust_reducers} == {r['name'] for r in cpp_reducers}
+    )
+    
+    if perfect_match:
+        print("✅ Schema structure matches (tables and reducers)")
+        print("⚠️  Note: There may be minor differences in:")
+        print("   - Index naming conventions (especially multi-column indexes)")
+        print("   - TestF enum payload support (C++ currently simplified)")
+    else:
+        print("❌ Schema structure has differences - review details above")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/modules/module-test-cpp/src/lib.cpp b/modules/module-test-cpp/src/lib.cpp
new file mode 100644
index 00000000000..41e0f3de266
--- /dev/null
+++ b/modules/module-test-cpp/src/lib.cpp
@@ -0,0 +1,510 @@
+// Set log level to TRACE for this module for repeating_test reducer
+#define STDB_LOG_LEVEL ::SpacetimeDb::LogLevelValue::TRACE
+
+#include <spacetimedb.h>
+#include <spacetimedb/range_queries.h>
+#include <variant>
+#include <optional>
+
+using namespace SpacetimeDb;
+using SpacetimeDb::Public;
+using SpacetimeDb::Private;
+
+
+// =============================================================================
+// C++ Module Test - Equivalent to Rust module-test
+// =============================================================================
+//
+// This module provides equivalence with the Rust module-test:
+// - Table definitions with constraints and indexes
+// - Support types and enums
+// - Reducers for testing various database operations
+// =============================================================================
+
+// struct CircularA {
+//     uint32_t id;
+//     std::vector<CircularA> circ_ref; // References to CircularB by id
+// };
+// SPACETIMEDB_STRUCT(CircularA, id, circ_ref)
+// SPACETIMEDB_TABLE(CircularA, circular_a, Public)
+
+// =============================================================================
+// SUPPORT TYPES AND ENUMS
+// =============================================================================
+
+// TestB struct - simple struct with a string field
+struct TestB {
+    std::string foo;
+};
+SPACETIMEDB_STRUCT(TestB, foo)
+
+// TestC enum - simple enum without payloads (with Namespace scope)
+SPACETIMEDB_ENUM(TestC, Foo, Bar)
+SPACETIMEDB_NAMESPACE(TestC, "Namespace")
+
+// TestF enum - simplified for now due to C++ SDK limitations (with Namespace scope)
+// Rust has: Foo, Bar, Baz(String) - mixed enum with payload
+// C++ SDK issue: std::variant can't have duplicate types (multiple unit/monostate)
+// and the Unit marker system doesn't fully resolve this yet
+SPACETIMEDB_ENUM(TestF, Foo, Bar, Baz)
+SPACETIMEDB_NAMESPACE(TestF, "Namespace")
+
+// Baz struct
+struct Baz {
+    std::string field;
+};
+SPACETIMEDB_STRUCT(Baz, field)
+
+// Foobar enum - variant enum with payloads
+SPACETIMEDB_ENUM(Foobar,
+    (BazVariant, Baz),
+    (Har, uint32_t)
+)
+
+// =============================================================================
+// TABLE DEFINITIONS
+// =============================================================================
+
+// Person table - public table with auto-increment primary key and age index
+// Matches Rust: index(name = age, btree(columns = [age]))
+struct Person {
+    uint32_t id;
+    std::string name;
+    uint8_t age;
+};
+SPACETIMEDB_STRUCT(Person, id, name, age)
+SPACETIMEDB_TABLE(Person, person, Public)
+FIELD_PrimaryKeyAutoInc(person, id)
+FIELD_Index(person, age)
+
+// TestA table - private table with foo index on x column
+// Matches Rust: index(name = foo, btree(columns = [x]))
+struct TestA {
+    uint32_t x;
+    uint32_t y;
+    std::string z;
+};
+SPACETIMEDB_STRUCT(TestA, x, y, z)
+SPACETIMEDB_TABLE(TestA, test_a, Private)
+// Note: Single column named indexes aren't supported - use regular index
+FIELD_Index(test_a, x)
+
+// Type alias for TestA
+using TestAlias = TestA;
+
+// TestD table - public table with optional TestC field
+struct TestD {
+    std::optional<TestC> test_c;
+    TestF test_f;  // Add TestF field to ensure it gets registered
+};
+SPACETIMEDB_STRUCT(TestD, test_c, test_f)
+SPACETIMEDB_TABLE(TestD, test_d, Public)
+
+// TestE table - private table with auto-increment primary key and btree index on name
+// Matches Rust: #[index(btree)] on name field
+struct TestE {
+    uint64_t id;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(TestE, id, name)
+SPACETIMEDB_TABLE(TestE, test_e, Private)
+FIELD_PrimaryKeyAutoInc(test_e, id)
+FIELD_Index(test_e, name)
+
+// TestFoobar table - public table with Foobar enum field
+struct TestFoobar {
+    Foobar field;
+};
+SPACETIMEDB_STRUCT(TestFoobar, field)
+SPACETIMEDB_TABLE(TestFoobar, test_f, Public)
+
+// PrivateTable - explicitly private table
+struct PrivateTable {
+    std::string name;
+};
+SPACETIMEDB_STRUCT(PrivateTable, name)
+SPACETIMEDB_TABLE(PrivateTable, private_table, Private)
+
+// Point table - private table with two coordinates and multi-column index
+// Rust has: index(name = multi_column_index, btree(columns = [x, y]))
+struct Point {
+    int64_t x;
+    int64_t y;
+};
+SPACETIMEDB_STRUCT(Point, x, y)
+SPACETIMEDB_TABLE(Point, points, Private)
+FIELD_NamedMultiColumnIndex(points, multi_column_index, x, y)
+
+// PkMultiIdentity - table with multiple constraints
+struct PkMultiIdentity {
+    uint32_t id;
+    uint32_t other;
+};
+SPACETIMEDB_STRUCT(PkMultiIdentity, id, other)
+SPACETIMEDB_TABLE(PkMultiIdentity, pk_multi_identity, Private)
+FIELD_PrimaryKey(pk_multi_identity, id)
+FIELD_UniqueAutoInc(pk_multi_identity, other)
+
+// RepeatingTestArg - table for scheduled reducer
+struct RepeatingTestArg {
+    uint64_t scheduled_id;
+    ScheduleAt scheduled_at;
+    Timestamp prev_time;
+};
+SPACETIMEDB_STRUCT(RepeatingTestArg, scheduled_id, scheduled_at, prev_time)
+SPACETIMEDB_TABLE(RepeatingTestArg, repeating_test_arg, Private)
+FIELD_PrimaryKeyAutoInc(repeating_test_arg, scheduled_id)
+SPACETIMEDB_SCHEDULE(repeating_test_arg, 1, repeating_test)
+
+// HasSpecialStuff - table with special types
+struct HasSpecialStuff {
+    Identity identity;
+    ConnectionId connection_id;
+};
+SPACETIMEDB_STRUCT(HasSpecialStuff, identity, connection_id)
+SPACETIMEDB_TABLE(HasSpecialStuff, has_special_stuff, Private)
+
+// Player table
+struct Player {
+    Identity identity;
+    uint64_t player_id;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(Player, identity, player_id, name)
+SPACETIMEDB_TABLE(Player, player, Public)
+FIELD_PrimaryKey(player, identity)
+FIELD_UniqueAutoInc(player, player_id)
+FIELD_Unique(player, name)
+
+SPACETIMEDB_TABLE(Player, logged_out_player, Public)
+FIELD_PrimaryKey(logged_out_player, identity)
+FIELD_UniqueAutoInc(logged_out_player, player_id)
+FIELD_Unique(logged_out_player, name)
+
+// =============================================================================
+// REDUCERS
+// =============================================================================
+
+// Init reducer - called when module is first published
+// COMMENTED OUT FOR DEBUGGING
+SPACETIMEDB_INIT(init) {
+    RepeatingTestArg arg{
+        0, // scheduled_id  
+        ScheduleAt(TimeDuration::from_millis(1000)),
+        ctx.timestamp
+    };
+    //ctx.db[repeating_test_arg].insert(arg);
+}
+
+// Repeating test reducer for scheduled operations
+SPACETIMEDB_REDUCER(repeating_test, ReducerContext ctx, RepeatingTestArg arg) {
+    // Log would show delta time since last run
+    // In C++ we don't have log::trace equivalent yet
+    auto delta_time = ctx.timestamp.duration_since(arg.prev_time);
+    LOG_TRACE("Timestamp: " + ctx.timestamp.to_string() + " Delta time: " + delta_time.to_string());
+}
+
+// Add a person to the Person table
+SPACETIMEDB_REDUCER(add, ReducerContext ctx, std::string name, uint8_t age) {
+    Person p{0, name, age}; // id will be auto-incremented
+    Person inserted = ctx.db[person].insert(p);
+    //LOG_INFO("Inserted person with auto-generated ID: " + std::to_string(inserted.id));
+}
+
+// Say hello to all persons
+SPACETIMEDB_REDUCER(say_hello, ReducerContext ctx) {
+    // In Rust this logs "Hello, {name}!" for each person
+    for (const auto& p : ctx.db[person]) {
+        LOG_INFO("Hello, " + p.name + "!");
+    }
+    LOG_INFO("Hello, World!");
+}
+
+// List persons over a certain age - showcases range query functionality
+SPACETIMEDB_REDUCER(list_over_age, ReducerContext ctx, uint8_t age) {
+    // Use index-based filtering with range queries - equivalent to Rust: ctx.db.person().age().filter(age..)
+    auto age_range = range_from(age);
+    
+    // Use the indexed field accessor for efficient filtering
+    // ctx.db[person_age] creates a TypedIndexedAccessor with filter methods
+    auto filtered_persons = ctx.db[person_age].filter(age_range);
+    
+    for (const auto& person : filtered_persons) {
+        LOG_INFO(person.name + " has age " + std::to_string(person.age) + " >= " + std::to_string(age));
+    }
+}
+
+// Log module identity
+SPACETIMEDB_REDUCER(log_module_identity, ReducerContext ctx) {
+    LOG_INFO("Module identity: " + ctx.identity().to_string());
+}
+
+// Complex test reducer with multiple parameters
+SPACETIMEDB_REDUCER(test, ReducerContext ctx, TestAlias arg, TestB arg2, TestC arg3, TestF arg4) {
+    LOG_INFO("BEGIN");
+    LOG_INFO("sender: " + ctx.sender.to_string());
+    LOG_INFO("timestamp: " + ctx.timestamp.to_string());
+    LOG_INFO("bar: " + arg2.foo);
+
+    // Match TestC enum
+    switch (arg3) {
+        case TestC::Foo:
+            LOG_INFO("Foo");
+            break;
+        case TestC::Bar:
+            LOG_INFO("Bar");
+            break;
+    }
+    
+    // Match TestF enum
+    switch (arg4) {
+        case TestF::Foo:
+            LOG_INFO("Foo");
+            break;
+        case TestF::Bar:
+            LOG_INFO("Bar");
+            break;
+        case TestF::Baz:
+            LOG_INFO("Baz");
+            break;
+    }
+
+    // Insert test data
+    for (uint32_t i = 0; i < 1000; ++i) {
+        TestA test_a_instance{i + arg.x, i + arg.y, "Yo"};
+        ctx.db[test_a].insert(test_a_instance);
+    }
+    
+    // Count rows before delete
+    uint64_t row_count_before_delete = ctx.db[test_a].count();
+    LOG_INFO("Row count before delete: " + std::to_string(row_count_before_delete));
+    
+    // Delete rows where x is between 5 and 10
+    uint32_t num_deleted = 0;
+    for (uint32_t row = 5; row < 10; ++row) {
+        auto to_delete = ctx.db[test_a_x].filter(row);
+        for (const auto& test_row : to_delete) {
+            LOG_INFO("Deleting row with x=" + std::to_string(test_row.x) + " y=" + std::to_string(test_row.y));
+            if (ctx.db[test_a].delete_by_value(test_row)) {
+            }
+        }
+        num_deleted++;
+    }
+    
+    // Count rows after delete
+    uint64_t row_count_after_delete = ctx.db[test_a].count();
+    
+    // Verify deletion worked correctly
+    if (row_count_before_delete != row_count_after_delete + num_deleted) {
+        LOG_ERROR("Started with " + std::to_string(row_count_before_delete) + 
+                 " rows, deleted " + std::to_string(num_deleted) + 
+                 ", and wound up with " + std::to_string(row_count_after_delete) + 
+                 " rows... huh?");
+    }
+    
+    // Test TestE insertion - using regular insert since try_insert isn't available in TableAccessor
+    try {
+        TestE test_e_instance{0, "Tyler"};
+        TestE inserted = ctx.db[test_e].insert(test_e_instance);
+        LOG_INFO("Inserted: id=" + std::to_string(inserted.id) + " name=" + inserted.name);
+    } catch (const std::exception& e) {
+        LOG_INFO("Error: " + std::string(e.what()));
+    }
+    
+    LOG_INFO("Row count after delete: " + std::to_string(row_count_after_delete));
+    
+    // Count all rows
+    uint64_t other_row_count = ctx.db[test_a].count();
+    LOG_INFO("Row count filtered by condition: " + std::to_string(other_row_count));
+    
+    LOG_INFO("MultiColumn");
+    
+    // Insert points for multi-column index testing
+    for (int64_t i = 0; i < 1000; ++i) {
+        Point point{i + static_cast<int64_t>(arg.x), i + static_cast<int64_t>(arg.y)};
+        ctx.db[points].insert(point);
+    }
+    
+    // Count points with multi-column condition - diagnostic version
+    uint64_t multi_row_count = 0;
+
+    for (const auto& point : ctx.db[points]) {
+        if (point.x >= 0 && point.y <= 200) {
+            multi_row_count++;
+        }
+    }
+    LOG_INFO("Row count filtered by multi-column condition: " + std::to_string(multi_row_count));
+    
+    LOG_INFO("END");
+}
+
+// Add a player (TestE entry)
+SPACETIMEDB_REDUCER(add_player, ReducerContext ctx, std::string name) {
+    // Try without specifying id at all - but TestE struct requires both fields
+    // So we have to use 0 as placeholder
+    TestE player{0, name}; // id will be auto-incremented
+
+    TestE inserted = ctx.db[test_e_id].try_insert_or_update(player);
+    LOG_INFO("Inserted player with auto-generated ID: " + std::to_string(inserted.id));
+
+    ctx.db[test_e_id].try_insert_or_update(inserted);
+    LOG_INFO("Updated player after insert-or-update");
+}
+
+// Delete a player by ID
+SPACETIMEDB_REDUCER(delete_player, ReducerContext ctx, uint64_t id) {
+    // Delete TestE entry with given id
+    // In C++ we'd need to implement delete by primary key
+    if (ctx.db[test_e_id].delete_by_key(id)) {
+        LOG_INFO("Deleted player with ID: " + std::to_string(id));
+    } else {
+        LOG_ERROR("No player found with ID: " + std::to_string(id));
+    }
+}
+
+// Delete players by name
+SPACETIMEDB_REDUCER(delete_players_by_name, ReducerContext ctx, std::string name) {
+    // Delete all TestE entries with given name
+    // In C++ we'd iterate and delete matching entries
+    //auto to_delete = ctx.db[test_e_name].filter(name);
+    auto deleted = ctx.db[test_e_name].delete_by_value(name);
+    LOG_INFO("Deleted " + std::to_string(deleted) + " players with name: " + name);
+}
+
+// Client connected lifecycle reducer
+SPACETIMEDB_CLIENT_CONNECTED(client_connected) {
+    // Called when a client connects
+}
+
+// Add entry to private table
+SPACETIMEDB_REDUCER(add_private, ReducerContext ctx, std::string name) {
+    PrivateTable entry{name};
+    auto secret_entry = ctx.db[private_table].insert(entry);
+    LOG_INFO("Inserted private table entry: " + secret_entry.name);
+}
+
+// Query private table
+SPACETIMEDB_REDUCER(query_private, ReducerContext ctx) {
+    // Iterate over private_table entries
+    // Would log each entry's name
+    for (const auto& entry : ctx.db[private_table]) {
+        LOG_INFO("Private, " + entry.name + "!");
+    }
+    LOG_INFO("Private, World!");
+}
+
+// Test btree index arguments - comprehensive range query testing
+SPACETIMEDB_REDUCER(test_btree_index_args, ReducerContext ctx) {
+    // This tests various range query patterns equivalent to Rust's comprehensive index testing
+    
+    // ==================================================================
+    // Single-column range queries on Person.age (uint8_t indexed field)  
+    // ==================================================================
+    
+    LOG_INFO("=== Testing age range queries ===");
+    
+    // Test all range construction patterns
+    auto range_from_25 = range_from(uint8_t(25));        // 25..
+    auto range_to_30 = range_to(uint8_t(30));            // ..30  
+    auto range_25_to_30 = range(uint8_t(25), uint8_t(30)); // 25..30
+    auto range_25_to_30_inc = range_inclusive(uint8_t(25), uint8_t(30)); // 25..=30
+    auto range_to_30_inc = range_to_inclusive(uint8_t(30)); // ..=30
+    auto range_all = range_full<uint8_t>();              // ..
+    
+    // Count matches for each range pattern using INDEX-BASED FILTERING
+    // Now using ctx.db[person_age] indexed field accessor for efficient queries
+    size_t count_25_plus = ctx.db[person_age].filter(range_from_25).size();
+    size_t count_under_30 = ctx.db[person_age].filter(range_to_30).size();
+    size_t count_25_to_30 = ctx.db[person_age].filter(range_25_to_30).size();
+    size_t count_25_to_30_inc = ctx.db[person_age].filter(range_25_to_30_inc).size();
+    size_t count_under_30_inc = ctx.db[person_age].filter(range_to_30_inc).size();
+    size_t count_all = ctx.db[person_age].filter(range_all).size();
+    
+    LOG_INFO("Age >= 25: " + std::to_string(count_25_plus));
+    LOG_INFO("Age < 30: " + std::to_string(count_under_30));
+    LOG_INFO("Age 25..30: " + std::to_string(count_25_to_30));
+    LOG_INFO("Age 25..=30: " + std::to_string(count_25_to_30_inc));
+    LOG_INFO("Age ..=30: " + std::to_string(count_under_30_inc));
+    LOG_INFO("All ages: " + std::to_string(count_all));
+    
+    // ==================================================================
+    // Multi-column range queries on Point.x, Point.y (int64_t fields)
+    // Equivalent to Rust's multi_column_index filter tests
+    // ==================================================================
+    
+    LOG_INFO("=== Testing coordinate range queries ===");
+    
+    // Test coordinate-based ranges  
+    auto x_range_positive = range_from(int64_t(0));      // x >= 0
+    auto x_range_0_to_100 = range(int64_t(0), int64_t(100)); // 0 <= x < 100
+    auto xy_combined = range_inclusive(int64_t(-50), int64_t(50)); // -50 <= coord <= 50
+    
+    size_t positive_x_count = 0, x_0_to_100_count = 0, xy_in_range_count = 0;
+    
+    for (const auto& point : ctx.db[points]) {
+        if (x_range_positive.contains(point.x)) positive_x_count++;
+        if (x_range_0_to_100.contains(point.x)) x_0_to_100_count++;
+        if (xy_combined.contains(point.x) && xy_combined.contains(point.y)) {
+            xy_in_range_count++;
+        }
+    }
+    
+    LOG_INFO("Points with x >= 0: " + std::to_string(positive_x_count));
+    LOG_INFO("Points with 0 <= x < 100: " + std::to_string(x_0_to_100_count));
+    LOG_INFO("Points with x,y in [-50,50]: " + std::to_string(xy_in_range_count));
+    
+    // ==================================================================
+    // String range queries on TestE.name (string indexed field)
+    // ==================================================================
+    
+    LOG_INFO("=== Testing string range queries ===");
+    
+    // String range examples - using INDEX-BASED FILTERING
+    auto name_range_a_to_m = range(std::string("A"), std::string("M"));  // Names starting A-L
+    auto name_range_from_t = range_from(std::string("T")); // Names starting T and later
+    
+    // Use ctx.db[test_e_name] indexed field accessor for efficient string range queries
+    size_t names_a_to_m = ctx.db[test_e_name].filter(name_range_a_to_m).size();
+    size_t names_from_t = ctx.db[test_e_name].filter(name_range_from_t).size();
+    
+    LOG_INFO("Names A-L: " + std::to_string(names_a_to_m));
+    LOG_INFO("Names T+: " + std::to_string(names_from_t));
+    
+    // ==================================================================
+    // Range query performance comparison
+    // ==================================================================
+    
+    LOG_INFO("=== Range vs Manual Filtering Comparison ===");
+    
+    auto performance_range = range_inclusive(uint8_t(20), uint8_t(40));
+    size_t range_matches = 0, manual_matches = 0;
+    
+    // Method 1: Range-based filtering
+    for (const auto& p : ctx.db[person]) {
+        if (performance_range.contains(p.age)) {
+            range_matches++;
+        }
+    }
+    
+    // Method 2: Manual filtering  
+    for (const auto& p : ctx.db[person]) {
+        if (p.age >= 20 && p.age <= 40) {
+            manual_matches++;
+        }
+    }
+    
+    LOG_INFO("Range-based matches: " + std::to_string(range_matches));
+    LOG_INFO("Manual matches: " + std::to_string(manual_matches));
+    LOG_INFO("Results match: " + std::to_string(range_matches == manual_matches ? 1 : 0));
+}
+
+// Test reducer for assertions
+SPACETIMEDB_REDUCER(assert_caller_identity_is_module_identity, ReducerContext ctx) {
+    LOG_INFO("Sender: " + ctx.sender.to_string() + " Identity: " + ctx.identity().to_string());
+    if (ctx.sender != ctx.identity()) {
+        LOG_ERROR("Assertion failed: caller identity does not match module identity");
+    } else {
+        LOG_INFO("Assertion passed: caller identity matches module identity");
+    }
+}
+
diff --git a/modules/sdk-test-cpp/.gitignore b/modules/sdk-test-cpp/.gitignore
new file mode 100644
index 00000000000..6c6b4203f30
--- /dev/null
+++ b/modules/sdk-test-cpp/.gitignore
@@ -0,0 +1,31 @@
+# Build directories
+build/
+build_*/
+.cache/
+
+# Build outputs
+*.wasm
+*.o
+*.a
+
+# Build logs
+*.log
+
+# Test outputs
+*_output.txt
+*.json
+!module_comparisons/client-comparison/rust-module-schema.json
+
+# Temporary test files
+publish_test.sh
+run_*.sh
+dump_*.js
+test_*.js
+
+# IDE files
+.vscode/
+.idea/
+
+# CMake cache
+CMakeCache.txt
+CMakeFiles/
\ No newline at end of file
diff --git a/modules/sdk-test-cpp/CMakeLists.txt b/modules/sdk-test-cpp/CMakeLists.txt
new file mode 100644
index 00000000000..3cd171c6e52
--- /dev/null
+++ b/modules/sdk-test-cpp/CMakeLists.txt
@@ -0,0 +1,65 @@
+cmake_minimum_required(VERSION 3.16)
+project(sdk-test-cpp)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Module source file
+if(NOT DEFINED MODULE_SOURCE)
+    set(MODULE_SOURCE "src/lib.cpp")
+endif()
+
+# Output name
+if(NOT DEFINED OUTPUT_NAME)
+    set(OUTPUT_NAME "lib")
+endif()
+
+# Set the path to the SpacetimeDB C++ library
+set(SPACETIMEDB_CPP_LIBRARY_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../crates/bindings-cpp")
+
+# Create the module executable
+add_executable(${OUTPUT_NAME} ${MODULE_SOURCE})
+
+# Include directories
+target_include_directories(${OUTPUT_NAME} PRIVATE
+    ${SPACETIMEDB_CPP_LIBRARY_PATH}/include
+)
+
+# Compile options for WASM
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    target_compile_options(${OUTPUT_NAME} PRIVATE -fno-exceptions)
+endif()
+
+# Link the SpacetimeDB library
+add_subdirectory(${SPACETIMEDB_CPP_LIBRARY_PATH} ${CMAKE_CURRENT_BINARY_DIR}/spacetimedb_cpp_library)
+target_link_libraries(${OUTPUT_NAME} PRIVATE spacetimedb_cpp_library)
+
+# Emscripten specific settings
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  # Export list as a single variable (no extra quoting per-platform)
+  set(EXPORTED_FUNCS "['_malloc','_free','___describe_module__','___call_reducer__']")
+
+  # Produce a standalone .wasm (no JS harness) with no entry point
+  target_link_options(lib PRIVATE
+    "SHELL:-sSTANDALONE_WASM=1"
+    "SHELL:-sWASM=1"
+    "SHELL:--no-entry"
+    # Exports
+    "SHELL:-sEXPORTED_FUNCTIONS=${EXPORTED_FUNCS}"
+    # Keep this ON for correctness; you can flip to 0 temporarily to probe
+    "SHELL:-sERROR_ON_UNDEFINED_SYMBOLS=1"
+    # Trim runtime
+    "SHELL:-sFILESYSTEM=0"
+    "SHELL:-sDISABLE_EXCEPTION_CATCHING=1"
+    "SHELL:-sALLOW_MEMORY_GROWTH=0"
+    "SHELL:-sINITIAL_MEMORY=16MB"
+    "SHELL:-sSUPPORT_LONGJMP=0"
+    "SHELL:-sSUPPORT_ERRNO=0"
+    # C++20 and O2 at link step (Emscripten accepts them here too)
+    "SHELL:-std=c++20"
+    "SHELL:-O2"
+  )
+
+  # Name the output lib.wasm
+  set_target_properties(lib PROPERTIES OUTPUT_NAME "lib" SUFFIX ".wasm")
+endif()
\ No newline at end of file
diff --git a/modules/sdk-test-cpp/README.md b/modules/sdk-test-cpp/README.md
new file mode 100644
index 00000000000..e6960581354
--- /dev/null
+++ b/modules/sdk-test-cpp/README.md
@@ -0,0 +1,50 @@
+# `sdk-test-cpp` C++ test module
+
+Exercise the functionality of the SpacetimeDB C++ SDK API surface, modeling all combinations
+of types, with several examples of tables, indexes, and reducers.
+
+Used to validate C++ SDK functionality and ensure parity with Rust/C# implementations.
+
+> **Note:** Mirrors functionality from [`modules/sdk-test`](../sdk-test/) and [`modules/sdk-test-cs`](../sdk-test-cs/).
+
+## Building
+
+```bash
+cd modules/sdk-test-cpp
+emcmake cmake -B build .
+cmake --build build
+```
+
+The built WASM module will be at `build/lib.wasm`.
+
+## Testing
+
+```bash
+# Start SpacetimeDB
+spacetime start
+
+# Publish the module
+spacetime publish . test-db --delete-data
+
+# Verify module schema
+spacetime describe test-db
+
+# Call example reducer
+spacetime call test-db add_player '"Alice"'
+
+# View logs
+spacetime logs test-db -f
+```
+
+## Module Contents
+
+`lib.cpp` contains comprehensive testing of:
+- All primitive types (integers, floats, bool, string)
+- Special types (Identity, ConnectionId, Timestamp, TimeDuration)  
+- Collections (vectors, optionals)
+- Custom structs and enums
+- Table constraints (PrimaryKey, Unique, AutoInc, indexes)
+- Lifecycle reducers (init, connect, disconnect)
+- CRUD operations
+
+For C++ SDK usage documentation, see [`crates/bindings-cpp/`](../../crates/bindings-cpp/).
\ No newline at end of file
diff --git a/modules/sdk-test-cpp/src/lib.cpp b/modules/sdk-test-cpp/src/lib.cpp
new file mode 100644
index 00000000000..841e4b1846a
--- /dev/null
+++ b/modules/sdk-test-cpp/src/lib.cpp
@@ -0,0 +1,1727 @@
+#include <spacetimedb.h>
+#include <variant>
+#include <optional>
+
+using namespace SpacetimeDb;
+
+// Field accessors will be declared directly under each table
+
+
+// =============================================================================
+// C++ SDK Test Module - Full Equivalence with Rust and C# SDKs
+// =============================================================================
+//
+// This module provides complete equivalence with the Rust and C# SDK test modules:
+// - All primitive types, enums, structs, and vectors
+// - Table operations with constraint support
+// - Comprehensive reducer functionality matching other SDKs
+// - Full constraint and primary key support
+// - Optional types and complex nested structures
+// =============================================================================
+
+// =============================================================================
+// ENUMS - Full Equivalence with C# and Rust
+// =============================================================================
+
+// SimpleEnum - C++ SDK supports basic C++ enums with U8 value!
+// Using unified SPACETIMEDB_ENUM with simple syntax (auto-detects non-parenthesized arguments)
+SPACETIMEDB_ENUM(SimpleEnum, Zero, One, Two)
+
+// EnumWithPayload - Using unified SPACETIMEDB_ENUM with complex syntax!
+// Auto-detects parenthesized pairs for variant enums
+// Full 23 variants - now supported!
+SPACETIMEDB_ENUM(EnumWithPayload,
+    (U8, uint8_t),
+    (U16, uint16_t),
+    (U32, uint32_t),
+    (U64, uint64_t),
+    (U128, SpacetimeDb::u128),
+    (U256, SpacetimeDb::u256),
+    (I8, int8_t),
+    (I16, int16_t),
+    (I32, int32_t),
+    (I64, int64_t),
+    (I128, SpacetimeDb::i128),
+    (I256, SpacetimeDb::i256),
+    (Bool, bool),
+    (F32, float),
+    (F64, double),
+    (Str, std::string),
+    (Identity, SpacetimeDb::Identity),
+    (ConnectionId, SpacetimeDb::ConnectionId),
+    (Timestamp, SpacetimeDb::Timestamp),
+    (Bytes, std::vector<uint8_t>),
+    (Ints, std::vector<int32_t>),
+    (Strings, std::vector<std::string>),
+    (SimpleEnums, std::vector<SimpleEnum>)
+)
+
+// =============================================================================
+// STRUCTS - Full Equivalence with C# and Rust  
+// =============================================================================
+
+// True unit struct - 0 fields in schema
+SPACETIMEDB_UNIT_STRUCT(UnitStruct)
+
+
+struct ByteStruct {
+    uint8_t b;
+};
+SPACETIMEDB_STRUCT(ByteStruct, b)
+
+struct EveryPrimitiveStruct {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    Identity q;
+    ConnectionId r;
+    Timestamp s;
+    TimeDuration t;
+};
+SPACETIMEDB_STRUCT(EveryPrimitiveStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+struct EveryVecStruct {
+    std::vector<uint8_t> a;
+    std::vector<uint16_t> b;
+    std::vector<uint32_t> c;
+    std::vector<uint64_t> d;
+    std::vector<u128> e;
+    std::vector<u256> f;
+    std::vector<int8_t> g;
+    std::vector<int16_t> h;
+    std::vector<int32_t> i;
+    std::vector<int64_t> j;
+    std::vector<i128> k;
+    std::vector<i256> l;
+    std::vector<bool> m;
+    std::vector<float> n;
+    std::vector<double> o;
+    std::vector<std::string> p;
+    std::vector<Identity> q;
+    std::vector<ConnectionId> r;
+    std::vector<Timestamp> s;
+    std::vector<TimeDuration> t;
+};
+SPACETIMEDB_STRUCT(EveryVecStruct, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+
+// =============================================================================
+// SINGLE VALUE TABLES - Matching Rust's OneXXX pattern
+// =============================================================================
+
+// Unsigned integer tables
+struct OneU8 { uint8_t n; };
+SPACETIMEDB_STRUCT(OneU8, n)
+SPACETIMEDB_TABLE(OneU8, one_u8, Public)
+
+struct OneU16 { uint16_t n; };
+SPACETIMEDB_STRUCT(OneU16, n)
+SPACETIMEDB_TABLE(OneU16, one_u16, Public)
+
+struct OneU32 { uint32_t n; };
+SPACETIMEDB_STRUCT(OneU32, n)
+SPACETIMEDB_TABLE(OneU32, one_u32, Public)
+
+struct OneU64 { uint64_t n; };
+SPACETIMEDB_STRUCT(OneU64, n)
+SPACETIMEDB_TABLE(OneU64, one_u64, Public)
+
+struct OneU128 { u128 n; };
+SPACETIMEDB_STRUCT(OneU128, n)
+SPACETIMEDB_TABLE(OneU128, one_u128, Public)
+
+struct OneU256 { u256 n; };
+SPACETIMEDB_STRUCT(OneU256, n)
+SPACETIMEDB_TABLE(OneU256, one_u256, Public)
+
+// Signed integer tables
+struct OneI8 { int8_t n; };
+SPACETIMEDB_STRUCT(OneI8, n)
+SPACETIMEDB_TABLE(OneI8, one_i8, Public)
+
+struct OneI16 { int16_t n; };
+SPACETIMEDB_STRUCT(OneI16, n)
+SPACETIMEDB_TABLE(OneI16, one_i16, Public)
+
+struct OneI32 { int32_t n; };
+SPACETIMEDB_STRUCT(OneI32, n)
+SPACETIMEDB_TABLE(OneI32, one_i32, Public)
+
+struct OneI64 { int64_t n; };
+SPACETIMEDB_STRUCT(OneI64, n)
+SPACETIMEDB_TABLE(OneI64, one_i64, Public)
+
+struct OneI128 { i128 n; };
+SPACETIMEDB_STRUCT(OneI128, n)
+SPACETIMEDB_TABLE(OneI128, one_i128, Public)
+
+struct OneI256 { i256 n; };
+SPACETIMEDB_STRUCT(OneI256, n)
+SPACETIMEDB_TABLE(OneI256, one_i256, Public)
+
+// Boolean and float tables
+struct OneBool { bool b; };
+SPACETIMEDB_STRUCT(OneBool, b)
+SPACETIMEDB_TABLE(OneBool, one_bool, Public)
+
+struct OneF32 { float f; };
+SPACETIMEDB_STRUCT(OneF32, f)
+SPACETIMEDB_TABLE(OneF32, one_f32, Public)
+
+struct OneF64 { double f; };
+SPACETIMEDB_STRUCT(OneF64, f)
+SPACETIMEDB_TABLE(OneF64, one_f64, Public)
+
+// String and special type tables
+struct OneString { std::string s; };
+SPACETIMEDB_STRUCT(OneString, s)
+SPACETIMEDB_TABLE(OneString, one_string, Public)
+
+struct OneIdentity { Identity i; };
+SPACETIMEDB_STRUCT(OneIdentity, i)
+SPACETIMEDB_TABLE(OneIdentity, one_identity, Public)
+
+struct OneConnectionId { ConnectionId a; };
+SPACETIMEDB_STRUCT(OneConnectionId, a)
+SPACETIMEDB_TABLE(OneConnectionId, one_connection_id, Public)
+
+struct OneTimestamp { Timestamp t; };
+SPACETIMEDB_STRUCT(OneTimestamp, t)
+SPACETIMEDB_TABLE(OneTimestamp, one_timestamp, Public)
+
+// Enum and struct tables
+struct OneSimpleEnum { SimpleEnum e; };
+SPACETIMEDB_STRUCT(OneSimpleEnum, e)
+SPACETIMEDB_TABLE(OneSimpleEnum, one_simple_enum, Public)
+
+struct OneEnumWithPayload { EnumWithPayload e; };
+SPACETIMEDB_STRUCT(OneEnumWithPayload, e)
+SPACETIMEDB_TABLE(OneEnumWithPayload, one_enum_with_payload, Public)
+
+struct OneUnitStruct { UnitStruct s; };
+SPACETIMEDB_STRUCT(OneUnitStruct, s)
+SPACETIMEDB_TABLE(OneUnitStruct, one_unit_struct, Public)
+
+struct OneByteStruct { ByteStruct s; };
+SPACETIMEDB_STRUCT(OneByteStruct, s)
+SPACETIMEDB_TABLE(OneByteStruct, one_byte_struct, Public)
+
+struct OneEveryPrimitiveStruct { EveryPrimitiveStruct s; };
+SPACETIMEDB_STRUCT(OneEveryPrimitiveStruct, s)
+SPACETIMEDB_TABLE(OneEveryPrimitiveStruct, one_every_primitive_struct, Public)
+
+struct OneEveryVecStruct { EveryVecStruct s; };
+SPACETIMEDB_STRUCT(OneEveryVecStruct, s)
+SPACETIMEDB_TABLE(OneEveryVecStruct, one_every_vec_struct, Public)
+
+// =============================================================================
+// VECTOR TABLES - Matching Rust's VecXXX pattern
+// =============================================================================
+
+struct VecU8 { std::vector<uint8_t> n; };
+SPACETIMEDB_STRUCT(VecU8, n)
+SPACETIMEDB_TABLE(VecU8, vec_u8, Public)
+
+struct VecU16 { std::vector<uint16_t> n; };
+SPACETIMEDB_STRUCT(VecU16, n)
+SPACETIMEDB_TABLE(VecU16, vec_u16, Public)
+
+struct VecU32 { std::vector<uint32_t> n; };
+SPACETIMEDB_STRUCT(VecU32, n)
+SPACETIMEDB_TABLE(VecU32, vec_u32, Public)
+
+struct VecU64 { std::vector<uint64_t> n; };
+SPACETIMEDB_STRUCT(VecU64, n)
+SPACETIMEDB_TABLE(VecU64, vec_u64, Public)
+
+struct VecU128 { std::vector<u128> n; };
+SPACETIMEDB_STRUCT(VecU128, n)
+SPACETIMEDB_TABLE(VecU128, vec_u128, Public)
+
+struct VecU256 { std::vector<u256> n; };
+SPACETIMEDB_STRUCT(VecU256, n)
+SPACETIMEDB_TABLE(VecU256, vec_u256, Public)
+
+struct VecI8 { std::vector<int8_t> n; };
+SPACETIMEDB_STRUCT(VecI8, n)
+SPACETIMEDB_TABLE(VecI8, vec_i8, Public)
+
+struct VecI16 { std::vector<int16_t> n; };
+SPACETIMEDB_STRUCT(VecI16, n)
+SPACETIMEDB_TABLE(VecI16, vec_i16, Public)
+
+struct VecI32 { std::vector<int32_t> n; };
+SPACETIMEDB_STRUCT(VecI32, n)
+SPACETIMEDB_TABLE(VecI32, vec_i32, Public)
+
+struct VecI64 { std::vector<int64_t> n; };
+SPACETIMEDB_STRUCT(VecI64, n)
+SPACETIMEDB_TABLE(VecI64, vec_i64, Public)
+
+struct VecI128 { std::vector<i128> n; };
+SPACETIMEDB_STRUCT(VecI128, n)
+SPACETIMEDB_TABLE(VecI128, vec_i128, Public)
+
+struct VecI256 { std::vector<i256> n; };
+SPACETIMEDB_STRUCT(VecI256, n)
+SPACETIMEDB_TABLE(VecI256, vec_i256, Public)
+
+struct VecBool { std::vector<bool> b; };
+SPACETIMEDB_STRUCT(VecBool, b)
+SPACETIMEDB_TABLE(VecBool, vec_bool, Public)
+
+struct VecF32 { std::vector<float> f; };
+SPACETIMEDB_STRUCT(VecF32, f)
+SPACETIMEDB_TABLE(VecF32, vec_f32, Public)
+
+struct VecF64 { std::vector<double> f; };
+SPACETIMEDB_STRUCT(VecF64, f)
+SPACETIMEDB_TABLE(VecF64, vec_f64, Public)
+
+struct VecString { std::vector<std::string> s; };
+SPACETIMEDB_STRUCT(VecString, s)
+SPACETIMEDB_TABLE(VecString, vec_string, Public)
+
+struct VecIdentity { std::vector<Identity> i; };
+SPACETIMEDB_STRUCT(VecIdentity, i)
+SPACETIMEDB_TABLE(VecIdentity, vec_identity, Public)
+
+struct VecConnectionId { std::vector<ConnectionId> a; };
+SPACETIMEDB_STRUCT(VecConnectionId, a)
+SPACETIMEDB_TABLE(VecConnectionId, vec_connection_id, Public)
+
+struct VecTimestamp { std::vector<Timestamp> t; };
+SPACETIMEDB_STRUCT(VecTimestamp, t)
+SPACETIMEDB_TABLE(VecTimestamp, vec_timestamp, Public)
+
+struct VecSimpleEnum { std::vector<SimpleEnum> e; };
+SPACETIMEDB_STRUCT(VecSimpleEnum, e)
+SPACETIMEDB_TABLE(VecSimpleEnum, vec_simple_enum, Public)
+
+struct VecEnumWithPayload { std::vector<EnumWithPayload> e; };
+SPACETIMEDB_STRUCT(VecEnumWithPayload, e)
+SPACETIMEDB_TABLE(VecEnumWithPayload, vec_enum_with_payload, Public)
+
+struct VecUnitStruct { std::vector<UnitStruct> s; };
+SPACETIMEDB_STRUCT(VecUnitStruct, s)
+SPACETIMEDB_TABLE(VecUnitStruct, vec_unit_struct, Public)
+
+struct VecByteStruct { std::vector<ByteStruct> s; };
+SPACETIMEDB_STRUCT(VecByteStruct, s)
+SPACETIMEDB_TABLE(VecByteStruct, vec_byte_struct, Public)
+
+struct VecEveryPrimitiveStruct { std::vector<EveryPrimitiveStruct> s; };
+SPACETIMEDB_STRUCT(VecEveryPrimitiveStruct, s)
+SPACETIMEDB_TABLE(VecEveryPrimitiveStruct, vec_every_primitive_struct, Public)
+
+struct VecEveryVecStruct { std::vector<EveryVecStruct> s; };
+SPACETIMEDB_STRUCT(VecEveryVecStruct, s)
+SPACETIMEDB_TABLE(VecEveryVecStruct, vec_every_vec_struct, Public)
+
+// =============================================================================
+// OPTIONAL TABLES - Using inlined std::optional instead of wrapper structs
+// =============================================================================
+
+struct OptionI32 { std::optional<int32_t> n; };
+SPACETIMEDB_STRUCT(OptionI32, n)
+SPACETIMEDB_TABLE(OptionI32, option_i32, Public)
+
+struct OptionString { std::optional<std::string> s; };
+SPACETIMEDB_STRUCT(OptionString, s)
+SPACETIMEDB_TABLE(OptionString, option_string, Public)
+
+struct OptionIdentity { std::optional<Identity> i; };
+SPACETIMEDB_STRUCT(OptionIdentity, i)
+SPACETIMEDB_TABLE(OptionIdentity, option_identity, Public)
+
+struct OptionSimpleEnum { std::optional<SimpleEnum> e; };
+SPACETIMEDB_STRUCT(OptionSimpleEnum, e)
+SPACETIMEDB_TABLE(OptionSimpleEnum, option_simple_enum, Public)
+
+struct OptionEveryPrimitiveStruct { std::optional<EveryPrimitiveStruct> s; };
+SPACETIMEDB_STRUCT(OptionEveryPrimitiveStruct, s)
+SPACETIMEDB_TABLE(OptionEveryPrimitiveStruct, option_every_primitive_struct, Public)
+
+// Complex nested optional type - NOW FIXED WITH TYPE REGISTRY!
+struct OptionVecOptionI32 { std::optional<std::vector<std::optional<int32_t>>> v; };
+SPACETIMEDB_STRUCT(OptionVecOptionI32, v)
+SPACETIMEDB_TABLE(OptionVecOptionI32, option_vec_option_i32, Public)
+
+// =============================================================================
+// UNIQUE CONSTRAINT TABLES - Matching Rust's UniqueXXX pattern
+// =============================================================================
+
+struct UniqueU8 { uint8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU8, n, data)
+SPACETIMEDB_TABLE(UniqueU8, unique_u8, Public)
+FIELD_Unique(unique_u8, n);
+
+struct UniqueU16 { uint16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU16, n, data)
+SPACETIMEDB_TABLE(UniqueU16, unique_u16, Public)
+FIELD_Unique(unique_u16, n);
+
+struct UniqueU32 { uint32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU32, n, data)
+SPACETIMEDB_TABLE(UniqueU32, unique_u32, Public)
+FIELD_Unique(unique_u32, n);
+
+struct UniqueU64 { uint64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU64, n, data)
+SPACETIMEDB_TABLE(UniqueU64, unique_u64, Public)
+FIELD_Unique(unique_u64, n);
+
+struct UniqueU128 { u128 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU128, n, data)
+SPACETIMEDB_TABLE(UniqueU128, unique_u128, Public)
+FIELD_Unique(unique_u128, n);
+
+struct UniqueU256 { u256 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueU256, n, data)
+SPACETIMEDB_TABLE(UniqueU256, unique_u256, Public)
+FIELD_Unique(unique_u256, n);
+
+struct UniqueI8 { int8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI8, n, data)
+SPACETIMEDB_TABLE(UniqueI8, unique_i8, Public)
+FIELD_Unique(unique_i8, n);
+
+struct UniqueI16 { int16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI16, n, data)
+SPACETIMEDB_TABLE(UniqueI16, unique_i16, Public)
+FIELD_Unique(unique_i16, n);
+
+struct UniqueI32 { int32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI32, n, data)
+SPACETIMEDB_TABLE(UniqueI32, unique_i32, Public)
+FIELD_Unique(unique_i32, n);
+
+struct UniqueI64 { int64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI64, n, data)
+SPACETIMEDB_TABLE(UniqueI64, unique_i64, Public)
+FIELD_Unique(unique_i64, n);
+
+struct UniqueI128 { i128 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI128, n, data)
+SPACETIMEDB_TABLE(UniqueI128, unique_i128, Public)
+FIELD_Unique(unique_i128, n);
+
+struct UniqueI256 { i256 n; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueI256, n, data)
+SPACETIMEDB_TABLE(UniqueI256, unique_i256, Public)
+FIELD_Unique(unique_i256, n);
+
+struct UniqueBool { bool b; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueBool, b, data)
+SPACETIMEDB_TABLE(UniqueBool, unique_bool, Public)
+FIELD_Unique(unique_bool, b);
+
+struct UniqueString { std::string s; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueString, s, data)
+SPACETIMEDB_TABLE(UniqueString, unique_string, Public)
+FIELD_Unique(unique_string, s);
+
+struct UniqueIdentity { Identity i; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueIdentity, i, data)
+SPACETIMEDB_TABLE(UniqueIdentity, unique_identity, Public)
+FIELD_Unique(unique_identity, i);
+
+struct UniqueConnectionId { ConnectionId a; int32_t data; };
+SPACETIMEDB_STRUCT(UniqueConnectionId, a, data)
+SPACETIMEDB_TABLE(UniqueConnectionId, unique_connection_id, Public)
+FIELD_Unique(unique_connection_id, a);
+
+// =============================================================================
+// PRIMARY KEY TABLES - Matching Rust's PkXXX pattern
+// =============================================================================
+
+struct PkU8 { uint8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU8, n, data)
+SPACETIMEDB_TABLE(PkU8, pk_u8, Public)
+FIELD_PrimaryKey(pk_u8, n);
+
+struct PkU16 { uint16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU16, n, data)
+SPACETIMEDB_TABLE(PkU16, pk_u16, Public)
+FIELD_PrimaryKey(pk_u16, n);
+
+struct PkU32 { uint32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU32, n, data)
+SPACETIMEDB_TABLE(PkU32, pk_u32, Public)
+FIELD_PrimaryKey(pk_u32, n);
+
+struct PkU32Two { uint32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU32Two, n, data)
+SPACETIMEDB_TABLE(PkU32Two, pk_u32_two, Public)
+FIELD_PrimaryKey(pk_u32_two, n);
+
+struct PkU64 { uint64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU64, n, data)
+SPACETIMEDB_TABLE(PkU64, pk_u64, Public)
+FIELD_PrimaryKey(pk_u64, n);
+
+struct PkU128 { u128 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU128, n, data)
+SPACETIMEDB_TABLE(PkU128, pk_u128, Public)
+FIELD_PrimaryKey(pk_u128, n);
+
+struct PkU256 { u256 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkU256, n, data)
+SPACETIMEDB_TABLE(PkU256, pk_u256, Public)
+FIELD_PrimaryKey(pk_u256, n);
+
+struct PkI8 { int8_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI8, n, data)
+SPACETIMEDB_TABLE(PkI8, pk_i8, Public)
+FIELD_PrimaryKey(pk_i8, n);
+
+struct PkI16 { int16_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI16, n, data)
+SPACETIMEDB_TABLE(PkI16, pk_i16, Public)
+FIELD_PrimaryKey(pk_i16, n);
+
+struct PkI32 { int32_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI32, n, data)
+SPACETIMEDB_TABLE(PkI32, pk_i32, Public)
+FIELD_PrimaryKey(pk_i32, n);
+
+struct PkI64 { int64_t n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI64, n, data)
+SPACETIMEDB_TABLE(PkI64, pk_i64, Public)
+FIELD_PrimaryKey(pk_i64, n);
+
+struct PkI128 { i128 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI128, n, data)
+SPACETIMEDB_TABLE(PkI128, pk_i128, Public)
+FIELD_PrimaryKey(pk_i128, n);
+
+struct PkI256 { i256 n; int32_t data; };
+SPACETIMEDB_STRUCT(PkI256, n, data)
+SPACETIMEDB_TABLE(PkI256, pk_i256, Public)
+FIELD_PrimaryKey(pk_i256, n);
+
+struct PkBool { bool b; int32_t data; };
+SPACETIMEDB_STRUCT(PkBool, b, data)
+SPACETIMEDB_TABLE(PkBool, pk_bool, Public)
+FIELD_PrimaryKey(pk_bool, b);
+
+struct PkString { std::string s; int32_t data; };
+SPACETIMEDB_STRUCT(PkString, s, data)
+SPACETIMEDB_TABLE(PkString, pk_string, Public)
+FIELD_PrimaryKey(pk_string, s);
+
+struct PkIdentity { Identity i; int32_t data; };
+SPACETIMEDB_STRUCT(PkIdentity, i, data)
+SPACETIMEDB_TABLE(PkIdentity, pk_identity, Public)
+FIELD_PrimaryKey(pk_identity, i);
+
+struct PkConnectionId { ConnectionId a; int32_t data; };
+SPACETIMEDB_STRUCT(PkConnectionId, a, data)
+SPACETIMEDB_TABLE(PkConnectionId, pk_connection_id, Public)
+FIELD_PrimaryKey(pk_connection_id, a);
+
+struct PkSimpleEnum { SimpleEnum a; int32_t data; };
+SPACETIMEDB_STRUCT(PkSimpleEnum, a, data)
+SPACETIMEDB_TABLE(PkSimpleEnum, pk_simple_enum, Public)
+FIELD_PrimaryKey(pk_simple_enum, a);
+
+// =============================================================================
+// ADDITIONAL SPECIALIZED TABLES
+// =============================================================================
+
+// Large comprehensive table
+struct LargeTable {
+    uint8_t a;
+    uint16_t b;
+    uint32_t c;
+    uint64_t d;
+    u128 e;
+    u256 f;
+    int8_t g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    i128 k;
+    i256 l;
+    bool m;
+    float n;
+    double o;
+    std::string p;
+    SimpleEnum q;
+    EnumWithPayload r;
+    UnitStruct s;
+    ByteStruct t;
+    EveryPrimitiveStruct u;
+    EveryVecStruct v;
+};
+SPACETIMEDB_STRUCT(LargeTable, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)
+SPACETIMEDB_TABLE(LargeTable, large_table, Public)
+
+// Table that holds other table structs
+struct TableHoldsTable {
+    OneU8 a;
+    VecU8 b;
+};
+SPACETIMEDB_STRUCT(TableHoldsTable, a, b)
+SPACETIMEDB_TABLE(TableHoldsTable, table_holds_table, Public)
+
+// Scheduled table
+struct ScheduledTable {
+    uint64_t scheduled_id;
+    ScheduleAt scheduled_at;
+    std::string text;
+};
+SPACETIMEDB_STRUCT(ScheduledTable, scheduled_id, scheduled_at, text)
+SPACETIMEDB_TABLE(ScheduledTable, scheduled_table, Public)
+FIELD_PrimaryKeyAutoInc(scheduled_table, scheduled_id);
+SPACETIMEDB_SCHEDULE(scheduled_table, 1, send_scheduled_message)  // Column 1 is scheduled_at
+
+// Indexed tables
+struct IndexedTable {
+    uint32_t player_id;
+};
+SPACETIMEDB_STRUCT(IndexedTable, player_id)
+SPACETIMEDB_TABLE(IndexedTable, indexed_table, Private)
+FIELD_Index(indexed_table, player_id);
+
+struct IndexedTable2 {
+    uint32_t player_id;
+    float player_snazz;
+};
+SPACETIMEDB_STRUCT(IndexedTable2, player_id, player_snazz)
+SPACETIMEDB_TABLE(IndexedTable2, indexed_table_2, Private)  // Remove constraint from table macro
+FIELD_NamedMultiColumnIndex(indexed_table_2, player_id_snazz_index, player_id, player_snazz);
+
+struct BTreeU32 {
+    uint32_t n;
+    int32_t data;
+};
+SPACETIMEDB_STRUCT(BTreeU32, n, data)
+SPACETIMEDB_TABLE(BTreeU32, btree_u32, Public)
+FIELD_Index(btree_u32, n);
+
+struct Users {
+    Identity identity;
+    std::string name;
+};
+SPACETIMEDB_STRUCT(Users, identity, name)
+SPACETIMEDB_TABLE(Users, users, Public)
+FIELD_PrimaryKey(users, identity);
+
+struct IndexedSimpleEnum {
+    SimpleEnum n;
+};
+SPACETIMEDB_STRUCT(IndexedSimpleEnum, n)
+SPACETIMEDB_TABLE(IndexedSimpleEnum, indexed_simple_enum, Public)
+FIELD_Index(indexed_simple_enum, n);
+
+
+
+// =============================================================================
+// SINGLE VALUE TABLE REDUCERS - INSERT OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_one_u8, ReducerContext ctx, uint8_t n)
+{
+    LOG_INFO("insert_one_u8 called with value: " + std::to_string(n));
+    ctx.db[one_u8].insert(OneU8{.n = n});
+    LOG_INFO("insert_one_u8 completed");
+}
+
+SPACETIMEDB_REDUCER(insert_one_u16, ReducerContext ctx, uint16_t n)
+{
+    ctx.db[one_u16].insert(OneU16{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u32, ReducerContext ctx, uint32_t n)
+{
+    ctx.db[one_u32].insert(OneU32{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u64, ReducerContext ctx, uint64_t n)
+{
+    ctx.db[one_u64].insert(OneU64{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u128, ReducerContext ctx, u128 n)
+{
+    ctx.db[one_u128].insert(OneU128{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_u256, ReducerContext ctx, u256 n)
+{
+    ctx.db[one_u256].insert(OneU256{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i8, ReducerContext ctx, int8_t n)
+{
+    ctx.db[one_i8].insert(OneI8{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i16, ReducerContext ctx, int16_t n)
+{
+    ctx.db[one_i16].insert(OneI16{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i32, ReducerContext ctx, int32_t n)
+{
+    ctx.db[one_i32].insert(OneI32{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i64, ReducerContext ctx, int64_t n)
+{
+    ctx.db[one_i64].insert(OneI64{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i128, ReducerContext ctx, i128 n)
+{
+    ctx.db[one_i128].insert(OneI128{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_i256, ReducerContext ctx, i256 n)
+{
+    ctx.db[one_i256].insert(OneI256{.n = n});
+}
+
+SPACETIMEDB_REDUCER(insert_one_bool, ReducerContext ctx, bool b)
+{
+    ctx.db[one_bool].insert(OneBool{.b = b});
+}
+
+SPACETIMEDB_REDUCER(insert_one_f32, ReducerContext ctx, float f)
+{
+    ctx.db[one_f32].insert(OneF32{.f = f});
+}
+
+SPACETIMEDB_REDUCER(insert_one_f64, ReducerContext ctx, double f)
+{
+    ctx.db[one_f64].insert(OneF64{.f = f});
+}
+
+SPACETIMEDB_REDUCER(insert_one_string, ReducerContext ctx, std::string s)
+{
+    ctx.db[one_string].insert(OneString{.s = s});
+}
+
+ SPACETIMEDB_REDUCER(insert_one_identity, ReducerContext ctx, Identity i)
+{
+    ctx.db[one_identity].insert(OneIdentity{.i = i});
+} 
+
+ SPACETIMEDB_REDUCER(insert_one_connection_id, ReducerContext ctx, ConnectionId a)
+{
+    ctx.db[one_connection_id].insert(OneConnectionId{.a = a});
+} 
+
+ SPACETIMEDB_REDUCER(insert_one_timestamp, ReducerContext ctx, Timestamp t)
+{
+    ctx.db[one_timestamp].insert(OneTimestamp{.t = t});
+} 
+
+SPACETIMEDB_REDUCER(insert_one_simple_enum, ReducerContext ctx, SimpleEnum e)
+{
+    ctx.db[one_simple_enum].insert(OneSimpleEnum{.e = e});
+}
+
+SPACETIMEDB_REDUCER(insert_one_enum_with_payload, ReducerContext ctx, EnumWithPayload e)
+{
+    ctx.db[one_enum_with_payload].insert(OneEnumWithPayload{e});
+}
+
+SPACETIMEDB_REDUCER(insert_one_unit_struct, ReducerContext ctx, UnitStruct s)
+{
+    fprintf(stdout, "SUCCESS: insert_one_unit_struct reducer called with UnitStruct\n");
+    ctx.db[one_unit_struct].insert(OneUnitStruct{s});
+}
+
+SPACETIMEDB_REDUCER(insert_one_byte_struct, ReducerContext ctx, ByteStruct s)
+{
+    ctx.db[one_byte_struct].insert(OneByteStruct{s});
+}
+
+SPACETIMEDB_REDUCER(insert_one_every_primitive_struct, ReducerContext ctx, EveryPrimitiveStruct s)
+{
+    ctx.db[one_every_primitive_struct].insert(OneEveryPrimitiveStruct{s});
+}
+
+ SPACETIMEDB_REDUCER(insert_one_every_vec_struct, ReducerContext ctx, EveryVecStruct s)
+{
+    ctx.db[one_every_vec_struct].insert(OneEveryVecStruct{s});
+} 
+
+// =============================================================================
+// VECTOR TABLE REDUCERS - INSERT OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_vec_u8, ReducerContext ctx, std::vector<uint8_t> n)
+{
+    ctx.db[vec_u8].insert(VecU8{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_u16, ReducerContext ctx, std::vector<uint16_t> n)
+{
+    ctx.db[vec_u16].insert(VecU16{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_u32, ReducerContext ctx, std::vector<uint32_t> n)
+{
+    ctx.db[vec_u32].insert(VecU32{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_u64, ReducerContext ctx, std::vector<uint64_t> n)
+{
+    ctx.db[vec_u64].insert(VecU64{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_u128, ReducerContext ctx, std::vector<u128> n)
+{
+    ctx.db[vec_u128].insert(VecU128{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_u256, ReducerContext ctx, std::vector<u256> n)
+{
+    ctx.db[vec_u256].insert(VecU256{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_i8, ReducerContext ctx, std::vector<int8_t> n)
+{
+    ctx.db[vec_i8].insert(VecI8{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_i16, ReducerContext ctx, std::vector<int16_t> n)
+{
+    ctx.db[vec_i16].insert(VecI16{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_i32, ReducerContext ctx, std::vector<int32_t> n)
+{
+    ctx.db[vec_i32].insert(VecI32{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_i64, ReducerContext ctx, std::vector<int64_t> n)
+{
+    ctx.db[vec_i64].insert(VecI64{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_i128, ReducerContext ctx, std::vector<i128> n)
+{
+    ctx.db[vec_i128].insert(VecI128{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_i256, ReducerContext ctx, std::vector<i256> n)
+{
+    ctx.db[vec_i256].insert(VecI256{n});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_bool, ReducerContext ctx, std::vector<bool> b)
+{
+    ctx.db[vec_bool].insert(VecBool{b});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_f32, ReducerContext ctx, std::vector<float> f)
+{
+    ctx.db[vec_f32].insert(VecF32{f});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_f64, ReducerContext ctx, std::vector<double> f)
+{
+    ctx.db[vec_f64].insert(VecF64{f});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_string, ReducerContext ctx, std::vector<std::string> s)
+{
+    ctx.db[vec_string].insert(VecString{s});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_identity, ReducerContext ctx, std::vector<Identity> i)
+{
+    ctx.db[vec_identity].insert(VecIdentity{i});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_connection_id, ReducerContext ctx, std::vector<ConnectionId> a)
+{
+    ctx.db[vec_connection_id].insert(VecConnectionId{a});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_timestamp, ReducerContext ctx, std::vector<Timestamp> t)
+{
+    ctx.db[vec_timestamp].insert(VecTimestamp{t});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_simple_enum, ReducerContext ctx, std::vector<SimpleEnum> e)
+{
+    ctx.db[vec_simple_enum].insert(VecSimpleEnum{e});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_enum_with_payload, ReducerContext ctx, std::vector<EnumWithPayload> e)
+{
+    ctx.db[vec_enum_with_payload].insert(VecEnumWithPayload{e});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_unit_struct, ReducerContext ctx, std::vector<UnitStruct> s)
+{
+    ctx.db[vec_unit_struct].insert(VecUnitStruct{s});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_byte_struct, ReducerContext ctx, std::vector<ByteStruct> s)
+{
+    ctx.db[vec_byte_struct].insert(VecByteStruct{s});
+}
+
+SPACETIMEDB_REDUCER(insert_vec_every_primitive_struct, ReducerContext ctx, std::vector<EveryPrimitiveStruct> s)
+{
+    ctx.db[vec_every_primitive_struct].insert(VecEveryPrimitiveStruct{s});
+}
+
+ SPACETIMEDB_REDUCER(insert_vec_every_vec_struct, ReducerContext ctx, std::vector<EveryVecStruct> s)
+{
+    ctx.db[vec_every_vec_struct].insert(VecEveryVecStruct{s});
+} 
+
+// =============================================================================
+// OPTIONAL TABLE REDUCERS - INSERT OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_option_i32, ReducerContext ctx, std::optional<int32_t> n)
+{
+    ctx.db[option_i32].insert(OptionI32{n});
+}
+
+SPACETIMEDB_REDUCER(insert_option_string, ReducerContext ctx, std::optional<std::string> s)
+{
+    ctx.db[option_string].insert(OptionString{s});
+}
+
+SPACETIMEDB_REDUCER(insert_option_identity, ReducerContext ctx, std::optional<Identity> i)
+{
+    ctx.db[option_identity].insert(OptionIdentity{i});
+}
+
+SPACETIMEDB_REDUCER(insert_option_simple_enum, ReducerContext ctx, std::optional<SimpleEnum> e)
+{
+    ctx.db[option_simple_enum].insert(OptionSimpleEnum{e});
+}
+
+SPACETIMEDB_REDUCER(insert_option_every_primitive_struct, ReducerContext ctx, std::optional<EveryPrimitiveStruct> s)
+{
+    ctx.db[option_every_primitive_struct].insert(OptionEveryPrimitiveStruct{s});
+}
+
+// Complex nested optional type - NOW FIXED!
+ SPACETIMEDB_REDUCER(insert_option_vec_option_i32, ReducerContext ctx, std::optional<std::vector<std::optional<int32_t>>> v)
+{
+    ctx.db[option_vec_option_i32].insert(OptionVecOptionI32{v});
+}
+
+// =============================================================================
+// UNIQUE CONSTRAINT TABLE REDUCERS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_unique_u8, ReducerContext ctx, uint8_t n, int32_t data)
+{
+    ctx.db[unique_u8].insert(UniqueU8{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_u16, ReducerContext ctx, uint16_t n, int32_t data)
+{
+    ctx.db[unique_u16].insert(UniqueU16{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_u32, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    ctx.db[unique_u32].insert(UniqueU32{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_u64, ReducerContext ctx, uint64_t n, int32_t data)
+{
+    ctx.db[unique_u64].insert(UniqueU64{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_u128, ReducerContext ctx, u128 n, int32_t data)
+{
+    ctx.db[unique_u128].insert(UniqueU128{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_u256, ReducerContext ctx, u256 n, int32_t data)
+{
+    ctx.db[unique_u256].insert(UniqueU256{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_i8, ReducerContext ctx, int8_t n, int32_t data)
+{
+    ctx.db[unique_i8].insert(UniqueI8{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_i16, ReducerContext ctx, int16_t n, int32_t data)
+{
+    ctx.db[unique_i16].insert(UniqueI16{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_i32, ReducerContext ctx, int32_t n, int32_t data)
+{
+    ctx.db[unique_i32].insert(UniqueI32{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_i64, ReducerContext ctx, int64_t n, int32_t data)
+{
+    ctx.db[unique_i64].insert(UniqueI64{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_i128, ReducerContext ctx, i128 n, int32_t data)
+{
+    ctx.db[unique_i128].insert(UniqueI128{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_i256, ReducerContext ctx, i256 n, int32_t data)
+{
+    ctx.db[unique_i256].insert(UniqueI256{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_bool, ReducerContext ctx, bool b, int32_t data)
+{
+    ctx.db[unique_bool].insert(UniqueBool{b, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_string, ReducerContext ctx, std::string s, int32_t data)
+{
+    ctx.db[unique_string].insert(UniqueString{s, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_identity, ReducerContext ctx, Identity i, int32_t data)
+{
+    ctx.db[unique_identity].insert(UniqueIdentity{i, data});
+}
+
+SPACETIMEDB_REDUCER(insert_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data)
+{
+    ctx.db[unique_connection_id].insert(UniqueConnectionId{a, data});
+}
+
+// =============================================================================
+// PRIMARY KEY TABLE REDUCERS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_pk_u8, ReducerContext ctx, uint8_t n, int32_t data)
+{
+    ctx.db[pk_u8].insert(PkU8{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_u16, ReducerContext ctx, uint16_t n, int32_t data)
+{
+    ctx.db[pk_u16].insert(PkU16{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_u32, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    ctx.db[pk_u32].insert(PkU32{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_u32_two, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    ctx.db[pk_u32_two].insert(PkU32Two{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_u64, ReducerContext ctx, uint64_t n, int32_t data)
+{
+    ctx.db[pk_u64].insert(PkU64{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_u128, ReducerContext ctx, u128 n, int32_t data)
+{
+    ctx.db[pk_u128].insert(PkU128{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_u256, ReducerContext ctx, u256 n, int32_t data)
+{
+    ctx.db[pk_u256].insert(PkU256{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_i8, ReducerContext ctx, int8_t n, int32_t data)
+{
+    ctx.db[pk_i8].insert(PkI8{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_i16, ReducerContext ctx, int16_t n, int32_t data)
+{
+    ctx.db[pk_i16].insert(PkI16{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_i32, ReducerContext ctx, int32_t n, int32_t data)
+{
+    ctx.db[pk_i32].insert(PkI32{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_i64, ReducerContext ctx, int64_t n, int32_t data)
+{
+    ctx.db[pk_i64].insert(PkI64{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_i128, ReducerContext ctx, i128 n, int32_t data)
+{
+    ctx.db[pk_i128].insert(PkI128{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_i256, ReducerContext ctx, i256 n, int32_t data)
+{
+    ctx.db[pk_i256].insert(PkI256{n, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_bool, ReducerContext ctx, bool b, int32_t data)
+{
+    ctx.db[pk_bool].insert(PkBool{b, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_string, ReducerContext ctx, std::string s, int32_t data)
+{
+    ctx.db[pk_string].insert(PkString{s, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_identity, ReducerContext ctx, Identity i, int32_t data)
+{
+    ctx.db[pk_identity].insert(PkIdentity{i, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_connection_id, ReducerContext ctx, ConnectionId a, int32_t data)
+{
+    ctx.db[pk_connection_id].insert(PkConnectionId{a, data});
+}
+
+SPACETIMEDB_REDUCER(insert_pk_simple_enum, ReducerContext ctx, SimpleEnum a, int32_t data)
+{
+    ctx.db[pk_simple_enum].insert(PkSimpleEnum{a, data});
+}
+
+// =============================================================================
+// DELETE OPERATIONS - PRIMARY KEY
+// =============================================================================
+
+SPACETIMEDB_REDUCER(delete_pk_u8, ReducerContext ctx, uint8_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_u8_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_u16, ReducerContext ctx, uint16_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_u16_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_u32, ReducerContext ctx, uint32_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_u32_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_u32_two, ReducerContext ctx, uint32_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_u32_two_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_u64, ReducerContext ctx, uint64_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_u64_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_u128, ReducerContext ctx, u128 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_u128_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_u256, ReducerContext ctx, u256 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_u256_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_i8, ReducerContext ctx, int8_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_i8_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_i16, ReducerContext ctx, int16_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_i16_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_i32, ReducerContext ctx, int32_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_i32_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_i64, ReducerContext ctx, int64_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_i64_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_i128, ReducerContext ctx, i128 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_i128_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_i256, ReducerContext ctx, i256 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_i256_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_bool, ReducerContext ctx, bool b)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_bool_b].delete_by_key(b);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_string, ReducerContext ctx, std::string s)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_string_s].delete_by_key(s);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_identity, ReducerContext ctx, Identity i)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_identity_i].delete_by_key(i);
+}
+
+SPACETIMEDB_REDUCER(delete_pk_connection_id, ReducerContext ctx, ConnectionId a)
+{
+    // Use optimized field accessor for direct index-based delete
+    (void)ctx.db[pk_connection_id_a].delete_by_key(a);
+}
+
+// =============================================================================
+// DELETE OPERATIONS - UNIQUE CONSTRAINT
+// =============================================================================
+
+SPACETIMEDB_REDUCER(delete_unique_u8, ReducerContext ctx, uint8_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_u8_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_u16, ReducerContext ctx, uint16_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_u16_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_u32, ReducerContext ctx, uint32_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_u32_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_u64, ReducerContext ctx, uint64_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_u64_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_u128, ReducerContext ctx, u128 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_u128_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_u256, ReducerContext ctx, u256 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_u256_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_i8, ReducerContext ctx, int8_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_i8_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_i16, ReducerContext ctx, int16_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_i16_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_i32, ReducerContext ctx, int32_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_i32_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_i64, ReducerContext ctx, int64_t n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_i64_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_i128, ReducerContext ctx, i128 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_i128_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_i256, ReducerContext ctx, i256 n)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_i256_n].delete_by_value(n);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_bool, ReducerContext ctx, bool b)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_bool_b].delete_by_value(b);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_string, ReducerContext ctx, std::string s)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_string_s].delete_by_value(s);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_identity, ReducerContext ctx, Identity i)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_identity_i].delete_by_value(i);
+}
+
+SPACETIMEDB_REDUCER(delete_unique_connection_id, ReducerContext ctx, ConnectionId a)
+{
+    // Use optimized field accessor for direct index-based delete
+    ctx.db[unique_connection_id_a].delete_by_value(a);
+}
+
+// =============================================================================
+// UPDATE OPERATIONS - PRIMARY KEY
+// =============================================================================
+
+SPACETIMEDB_REDUCER(update_pk_u8, ReducerContext ctx, uint8_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_u8_n].update(PkU8{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_u16, ReducerContext ctx, uint16_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_u16_n].update(PkU16{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_u32, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_u32_n].update(PkU32{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_u32_two, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_u32_two_n].update(PkU32Two{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_u64, ReducerContext ctx, uint64_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_u64_n].update(PkU64{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_u128, ReducerContext ctx, u128 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_u128_n].update(PkU128{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_u256, ReducerContext ctx, u256 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_u256_n].update(PkU256{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_i8, ReducerContext ctx, int8_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_i8_n].update(PkI8{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_i16, ReducerContext ctx, int16_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_i16_n].update(PkI16{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_i32, ReducerContext ctx, int32_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_i32_n].update(PkI32{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_i64, ReducerContext ctx, int64_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_i64_n].update(PkI64{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_i128, ReducerContext ctx, i128 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_i128_n].update(PkI128{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_i256, ReducerContext ctx, i256 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_i256_n].update(PkI256{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_bool, ReducerContext ctx, bool b, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_bool_b].update(PkBool{b, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_string, ReducerContext ctx, std::string s, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_string_s].update(PkString{s, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_identity, ReducerContext ctx, Identity i, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_identity_i].update(PkIdentity{i, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_connection_id, ReducerContext ctx, ConnectionId a, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_connection_id_a].update(PkConnectionId{a, data});
+}
+
+SPACETIMEDB_REDUCER(update_pk_simple_enum, ReducerContext ctx, SimpleEnum a, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    (void)ctx.db[pk_simple_enum_a].update(PkSimpleEnum{a, data});
+}
+
+// =============================================================================
+// UPDATE OPERATIONS - UNIQUE CONSTRAINT
+// =============================================================================
+
+SPACETIMEDB_REDUCER(update_unique_u8, ReducerContext ctx, uint8_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_u8_n].update(UniqueU8{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_u16, ReducerContext ctx, uint16_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_u16_n].update(UniqueU16{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_u32, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_u32_n].update(UniqueU32{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_u64, ReducerContext ctx, uint64_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_u64_n].update(UniqueU64{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_u128, ReducerContext ctx, u128 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_u128_n].update(UniqueU128{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_u256, ReducerContext ctx, u256 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_u256_n].update(UniqueU256{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_i8, ReducerContext ctx, int8_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_i8_n].update(UniqueI8{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_i16, ReducerContext ctx, int16_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_i16_n].update(UniqueI16{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_i32, ReducerContext ctx, int32_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_i32_n].update(UniqueI32{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_i64, ReducerContext ctx, int64_t n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_i64_n].update(UniqueI64{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_i128, ReducerContext ctx, i128 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_i128_n].update(UniqueI128{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_i256, ReducerContext ctx, i256 n, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_i256_n].update(UniqueI256{n, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_bool, ReducerContext ctx, bool b, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_bool_b].update(UniqueBool{b, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_string, ReducerContext ctx, std::string s, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_string_s].update(UniqueString{s, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_identity, ReducerContext ctx, Identity i, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_identity_i].update(UniqueIdentity{i, data});
+}
+
+SPACETIMEDB_REDUCER(update_unique_connection_id, ReducerContext ctx, ConnectionId a, int32_t data)
+{
+    // Use optimized field accessor for direct index-based update
+    ctx.db[unique_connection_id_a].update(UniqueConnectionId{a, data});
+}
+
+// =============================================================================
+// COMPREHENSIVE TABLE REDUCERS
+// =============================================================================
+
+ SPACETIMEDB_REDUCER(insert_large_table, ReducerContext ctx,
+    uint8_t a, uint16_t b, uint32_t c, uint64_t d, u128 e, u256 f,
+    int8_t g, int16_t h, int32_t i, int64_t j, i128 k, i256 l,
+    bool m, float n, double o, std::string p,
+    SimpleEnum q, EnumWithPayload r, UnitStruct s, ByteStruct t,
+    EveryPrimitiveStruct u, EveryVecStruct v)
+{
+    ctx.db[large_table].insert(LargeTable{
+        a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v
+    });
+} 
+
+ SPACETIMEDB_REDUCER(delete_large_table, ReducerContext ctx,
+    uint8_t a, uint16_t b, uint32_t c, uint64_t d, u128 e, u256 f,
+    int8_t g, int16_t h, int32_t i, int64_t j, i128 k, i256 l,
+    bool m, float n, double o, std::string p,
+    SimpleEnum q, EnumWithPayload r, UnitStruct s, ByteStruct t,
+    EveryPrimitiveStruct u, EveryVecStruct v)
+{
+    ctx.db[large_table].delete_by_value(LargeTable{
+        a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v
+    });
+} 
+
+SPACETIMEDB_REDUCER(insert_table_holds_table, ReducerContext ctx, OneU8 a, VecU8 b)
+{
+    ctx.db[table_holds_table].insert(TableHoldsTable{a, b});
+}
+
+// =============================================================================
+// SPECIAL CONTEXT REDUCERS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_caller_one_identity, ReducerContext ctx)
+{
+    ctx.db[one_identity].insert(OneIdentity{ctx.sender});
+}
+
+SPACETIMEDB_REDUCER(insert_caller_vec_identity, ReducerContext ctx)
+{
+    ctx.db[vec_identity].insert(VecIdentity{{ctx.sender}});
+}
+
+SPACETIMEDB_REDUCER(insert_caller_unique_identity, ReducerContext ctx, int32_t data)
+{
+    ctx.db[unique_identity].insert(UniqueIdentity{ctx.sender, data});
+}
+
+SPACETIMEDB_REDUCER(insert_caller_pk_identity, ReducerContext ctx, int32_t data)
+{
+    ctx.db[pk_identity].insert(PkIdentity{ctx.sender, data});
+}
+
+SPACETIMEDB_REDUCER(insert_caller_one_connection_id, ReducerContext ctx)
+{
+    if (ctx.connection_id.has_value()) {
+        ctx.db[one_connection_id].insert(OneConnectionId{ctx.connection_id.value()});
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_caller_vec_connection_id, ReducerContext ctx)
+{
+    if (ctx.connection_id.has_value()) {
+        ctx.db[vec_connection_id].insert(VecConnectionId{{ctx.connection_id.value()}});
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_caller_unique_connection_id, ReducerContext ctx, int32_t data)
+{
+    if (ctx.connection_id.has_value()) {
+        ctx.db[unique_connection_id].insert(UniqueConnectionId{ctx.connection_id.value(), data});
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_caller_pk_connection_id, ReducerContext ctx, int32_t data)
+{
+    if (ctx.connection_id.has_value()) {
+        ctx.db[pk_connection_id].insert(PkConnectionId{ctx.connection_id.value(), data});
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_call_timestamp, ReducerContext ctx)
+{
+    ctx.db[one_timestamp].insert(OneTimestamp{ctx.timestamp});
+}
+
+SPACETIMEDB_REDUCER(insert_primitives_as_strings, ReducerContext ctx, EveryPrimitiveStruct s)
+{
+    // Helper function to format floats like Rust (no trailing zeros)
+    auto format_float = [](float f) -> std::string {
+        if (f == 1.0f) return "1";
+        if (f == -1.0f) return "-1";
+        return std::to_string(f);
+    };
+    
+    std::vector<std::string> string_values = {
+        std::to_string(s.a), std::to_string(s.b), std::to_string(s.c), std::to_string(s.d),
+        s.e.to_string(), s.f.to_string(),
+        std::to_string(s.g), std::to_string(s.h), std::to_string(s.i), std::to_string(s.j),
+        s.k.to_string(), s.l.to_string(),
+        s.m ? "true" : "false", format_float(s.n), format_float(s.o), s.p,
+        s.q.to_string(), s.r.to_string(), s.s.to_string(), s.t.to_string()
+    };
+    ctx.db[vec_string].insert(VecString{string_values});
+}
+
+// =============================================================================
+// SPECIALIZED OPERATIONS
+// =============================================================================
+
+SPACETIMEDB_REDUCER(insert_into_btree_u32, ReducerContext ctx, std::vector<BTreeU32> rows)
+{
+    for (const auto& row : rows) {
+        ctx.db[btree_u32].insert(row);
+    }
+}
+
+SPACETIMEDB_REDUCER(delete_from_btree_u32, ReducerContext ctx, std::vector<BTreeU32> rows)
+{
+    for (const auto& row : rows) {
+        ctx.db[btree_u32].delete_by_value(row);
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_into_pk_btree_u32, ReducerContext ctx, std::vector<PkU32> pk_u32, std::vector<BTreeU32> bt_u32)
+{
+    for (const auto& row : pk_u32) {
+        ctx.db[::pk_u32].insert(row);
+    }
+    for (const auto& row : bt_u32) {
+        ctx.db[btree_u32].insert(row);
+    }
+}
+
+SPACETIMEDB_REDUCER(insert_unique_u32_update_pk_u32, ReducerContext ctx, uint32_t n, int32_t d_unique, int32_t d_pk)
+{
+    ctx.db[unique_u32].insert(UniqueU32{n, d_unique});
+    // Use the update method via field accessor for primary key tables
+    (void)ctx.db[pk_u32_n].update(PkU32{n, d_pk});
+}
+
+SPACETIMEDB_REDUCER(delete_pk_u32_insert_pk_u32_two, ReducerContext ctx, uint32_t n, int32_t data)
+{
+    ctx.db[pk_u32_two].insert(PkU32Two{n, data});
+    (void)ctx.db[pk_u32_n].delete_by_key(n);
+}
+
+SPACETIMEDB_REDUCER(insert_user, ReducerContext ctx, std::string name, Identity identity)
+{
+    ctx.db[users].insert(Users{identity, name});
+}
+
+SPACETIMEDB_REDUCER(insert_into_indexed_simple_enum, ReducerContext ctx, SimpleEnum n)
+{
+    ctx.db[indexed_simple_enum].insert(IndexedSimpleEnum{n});
+}
+
+SPACETIMEDB_REDUCER(update_indexed_simple_enum, ReducerContext ctx, SimpleEnum a, SimpleEnum b)
+{
+    auto table = ctx.db[indexed_simple_enum];
+    
+    // Find and delete rows with value a, then insert row with value b
+    for (auto& row : table) {
+        if (row.n == a) {
+            table.delete_by_value(row);
+            table.insert(IndexedSimpleEnum{b});
+            break;  // Only update the first match
+        }
+    }
+}
+
+
+// Scheduled table operations
+SPACETIMEDB_REDUCER(send_scheduled_message, ReducerContext ctx, ScheduledTable arg)
+{
+    LOG_INFO_F("Scheduled message executed: ID=%llu, text=%s", arg.scheduled_id, arg.text.c_str());
+}
+
+// =============================================================================
+// CLIENT VISIBILITY FILTERS
+// =============================================================================
+
+SPACETIMEDB_CLIENT_VISIBILITY_FILTER(
+    one_u8_visible,
+    "SELECT * FROM one_u8"
+)
+
+SPACETIMEDB_CLIENT_VISIBILITY_FILTER(
+    users_filter,
+    "SELECT * FROM users WHERE identity = :sender"
+)
+
+// =============================================================================
+// NO-OP REDUCER FOR TESTING
+// =============================================================================
+
+SPACETIMEDB_REDUCER(no_op_succeeds, ReducerContext ctx)
+{
+    LOG_INFO("No-op reducer executed successfully");
+}