diff --git a/crates/core/src/db/datastore/locking_tx_datastore/mod.rs b/crates/core/src/db/datastore/locking_tx_datastore/mod.rs
index f947a9e20e0..16e11b5684e 100644
--- a/crates/core/src/db/datastore/locking_tx_datastore/mod.rs
+++ b/crates/core/src/db/datastore/locking_tx_datastore/mod.rs
@@ -1147,29 +1147,32 @@ impl Inner {
     }
 
     fn algebraic_type_is_numeric(ty: &AlgebraicType) -> bool {
-        matches!(*ty, |AlgebraicType::I8| AlgebraicType::U8
-            | AlgebraicType::I16
-            | AlgebraicType::U16
-            | AlgebraicType::I32
-            | AlgebraicType::U32
-            | AlgebraicType::I64
-            | AlgebraicType::U64
-            | AlgebraicType::I128
-            | AlgebraicType::U128)
+        matches!(
+            *ty,
+            AlgebraicType::Builtin(|spacetimedb_sats::BuiltinType::I8| spacetimedb_sats::BuiltinType::U8
+                | spacetimedb_sats::BuiltinType::I16
+                | spacetimedb_sats::BuiltinType::U16
+                | spacetimedb_sats::BuiltinType::I32
+                | spacetimedb_sats::BuiltinType::U32
+                | spacetimedb_sats::BuiltinType::I64
+                | spacetimedb_sats::BuiltinType::U64
+                | spacetimedb_sats::BuiltinType::I128
+                | spacetimedb_sats::BuiltinType::U128)
+        )
     }
 
     fn sequence_value_to_algebraic_value(ty: &AlgebraicType, sequence_value: i128) -> AlgebraicValue {
         match *ty {
-            AlgebraicType::I8 => (sequence_value as i8).into(),
-            AlgebraicType::U8 => (sequence_value as u8).into(),
-            AlgebraicType::I16 => (sequence_value as i16).into(),
-            AlgebraicType::U16 => (sequence_value as u16).into(),
-            AlgebraicType::I32 => (sequence_value as i32).into(),
-            AlgebraicType::U32 => (sequence_value as u32).into(),
-            AlgebraicType::I64 => (sequence_value as i64).into(),
-            AlgebraicType::U64 => (sequence_value as u64).into(),
-            AlgebraicType::I128 => sequence_value.into(),
-            AlgebraicType::U128 => (sequence_value as u128).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I8) => (sequence_value as i8).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U8) => (sequence_value as u8).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I16) => (sequence_value as i16).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U16) => (sequence_value as u16).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I32) => (sequence_value as i32).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U32) => (sequence_value as u32).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I64) => (sequence_value as i64).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U64) => (sequence_value as u64).into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I128) => sequence_value.into(),
+            AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U128) => (sequence_value as u128).into(),
             _ => unreachable!("should have been prevented in `fn insert`"),
         }
     }
