rivet-dev · MasterPtato · Jun 23, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/engine/packages/depot/src/conveyer/types/branch.rs b/engine/packages/depot/src/conveyer/types/branch.rs
@@ -77,14 +77,14 @@ impl OwnedVersionedData for VersionedDatabaseBranchRecord {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::Current(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::Current(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DatabaseBranchRecord version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::Current(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::Current(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -108,14 +108,14 @@ impl OwnedVersionedData for VersionedDatabasePointer {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DatabasePointer version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -139,14 +139,14 @@ impl OwnedVersionedData for VersionedBucketBranchRecord {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot BucketBranchRecord version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -170,14 +170,14 @@ impl OwnedVersionedData for VersionedBucketPointer {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot BucketPointer version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -201,14 +201,14 @@ impl OwnedVersionedData for VersionedPointerSnapshot {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot PointerSnapshot version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

diff --git a/engine/packages/depot/src/conveyer/types/compaction.rs b/engine/packages/depot/src/conveyer/types/compaction.rs
@@ -61,14 +61,14 @@ macro_rules! impl_compaction_versioned_data {
 
 			fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 				match version {
-					1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+					1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 					_ => bail!("invalid depot {} version: {version}", $name),
 				}
 			}
 
 			fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 				match self {
-					Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+					Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 				}
 			}
 		}

diff --git a/engine/packages/depot/src/conveyer/types/history_pin.rs b/engine/packages/depot/src/conveyer/types/history_pin.rs
@@ -43,14 +43,14 @@ impl OwnedVersionedData for VersionedDbHistoryPin {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DbHistoryPin version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

diff --git a/engine/packages/depot/src/conveyer/types/policy.rs b/engine/packages/depot/src/conveyer/types/policy.rs
@@ -59,14 +59,14 @@ impl OwnedVersionedData for VersionedPitrPolicy {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot PitrPolicy version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(policy) => serde_bare::to_vec(&policy).map_err(Into::into),
+			Self::V1(policy) => rivet_util::serde::bare_to_vec!(&policy).map_err(Into::into),
 		}
 	}
 }
@@ -86,14 +86,14 @@ impl OwnedVersionedData for VersionedShardCachePolicy {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot ShardCachePolicy version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(policy) => serde_bare::to_vec(&policy).map_err(Into::into),
+			Self::V1(policy) => rivet_util::serde::bare_to_vec!(&policy).map_err(Into::into),
 		}
 	}
 }

diff --git a/engine/packages/depot/src/conveyer/types/restore_points.rs b/engine/packages/depot/src/conveyer/types/restore_points.rs
@@ -161,14 +161,14 @@ impl OwnedVersionedData for VersionedRestorePointRecord {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot RestorePointRecord version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

diff --git a/engine/packages/depot/src/conveyer/types/storage.rs b/engine/packages/depot/src/conveyer/types/storage.rs
@@ -53,14 +53,14 @@ impl OwnedVersionedData for VersionedDBHead {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot DBHead version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -84,14 +84,14 @@ impl OwnedVersionedData for VersionedCommitRow {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot CommitRow version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }
@@ -115,14 +115,14 @@ impl OwnedVersionedData for VersionedMetaCompact {
 
 	fn deserialize_version(payload: &[u8], version: u16) -> Result<Self> {
 		match version {
-			1 => Ok(Self::V1(serde_bare::from_slice(payload)?)),
+			1 => Ok(Self::V1(rivet_util::serde::bare_from_slice!(payload)?)),
 			_ => bail!("invalid depot MetaCompact version: {version}"),
 		}
 	}
 
 	fn serialize_version(self, _version: u16) -> Result<Vec<u8>> {
 		match self {
-			Self::V1(data) => serde_bare::to_vec(&data).map_err(Into::into),
+			Self::V1(data) => rivet_util::serde::bare_to_vec!(&data).map_err(Into::into),
 		}
 	}
 }

diff --git a/engine/packages/engine/src/commands/udb/cli.rs b/engine/packages/engine/src/commands/udb/cli.rs
@@ -929,21 +929,23 @@ impl SubCommand {
 										// A v2 entry roundtrips byte-identically through the v2
 										// schema. v3 entries either fail to deserialize as v2 or
 										// re-serialize to different bytes, so they are ignored.
-										let v2_entry: proto_v2::ChangelogEntry =
-											match serde_bare::from_slice(entry.value()) {
-												Ok(v) => v,
-												Err(_) => {
-													v3_count += 1;
-													continue;
-												}
-											};
-										let reserialized = match serde_bare::to_vec(&v2_entry) {
-											Ok(b) => b,
+										let v2_entry: proto_v2::ChangelogEntry = match rivet_util::serde::bare_from_slice!(
+											entry.value()
+										) {
+											Ok(v) => v,
 											Err(_) => {
 												v3_count += 1;
 												continue;
 											}
 										};
+										let reserialized =
+											match rivet_util::serde::bare_to_vec!(&v2_entry) {
+												Ok(b) => b,
+												Err(_) => {
+													v3_count += 1;
+													continue;
+												}
+											};
 										if reserialized != entry.value() {
 											v3_count += 1;
 											continue;

diff --git a/engine/packages/epoxy/src/http_client.rs b/engine/packages/epoxy/src/http_client.rs
@@ -179,7 +179,8 @@ async fn send_request_to_address(
 	let client = rivet_pools::reqwest::client().await?;
 
 	// Create the request
-	let request = serde_bare::to_vec(&request).context("failed to serialize epoxy request")?;
+	let request =
+		rivet_util::serde::bare_to_vec!(&request).context("failed to serialize epoxy request")?;
 
 	// Send the request
 	let response_result = client
@@ -223,7 +224,7 @@ async fn send_request_to_address(
 	}
 
 	let body = response.bytes().await?;
-	let response_body = serde_bare::from_slice(&body)?;
+	let response_body = rivet_util::serde::bare_from_slice!(&body)?;
 
 	tracing::debug!(
 		to_replica = to_replica_id,

diff --git a/engine/packages/epoxy/src/http_routes.rs b/engine/packages/epoxy/src/http_routes.rs
@@ -91,5 +91,5 @@ async fn handle_request(ctx: ApiCtx, request: protocol::Request) -> Result<Vec<u
 	metrics::record_request_result(kind_label, result_label);
 	perf_finish!(measure, fields: { result = %result_label });
 
-	serde_bare::to_vec(&res?).map_err(Into::into)
+	rivet_util::serde::bare_to_vec!(&res?).map_err(Into::into)
 }
diff --git a/engine/packages/epoxy/src/keys/keys.rs b/engine/packages/epoxy/src/keys/keys.rs
@@ -148,11 +148,11 @@ impl FormalKey for KvBallotKey {
 	type Value = protocol::Ballot;
 
 	fn deserialize(&self, raw: &[u8]) -> Result<Self::Value> {
-		serde_bare::from_slice(raw).map_err(Into::into)
+		rivet_util::serde::bare_from_slice!(raw).map_err(Into::into)
 	}
 
 	fn serialize(&self, value: Self::Value) -> Result<Vec<u8>> {
-		serde_bare::to_vec(&value).map_err(Into::into)
+		rivet_util::serde::bare_to_vec!(&value).map_err(Into::into)
 	}
 }
 
@@ -203,11 +203,11 @@ impl FormalKey for KvAcceptedKey {
 	type Value = KvAcceptedValue;
 
 	fn deserialize(&self, raw: &[u8]) -> Result<Self::Value> {
-		serde_bare::from_slice(raw).map_err(Into::into)
+		rivet_util::serde::bare_from_slice!(raw).map_err(Into::into)
 	}
 
 	fn serialize(&self, value: Self::Value) -> Result<Vec<u8>> {
-		serde_bare::to_vec(&value).map_err(Into::into)
+		rivet_util::serde::bare_to_vec!(&value).map_err(Into::into)
 	}
 }
 
@@ -368,11 +368,11 @@ impl FormalKey for ChangelogKey {
 	// TODO: this is mistakenly not versioned. Transition to vbare so future
 	// changes to ChangelogEntry don't require hand-rolled LegacyXxx fallbacks.
 	fn deserialize(&self, raw: &[u8]) -> Result<Self::Value> {
-		serde_bare::from_slice(raw).map_err(Into::into)
+		rivet_util::serde::bare_from_slice!(raw).map_err(Into::into)
 	}
 
 	fn serialize(&self, value: Self::Value) -> Result<Vec<u8>> {
-		serde_bare::to_vec(&value).map_err(Into::into)
+		rivet_util::serde::bare_to_vec!(&value).map_err(Into::into)
 	}
 }
 

diff --git a/engine/packages/epoxy/src/keys/replica.rs b/engine/packages/epoxy/src/keys/replica.rs
@@ -11,11 +11,11 @@ impl FormalKey for ConfigKey {
 	// TODO: this is mistakenly not versioned. Transition to vbare so future
 	// changes to ClusterConfig don't require hand-rolled LegacyXxx fallbacks.
 	fn deserialize(&self, raw: &[u8]) -> Result<Self::Value> {
-		serde_bare::from_slice(raw).map_err(Into::into)
+		rivet_util::serde::bare_from_slice!(raw).map_err(Into::into)
 	}
 
 	fn serialize(&self, value: Self::Value) -> Result<Vec<u8>> {
-		serde_bare::to_vec(&value).map_err(Into::into)
+		rivet_util::serde::bare_to_vec!(&value).map_err(Into::into)
 	}
 }
 

diff --git a/engine/packages/gasoline/src/workflow.rs b/engine/packages/gasoline/src/workflow.rs
@@ -33,7 +33,7 @@ impl<'a, T: DeserializeOwned + Serialize> StateGuard<'a, T> {
 	pub(crate) fn new(
 		guard: MutexGuard<'a, (Box<serde_json::value::RawValue>, bool)>,
 	) -> Result<Self> {
-		let value = rivet_util::observe!(serde_json::from_str::<T>(guard.0.get())?);
+		let value = rivet_util::serde::json_from_str!(guard.0.get())?;
 
 		Ok(Self {
 			guard,

diff --git a/engine/packages/pegboard-runner/Cargo.toml b/engine/packages/pegboard-runner/Cargo.toml
@@ -29,6 +29,7 @@ rivet-metrics.workspace = true
 rivet-runner-protocol.workspace = true
 rivet-runtime.workspace = true
 rivet-types.workspace = true
+rivet-util.workspace = true
 scc.workspace = true
 serde_bare.workspace = true
 serde_json.workspace = true

diff --git a/engine/packages/pegboard-runner/src/ws_to_tunnel_task.rs b/engine/packages/pegboard-runner/src/ws_to_tunnel_task.rs
@@ -1028,15 +1028,15 @@ async fn compat_ack_tunnel_message(conn: &Conn, payload: &[u8]) -> Result<()> {
 	use rivet_runner_protocol::generated::v2 as protocol_v2;
 
 	// Parse payload
-	let msg = serde_bare::from_slice::<protocol_v2::ToServer>(&payload)?;
+	let msg: protocol_v2::ToServer = rivet_util::serde::bare_from_slice!(&payload)?;
 	let protocol_v2::ToServer::ToServerTunnelMessage(msg) = msg else {
 		return Ok(());
 	};
 
 	tracing::debug!(?msg.request_id, ?msg.message_id, "sending v2 compat tunnel ack");
 
 	// Serialize response
-	let ack_msg = serde_bare::to_vec(&protocol_v2::ToClient::ToClientTunnelMessage(
+	let ack_msg = rivet_util::serde::bare_to_vec!(&protocol_v2::ToClient::ToClientTunnelMessage(
 		protocol_v2::ToClientTunnelMessage {
 			request_id: msg.request_id,
 			message_id: msg.message_id,