diff --git a/src/EventTrace.cc b/src/EventTrace.cc
index baac235a57..d313f7c3ea 100644
--- a/src/EventTrace.cc
+++ b/src/EventTrace.cc
@@ -314,13 +314,13 @@ void ValTrace::TraceTable(const TableValPtr& tv)
 void ValTrace::TraceVector(const VectorValPtr& vv)
 	{
 	auto& vec = vv->RawVec();
-	auto n = vec->size();
+	auto n = vec.size();
 	auto& yt = vv->RawYieldType();
 	auto& yts = vv->RawYieldTypes();
 
 	for ( auto i = 0U; i < n; ++i )
 		{
-		auto& elem = (*vec)[i];
+		auto& elem = vec[i];
 		if ( elem )
 			{
 			auto& t = yts ? (*yts)[i] : yt;
diff --git a/src/Stmt.cc b/src/Stmt.cc
index 58728517fd..9bccb790cf 100644
--- a/src/Stmt.cc
+++ b/src/Stmt.cc
@@ -1411,7 +1411,7 @@ ValPtr ForStmt::DoExec(Frame* f, Val* v, StmtFlowType& flow)
 	else if ( v->GetType()->Tag() == TYPE_VECTOR )
 		{
 		VectorVal* vv = v->AsVectorVal();
-		const auto& raw_vv = *vv->RawVec();
+		const auto& raw_vv = vv->RawVec();
 
 		for ( auto i = 0u; i < vv->Size(); ++i )
 			{
diff --git a/src/Val.cc b/src/Val.cc
index cf99dcf0d1..332bf554b5 100644
--- a/src/Val.cc
+++ b/src/Val.cc
@@ -3487,11 +3487,8 @@ ValPtr TypeVal::DoClone(CloneState* state)
 	return {NewRef{}, this};
 	}
 
-VectorVal::VectorVal(VectorTypePtr t) : VectorVal(t, new vector<std::optional<ZVal>>()) { }
-
-VectorVal::VectorVal(VectorTypePtr t, std::vector<std::optional<ZVal>>* vals) : Val(t)
+VectorVal::VectorVal(VectorTypePtr t) : Val(t)
 	{
-	vector_val = vals;
 	yield_type = t->Yield();
 
 	auto y_tag = yield_type->Tag();
@@ -3499,6 +3496,12 @@ VectorVal::VectorVal(VectorTypePtr t, std::vector<std::optional<ZVal>>* vals) :
 	managed_yield = ZVal::IsManagedType(yield_type);
 	}
 
+VectorVal::VectorVal(VectorTypePtr t, std::vector<std::optional<ZVal>>* vals) : VectorVal(t)
+	{
+	if ( vals )
+		vector_val = std::move(*vals);
+	}
+
 VectorVal::~VectorVal()
 	{
 	if ( yield_types )
@@ -3506,7 +3509,7 @@ VectorVal::~VectorVal()
 		int n = yield_types->size();
 		for ( auto i = 0; i < n; ++i )
 			{
-			auto& elem = (*vector_val)[i];
+			auto& elem = vector_val[i];
 			if ( elem )
 				ZVal::DeleteIfManaged(*elem, (*yield_types)[i]);
 			}
@@ -3515,17 +3518,15 @@ VectorVal::~VectorVal()
 
 	else if ( managed_yield )
 		{
-		for ( auto& elem : *vector_val )
+		for ( auto& elem : vector_val )
 			if ( elem )
 				ZVal::DeleteManagedType(*elem);
 		}
-
-	delete vector_val;
 	}
 
 ValPtr VectorVal::SizeVal() const
 	{
-	return val_mgr->Count(uint32_t(vector_val->size()));
+	return val_mgr->Count(uint32_t(vector_val.size()));
 	}
 
 bool VectorVal::CheckElementType(const ValPtr& element)
@@ -3540,7 +3541,7 @@ bool VectorVal::CheckElementType(const ValPtr& element)
 
 	if ( any_yield )
 		{
-		int n = vector_val->size();
+		int n = vector_val.size();
 
 		if ( n == 0 )
 			{
@@ -3574,14 +3575,14 @@ bool VectorVal::Assign(unsigned int index, ValPtr element)
 	if ( ! CheckElementType(element) )
 		return false;
 
-	unsigned int n = vector_val->size();
+	unsigned int n = vector_val.size();
 
 	if ( index >= n )
 		{
 		if ( index > n )
 			AddHoles(index - n);
 
-		vector_val->resize(index + 1);
+		vector_val.resize(index + 1);
 		if ( yield_types )
 			yield_types->resize(index + 1);
 		}
@@ -3590,14 +3591,14 @@ bool VectorVal::Assign(unsigned int index, ValPtr element)
 		{
 		const auto& t = element->GetType();
 		(*yield_types)[index] = t;
-		auto& elem = (*vector_val)[index];
+		auto& elem = vector_val[index];
 		if ( elem )
 			ZVal::DeleteIfManaged(*elem, t);
 		elem = ZVal(std::move(element), t);
 		}
 	else
 		{
-		auto& elem = (*vector_val)[index];
+		auto& elem = vector_val[index];
 		if ( managed_yield && elem )
 			ZVal::DeleteManagedType(*elem);
 
@@ -3630,17 +3631,17 @@ bool VectorVal::Insert(unsigned int index, ValPtr element)
 	vector<std::optional<ZVal>>::iterator it;
 	vector<TypePtr>::iterator types_it;
 
-	auto n = vector_val->size();
+	auto n = vector_val.size();
 
 	if ( index < n )
 		{ // Find location within existing vector elements.
-		it = std::next(vector_val->begin(), index);
+		it = std::next(vector_val.begin(), index);
 		if ( yield_types )
 			types_it = std::next(yield_types->begin(), index);
 		}
 	else
 		{
-		it = vector_val->end();
+		it = vector_val.end();
 		if ( yield_types )
 			types_it = yield_types->end();
 
@@ -3654,13 +3655,13 @@ bool VectorVal::Insert(unsigned int index, ValPtr element)
 			{
 			const auto& t = element->GetType();
 			yield_types->insert(types_it, t);
-			vector_val->insert(it, ZVal(std::move(element), t));
+			vector_val.insert(it, ZVal(std::move(element), t));
 			}
 		else
-			vector_val->insert(it, ZVal(std::move(element), yield_type));
+			vector_val.insert(it, ZVal(std::move(element), yield_type));
 		}
 	else
-		vector_val->insert(it, std::nullopt);
+		vector_val.insert(it, std::nullopt);
 
 	Modified();
 	return true;
@@ -3673,15 +3674,15 @@ void VectorVal::AddHoles(int nholes)
 		fill_t = base_type(TYPE_ANY);
 
 	for ( auto i = 0; i < nholes; ++i )
-		vector_val->emplace_back(std::nullopt);
+		vector_val.emplace_back(std::nullopt);
 	}
 
 bool VectorVal::Remove(unsigned int index)
 	{
-	if ( index >= vector_val->size() )
+	if ( index >= vector_val.size() )
 		return false;
 
-	auto it = std::next(vector_val->begin(), index);
+	auto it = std::next(vector_val.begin(), index);
 
 	if ( yield_types )
 		{
@@ -3697,7 +3698,7 @@ bool VectorVal::Remove(unsigned int index)
 			ZVal::DeleteManagedType(**it);
 		}
 
-	vector_val->erase(it);
+	vector_val.erase(it);
 
 	Modified();
 	return true;
@@ -3730,10 +3731,10 @@ bool VectorVal::AddTo(Val* val, bool /* is_first_init */) const
 
 ValPtr VectorVal::At(unsigned int index) const
 	{
-	if ( index >= vector_val->size() )
+	if ( index >= vector_val.size() )
 		return Val::nil;
 
-	auto& elem = (*vector_val)[index];
+	auto& elem = vector_val[index];
 	if ( ! elem )
 		return Val::nil;
 
@@ -3850,7 +3851,7 @@ void VectorVal::Sort(Func* cmp_func)
 			}
 		}
 
-	sort(vector_val->begin(), vector_val->end(), sort_func);
+	sort(vector_val.begin(), vector_val.end(), sort_func);
 	}
 
 VectorValPtr VectorVal::Order(Func* cmp_func)
@@ -3895,7 +3896,7 @@ VectorValPtr VectorVal::Order(Func* cmp_func)
 	for ( i = 0; i < n; ++i )
 		{
 		ind_vv[i] = i;
-		index_map.emplace_back(&(*vector_val)[i]);
+		index_map.emplace_back(&vector_val[i]);
 		}
 
 	sort(ind_vv.begin(), ind_vv.end(), sort_func);
@@ -3920,14 +3921,14 @@ bool VectorVal::Concretize(const TypePtr& t)
 		// shouldn't happen in any case.
 		return yield_type->Tag() == t->Tag();
 
-	if ( ! vector_val )
+	if ( vector_val.empty() )
 		// Trivially concretized.
 		return true;
 
-	auto n = vector_val->size();
+	auto n = vector_val.size();
 	for ( auto i = 0U; i < n; ++i )
 		{
-		auto& v = (*vector_val)[i];
+		auto& v = vector_val[i];
 		if ( ! v )
 			// Vector hole does not require concretization.
 			continue;
@@ -3960,7 +3961,7 @@ bool VectorVal::Concretize(const TypePtr& t)
 
 unsigned int VectorVal::ComputeFootprint(std::unordered_set<const Val*>* analyzed_vals) const
 	{
-	auto n = vector_val->size();
+	auto n = vector_val.size();
 	unsigned int fp = n;
 
 	for ( auto i = 0U; i < n; ++i )
@@ -3975,9 +3976,9 @@ unsigned int VectorVal::ComputeFootprint(std::unordered_set<const Val*>* analyze
 
 unsigned int VectorVal::Resize(unsigned int new_num_elements)
 	{
-	unsigned int oldsize = vector_val->size();
-	vector_val->reserve(new_num_elements);
-	vector_val->resize(new_num_elements);
+	unsigned int oldsize = vector_val.size();
+	vector_val.reserve(new_num_elements);
+	vector_val.resize(new_num_elements);
 
 	if ( yield_types )
 		{
@@ -3990,7 +3991,7 @@ unsigned int VectorVal::Resize(unsigned int new_num_elements)
 
 unsigned int VectorVal::ResizeAtLeast(unsigned int new_num_elements)
 	{
-	unsigned int old_size = vector_val->size();
+	unsigned int old_size = vector_val.size();
 	if ( new_num_elements <= old_size )
 		return old_size;
 
@@ -3999,7 +4000,7 @@ unsigned int VectorVal::ResizeAtLeast(unsigned int new_num_elements)
 
 void VectorVal::Reserve(unsigned int num_elements)
 	{
-	vector_val->reserve(num_elements);
+	vector_val.reserve(num_elements);
 
 	if ( yield_types )
 		yield_types->reserve(num_elements);
@@ -4008,10 +4009,10 @@ void VectorVal::Reserve(unsigned int num_elements)
 ValPtr VectorVal::DoClone(CloneState* state)
 	{
 	auto vv = make_intrusive<VectorVal>(GetType<VectorType>());
-	vv->Reserve(vector_val->size());
+	vv->Reserve(vector_val.size());
 	state->NewClone(this, vv);
 
-	int n = vector_val->size();
+	int n = vector_val.size();
 
 	for ( auto i = 0; i < n; ++i )
 		{
@@ -4026,7 +4027,7 @@ void VectorVal::ValDescribe(ODesc* d) const
 	{
 	d->Add("[");
 
-	size_t vector_size = vector_val->size();
+	size_t vector_size = vector_val.size();
 
 	if ( vector_size != 0 )
 		{
diff --git a/src/Val.h b/src/Val.h
index 7e90f9ad03..31acb6e68c 100644
--- a/src/Val.h
+++ b/src/Val.h
@@ -1592,7 +1592,7 @@ public:
 	// Returns true if successful.
 	bool AddTo(Val* v, bool is_first_init) const override;
 
-	unsigned int Size() const { return vector_val->size(); }
+	unsigned int Size() const { return vector_val.size(); }
 
 	// Is there any way to reclaim previously-allocated memory when you
 	// shrink a vector?  The return value is the old size.
@@ -1662,10 +1662,7 @@ public:
 
 	ValPtr ValAt(unsigned int index) const { return At(index); }
 
-	bool Has(unsigned int index) const
-		{
-		return index < vector_val->size() && (*vector_val)[index];
-		}
+	bool Has(unsigned int index) const { return index < vector_val.size() && vector_val[index]; }
 
 	/**
 	 * Returns the given element in a given underlying representation.
@@ -1675,26 +1672,17 @@ public:
 	 * @param index  The position in the vector of the element to return.
 	 * @return  The element's underlying value.
 	 */
-	zeek_int_t IntAt(unsigned int index) const { return (*vector_val)[index]->int_val; }
-	zeek_uint_t CountAt(unsigned int index) const { return (*vector_val)[index]->uint_val; }
-	double DoubleAt(unsigned int index) const { return (*vector_val)[index]->double_val; }
-	const RecordVal* RecordValAt(unsigned int index) const
-		{
-		return (*vector_val)[index]->record_val;
-		}
-	bool BoolAt(unsigned int index) const
-		{
-		return static_cast<bool>((*vector_val)[index]->uint_val);
-		}
-	const StringVal* StringValAt(unsigned int index) const
-		{
-		return (*vector_val)[index]->string_val;
-		}
+	zeek_int_t IntAt(unsigned int index) const { return vector_val[index]->int_val; }
+	zeek_uint_t CountAt(unsigned int index) const { return vector_val[index]->uint_val; }
+	double DoubleAt(unsigned int index) const { return vector_val[index]->double_val; }
+	const RecordVal* RecordValAt(unsigned int index) const { return vector_val[index]->record_val; }
+	bool BoolAt(unsigned int index) const { return static_cast<bool>(vector_val[index]->uint_val); }
+	const StringVal* StringValAt(unsigned int index) const { return vector_val[index]->string_val; }
 	const String* StringAt(unsigned int index) const { return StringValAt(index)->AsString(); }
 
 	// Only intended for low-level access by internal or compiled code.
-	const auto& RawVec() const { return vector_val; }
-	auto& RawVec() { return vector_val; }
+	const std::vector<std::optional<ZVal>>& RawVec() const { return vector_val; }
+	std::vector<std::optional<ZVal>>& RawVec() { return vector_val; }
 
 	const auto& RawYieldType() const { return yield_type; }
 	const auto& RawYieldTypes() const { return yield_types; }
@@ -1730,7 +1718,7 @@ private:
 	// Add the given number of "holes" to the end of a vector.
 	void AddHoles(int nholes);
 
-	std::vector<std::optional<ZVal>>* vector_val;
+	std::vector<std::optional<ZVal>> vector_val;
 
 	// For homogeneous vectors (the usual case), the type of the
 	// elements.  Will be TYPE_VOID for empty vectors created using
diff --git a/src/logging/Manager.cc b/src/logging/Manager.cc
index e938a3f140..28db8f41cf 100644
--- a/src/logging/Manager.cc
+++ b/src/logging/Manager.cc
@@ -1113,7 +1113,7 @@ threading::Value* Manager::ValToLogVal(std::optional<ZVal>& val, Type* ty)
 
 			for ( zeek_int_t i = 0; i < lval->val.vector_val.size; i++ )
 				{
-				lval->val.vector_val.vals[i] = ValToLogVal((*vv)[i], vt.get());
+				lval->val.vector_val.vals[i] = ValToLogVal(vv[i], vt.get());
 				}
 
 			break;
diff --git a/src/script_opt/ZAM/Ops.in b/src/script_opt/ZAM/Ops.in
index 2d555aaaee..09df3828b4 100644
--- a/src/script_opt/ZAM/Ops.in
+++ b/src/script_opt/ZAM/Ops.in
@@ -364,7 +364,7 @@ eval	auto vv = frame[z.v1].vector_val;
 		vv->Assign(0, $1.ToVal(z.t));
 	else
 		{
-		vv->RawVec()->push_back(CopyVal($1));
+		vv->RawVec().push_back(CopyVal($1));
 		vv->Modified();
 		}
 
@@ -876,9 +876,9 @@ eval	AssignV1(frame[z.v2].int_val ? CopyVal(z.c) : CopyVal(frame[z.v3]))
 op Bool-Vec-Cond
 type VVVV
 set-type $2
-eval	auto& vsel = *frame[z.v2].vector_val->RawVec();
-	auto& v1 = *frame[z.v3].vector_val->RawVec();
-	auto& v2 = *frame[z.v4].vector_val->RawVec();
+eval	auto& vsel = frame[z.v2].vector_val->RawVec();
+	auto& v1 = frame[z.v3].vector_val->RawVec();
+	auto& v2 = frame[z.v4].vector_val->RawVec();
 	auto n = v1.size();
 	auto res = new vector<std::optional<ZVal>>(n);
 	for ( auto i = 0U; i < n; ++i )
@@ -968,11 +968,11 @@ eval	EvalIndexVec(frame[z.v3].uint_val)
 
 macro EvalIndexVec(index)
 	auto& vv = frame[z.v2].vector_val->RawVec();
-	const auto& vec = *vv;
+	const auto& vec = vv;
 	zeek_int_t ind = index;
 	if ( ind < 0 )
-		ind += vv->size();
-	if ( ind < 0 || ind >= vv->size() )
+		ind += vv.size();
+	if ( ind < 0 || ind >= vv.size() )
 		ZAM_run_time_error(z.loc, "no such index");
 	AssignV1(CopyVal(*vec[ind]))
 
@@ -1847,7 +1847,7 @@ internal-op Init-Vector-Loop
 type VV
 op1-read
 eval	auto& vv = frame[z.v1].vector_val->RawVec();
-	step_iters[z.v2].InitLoop(vv);
+	step_iters[z.v2].InitLoop(&vv);
 
 macro NextVectorIterCore(info, branch)
 	auto& si = step_iters[info];
diff --git a/src/script_opt/ZAM/ZBody.cc b/src/script_opt/ZAM/ZBody.cc
index 63ebe9a7e4..a63361ec51 100644
--- a/src/script_opt/ZAM/ZBody.cc
+++ b/src/script_opt/ZAM/ZBody.cc
@@ -60,7 +60,7 @@ static bool copy_vec_elem(VectorVal* vv, zeek_uint_t ind, ZVal zv, const TypePtr
 	if ( vv->Size() <= ind )
 		vv->Resize(ind + 1);
 
-	auto& elem = (*vv->RawVec())[ind];
+	auto& elem = vv->RawVec()[ind];
 
 	if ( ! ZVal::IsManagedType(t) )
 		{
@@ -96,12 +96,12 @@ static void vec_exec(ZOp op, TypePtr t, VectorVal*& v1, const VectorVal* v2, con
 #define VEC_COERCE(tag, lhs_type, cast, rhs_accessor, ov_check, ov_err)                            \
 	static VectorVal* vec_coerce_##tag(VectorVal* vec, const ZInst& z)                             \
 		{                                                                                          \
-		auto& v = *vec->RawVec();                                                                  \
+		auto& v = vec->RawVec();                                                                   \
 		auto yt = make_intrusive<VectorType>(base_type(lhs_type));                                 \
 		auto res_zv = new VectorVal(yt);                                                           \
 		auto n = v.size();                                                                         \
 		res_zv->Resize(n);                                                                         \
-		auto& res = *res_zv->RawVec();                                                             \
+		auto& res = res_zv->RawVec();                                                              \
 		for ( auto i = 0U; i < n; ++i )                                                            \
 			if ( v[i] )                                                                            \
 				{                                                                                  \
@@ -479,7 +479,7 @@ static void vec_exec(ZOp op, TypePtr t, VectorVal*& v1, const VectorVal* v2, con
 	// well move the whole kit-and-caboodle into the Exec method).  But
 	// that seems like a lot of code bloat for only a very modest gain.
 
-	auto& vec2 = *v2->RawVec();
+	auto& vec2 = v2->RawVec();
 	auto n = vec2.size();
 	auto vec1_ptr = new vector<std::optional<ZVal>>(n);
 	auto& vec1 = *vec1_ptr;
@@ -511,8 +511,8 @@ static void vec_exec(ZOp op, TypePtr t, VectorVal*& v1, const VectorVal* v2, con
 	{
 	// See comment above re further speed-up.
 
-	auto& vec2 = *v2->RawVec();
-	auto& vec3 = *v3->RawVec();
+	auto& vec2 = v2->RawVec();
+	auto& vec3 = v3->RawVec();
 	auto n = vec2.size();
 	auto vec1_ptr = new vector<std::optional<ZVal>>(n);
 	auto& vec1 = *vec1_ptr;