diff --git a/crates/sats/src/algebraic_type.rs b/crates/sats/src/algebraic_type.rs
index 1602e8c6bed..92d72c4912c 100644
--- a/crates/sats/src/algebraic_type.rs
+++ b/crates/sats/src/algebraic_type.rs
@@ -245,18 +245,18 @@ impl AlgebraicType {
     /// Given an AlgebraicType, returns the min value for that type.
     pub fn min_value(&self) -> Option<AlgebraicValue> {
         match *self {
-            Self::I8 => Some(i8::MIN.into()),
-            Self::U8 => Some(u8::MIN.into()),
-            Self::I16 => Some(i16::MIN.into()),
-            Self::U16 => Some(u16::MIN.into()),
-            Self::I32 => Some(i32::MIN.into()),
-            Self::U32 => Some(u32::MIN.into()),
-            Self::I64 => Some(i64::MIN.into()),
-            Self::U64 => Some(u64::MIN.into()),
-            Self::I128 => Some(i128::MIN.into()),
-            Self::U128 => Some(u128::MIN.into()),
-            Self::F32 => Some(f32::MIN.into()),
-            Self::F64 => Some(f64::MIN.into()),
+            Self::Builtin(crate::BuiltinType::I8) => Some(i8::MIN.into()),
+            Self::Builtin(crate::BuiltinType::U8) => Some(u8::MIN.into()),
+            Self::Builtin(crate::BuiltinType::I16) => Some(i16::MIN.into()),
+            Self::Builtin(crate::BuiltinType::U16) => Some(u16::MIN.into()),
+            Self::Builtin(crate::BuiltinType::I32) => Some(i32::MIN.into()),
+            Self::Builtin(crate::BuiltinType::U32) => Some(u32::MIN.into()),
+            Self::Builtin(crate::BuiltinType::I64) => Some(i64::MIN.into()),
+            Self::Builtin(crate::BuiltinType::U64) => Some(u64::MIN.into()),
+            Self::Builtin(crate::BuiltinType::I128) => Some(i128::MIN.into()),
+            Self::Builtin(crate::BuiltinType::U128) => Some(u128::MIN.into()),
+            Self::Builtin(crate::BuiltinType::F32) => Some(f32::MIN.into()),
+            Self::Builtin(crate::BuiltinType::F64) => Some(f64::MIN.into()),
             _ => None,
         }
     }
@@ -265,18 +265,18 @@ impl AlgebraicType {
     /// Given an AlgebraicType, returns the max value for that type.
     pub fn max_value(&self) -> Option<AlgebraicValue> {
         match *self {
-            Self::I8 => Some(i8::MAX.into()),
-            Self::U8 => Some(u8::MAX.into()),
-            Self::I16 => Some(i16::MAX.into()),
-            Self::U16 => Some(u16::MAX.into()),
-            Self::I32 => Some(i32::MAX.into()),
-            Self::U32 => Some(u32::MAX.into()),
-            Self::I64 => Some(i64::MAX.into()),
-            Self::U64 => Some(u64::MAX.into()),
-            Self::I128 => Some(i128::MAX.into()),
-            Self::U128 => Some(u128::MAX.into()),
-            Self::F32 => Some(f32::MAX.into()),
-            Self::F64 => Some(f64::MAX.into()),
+            Self::Builtin(crate::BuiltinType::I8) => Some(i8::MAX.into()),
+            Self::Builtin(crate::BuiltinType::U8) => Some(u8::MAX.into()),
+            Self::Builtin(crate::BuiltinType::I16) => Some(i16::MAX.into()),
+            Self::Builtin(crate::BuiltinType::U16) => Some(u16::MAX.into()),
+            Self::Builtin(crate::BuiltinType::I32) => Some(i32::MAX.into()),
+            Self::Builtin(crate::BuiltinType::U32) => Some(u32::MAX.into()),
+            Self::Builtin(crate::BuiltinType::I64) => Some(i64::MAX.into()),
+            Self::Builtin(crate::BuiltinType::U64) => Some(u64::MAX.into()),
+            Self::Builtin(crate::BuiltinType::I128) => Some(i128::MAX.into()),
+            Self::Builtin(crate::BuiltinType::U128) => Some(u128::MAX.into()),
+            Self::Builtin(crate::BuiltinType::F32) => Some(f32::MAX.into()),
+            Self::Builtin(crate::BuiltinType::F64) => Some(f64::MAX.into()),
             _ => None,
         }
     }
diff --git a/crates/sats/src/algebraic_type/fmt.rs b/crates/sats/src/algebraic_type/fmt.rs
index fe45b5902e3..a51d894cf5e 100644
--- a/crates/sats/src/algebraic_type/fmt.rs
+++ b/crates/sats/src/algebraic_type/fmt.rs
@@ -19,20 +19,20 @@ pub fn fmt_algebraic_type(ty: &AlgebraicType) -> impl '_ + Display {
         AlgebraicType::Product(ty) => write!(f, "{}", fmt_product_type(ty)),
         AlgebraicType::Builtin(BuiltinType::Array(a)) => write!(f, "Array<{}>", fmt(&a.elem_ty)),
         AlgebraicType::Builtin(BuiltinType::Map(m)) => write!(f, "Map<{}, {}>", fmt(&m.key_ty), fmt(&m.ty)),
-        &AlgebraicType::Bool => write!(f, "Bool"),
-        &AlgebraicType::I8 => write!(f, "I8"),
-        &AlgebraicType::U8 => write!(f, "U8"),
-        &AlgebraicType::I16 => write!(f, "I16"),
-        &AlgebraicType::U16 => write!(f, "U16"),
-        &AlgebraicType::I32 => write!(f, "I32"),
-        &AlgebraicType::U32 => write!(f, "U32"),
-        &AlgebraicType::I64 => write!(f, "I64"),
-        &AlgebraicType::U64 => write!(f, "U64"),
-        &AlgebraicType::I128 => write!(f, "I128"),
-        &AlgebraicType::U128 => write!(f, "U128"),
-        &AlgebraicType::F32 => write!(f, "F32"),
-        &AlgebraicType::F64 => write!(f, "F64"),
-        &AlgebraicType::String => write!(f, "String"),
+        AlgebraicType::Builtin(BuiltinType::Bool) => write!(f, "Bool"),
+        AlgebraicType::Builtin(BuiltinType::I8) => write!(f, "I8"),
+        AlgebraicType::Builtin(BuiltinType::U8) => write!(f, "U8"),
+        AlgebraicType::Builtin(BuiltinType::I16) => write!(f, "I16"),
+        AlgebraicType::Builtin(BuiltinType::U16) => write!(f, "U16"),
+        AlgebraicType::Builtin(BuiltinType::I32) => write!(f, "I32"),
+        AlgebraicType::Builtin(BuiltinType::U32) => write!(f, "U32"),
+        AlgebraicType::Builtin(BuiltinType::I64) => write!(f, "I64"),
+        AlgebraicType::Builtin(BuiltinType::U64) => write!(f, "U64"),
+        AlgebraicType::Builtin(BuiltinType::I128) => write!(f, "I128"),
+        AlgebraicType::Builtin(BuiltinType::U128) => write!(f, "U128"),
+        AlgebraicType::Builtin(BuiltinType::F32) => write!(f, "F32"),
+        AlgebraicType::Builtin(BuiltinType::F64) => write!(f, "F64"),
+        AlgebraicType::Builtin(BuiltinType::String) => write!(f, "String"),
     })
 }
 
diff --git a/crates/sats/src/algebraic_type/map_notation.rs b/crates/sats/src/algebraic_type/map_notation.rs
index b1edb5ed3dc..86d9bbb42c7 100644
--- a/crates/sats/src/algebraic_type/map_notation.rs
+++ b/crates/sats/src/algebraic_type/map_notation.rs
@@ -31,19 +31,19 @@ pub fn fmt_algebraic_type(ty: &AlgebraicType) -> impl '_ + fmt::Display {
         }
         AlgebraicType::Builtin(Array(ty)) => write!(f, "{{ ty_: Array, 0: {} }}", fmt(&ty.elem_ty)),
         AlgebraicType::Builtin(Map(map)) => write!(f, "{{ ty_: Map, 0: {}, 1: {} }}", fmt(&map.key_ty), fmt(&map.ty)),
-        &AlgebraicType::Bool => write!(f, "{{ ty_: Bool }}"),
-        &AlgebraicType::I8 => write!(f, "{{ ty_: I8 }}"),
-        &AlgebraicType::U8 => write!(f, "{{ ty_: U8 }}"),
-        &AlgebraicType::I16 => write!(f, "{{ ty_: I16 }}"),
-        &AlgebraicType::U16 => write!(f, "{{ ty_: U16 }}"),
-        &AlgebraicType::I32 => write!(f, "{{ ty_: I32 }}"),
-        &AlgebraicType::U32 => write!(f, "{{ ty_: U32 }}"),
-        &AlgebraicType::I64 => write!(f, "{{ ty_: I64 }}"),
-        &AlgebraicType::U64 => write!(f, "{{ ty_: U64 }}"),
-        &AlgebraicType::I128 => write!(f, "{{ ty_: I128 }}"),
-        &AlgebraicType::U128 => write!(f, "{{ ty_: U128 }}"),
-        &AlgebraicType::F32 => write!(f, "{{ ty_: F32 }}"),
-        &AlgebraicType::F64 => write!(f, "{{ ty_: F64 }}"),
-        &AlgebraicType::String => write!(f, "{{ ty_: String }}"),
+        AlgebraicType::Builtin(Bool) => write!(f, "{{ ty_: Bool }}"),
+        AlgebraicType::Builtin(I8) => write!(f, "{{ ty_: I8 }}"),
+        AlgebraicType::Builtin(U8) => write!(f, "{{ ty_: U8 }}"),
+        AlgebraicType::Builtin(I16) => write!(f, "{{ ty_: I16 }}"),
+        AlgebraicType::Builtin(U16) => write!(f, "{{ ty_: U16 }}"),
+        AlgebraicType::Builtin(I32) => write!(f, "{{ ty_: I32 }}"),
+        AlgebraicType::Builtin(U32) => write!(f, "{{ ty_: U32 }}"),
+        AlgebraicType::Builtin(I64) => write!(f, "{{ ty_: I64 }}"),
+        AlgebraicType::Builtin(U64) => write!(f, "{{ ty_: U64 }}"),
+        AlgebraicType::Builtin(I128) => write!(f, "{{ ty_: I128 }}"),
+        AlgebraicType::Builtin(U128) => write!(f, "{{ ty_: U128 }}"),
+        AlgebraicType::Builtin(F32) => write!(f, "{{ ty_: F32 }}"),
+        AlgebraicType::Builtin(F64) => write!(f, "{{ ty_: F64 }}"),
+        AlgebraicType::Builtin(String) => write!(f, "{{ ty_: String }}"),
     })
 }
diff --git a/crates/sats/src/de/impls.rs b/crates/sats/src/de/impls.rs
index 922474f6cba..6e8808eab4a 100644
--- a/crates/sats/src/de/impls.rs
+++ b/crates/sats/src/de/impls.rs
@@ -304,20 +304,20 @@ impl<'de> DeserializeSeed<'de> for WithTypespace<'_, AlgebraicType> {
             AlgebraicType::Product(prod) => self.with(prod).deserialize(de).map(Into::into),
             AlgebraicType::Builtin(crate::BuiltinType::Array(ty)) => self.with(ty).deserialize(de).map(Into::into),
             AlgebraicType::Builtin(crate::BuiltinType::Map(ty)) => self.with(&**ty).deserialize(de).map(Into::into),
-            &AlgebraicType::Bool => bool::deserialize(de).map(Into::into),
-            &AlgebraicType::I8 => i8::deserialize(de).map(Into::into),
-            &AlgebraicType::U8 => u8::deserialize(de).map(Into::into),
-            &AlgebraicType::I16 => i16::deserialize(de).map(Into::into),
-            &AlgebraicType::U16 => u16::deserialize(de).map(Into::into),
-            &AlgebraicType::I32 => i32::deserialize(de).map(Into::into),
-            &AlgebraicType::U32 => u32::deserialize(de).map(Into::into),
-            &AlgebraicType::I64 => i64::deserialize(de).map(Into::into),
-            &AlgebraicType::U64 => u64::deserialize(de).map(Into::into),
-            &AlgebraicType::I128 => i128::deserialize(de).map(Into::into),
-            &AlgebraicType::U128 => u128::deserialize(de).map(Into::into),
-            &AlgebraicType::F32 => f32::deserialize(de).map(Into::into),
-            &AlgebraicType::F64 => f64::deserialize(de).map(Into::into),
-            &AlgebraicType::String => String::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::Bool) => bool::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::I8) => i8::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::U8) => u8::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::I16) => i16::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::U16) => u16::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::I32) => i32::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::U32) => u32::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::I64) => i64::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::U64) => u64::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::I128) => i128::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::U128) => u128::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::F32) => f32::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::F64) => f64::deserialize(de).map(Into::into),
+            AlgebraicType::Builtin(crate::BuiltinType::String) => String::deserialize(de).map(Into::into),
         }
     }
 }
@@ -441,20 +441,22 @@ impl<'de> DeserializeSeed<'de> for WithTypespace<'_, ArrayType> {
                 AlgebraicType::Builtin(crate::BuiltinType::Map(ty)) => deserializer
                     .deserialize_array_seed(BasicVecVisitor, self.with(&**ty))
                     .map(ArrayValue::Map),
-                &AlgebraicType::Bool => de_array(deserializer, ArrayValue::Bool),
-                &AlgebraicType::I8 => de_array(deserializer, ArrayValue::I8),
-                &AlgebraicType::U8 => deserializer.deserialize_bytes(OwnedSliceVisitor).map(ArrayValue::U8),
-                &AlgebraicType::I16 => de_array(deserializer, ArrayValue::I16),
-                &AlgebraicType::U16 => de_array(deserializer, ArrayValue::U16),
-                &AlgebraicType::I32 => de_array(deserializer, ArrayValue::I32),
-                &AlgebraicType::U32 => de_array(deserializer, ArrayValue::U32),
-                &AlgebraicType::I64 => de_array(deserializer, ArrayValue::I64),
-                &AlgebraicType::U64 => de_array(deserializer, ArrayValue::U64),
-                &AlgebraicType::I128 => de_array(deserializer, ArrayValue::I128),
-                &AlgebraicType::U128 => de_array(deserializer, ArrayValue::U128),
-                &AlgebraicType::F32 => de_array(deserializer, ArrayValue::F32),
-                &AlgebraicType::F64 => de_array(deserializer, ArrayValue::F64),
-                &AlgebraicType::String => de_array(deserializer, ArrayValue::String),
+                AlgebraicType::Builtin(crate::BuiltinType::Bool) => de_array(deserializer, ArrayValue::Bool),
+                AlgebraicType::Builtin(crate::BuiltinType::I8) => de_array(deserializer, ArrayValue::I8),
+                AlgebraicType::Builtin(crate::BuiltinType::U8) => {
+                    deserializer.deserialize_bytes(OwnedSliceVisitor).map(ArrayValue::U8)
+                }
+                AlgebraicType::Builtin(crate::BuiltinType::I16) => de_array(deserializer, ArrayValue::I16),
+                AlgebraicType::Builtin(crate::BuiltinType::U16) => de_array(deserializer, ArrayValue::U16),
+                AlgebraicType::Builtin(crate::BuiltinType::I32) => de_array(deserializer, ArrayValue::I32),
+                AlgebraicType::Builtin(crate::BuiltinType::U32) => de_array(deserializer, ArrayValue::U32),
+                AlgebraicType::Builtin(crate::BuiltinType::I64) => de_array(deserializer, ArrayValue::I64),
+                AlgebraicType::Builtin(crate::BuiltinType::U64) => de_array(deserializer, ArrayValue::U64),
+                AlgebraicType::Builtin(crate::BuiltinType::I128) => de_array(deserializer, ArrayValue::I128),
+                AlgebraicType::Builtin(crate::BuiltinType::U128) => de_array(deserializer, ArrayValue::U128),
+                AlgebraicType::Builtin(crate::BuiltinType::F32) => de_array(deserializer, ArrayValue::F32),
+                AlgebraicType::Builtin(crate::BuiltinType::F64) => de_array(deserializer, ArrayValue::F64),
+                AlgebraicType::Builtin(crate::BuiltinType::String) => de_array(deserializer, ArrayValue::String),
             };
         }
     }
diff --git a/crates/sats/src/ser/impls.rs b/crates/sats/src/ser/impls.rs
index 4d215c96740..2cf2b4aa5bf 100644
--- a/crates/sats/src/ser/impls.rs
+++ b/crates/sats/src/ser/impls.rs
@@ -149,20 +149,20 @@ impl_serialize!([] ValueWithType<'_, AlgebraicValue>, (self, ser) => {
             (AlgebraicValue::Product(val), AlgebraicType::Product(ty)) => self.with(ty, val).serialize(ser),
             (AlgebraicValue::Array(val), AlgebraicType::Builtin(crate::BuiltinType::Array(ty))) => self.with(ty, val).serialize(ser),
             (AlgebraicValue::Map(val), AlgebraicType::Builtin(crate::BuiltinType::Map(ty))) => self.with(&**ty, val).serialize(ser),
-            (AlgebraicValue::Bool(v), &AlgebraicType::Bool) => ser.serialize_bool(*v),
-            (AlgebraicValue::I8(v), &AlgebraicType::I8) => ser.serialize_i8(*v),
-            (AlgebraicValue::U8(v), &AlgebraicType::U8) => ser.serialize_u8(*v),
-            (AlgebraicValue::I16(v), &AlgebraicType::I16) => ser.serialize_i16(*v),
-            (AlgebraicValue::U16(v), &AlgebraicType::U16) => ser.serialize_u16(*v),
-            (AlgebraicValue::I32(v), &AlgebraicType::I32) => ser.serialize_i32(*v),
-            (AlgebraicValue::U32(v), &AlgebraicType::U32) => ser.serialize_u32(*v),
-            (AlgebraicValue::I64(v), &AlgebraicType::I64) => ser.serialize_i64(*v),
-            (AlgebraicValue::U64(v), &AlgebraicType::U64) => ser.serialize_u64(*v),
-            (AlgebraicValue::I128(v), &AlgebraicType::I128) => ser.serialize_i128(*v),
-            (AlgebraicValue::U128(v), &AlgebraicType::U128) => ser.serialize_u128(*v),
-            (AlgebraicValue::F32(v), &AlgebraicType::F32) => ser.serialize_f32((*v).into()),
-            (AlgebraicValue::F64(v), &AlgebraicType::F64) => ser.serialize_f64((*v).into()),
-            (AlgebraicValue::String(s), &AlgebraicType::String) => ser.serialize_str(s),
+            (AlgebraicValue::Bool(v), AlgebraicType::Builtin(crate::BuiltinType::Bool)) => ser.serialize_bool(*v),
+            (AlgebraicValue::I8(v), AlgebraicType::Builtin(crate::BuiltinType::I8)) => ser.serialize_i8(*v),
+            (AlgebraicValue::U8(v), AlgebraicType::Builtin(crate::BuiltinType::U8)) => ser.serialize_u8(*v),
+            (AlgebraicValue::I16(v), AlgebraicType::Builtin(crate::BuiltinType::I16)) => ser.serialize_i16(*v),
+            (AlgebraicValue::U16(v), AlgebraicType::Builtin(crate::BuiltinType::U16)) => ser.serialize_u16(*v),
+            (AlgebraicValue::I32(v), AlgebraicType::Builtin(crate::BuiltinType::I32)) => ser.serialize_i32(*v),
+            (AlgebraicValue::U32(v), AlgebraicType::Builtin(crate::BuiltinType::U32)) => ser.serialize_u32(*v),
+            (AlgebraicValue::I64(v), AlgebraicType::Builtin(crate::BuiltinType::I64)) => ser.serialize_i64(*v),
+            (AlgebraicValue::U64(v), AlgebraicType::Builtin(crate::BuiltinType::U64)) => ser.serialize_u64(*v),
+            (AlgebraicValue::I128(v), AlgebraicType::Builtin(crate::BuiltinType::I128)) => ser.serialize_i128(*v),
+            (AlgebraicValue::U128(v), AlgebraicType::Builtin(crate::BuiltinType::U128)) => ser.serialize_u128(*v),
+            (AlgebraicValue::F32(v), AlgebraicType::Builtin(crate::BuiltinType::F32)) => ser.serialize_f32((*v).into()),
+            (AlgebraicValue::F64(v), AlgebraicType::Builtin(crate::BuiltinType::F64)) => ser.serialize_f64((*v).into()),
+            (AlgebraicValue::String(s), AlgebraicType::Builtin(crate::BuiltinType::String)) => ser.serialize_str(s),
             (val, ty) => panic!("mismatched value and schema : {val:?} {ty:?}"),
         };
     }
@@ -197,20 +197,20 @@ impl_serialize!([] ValueWithType<'_, ArrayValue>, (self, ser) => match (self.val
     (ArrayValue::Sum(v), AlgebraicType::Sum(ty)) => self.with(ty, v).serialize(ser),
     (ArrayValue::Product(v), AlgebraicType::Product(ty)) => self.with(ty, v).serialize(ser),
     (ArrayValue::Map(v), AlgebraicType::Builtin(crate::BuiltinType::Map(m))) => self.with(&**m, v).serialize(ser),
-    (ArrayValue::Bool(v), &AlgebraicType::Bool) => v.serialize(ser),
-    (ArrayValue::I8(v), &AlgebraicType::I8) => v.serialize(ser),
-    (ArrayValue::U8(v), &AlgebraicType::U8) => v.serialize(ser),
-    (ArrayValue::I16(v), &AlgebraicType::I16) => v.serialize(ser),
-    (ArrayValue::U16(v), &AlgebraicType::U16) => v.serialize(ser),
-    (ArrayValue::I32(v), &AlgebraicType::I32) => v.serialize(ser),
-    (ArrayValue::U32(v), &AlgebraicType::U32) => v.serialize(ser),
-    (ArrayValue::I64(v), &AlgebraicType::I64) => v.serialize(ser),
-    (ArrayValue::U64(v), &AlgebraicType::U64) => v.serialize(ser),
-    (ArrayValue::I128(v), &AlgebraicType::I128) => v.serialize(ser),
-    (ArrayValue::U128(v), &AlgebraicType::U128) => v.serialize(ser),
-    (ArrayValue::F32(v), &AlgebraicType::F32) => v.serialize(ser),
-    (ArrayValue::F64(v), &AlgebraicType::F64) => v.serialize(ser),
-    (ArrayValue::String(v), &AlgebraicType::String) => v.serialize(ser),
+    (ArrayValue::Bool(v), AlgebraicType::Builtin(crate::BuiltinType::Bool)) => v.serialize(ser),
+    (ArrayValue::I8(v), AlgebraicType::Builtin(crate::BuiltinType::I8)) => v.serialize(ser),
+    (ArrayValue::U8(v), AlgebraicType::Builtin(crate::BuiltinType::U8)) => v.serialize(ser),
+    (ArrayValue::I16(v), AlgebraicType::Builtin(crate::BuiltinType::I16)) => v.serialize(ser),
+    (ArrayValue::U16(v), AlgebraicType::Builtin(crate::BuiltinType::U16)) => v.serialize(ser),
+    (ArrayValue::I32(v), AlgebraicType::Builtin(crate::BuiltinType::I32)) => v.serialize(ser),
+    (ArrayValue::U32(v), AlgebraicType::Builtin(crate::BuiltinType::U32)) => v.serialize(ser),
+    (ArrayValue::I64(v), AlgebraicType::Builtin(crate::BuiltinType::I64)) => v.serialize(ser),
+    (ArrayValue::U64(v), AlgebraicType::Builtin(crate::BuiltinType::U64)) => v.serialize(ser),
+    (ArrayValue::I128(v), AlgebraicType::Builtin(crate::BuiltinType::I128)) => v.serialize(ser),
+    (ArrayValue::U128(v), AlgebraicType::Builtin(crate::BuiltinType::U128)) => v.serialize(ser),
+    (ArrayValue::F32(v), AlgebraicType::Builtin(crate::BuiltinType::F32)) => v.serialize(ser),
+    (ArrayValue::F64(v), AlgebraicType::Builtin(crate::BuiltinType::F64)) => v.serialize(ser),
+    (ArrayValue::String(v), AlgebraicType::Builtin(crate::BuiltinType::String)) => v.serialize(ser),
     (ArrayValue::Array(v), AlgebraicType::Builtin(crate::BuiltinType::Array(ty))) => self.with(ty, v).serialize(ser),
     (val, _) if val.is_empty() => ser.serialize_array(0)?.end(),
     (val, ty) => panic!("mismatched value and schema: {val:?} {ty:?}"),
diff --git a/crates/vm/src/ops/parse.rs b/crates/vm/src/ops/parse.rs
index a40b82bdbfc..8d7434ece5b 100644
--- a/crates/vm/src/ops/parse.rs
+++ b/crates/vm/src/ops/parse.rs
@@ -34,20 +34,20 @@ where
 /// ```
 pub fn parse(value: &str, ty: &AlgebraicType) -> Result<AlgebraicValue, ErrorVm> {
     match ty {
-        &AlgebraicType::Bool => _parse::<bool>(value, ty),
-        &AlgebraicType::I8 => _parse::<i8>(value, ty),
-        &AlgebraicType::U8 => _parse::<u8>(value, ty),
-        &AlgebraicType::I16 => _parse::<i16>(value, ty),
-        &AlgebraicType::U16 => _parse::<u16>(value, ty),
-        &AlgebraicType::I32 => _parse::<i32>(value, ty),
-        &AlgebraicType::U32 => _parse::<u32>(value, ty),
-        &AlgebraicType::I64 => _parse::<i64>(value, ty),
-        &AlgebraicType::U64 => _parse::<u64>(value, ty),
-        &AlgebraicType::I128 => _parse::<i128>(value, ty),
-        &AlgebraicType::U128 => _parse::<u128>(value, ty),
-        &AlgebraicType::F32 => _parse::<f32>(value, ty),
-        &AlgebraicType::F64 => _parse::<f64>(value, ty),
-        &AlgebraicType::String => Ok(AlgebraicValue::String(value.to_string())),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::Bool) => _parse::<bool>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I8) => _parse::<i8>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U8) => _parse::<u8>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I16) => _parse::<i16>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U16) => _parse::<u16>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I32) => _parse::<i32>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U32) => _parse::<u32>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I64) => _parse::<i64>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U64) => _parse::<u64>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::I128) => _parse::<i128>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::U128) => _parse::<u128>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::F32) => _parse::<f32>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::F64) => _parse::<f64>(value, ty),
+        AlgebraicType::Builtin(spacetimedb_sats::BuiltinType::String) => Ok(AlgebraicValue::String(value.to_string())),
         x => Err(ErrorVm::Unsupported(format!(
             "Can't parse '{value}' to {}",
             x.to_satn_pretty()