From 22d2240994be3fbd93ccbcd7d75897a57f6a77c3 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 5 Dec 2025 16:28:10 +0000
Subject: [PATCH 01/26] Switch from old stable version to pending PR for
 mainline adoption

---
 cmake/FindEXT_TENSORSTORE.cmake | 17 ++++++++++++-----
 mdio/dataset.h                  | 14 +++++++++-----
 mdio/variable.h                 |  7 +++++--
 3 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/cmake/FindEXT_TENSORSTORE.cmake b/cmake/FindEXT_TENSORSTORE.cmake
index 250f4fc..101b38b 100644
--- a/cmake/FindEXT_TENSORSTORE.cmake
+++ b/cmake/FindEXT_TENSORSTORE.cmake
@@ -3,11 +3,18 @@ IF ( NOT TARGET tensorstore )
 
  include(FetchContent)
 
- FetchContent_Declare(
-  tensorstore
-  GIT_REPOSITORY
-  https://github.com/brian-michell/tensorstore.git
-  GIT_TAG v0.1.63_latest
+#  FetchContent_Declare(
+#   tensorstore
+#   GIT_REPOSITORY
+#   https://github.com/brian-michell/tensorstore.git
+#   GIT_TAG v0.1.63_latest
+# )
+
+FetchContent_Declare(
+ tensorstore
+ GIT_REPOSITORY
+ https://github.com/BrianMichell/tensorstore.git
+ GIT_TAG v3_structs
 )
 
 FetchContent_MakeAvailable(tensorstore)
diff --git a/mdio/dataset.h b/mdio/dataset.h
index 150940b..71590b4 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -36,6 +36,8 @@
 #include "mdio/variable_collection.h"
 #include "tensorstore/driver/zarr/metadata.h"
 #include "tensorstore/util/future.h"
+#include "tensorstore/util/option.h"
+#include "tensorstore/util/status.h"
 
 // clang-format off
 #include <nlohmann/json-schema.hpp>  // NOLINT
@@ -1051,8 +1053,9 @@ class Dataset {
   template <typename S = std::string, typename... Option>
   static std::enable_if_t<(std::is_same_v<S, std::string>), Future<Dataset>>
   Open(const S& dataset_path, Option&&... options) {
-    TENSORSTORE_INTERNAL_ASSIGN_OPTIONS_OR_RETURN(TransactionalOpenOptions,
-                                                  transact_options, options)
+    TransactionalOpenOptions transact_options;
+    TENSORSTORE_RETURN_IF_ERROR(
+        tensorstore::internal::SetAll(transact_options, options...));
 
     if (transact_options.open_mode != constants::kOpen) {
       return absl::Status(absl::StatusCode::kInvalidArgument,
@@ -1060,7 +1063,7 @@ class Dataset {
     }
 
     MDIO_ASSIGN_OR_RETURN(auto params_from_zmetadata,
-                          mdio::internal::from_zmetadata(dataset_path).result())
+                          mdio::internal::from_zmetadata(dataset_path).result());
     auto [dataset_metadata, json_vars] = params_from_zmetadata;
 
     return mdio::Dataset::Open(dataset_metadata, json_vars,
@@ -1083,8 +1086,9 @@ class Dataset {
       const std::vector<::nlohmann::json>& json_variables,
       Option&&... options) {
     // I need to know if we are intending to create a dataset from scratch?
-    TENSORSTORE_INTERNAL_ASSIGN_OPTIONS_OR_RETURN(TransactionalOpenOptions,
-                                                  transact_options, options)
+    TransactionalOpenOptions transact_options;
+    TENSORSTORE_RETURN_IF_ERROR(
+        tensorstore::internal::SetAll(transact_options, options...));
     bool do_create = transact_options.open_mode == constants::kCreateClean ||
                      transact_options.open_mode == constants::kCreate;
 
diff --git a/mdio/variable.h b/mdio/variable.h
index eedebdc..cc202fc 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -41,6 +41,8 @@
 #include "tensorstore/stack.h"
 #include "tensorstore/tensorstore.h"
 #include "tensorstore/util/future.h"
+#include "tensorstore/util/option.h"
+#include "tensorstore/util/status.h"
 
 // clang-format off
 #include <nlohmann/json.hpp>  // NOLINT
@@ -809,8 +811,9 @@ class Variable {
                               TransactionalOpenOptions, Option...>),
                           Future<Variable<T, R, M>>>
   Open(const nlohmann::json& json_spec, Option&&... option) {
-    TENSORSTORE_INTERNAL_ASSIGN_OPTIONS_OR_RETURN(TransactionalOpenOptions,
-                                                  options, option)
+    TransactionalOpenOptions options;
+    TENSORSTORE_RETURN_IF_ERROR(tensorstore::internal::SetAll(
+        options, std::forward<Option>(option)...));
     return mdio::internal::Open<T, R, M>(json_spec, std::move(options));
   }
 

From eb31d966f1333be940015ab36f0fc5a2af6f93fa Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 5 Dec 2025 20:59:27 +0000
Subject: [PATCH 02/26] Apply minimal updates to get working

---
 mdio/acceptance_test.cc |  4 ++--
 mdio/dataset.h          |  7 ++++---
 mdio/variable.h         | 33 ++++++++++++++++++++++++++-------
 mdio/variable_test.cc   | 19 ++++++++++++++++---
 4 files changed, 48 insertions(+), 15 deletions(-)

diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index c464291..18198ec 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -1436,11 +1436,11 @@ TEST(Dataset, open) {
 TEST(Dataset, condensed) {
   std::string path = "zarrs/acceptance/";
   auto ds = mdio::Dataset::Open(path, mdio::constants::kOpen);
-  ASSERT_TRUE(ds.status().ok()) << ds.status();
+  ASSERT_TRUE(ds.status().ok()) << "Failed in test 1 of 2: " << ds.status();
 
   std::string missingSlashPath = "zarrs/acceptance";
   auto ds2 = mdio::Dataset::Open(missingSlashPath, mdio::constants::kOpen);
-  ASSERT_TRUE(ds2.status().ok()) << ds2.status();
+  ASSERT_TRUE(ds2.status().ok()) << "Failed in test 2 of 2: " << ds2.status();
 }
 
 TEST(Dataset, read) {
diff --git a/mdio/dataset.h b/mdio/dataset.h
index 71590b4..4891135 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -374,7 +374,8 @@ from_zmetadata(const std::string& dataset_path) {
       nlohmann::json new_dict = {
           {"driver", "zarr"},
           {"kvstore",
-           {{"driver", driver}, {"path", dataset_path + "/" + variable_name}}}};
+           // {{"driver", driver}, {"path", dataset_path + "/" + variable_name}}}};
+    {{"driver", driver}, {"path", dataset_path + variable_name}}}};
       if (driver != "file") {
         new_dict["kvstore"]["bucket"] = bucket;
         new_dict["kvstore"]["path"] = cloudPath + variable_name;
@@ -1298,8 +1299,8 @@ class Dataset {
     if (specJson["kvstore"].contains("bucket")) {
       base["kvstore"]["bucket"] = specJson["kvstore"]["bucket"];
       std::string cloudPath = base["kvstore"]["path"].get<std::string>();
-      cloudPath
-          .pop_back();  // We need to remove the trailing / from a cloud path
+      // cloudPath
+      //     .pop_back();  // We need to remove the trailing / from a cloud path
       base["kvstore"]["path"] = cloudPath;
     }
 
diff --git a/mdio/variable.h b/mdio/variable.h
index cc202fc..f5448f4 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -424,13 +424,13 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   // void.
   auto do_handle_structarray =
       zarr_dtype.has_fields && !json_spec.contains("field");
-  auto json_spec_with_field = json_spec;
+  auto json_spec_with_open_flag = json_spec;
   if (do_handle_structarray) {
     // pick the first name, it won't effect the .zarray json:
-    json_spec_with_field["field"] = zarr_dtype.fields[0].name;
+    json_spec_with_open_flag["field"] = zarr_dtype.fields[0].name;
   }
 
-  auto json_spec_without_metadata = json_spec;
+  auto json_spec_without_metadata = json_spec_with_open_flag;
   json_spec_without_metadata.erase("metadata");
   auto future_json_store = tensorstore::MakeReadyFuture<::nlohmann::json>(
       json_spec_without_metadata);
@@ -462,7 +462,8 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
         output_json.erase("coordinates");
       }
     }
-    std::string outpath = "/.zattrs";
+    // std::string outpath = "/.zattrs";
+    std::string outpath = ".zattrs";
     if (isCloudStore) {
       outpath = ".zattrs";
     }
@@ -478,7 +479,12 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   auto apply_reopen = [](const tensorstore::TensorStore<T, R, M>& store,
                          const ::nlohmann::json& attributes,
                          const ::nlohmann::json& json_spec) {
-    return tensorstore::Open<T, R, M>(json_spec);
+    // try {
+    auto json_spec_cpy = json_spec;
+        json_spec_cpy.erase("field");
+        json_spec_cpy["open_as_void"] = true;
+    // } catch (ex)
+    return tensorstore::Open<T, R, M>(json_spec_cpy);
   };
 
   auto build = [](const ::nlohmann::json& metadata,
@@ -500,7 +506,7 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
 
   // Start by creating a future for the store ...
   auto future_store = tensorstore::Open<T, R, M>(
-      json_spec_with_field, std::forward<Option>(options)...);
+      json_spec_with_open_flag, std::forward<Option>(options)...);
 
   auto handled_store = future_store;
   if (do_handle_structarray) {
@@ -595,6 +601,7 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
   auto read = [](const tensorstore::KvStore& kvstore)
       -> Future<tensorstore::kvstore::ReadResult> {
     return tensorstore::kvstore::Read(kvstore, "/.zattrs");
+    // return tensorstore::kvstore::Read(kvstore, ".zattrs");
   };
 
   // go read the attributes return json ...
@@ -709,6 +716,17 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
   auto metadata = tensorstore::MapFutureValue(tensorstore::InlineExecutor{},
                                               parse, kvs_read_future, spec);
 
+  if (!future_store.status().ok()) {
+      std::string status_message = future_store.status().ToString();
+      if (status_message.find("Must specify a \"field\"") != std::string::npos && !store_spec.contains("open_as_void")) {
+          std::cout << "Detected a structured Variable without a field or void flag. Retrying with void flag..." << std::endl;
+          // store_spec["open_as_void"] = true;
+          auto cpy = json_store;
+          cpy["open_as_void"] = true;
+          return OpenVariable<T, R, M>(cpy, std::forward<Option>(options)...);
+      }
+  }
+
   return tensorstore::MapFutureValue(
       tensorstore::InlineExecutor{}, make_variable, metadata, future_store,
       tensorstore::MakeReadyFuture<::nlohmann::json>(suppliedAttributes));
@@ -1254,7 +1272,8 @@ class Variable {
         output_json["attributes"]["coordinates"] = output_json["coordinates"];
         output_json.erase("coordinates");
       }
-      std::string outpath = "/.zattrs";
+      // std::string outpath = "/.zattrs";
+      std::string outpath = ".zattrs";
       if (isCloudStore) {
         outpath = ".zattrs";
       }
diff --git a/mdio/variable_test.cc b/mdio/variable_test.cc
index 79cfeb8..dfd188e 100644
--- a/mdio/variable_test.cc
+++ b/mdio/variable_test.cc
@@ -269,11 +269,17 @@ TEST(Variable, context) {
 }
 
 TEST(Variable, structArray) {
+  // GTEST_SKIP() << "Struct arrays will need more work";
   // tests the struct array on creation
   auto json_spec = GetJsonSpecStruct();
 
-  auto variable =
-      mdio::Variable<>::Open(json_spec, mdio::constants::kCreateClean).result();
+  // auto variable =
+  //     mdio::Variable<>::Open(json_spec, mdio::constants::kCreateClean).result();
+  auto varRes = mdio::Variable<>::Open(json_spec, mdio::constants::kCreateClean);
+  if (!varRes.status().ok()) {
+      std::cout << varRes.status() << std::endl;
+  }
+  auto variable = varRes.result();
 
   ASSERT_TRUE(variable.ok());
 
@@ -291,6 +297,7 @@ TEST(Variable, structArray) {
 }
 
 TEST(Variable, structArrayField) {
+  // GTEST_SKIP() << "Struct arrays will need more work";
   auto json_spec = GetJsonSpecStruct();
   json_spec["field"] = "a";
 
@@ -310,6 +317,7 @@ TEST(Variable, structArrayField) {
 }
 
 TEST(Variable, structArrayOpen) {
+  // GTEST_SKIP() << "Struct arrays will need more work";
   // tests the struct array on open
   auto json_spec = GetJsonSpecStruct();
 
@@ -324,7 +332,12 @@ TEST(Variable, structArrayOpen) {
   open_json_spec.erase("attributes");
 
   // opens the file ...
-  variable = mdio::Variable<>::Open(open_json_spec).result();
+  // variable = mdio::Variable<>::Open(open_json_spec).result();
+  auto varRes = mdio::Variable<>::Open(open_json_spec);
+  if (!varRes.status().ok()) {
+      std::cout << varRes.status() << std::endl;
+  }
+  variable = varRes.result();
 
   ASSERT_TRUE(variable.ok());
 

From e500bfd00a3f41bdb2fde176ed9ee907af00c79b Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Mon, 8 Dec 2025 15:56:02 +0000
Subject: [PATCH 03/26] Updates to support both drivers

---
 mdio/CMakeLists.txt        |   52 ++
 mdio/acceptance_test_v3.cc | 1330 ++++++++++++++++++++++++++++++++++++
 mdio/dataset.h             |  332 ++-------
 mdio/dataset_factory.h     |  329 ++++++---
 mdio/variable.h            |  167 +++--
 mdio/zarr/zarr.h           |  199 ++++++
 mdio/zarr/zarr_driver.h    |  219 ++++++
 mdio/zarr/zarr_test.cc     |  517 ++++++++++++++
 mdio/zarr/zarr_v2.h        |  499 ++++++++++++++
 mdio/zarr/zarr_v3.h        |  514 ++++++++++++++
 10 files changed, 3728 insertions(+), 430 deletions(-)
 create mode 100644 mdio/acceptance_test_v3.cc
 create mode 100644 mdio/zarr/zarr.h
 create mode 100644 mdio/zarr/zarr_driver.h
 create mode 100644 mdio/zarr/zarr_test.cc
 create mode 100644 mdio/zarr/zarr_v2.h
 create mode 100644 mdio/zarr/zarr_v3.h

diff --git a/mdio/CMakeLists.txt b/mdio/CMakeLists.txt
index 47fc89f..f26be9e 100644
--- a/mdio/CMakeLists.txt
+++ b/mdio/CMakeLists.txt
@@ -186,6 +186,7 @@ mdio_cc_test(
   GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack
@@ -209,6 +210,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack
@@ -232,6 +234,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::tensorstore
@@ -255,6 +258,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack
@@ -357,3 +361,51 @@ mdio_cc_test(
     tensorstore::util_status_testutil
     nlohmann_json_schema_validator
 )
+
+mdio_cc_test(
+  NAME
+    zarr_test
+  SRCS
+    zarr/zarr_test.cc
+  COPTS
+    ${mdio_DEFAULT_COPTS} 
+  LINKOPTS
+    ${mdio_DEFAULT_LINKOPTS}
+  DEPS
+    GTest::gmock_main
+    tensorstore::driver_array
+    tensorstore::driver_zarr
+    tensorstore::driver_zarr3
+    tensorstore::driver_json
+    tensorstore::kvstore_file
+    tensorstore::tensorstore
+    tensorstore::stack
+    tensorstore::index_space_dim_expression
+    tensorstore::index_space_index_transform
+    tensorstore::util_status_testutil
+    nlohmann_json_schema_validator
+)
+
+mdio_cc_test(
+  NAME
+    acceptance_test_v3
+  SRCS
+    acceptance_test_v3.cc
+  COPTS
+    ${mdio_DEFAULT_COPTS} 
+  LINKOPTS
+    ${mdio_DEFAULT_LINKOPTS}
+  DEPS
+    GTest::gmock_main
+    tensorstore::driver_array
+    tensorstore::driver_zarr
+    tensorstore::driver_zarr3
+    tensorstore::driver_json
+    tensorstore::kvstore_file
+    tensorstore::stack
+    tensorstore::tensorstore
+    tensorstore::index_space_dim_expression
+    tensorstore::index_space_index_transform
+    tensorstore::util_status_testutil
+    nlohmann_json_schema_validator
+)
diff --git a/mdio/acceptance_test_v3.cc b/mdio/acceptance_test_v3.cc
new file mode 100644
index 0000000..d92fe78
--- /dev/null
+++ b/mdio/acceptance_test_v3.cc
@@ -0,0 +1,1330 @@
+// Copyright 2024 TGS
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file acceptance_test_v3.cc
+ * @brief Acceptance tests for Zarr V3 driver support.
+ *
+ * This file contains tests that verify the MDIO library works correctly
+ * with the Zarr V3 format, including variable creation, reading, writing,
+ * and dataset operations.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <cstdlib>
+#include <filesystem>
+#include <nlohmann/json.hpp>  // NOLINT
+
+#include "mdio/dataset.h"
+#include "mdio/dataset_factory.h"
+#include "mdio/zarr/zarr.h"
+
+namespace {
+
+constexpr char FILE_PATH_BASE_V3[] = "./zarrs/acceptance_v3/";
+
+namespace VariableTestingV3 {
+
+using float16_t = mdio::dtypes::float_16_t;
+
+// Base specs for Zarr V3 variables (without full metadata - used for opening)
+nlohmann::json i2Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/i2"
+        }
+    }
+)"_json;
+
+nlohmann::json i4Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/i4"
+        }
+    }
+)"_json;
+
+nlohmann::json i8Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/i8"
+        }
+    }
+)"_json;
+
+nlohmann::json f2Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/f2"
+        }
+    }
+)"_json;
+
+nlohmann::json f4Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/f4"
+        }
+    }
+)"_json;
+
+nlohmann::json f8Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/f8"
+        }
+    }
+)"_json;
+
+nlohmann::json u2Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/u2"
+        }
+    }
+)"_json;
+
+nlohmann::json u4Base = R"(
+    {
+        "driver": "zarr3",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance_v3/u4"
+        }
+    }
+)"_json;
+
+// Test to set up some pre-existing elements for testing with Zarr V3
+TEST(VariableV3, SETUP) {
+  mdio::TransactionalOpenOptions options;
+  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
+
+  // int16 variable - using minimal V3 spec format
+  nlohmann::json i2Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/i2"
+            },
+            "metadata": {
+                "data_type": "int16",
+                "shape": [10, 10],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [5, 5]}
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {"separator": "/"}
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "long_name": "2-byte integer test",
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
+  auto [i2Store, i2Metadata] = i2Schema;
+  auto i2 =
+      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+
+  // int32 variable
+  nlohmann::json i4Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/i4"
+            },
+            "metadata": {
+                "data_type": "int32",
+                "shape": [10, 10],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [5, 5]}
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {"separator": "/"}
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "long_name": "4-byte integer test",
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto i4Schema = mdio::internal::ValidateAndProcessJson(i4Spec).value();
+  auto [i4Store, i4Metadata] = i4Schema;
+  auto i4 =
+      mdio::internal::CreateVariable(i4Store, i4Metadata, std::move(options));
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+
+  // int64 variable
+  nlohmann::json i8Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/i8"
+            },
+            "metadata": {
+                "data_type": "int64",
+                "shape": [10, 10],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [5, 5]}
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {"separator": "/"}
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "long_name": "8-byte integer test",
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto i8Schema = mdio::internal::ValidateAndProcessJson(i8Spec).value();
+  auto [i8Store, i8Metadata] = i8Schema;
+  auto i8 =
+      mdio::internal::CreateVariable(i8Store, i8Metadata, std::move(options));
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+
+  // float16 variable
+  nlohmann::json f2Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/f2"
+            },
+            "metadata": {
+                "data_type": "float16",
+                "shape": [10, 10],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [5, 5]}
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {"separator": "/"}
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "long_name": "2-byte float test",
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto f2Schema = mdio::internal::ValidateAndProcessJson(f2Spec).value();
+  auto [f2Store, f2Metadata] = f2Schema;
+  auto f2 =
+      mdio::internal::CreateVariable(f2Store, f2Metadata, std::move(options));
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+
+  // float32 variable
+  nlohmann::json f4Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/f4"
+            },
+            "metadata": {
+                "data_type": "float32",
+                "shape": [10, 10],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [5, 5]}
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {"separator": "/"}
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "long_name": "4-byte float test",
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto f4Schema = mdio::internal::ValidateAndProcessJson(f4Spec).value();
+  auto [f4Store, f4Metadata] = f4Schema;
+  auto f4 =
+      mdio::internal::CreateVariable(f4Store, f4Metadata, std::move(options));
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+
+  // float64 variable
+  nlohmann::json f8Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/f8"
+            },
+            "metadata": {
+                "data_type": "float64",
+                "shape": [10, 10],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [5, 5]}
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {"separator": "/"}
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {
+                "long_name": "8-byte float test",
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto f8Schema = mdio::internal::ValidateAndProcessJson(f8Spec).value();
+  auto [f8Store, f8Metadata] = f8Schema;
+  auto f8 =
+      mdio::internal::CreateVariable(f8Store, f8Metadata, std::move(options));
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+}
+
+TEST(VariableV3, open) {
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(i2Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(i4Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(i8Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(f2Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(f4Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(f8Base, mdio::constants::kOpen).status().ok());
+}
+
+TEST(VariableV3, name) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().get_variable_name(), "i2")
+      << i2.value().get_variable_name();
+  EXPECT_EQ(i4.value().get_variable_name(), "i4")
+      << i4.value().get_variable_name();
+  EXPECT_EQ(i8.value().get_variable_name(), "i8")
+      << i8.value().get_variable_name();
+  EXPECT_EQ(f2.value().get_variable_name(), "f2")
+      << f2.value().get_variable_name();
+  EXPECT_EQ(f4.value().get_variable_name(), "f4")
+      << f4.value().get_variable_name();
+  EXPECT_EQ(f8.value().get_variable_name(), "f8")
+      << f8.value().get_variable_name();
+}
+
+TEST(VariableV3, longName) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().get_long_name(), "2-byte integer test")
+      << i2.value().get_long_name();
+  EXPECT_EQ(i4.value().get_long_name(), "4-byte integer test")
+      << i4.value().get_long_name();
+  EXPECT_EQ(i8.value().get_long_name(), "8-byte integer test")
+      << i8.value().get_long_name();
+  EXPECT_EQ(f2.value().get_long_name(), "2-byte float test")
+      << f2.value().get_long_name();
+  EXPECT_EQ(f4.value().get_long_name(), "4-byte float test")
+      << f4.value().get_long_name();
+  EXPECT_EQ(f8.value().get_long_name(), "8-byte float test")
+      << f8.value().get_long_name();
+}
+
+TEST(VariableV3, optionalAttrs) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().GetAttributes()["attributes"]["foo"], "bar")
+      << i2.value().GetAttributes();
+  EXPECT_EQ(i4.value().GetAttributes()["attributes"]["foo"], "bar")
+      << i4.value().GetAttributes();
+  EXPECT_EQ(i8.value().GetAttributes()["attributes"]["foo"], "bar")
+      << i8.value().GetAttributes();
+  EXPECT_EQ(f2.value().GetAttributes()["attributes"]["foo"], "bar")
+      << f2.value().GetAttributes();
+  EXPECT_EQ(f4.value().GetAttributes()["attributes"]["foo"], "bar")
+      << f4.value().GetAttributes();
+  EXPECT_EQ(f8.value().GetAttributes()["attributes"]["foo"], "bar")
+      << f8.value().GetAttributes();
+}
+
+TEST(VariableV3, namedDimensions) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().getMetadata()["dimension_names"].size(), 2)
+      << i2.value().getMetadata();
+  EXPECT_EQ(i4.value().getMetadata()["dimension_names"].size(), 2)
+      << i4.value().getMetadata();
+  EXPECT_EQ(i8.value().getMetadata()["dimension_names"].size(), 2)
+      << i8.value().getMetadata();
+  EXPECT_EQ(f2.value().getMetadata()["dimension_names"].size(), 2)
+      << f2.value().getMetadata();
+  EXPECT_EQ(f4.value().getMetadata()["dimension_names"].size(), 2)
+      << f4.value().getMetadata();
+  EXPECT_EQ(f8.value().getMetadata()["dimension_names"].size(), 2)
+      << f8.value().getMetadata();
+}
+
+TEST(VariableV3, sliceByDimIdx) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
+
+  auto i2Slice = i2.value().slice(zeroIdxSlice, oneIdxSlice);
+  auto i4Slice = i4.value().slice(zeroIdxSlice, oneIdxSlice);
+  auto i8Slice = i8.value().slice(zeroIdxSlice, oneIdxSlice);
+  auto f2Slice = f2.value().slice(zeroIdxSlice, oneIdxSlice);
+  auto f4Slice = f4.value().slice(zeroIdxSlice, oneIdxSlice);
+  auto f8Slice = f8.value().slice(zeroIdxSlice, oneIdxSlice);
+
+  EXPECT_TRUE(i2Slice.status().ok()) << i2Slice.status();
+  EXPECT_TRUE(i4Slice.status().ok()) << i4Slice.status();
+  EXPECT_TRUE(i8Slice.status().ok()) << i8Slice.status();
+  EXPECT_TRUE(f2Slice.status().ok()) << f2Slice.status();
+  EXPECT_TRUE(f4Slice.status().ok()) << f4Slice.status();
+  EXPECT_TRUE(f8Slice.status().ok()) << f8Slice.status();
+  EXPECT_THAT(i2Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << i2Slice.value().dimensions();
+  EXPECT_THAT(i4Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << i4Slice.value().dimensions();
+  EXPECT_THAT(i8Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << i8Slice.value().dimensions();
+  EXPECT_THAT(f2Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << f2Slice.value().dimensions();
+  EXPECT_THAT(f4Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << f4Slice.value().dimensions();
+  EXPECT_THAT(f8Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << f8Slice.value().dimensions();
+}
+
+TEST(VariableV3, dimensionUnits) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_TRUE(i2.value().getMetadata().contains("dimension_units"))
+      << i2.value().getMetadata();
+  EXPECT_TRUE(i4.value().getMetadata().contains("dimension_units"))
+      << i4.value().getMetadata();
+  EXPECT_TRUE(i8.value().getMetadata().contains("dimension_units"))
+      << i8.value().getMetadata();
+  EXPECT_TRUE(f2.value().getMetadata().contains("dimension_units"))
+      << f2.value().getMetadata();
+  EXPECT_TRUE(f4.value().getMetadata().contains("dimension_units"))
+      << f4.value().getMetadata();
+  EXPECT_TRUE(f8.value().getMetadata().contains("dimension_units"))
+      << f8.value().getMetadata();
+}
+
+TEST(VariableV3, chunkSize) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_TRUE(i2.value().get_chunk_shape().status().ok())
+      << i2.value().get_chunk_shape().status();
+  EXPECT_TRUE(i4.value().get_chunk_shape().status().ok())
+      << i4.value().get_chunk_shape().status();
+  EXPECT_TRUE(i8.value().get_chunk_shape().status().ok())
+      << i8.value().get_chunk_shape().status();
+  EXPECT_TRUE(f2.value().get_chunk_shape().status().ok())
+      << f2.value().get_chunk_shape().status();
+  EXPECT_TRUE(f4.value().get_chunk_shape().status().ok())
+      << f4.value().get_chunk_shape().status();
+  EXPECT_TRUE(f8.value().get_chunk_shape().status().ok())
+      << f8.value().get_chunk_shape().status();
+}
+
+TEST(VariableV3, shape) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_THAT(i2.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
+      << i2.value().dimensions();
+  EXPECT_THAT(i4.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
+      << i4.value().dimensions();
+  EXPECT_THAT(i8.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
+      << i8.value().dimensions();
+  EXPECT_THAT(f2.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
+      << f2.value().dimensions();
+  EXPECT_THAT(f4.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
+      << f4.value().dimensions();
+  EXPECT_THAT(f8.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
+      << f8.value().dimensions();
+}
+
+TEST(VariableV3, dtype) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().dtype(), mdio::constants::kInt16) << i2.value().dtype();
+  EXPECT_EQ(i4.value().dtype(), mdio::constants::kInt32) << i4.value().dtype();
+  EXPECT_EQ(i8.value().dtype(), mdio::constants::kInt64) << i8.value().dtype();
+  EXPECT_EQ(f2.value().dtype(), mdio::constants::kFloat16)
+      << f2.value().dtype();
+  EXPECT_EQ(f4.value().dtype(), mdio::constants::kFloat32)
+      << f4.value().dtype();
+  EXPECT_EQ(f8.value().dtype(), mdio::constants::kFloat64)
+      << f8.value().dtype();
+}
+
+TEST(VariableV3, domain) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  const mdio::Index EXPECTED_SHAPE = 10;
+  EXPECT_EQ(i2.value().dimensions().shape()[0], EXPECTED_SHAPE)
+      << i2.value().dimensions();
+  EXPECT_EQ(i4.value().dimensions().shape()[0], EXPECTED_SHAPE)
+      << i4.value().dimensions();
+  EXPECT_EQ(i8.value().dimensions().shape()[0], EXPECTED_SHAPE)
+      << i8.value().dimensions();
+  EXPECT_EQ(f2.value().dimensions().shape()[0], EXPECTED_SHAPE)
+      << f2.value().dimensions();
+  EXPECT_EQ(f4.value().dimensions().shape()[0], EXPECTED_SHAPE)
+      << f4.value().dimensions();
+  EXPECT_EQ(f8.value().dimensions().shape()[0], EXPECTED_SHAPE)
+      << f8.value().dimensions();
+
+  EXPECT_EQ(i2.value().dimensions().rank(), 2) << i2.value().dimensions();
+  EXPECT_EQ(i4.value().dimensions().rank(), 2) << i4.value().dimensions();
+  EXPECT_EQ(i8.value().dimensions().rank(), 2) << i8.value().dimensions();
+  EXPECT_EQ(f2.value().dimensions().rank(), 2) << f2.value().dimensions();
+  EXPECT_EQ(f4.value().dimensions().rank(), 2) << f4.value().dimensions();
+  EXPECT_EQ(f8.value().dimensions().rank(), 2) << f8.value().dimensions();
+}
+
+TEST(VariableV3, sliceByDimName) {
+  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
+  auto i2Slice = i2.value().slice(inlineSlice, crosslineSpec);
+  auto i4Slice = i4.value().slice(inlineSlice, crosslineSpec);
+  auto i8Slice = i8.value().slice(inlineSlice, crosslineSpec);
+  auto f2Slice = f2.value().slice(inlineSlice, crosslineSpec);
+  auto f4Slice = f4.value().slice(inlineSlice, crosslineSpec);
+  auto f8Slice = f8.value().slice(inlineSlice, crosslineSpec);
+
+  EXPECT_TRUE(i2Slice.status().ok()) << i2.status();
+  EXPECT_TRUE(i4Slice.status().ok()) << i4Slice.status();
+  EXPECT_TRUE(i8Slice.status().ok()) << i8Slice.status();
+  EXPECT_TRUE(f2Slice.status().ok()) << f2Slice.status();
+  EXPECT_TRUE(f4Slice.status().ok()) << f4Slice.status();
+  EXPECT_TRUE(f8Slice.status().ok()) << f8Slice.status();
+  EXPECT_THAT(i2Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << i2Slice.value().dimensions();
+  EXPECT_THAT(i4Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << i4Slice.value().dimensions();
+  EXPECT_THAT(i8Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << i8Slice.value().dimensions();
+  EXPECT_THAT(f2Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << f2Slice.value().dimensions();
+  EXPECT_THAT(f4Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << f4Slice.value().dimensions();
+  EXPECT_THAT(f8Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5))
+      << f8Slice.value().dimensions();
+}
+
+// A test to clean up after the test suite
+TEST(VariableV3, TEARDOWN) {
+  std::filesystem::remove_all("zarrs/acceptance_v3/i2");
+  std::filesystem::remove_all("zarrs/acceptance_v3/i4");
+  std::filesystem::remove_all("zarrs/acceptance_v3/i8");
+  std::filesystem::remove_all("zarrs/acceptance_v3/f2");
+  std::filesystem::remove_all("zarrs/acceptance_v3/f4");
+  std::filesystem::remove_all("zarrs/acceptance_v3/f8");
+  std::filesystem::remove_all("zarrs/acceptance_v3");
+  ASSERT_TRUE(true);
+}
+
+}  // namespace VariableTestingV3
+
+namespace VariableDataTestV3 {
+
+template <typename T = void, mdio::DimensionIndex R = mdio::dynamic_rank,
+          mdio::ReadWriteMode M = mdio::ReadWriteMode::dynamic>
+mdio::Variable<T, R, M> getVariable() {
+  nlohmann::json i2Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/i2"
+            }
+        }
+    )"_json;
+  auto i2 = mdio::Variable<>::Open(i2Spec, (mdio::constants::kOpen));
+  if (!i2.status().ok()) {
+    std::cout << "Error opening i2: " << i2.status() << std::endl;
+    return mdio::Variable<T, R, M>();
+  }
+  return i2.value();
+}
+
+TEST(VariableDataV3, SETUP) {
+  mdio::TransactionalOpenOptions options;
+  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
+  nlohmann::json i2Spec = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/i2"
+            },
+            "metadata": {
+                "data_type": "int16",
+                "shape": [10, 10],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [5, 5]}
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {"separator": "/"}
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "long_name": "2-byte integer test",
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
+  auto [i2Store, i2Metadata] = i2Schema;
+  auto i2 =
+      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+}
+
+TEST(VariableDataV3, name) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.variableName, "i2") << variableData.variableName;
+}
+
+TEST(VariableDataV3, longName) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.longName, "2-byte integer test")
+      << variableData.longName;
+}
+
+TEST(VariableDataV3, optionalAttrs) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.metadata["metadata"]["attributes"]["foo"], "bar")
+      << variableData.metadata.dump(4);
+}
+
+TEST(VariableDataV3, namedDimensions) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.metadata["dimension_names"].size(), 2)
+      << variableData.metadata;
+}
+
+TEST(VariableDataV3, sliceByDimIdx) {
+  auto variableData = getVariable().Read().value();
+  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
+  auto slicedVariableData = variableData.slice(zeroIdxSlice, oneIdxSlice);
+  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
+  EXPECT_THAT(slicedVariableData.value().domain().shape(),
+              ::testing::ElementsAre(5, 5))
+      << slicedVariableData.value().domain();
+}
+
+TEST(VariableDataV3, sliceByDimName) {
+  auto variableData = getVariable().Read().value();
+  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
+  auto slicedVariableData = variableData.slice(inlineSlice, crosslineSpec);
+  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
+  EXPECT_THAT(slicedVariableData.value().domain().shape(),
+              ::testing::ElementsAre(5, 5))
+      << slicedVariableData.value().domain();
+}
+
+TEST(VariableDataV3, writeToStore) {
+  auto variable = getVariable();
+  auto variableData = variable.Read().value();
+  auto data =
+      reinterpret_cast<int16_t*>(variableData.get_data_accessor().data());
+  data[0] = 0xff;
+  auto writeFuture = variable.Write(variableData);
+  writeFuture.result();
+  EXPECT_TRUE(writeFuture.status().ok()) << writeFuture.status();
+
+  auto variableCheck = getVariable().Read().value();
+  auto dataCheck =
+      reinterpret_cast<int16_t*>(variableCheck.get_data_accessor().data());
+  EXPECT_EQ(dataCheck[0], 0xff) << dataCheck[0];
+}
+
+TEST(VariableDataV3, dimensionUnits) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.metadata["dimension_units"].size(), 2)
+      << variableData.metadata;
+}
+
+TEST(VariableDataV3, TEARDOWN) {
+  std::filesystem::remove_all("zarrs/acceptance_v3/i2");
+  ASSERT_TRUE(true);
+}
+
+}  // namespace VariableDataTestV3
+
+namespace DatasetTestV3 {
+
+// clang-format off
+/*NOLINT*/  std::string datasetManifest = R"(
+{
+  "metadata": {
+    "name": "campos_3d_v3",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00",
+    "attributes": {
+      "textHeader": [
+        "C01 .......................... ",
+        "C02 .......................... ",
+        "C03 .......................... "
+      ],
+      "foo": "bar"
+    }
+  },
+  "variables": [
+    {
+      "name": "image",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512},
+        {"name": "depth", "size": 384}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        },
+        "statsV1": {
+          "count": 100,
+          "sum": 1215.1,
+          "sumSquares": 125.12,
+          "min": 5.61,
+          "max": 10.84,
+          "histogram": {"binCenters":  [1, 2], "counts":  [10, 15]}
+        },
+        "attributes": {
+          "fizz": "buzz"
+        }
+    },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
+      "compressor": {"name": "blosc", "algorithm": "zstd"}
+    },
+    {
+      "name": "velocity",
+      "dataType": "float64",
+      "dimensions": ["inline", "crossline", "depth"],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        },
+        "unitsV1": {"speed": "m/s"}
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+      "name": "image_inline",
+      "dataType": "int16",
+      "dimensions": ["inline", "crossline", "depth"],
+      "longName": "inline optimized version of 3d_stack",
+      "compressor": {"name": "blosc", "algorithm": "zstd"},
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        }
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+      "name": "inline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "inline", "size": 256}]
+    },
+    {
+      "name": "crossline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "crossline", "size": 512}]
+    },
+    {
+      "name": "depth",
+      "dataType": "uint32",
+      "dimensions": [{"name": "depth", "size": 384}],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    },
+    {
+      "name": "cdp-x",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    },
+    {
+      "name": "cdp-y",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    }
+  ]
+}
+    )";
+// clang-format on
+
+TEST(DatasetSpecV3, valid) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto res = Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(res.status().ok()) << res.status();
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed = res.value();
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+  // Note: 8 variables (no struct array for V3 currently)
+  EXPECT_EQ(variables.size(), 8) << variables.size();
+
+  // Verify that the specs have zarr3 driver
+  for (const auto& var : variables) {
+    EXPECT_EQ(var["driver"], "zarr3") << var.dump(2);
+  }
+}
+
+TEST(DatasetV3, open) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto construct =
+      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
+      construct.value();
+  nlohmann::json metadata = std::get<0>(parsed);
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kCreateClean);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+}
+
+TEST(DatasetV3, read) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto construct =
+      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
+      construct.value();
+  nlohmann::json metadata = std::get<0>(parsed);
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  auto ds = dataset.value();
+
+  for (auto& kv : ds.coordinates) {
+    std::string key = kv.first;
+    auto var = ds.get_variable(key);
+    ASSERT_TRUE(var.status().ok()) << var.status();
+  }
+}
+
+TEST(DatasetV3, write) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto construct =
+      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
+      construct.value();
+  nlohmann::json metadata = std::get<0>(parsed);
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  auto ds = dataset.value();
+
+  std::vector<std::string> names = ds.variables.get_keys();
+
+  // Construct a vector of Variables to work with
+  std::vector<mdio::Variable<>> openVariables;
+  for (auto& key : names) {
+    auto var = ds.get_variable(key);
+    openVariables.emplace_back(var.value());
+  }
+
+  // Now we can start opening all the Variables
+  std::vector<mdio::Future<mdio::VariableData<>>> readVariablesFutures;
+  for (auto& v : openVariables) {
+    auto read = v.Read();
+    readVariablesFutures.emplace_back(read);
+  }
+
+  // Now we make sure all the reads were successful
+  std::vector<mdio::VariableData<>> readVariables;
+  for (auto& v : readVariablesFutures) {
+    ASSERT_TRUE(v.status().ok()) << v.status();
+    readVariables.emplace_back(v.value());
+  }
+
+  for (auto variable : readVariables) {
+    std::string name = variable.variableName;
+    mdio::DataType dtype = variable.dtype();
+    if (dtype == mdio::constants::kFloat32 && name == "image") {
+      auto data = reinterpret_cast<float*>(variable.get_data_accessor().data());
+      data[0] = 3.14f;
+    } else if (dtype == mdio::constants::kFloat64 && name == "velocity") {
+      auto data =
+          reinterpret_cast<double*>(variable.get_data_accessor().data());
+      data[0] = 2.71828;
+    } else if (dtype == mdio::constants::kInt16 && name == "image_inline") {
+      auto data =
+          reinterpret_cast<int16_t*>(variable.get_data_accessor().data());
+      data[0] = 0xff;
+    } else if (name == "inline") {
+      auto data =
+          reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
+      for (uint32_t i = 0; i < 256; ++i) {
+        data[i] = i;
+      }
+    } else if (name == "crossline") {
+      auto data =
+          reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
+      for (uint32_t i = 0; i < 512; ++i) {
+        data[i] = i;
+      }
+    } else if (name == "depth") {
+      auto data =
+          reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
+      for (uint32_t i = 0; i < 384; ++i) {
+        data[i] = i;
+      }
+    }
+  }
+
+  // Pair the Variables to the VariableData objects via name matching so we can
+  // write them out correctly This makes an assumption that the vectors are 1-1
+  std::map<std::size_t, std::size_t> variableIdxPair;
+  for (std::size_t i = 0; i < openVariables.size(); i++) {
+    for (std::size_t j = 0; j < readVariables.size(); j++) {
+      if (openVariables[i].get_variable_name() ==
+          readVariables[j].variableName) {
+        variableIdxPair[i] = j;
+        break;
+      }
+    }
+  }
+
+  // Now we can write the Variables back to the store
+  std::vector<mdio::WriteFutures> writeFutures;
+  for (auto& idxPair : variableIdxPair) {
+    auto write =
+        openVariables[idxPair.second].Write(readVariables[idxPair.first]);
+    writeFutures.emplace_back(write);
+  }
+
+  // Now we make sure all the writes were successful
+  for (auto& w : writeFutures) {
+    ASSERT_TRUE(w.status().ok()) << w.status();
+  }
+
+  nlohmann::json imageJson = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/image"
+            }
+        }
+    )"_json;
+
+  nlohmann::json velocityJson = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/velocity"
+            }
+        }
+    )"_json;
+
+  nlohmann::json imageInlineJson = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance_v3/image_inline"
+            }
+        }
+    )"_json;
+
+  auto image = mdio::Variable<>::Open(imageJson, mdio::constants::kOpen);
+  auto velocity = mdio::Variable<>::Open(velocityJson, mdio::constants::kOpen);
+  auto imageInline =
+      mdio::Variable<>::Open(imageInlineJson, mdio::constants::kOpen);
+
+  ASSERT_TRUE(image.status().ok()) << image.status();
+  ASSERT_TRUE(velocity.status().ok()) << velocity.status();
+  ASSERT_TRUE(imageInline.status().ok()) << imageInline.status();
+
+  auto imageData = image.result()->Read();
+  auto velocityData = velocity.result()->Read();
+  auto imageInlineData = imageInline.result()->Read();
+
+  ASSERT_TRUE(imageData.status().ok()) << imageData.status();
+  ASSERT_TRUE(velocityData.status().ok()) << velocityData.status();
+  ASSERT_TRUE(imageInlineData.status().ok()) << imageInlineData.status();
+
+  auto castedImage =
+      reinterpret_cast<float*>(imageData.value().get_data_accessor().data());
+  auto castedVelociy = reinterpret_cast<double*>(
+      velocityData.value().get_data_accessor().data());
+  auto castedImageInline = reinterpret_cast<int16_t*>(
+      imageInlineData.value().get_data_accessor().data());
+
+  EXPECT_EQ(castedImage[0], 3.14f) << castedImage[0];
+  EXPECT_EQ(castedVelociy[0], 2.71828) << castedVelociy[0];
+  EXPECT_EQ(castedImageInline[0], 0xff) << castedImageInline[0];
+}
+
+TEST(DatasetV3, name) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto construct =
+      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
+      construct.value();
+  nlohmann::json metadata = std::get<0>(parsed);
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+
+  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d_v3") << ds.getMetadata();
+}
+
+TEST(DatasetV3, optionalAttrs) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto construct =
+      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
+      construct.value();
+  nlohmann::json metadata = std::get<0>(parsed);
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+
+  EXPECT_TRUE(ds.getMetadata().contains("name")) << ds.getMetadata();
+}
+
+TEST(DatasetV3, isel) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto construct =
+      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
+      construct.value();
+  nlohmann::json metadata = std::get<0>(parsed);
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  auto ds = dataset.value();
+
+  mdio::RangeDescriptor<mdio::Index> desc1 = {"inline", 0, 5, 1};
+  auto slice = ds.isel(desc1);
+  ASSERT_TRUE(slice.status().ok());
+
+  auto domain = slice->domain;
+  ASSERT_EQ(domain.rank(), 3) << "This should have a rank of 3...";
+
+  // Check depth range
+  auto depthRange = domain[1];
+  EXPECT_EQ(depthRange.interval().inclusive_min(), 0)
+      << "Depth range should start at 0";
+  EXPECT_EQ(depthRange.interval().exclusive_max(), 384)
+      << "Depth range should end at 384";
+
+  // Check crossline range
+  auto crosslineRange = domain[0];
+  EXPECT_EQ(crosslineRange.interval().inclusive_min(), 0)
+      << "Crossline range should start at 0";
+  EXPECT_EQ(crosslineRange.interval().exclusive_max(), 512)
+      << "Crossline range should end at 512";
+
+  // Check inline range
+  auto inlineRange = domain[2];
+  EXPECT_EQ(inlineRange.interval().inclusive_min(), 0)
+      << "Inline range should start at 0";
+  EXPECT_EQ(inlineRange.interval().exclusive_max(), 5)
+      << "Inline range should end at 5";
+}
+
+TEST(DatasetV3, listVars) {
+  nlohmann::json j = nlohmann::json::parse(datasetManifest);
+  auto construct =
+      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
+      construct.value();
+  nlohmann::json metadata = std::get<0>(parsed);
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  std::vector<std::string> varList = dataset.value().variables.get_keys();
+  // 8 variables (no struct array for V3)
+  EXPECT_TRUE(varList.size() == 8) << "No variables found in dataset";
+}
+
+TEST(DatasetV3, TEARDOWN) {
+  std::filesystem::remove_all("zarrs/acceptance_v3");
+  ASSERT_TRUE(true);
+}
+
+}  // namespace DatasetTestV3
+
+}  // namespace
diff --git a/mdio/dataset.h b/mdio/dataset.h
index 4891135..78d8590 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -34,6 +34,7 @@
 #include "mdio/dataset_factory.h"
 #include "mdio/variable.h"
 #include "mdio/variable_collection.h"
+#include "mdio/zarr/zarr.h"
 #include "tensorstore/driver/zarr/metadata.h"
 #include "tensorstore/util/future.h"
 #include "tensorstore/util/option.h"
@@ -50,78 +51,25 @@ namespace internal {
  * @brief Retrieves the .zarray JSON metadata from the given `metadata`.
  *
  * This function derives the .zarray JSON metadata without actually reading it.
+ * This is a compatibility wrapper that delegates to the zarr V2 implementation.
  *
  * @param metadata The input JSON metadata.
  * @return An `mdio::Result` containing the .zarray JSON metadata on success, or
  * an error on failure.
+ * @deprecated Use zarr::v2::GetZarray directly for V2 stores.
  */
 inline Result<nlohmann::json> get_zarray(const ::nlohmann::json metadata) {
-  // derive .zarray json metadata (without reading it).
-  auto json =
-      metadata;  // Why am I doing this? It's an extra copy that does nothing!
-  nlohmann::json zarray;
-  if (!json.contains("metadata")) {
-    json["metadata"] = nlohmann::json::object();  // Just add an empty object
-    json["metadata"]["attributes"] =
-        nlohmann::json::object();  // We need attributes as well
-  }
-
-  // these fields can have defaults:
-  if (!json["metadata"].contains("order")) {
-    zarray["order"] = "C";
-  } else {
-    zarray["order"] = json["metadata"]["order"];
-  }
-  if (!json["metadata"].contains("filters")) {
-    zarray["filters"] = nullptr;
-  } else {
-    zarray["filters"] = json["metadata"]["filters"];
-  }
-
-  if (!json["metadata"].contains("fill_value")) {
-    zarray["fill_value"] = nullptr;
-  } else {
-    zarray["fill_value"] = json["metadata"]["fill_value"];
-  }
-
-  if (!json["metadata"].contains("zarr_format")) {
-    zarray["zarr_format"] = 2;
-  } else {
-    zarray["zarr_format"] = json["metadata"]["zarr_format"];
-  }
-
-  if (!json["metadata"].contains("chunks") &&
-      json["metadata"].contains("shape")) {
-    zarray["chunks"] = json["metadata"]["shape"];
-  } else {
-    zarray["chunks"] = json["metadata"]["chunks"];
-  }
-
-  if (!json["metadata"].contains("compressor")) {
-    zarray["compressor"] = nullptr;
-  } else {
-    zarray["compressor"] = json["metadata"]["compressor"];
-  }
-
-  if (!json["metadata"].contains("dimension_separator")) {
-    zarray["dimension_separator"] = "/";
-  } else {
-    zarray["dimension_separator"] = json["metadata"]["dimension_separator"];
-  }
-
-  zarray["shape"] = json["metadata"]["shape"];
-  zarray["dtype"] = json["metadata"]["dtype"];
-
-  // fixme chunks must be configured ...
-  MDIO_ASSIGN_OR_RETURN(
-      auto zarr_metadata,
-      tensorstore::internal_zarr::ZarrMetadata::FromJson(zarray))
-
-  return ::nlohmann::json(zarr_metadata);
+  return zarr::v2::GetZarray(metadata);
 }
 
 /**
- * @brief Writes the zmetadata for the dataset.
+ * @brief Writes the metadata for the dataset.
+ *
+ * For Zarr V2, writes consolidated metadata (.zmetadata, .zgroup, .zattrs).
+ * For Zarr V3, writes only root zarr.json (no consolidated metadata support).
+ *
+ * This overload auto-detects the Zarr version from the first variable's
+ * driver specification.
  *
  * @param dataset_metadata The metadata for the dataset.
  * @param json_variables The JSON variables.
@@ -130,121 +78,11 @@ inline Result<nlohmann::json> get_zarray(const ::nlohmann::json metadata) {
 inline Future<void> write_zmetadata(
     const ::nlohmann::json& dataset_metadata,
     const std::vector<::nlohmann::json>& json_variables) {
-  // header material at the root of the dataset ...
-  // Configure a kvstore (we can't deduce if it's in memory etc).
-  // {
-  //    "kvstore",
-  //    {
-  //        {"driver", "file"},
-  //        {"path", "name"}
-  //    }
-  //}
-  auto zattrs = dataset_metadata;
-
-  // FIXME - generalize for zarr v3
-  ::nlohmann::json zgroup;
-  zgroup["zarr_format"] = 2;
-
-  // The consolidated metadata for the datset
-  ::nlohmann::json zmetadata;
-
-  // FIXME - don't hard code here ...
-  zmetadata["zarr_consolidated_format"] = 1;
-
-  zmetadata["metadata"][".zattrs"] = zattrs;
-  zmetadata["metadata"][".zgroup"] = zgroup;
-
-  std::string zarray_key;
-  std::string zattrs_key;
-  std::string driver =
-      json_variables[0]["kvstore"]["driver"].get<std::string>();
-
-  for (const auto& json : json_variables) {
-    zarray_key =
-        std::filesystem::path(json["kvstore"]["path"]).stem() / ".zarray";
-    zattrs_key =
-        std::filesystem::path(json["kvstore"]["path"]).stem() / ".zattrs";
-
-    MDIO_ASSIGN_OR_RETURN(zmetadata["metadata"][zarray_key], get_zarray(json))
-
-    nlohmann::json fixedJson = json["attributes"];
-    fixedJson["_ARRAY_DIMENSIONS"] = fixedJson["dimension_names"];
-    fixedJson.erase("dimension_names");
-    // We do not want to be seralizing the variable_name. It should be
-    // self-describing
-    if (fixedJson.contains("variable_name")) {
-      fixedJson.erase("variable_name");
-    }
-    if (fixedJson.contains("long_name") &&
-        fixedJson["long_name"].get<std::string>() == "") {
-      fixedJson.erase("long_name");
-    }
-    if (fixedJson.contains("metadata")) {
-      if (fixedJson["metadata"].contains("chunkGrid")) {
-        fixedJson["metadata"].erase("chunkGrid");
-      }
-      for (auto& item : fixedJson["metadata"].items()) {
-        fixedJson[item.key()] = std::move(item.value());
-      }
-      fixedJson.erase("metadata");
-    }
-    // Case where an empty array of coordinates were provided
-    if (fixedJson.contains("coordinates")) {
-      auto coords = fixedJson["coordinates"];
-      if (coords.empty() ||
-          (coords.is_string() && coords.get<std::string>() == "")) {
-        fixedJson.erase("coordinates");
-      }
-    }
-    zmetadata["metadata"][zattrs_key] = fixedJson;
-  }
-
-  nlohmann::json kvstore = nlohmann::json::object();
-  kvstore["driver"] = driver;
-  std::vector<std::string> file_parts = absl::StrSplit(
-      json_variables[0]["kvstore"]["path"].get<std::string>(), '/');
-  size_t toRemove = file_parts.back().size();
-  std::string strippedPath =
-      json_variables[0]["kvstore"]["path"].get<std::string>().substr(
-          0, json_variables[0]["kvstore"]["path"].get<std::string>().size() -
-                 toRemove - 1);
-  kvstore["path"] = strippedPath;
-
-  if (driver == "gcs" || driver == "s3") {
-    kvstore["bucket"] =
-        json_variables[0]["kvstore"]["bucket"].get<std::string>();
-    std::string cloudPath = kvstore["path"].get<std::string>();
-    kvstore["path"] = cloudPath;
+  zarr::ZarrVersion version = zarr::ZarrVersion::kV2;
+  if (!json_variables.empty()) {
+    version = zarr::GetVersionFromSpec(json_variables[0]);
   }
-
-  auto kvs_future = tensorstore::kvstore::Open(kvstore);
-
-  auto zattrs_future = tensorstore::MapFutureValue(
-      tensorstore::InlineExecutor{},
-      [zattrs = std::move(zattrs)](const tensorstore::KvStore& kvstore) {
-        return tensorstore::kvstore::Write(kvstore, "/.zattrs",
-                                           absl::Cord(zattrs.dump(4)));
-      },
-      kvs_future);
-
-  auto zmetadata_future = tensorstore::MapFutureValue(
-      tensorstore::InlineExecutor{},
-      [zmetadata = std::move(zmetadata)](const tensorstore::KvStore& kvstore) {
-        return tensorstore::kvstore::Write(kvstore, "/.zmetadata",
-                                           absl::Cord(zmetadata.dump(4)));
-      },
-      kvs_future);
-
-  auto zgroup_future = tensorstore::MapFutureValue(
-      tensorstore::InlineExecutor{},
-      [zgroup = std::move(zgroup)](const tensorstore::KvStore& kvstore) {
-        return tensorstore::kvstore::Write(kvstore, "/.zgroup",
-                                           absl::Cord(zgroup.dump(4)));
-      },
-      kvs_future);
-
-  return tensorstore::WaitAllFuture(zattrs_future, zmetadata_future,
-                                    zgroup_future);
+  return zarr::WriteDatasetMetadata(version, dataset_metadata, json_variables);
 }
 
 /**
@@ -269,7 +107,11 @@ inline Future<tensorstore::KvStore> dataset_kvs_store(
     kvstore["driver"] = "s3";
   } else {
     kvstore["driver"] = "file";
-    kvstore["path"] = output_file;
+    std::string path = std::string(output_file);
+    if (!path.empty() && path.back() != '/') {
+      path.push_back('/');
+    }
+    kvstore["path"] = path;
     return tensorstore::kvstore::Open(kvstore);
   }  // FIXME - we need azure support ...
 
@@ -284,6 +126,9 @@ inline Future<tensorstore::KvStore> dataset_kvs_store(
   for (std::size_t i = 2; i < file_parts.size(); ++i) {
     filepath += "/" + file_parts[i];
   }
+  if (!filepath.empty() && filepath.back() != '/') {
+    filepath.push_back('/');
+  }
   // update the bucket and path ...
   kvstore["bucket"] = bucket;
   kvstore["path"] = filepath;
@@ -292,105 +137,52 @@ inline Future<tensorstore::KvStore> dataset_kvs_store(
 }
 
 /**
- * @brief Retrieves the .zmetadata for the dataset.
- * This is for executing a read on the dataset's consolidated metadata.
- * It will also attempt to infer the driver based on the prefix of the path.
- * It will default to the "file" driver if no prefix is found.
+ * @brief Retrieves the metadata for the dataset with auto-detection.
+ * This version auto-detects the Zarr version by checking for V3 markers first.
  * @param dataset_path The path to the dataset.
- * @return An `mdio::Future` containing the .zmetadata JSON on success, or an
+ * @return An `mdio::Future` containing the metadata JSON on success, or an
  * error on failure.
  */
 inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
 from_zmetadata(const std::string& dataset_path) {
-  // e.g. dataset_path = "zarrs/acceptance/";
-  //  FIXME - enable async
-  auto kvs_future = mdio::internal::dataset_kvs_store(dataset_path).result();
-
-  if (!kvs_future.ok()) {
-    return internal::CheckMissingDriverStatus(kvs_future.status());
-  }
-  auto kvs_read_result =
-      tensorstore::kvstore::Read(kvs_future.value(), ".zmetadata").result();
-  if (!kvs_read_result.ok()) {
-    return internal::CheckMissingDriverStatus(kvs_read_result.status());
-  }
+  auto kvs_future = mdio::internal::dataset_kvs_store(dataset_path);
 
-  ::nlohmann::json zmetadata;
-  try {
-    zmetadata =
-        ::nlohmann::json::parse(std::string(kvs_read_result.value().value));
-  } catch (const nlohmann::json::parse_error& e) {
-    // It's a common error to not have a trailing slash on the dataset path.
-    if (!dataset_path.empty() && dataset_path.back() != '/') {
-      std::string fixPath = dataset_path + "/";
-      return mdio::internal::from_zmetadata(fixPath);
-    }
-    return absl::Status(absl::StatusCode::kInvalidArgument, e.what());
-  }
+  auto pair = tensorstore::PromiseFuturePair<
+      std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>::Make();
 
-  if (!zmetadata.contains("metadata")) {
-    return absl::Status(absl::StatusCode::kInvalidArgument,
-                        "zmetadata does not contain metadata.");
-  }
-
-  if (!zmetadata["metadata"].contains(".zattrs")) {
-    return absl::Status(absl::StatusCode::kInvalidArgument,
-                        "zmetadata does not contain dataset metadata.");
-  }
-
-  auto dataset_metadata = zmetadata["metadata"][".zattrs"];
+  kvs_future.ExecuteWhenReady(
+      [promise = std::move(pair.promise),
+       dataset_path](tensorstore::ReadyFuture<tensorstore::KvStore> ready_kvs) {
+        if (!ready_kvs.result().ok()) {
+          promise.SetResult(
+              internal::CheckMissingDriverStatus(ready_kvs.result().status()));
+          return;
+        }
 
-  std::string driver = "file";
-  // TODO(BrianMichell): Make this more robust. May be invalid if the stored
-  // path gets mangled somehow. Infer the driver
-  if (dataset_path.length() > 5) {
-    if (dataset_path.substr(0, 5) == "gs://") {
-      driver = "gcs";
-    } else if (dataset_path.substr(0, 5) == "s3://") {
-      driver = "s3";
-    }
-  }
+        // Auto-detect version
+        auto version_future = zarr::DetectVersion(ready_kvs.value());
+        version_future.ExecuteWhenReady(
+            [promise = std::move(promise), dataset_path,
+             kvs = ready_kvs.value()](
+                tensorstore::ReadyFuture<zarr::ZarrVersion> version_ready) {
+              zarr::ZarrVersion version = zarr::ZarrVersion::kV2;
+              if (version_ready.result().ok()) {
+                version = version_ready.value();
+              }
 
-  std::string bucket;
-  std::string cloudPath;
-  if (driver != "file") {
-    std::string providedPath =
-        dataset_path.substr(5);  // Strip the gs:// or s3://
-    size_t bucketLen = providedPath.find_first_of('/');
-    bucket = providedPath.substr(0, bucketLen);  // Extract the bucket name
-    cloudPath = providedPath.substr(
-        bucketLen + 1, providedPath.length() - 2);  // Extract the path
-  }
+              auto result_future = zarr::ReadDatasetMetadata(
+                  version, dataset_path,
+                  tensorstore::MakeReadyFuture<tensorstore::KvStore>(kvs));
 
-  // Remove .zattrs from metadata
-  zmetadata["metadata"].erase(".zattrs");
-  std::vector<nlohmann::json> json_vars_from_zmeta;
-  // Assemble a list of json for opening the variables in the dataset.
-  for (auto& element : zmetadata["metadata"].items()) {
-    // FIXME - remove hard code .zarray
-    if (element.key().substr(element.key().find_last_of(".") + 1) == "zarray") {
-      std::string variable_name =
-          element.key().substr(0, element.key().find("/"));
-      nlohmann::json new_dict = {
-          {"driver", "zarr"},
-          {"kvstore",
-           // {{"driver", driver}, {"path", dataset_path + "/" + variable_name}}}};
-    {{"driver", driver}, {"path", dataset_path + variable_name}}}};
-      if (driver != "file") {
-        new_dict["kvstore"]["bucket"] = bucket;
-        new_dict["kvstore"]["path"] = cloudPath + variable_name;
-      }
-      json_vars_from_zmeta.push_back(new_dict);
-    }
-  }
-  if (!json_vars_from_zmeta.size()) {
-    return absl::Status(absl::StatusCode::kInvalidArgument,
-                        "Not variables found in zmetadata.");
-  }
+              result_future.ExecuteWhenReady(
+                  [promise = std::move(promise)](
+                      tensorstore::ReadyFuture<std::tuple<
+                          ::nlohmann::json, std::vector<::nlohmann::json>>>
+                          result) { promise.SetResult(result.result()); });
+            });
+      });
 
-  return tensorstore::ReadyFuture<
-      std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>(
-      std::make_tuple(dataset_metadata, json_vars_from_zmeta));
+  return pair.future;
 }
 }  // namespace internal
 
@@ -1265,10 +1057,15 @@ class Dataset {
                               variableName + "'.");
     }
 
+    // Detect Zarr version from the spec
+    std::string driverName = specJson.contains("driver")
+                                 ? specJson["driver"].get<std::string>()
+                                 : "zarr";
+
     // Create a new Variable with the selected field
     std::string baseStr = R"(
             {
-                "driver": "zarr",
+                "driver": "DRIVER_PLACEHOLDER",
                 "field": "FIELD",
                 "kvstore": {
                     "driver": "DRIVER",
@@ -1277,6 +1074,7 @@ class Dataset {
             }
         )";
     nlohmann::json base = nlohmann::json::parse(baseStr, nullptr, false);
+    base["driver"] = driverName;
     if (base.is_discarded()) {
       return absl::Status(absl::StatusCode::kInternal,
                           "Failed to parse base JSON.");
diff --git a/mdio/dataset_factory.h b/mdio/dataset_factory.h
index 1824800..79a1bfb 100644
--- a/mdio/dataset_factory.h
+++ b/mdio/dataset_factory.h
@@ -15,6 +15,7 @@
 #ifndef MDIO_DATASET_FACTORY_H_
 #define MDIO_DATASET_FACTORY_H_
 
+#include <optional>
 #include <set>
 #include <string>
 #include <tuple>
@@ -23,7 +24,7 @@
 
 #include "mdio/dataset_validator.h"
 #include "mdio/impl.h"
-// #include "tensorstore/tensorstore.h"
+#include "mdio/zarr/zarr.h"
 
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_format.h"
@@ -42,46 +43,28 @@ inline std::string encode_base64(const std::string raw) {
 }
 
 /**
- * @brief Converts a Dataset spec dtype to a numpy style dtype
+ * @brief Converts a Dataset spec dtype to a numpy style dtype (Zarr V2)
  * This function is intended to be an internal helper function for formatting
  * Variable specs It presupposes that all dtypes are little endian or endianless
  * if bool.
  * @param dtype A string representing the dtype of a Variable
  * @return A string representing the dtype in numpy format limited to the dtypes
  * supported by MDIO Dataset
+ * @deprecated Use mdio::zarr::v2::ToZarrDtype for explicit V2 conversions.
  */
 inline tensorstore::Result<std::string> to_zarr_dtype(const std::string dtype) {
-  // Convert the input dtype to Zarr dtype
-  if (dtype == "int8") {
-    return "<i1";
-  } else if (dtype == "int16") {
-    return "<i2";
-  } else if (dtype == "int32") {
-    return "<i4";
-  } else if (dtype == "int64") {
-    return "<i8";
-  } else if (dtype == "uint8") {
-    return "<u1";
-  } else if (dtype == "uint16") {
-    return "<u2";
-  } else if (dtype == "uint32") {
-    return "<u4";
-  } else if (dtype == "uint64") {
-    return "<u8";
-  } else if (dtype == "float16") {
-    return "<f2";
-  } else if (dtype == "float32") {
-    return "<f4";
-  } else if (dtype == "float64") {
-    return "<f8";
-  } else if (dtype == "bool") {
-    return "|b1";
-  } else if (dtype == "complex64") {
-    return "<c8";
-  } else if (dtype == "complex128") {
-    return "<c16";
-  }
-  return absl::InvalidArgumentError("Unknown dtype: " + dtype);
+  return mdio::zarr::v2::ToZarrDtype(dtype);
+}
+
+/**
+ * @brief Converts a Dataset spec dtype to the appropriate Zarr format
+ * @param dtype A string representing the dtype of a Variable
+ * @param version The Zarr version to target
+ * @return The dtype in the appropriate format for the version
+ */
+inline tensorstore::Result<nlohmann::json> to_zarr_dtype(
+    const std::string dtype, mdio::zarr::ZarrVersion version) {
+  return mdio::zarr::ConvertDtype(version, dtype);
 }
 
 /**
@@ -90,12 +73,22 @@ inline tensorstore::Result<std::string> to_zarr_dtype(const std::string dtype) {
  * Variable specs It will modify with side-effect on "input"
  * @param input A MDIO Variable spec
  * @param variable A Variable stub (Will be modified)
+ * @param version The Zarr version to target (defaults to V2)
  * @return OkStatus if successful, InvalidArgumentError if dtype is not
  * supported
  */
-inline absl::Status transform_dtype(nlohmann::json& input /*NOLINT*/,
-                                    nlohmann::json& variable /*NOLINT*/) {
+inline absl::Status transform_dtype(
+    nlohmann::json& input /*NOLINT*/, nlohmann::json& variable /*NOLINT*/,
+    mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
+  std::string dtype_key =
+      (version == mdio::zarr::ZarrVersion::kV3) ? "data_type" : "dtype";
+
   if (input["dataType"].contains("fields")) {
+    if (version == mdio::zarr::ZarrVersion::kV3) {
+      // V3 doesn't support structured dtypes in the same way
+      return absl::InvalidArgumentError(
+          "Structured dtypes are not yet supported in Zarr V3");
+    }
     nlohmann::json dtypeFields = nlohmann::json::array();
     for (const auto& field : input["dataType"]["fields"]) {
       auto dtype = to_zarr_dtype(field["format"]);
@@ -104,13 +97,13 @@ inline absl::Status transform_dtype(nlohmann::json& input /*NOLINT*/,
       }
       dtypeFields.emplace_back(nlohmann::json{field["name"], dtype.value()});
     }
-    variable["metadata"]["dtype"] = dtypeFields;
+    variable["metadata"][dtype_key] = dtypeFields;
   } else {
-    auto dtype = to_zarr_dtype(input["dataType"]);
+    auto dtype = to_zarr_dtype(input["dataType"], version);
     if (!dtype.status().ok()) {
       return dtype.status();
     }
-    variable["metadata"]["dtype"] = dtype.value();
+    variable["metadata"][dtype_key] = dtype.value();
   }
   return absl::OkStatus();
 }
@@ -121,52 +114,106 @@ inline absl::Status transform_dtype(nlohmann::json& input /*NOLINT*/,
  * Variable specs It will modify with side-effect on "input"
  * @param input A MDIO Variable spec
  * @param variable A Variable stub (Will be modified)
+ * @param version The Zarr version to target (defaults to V2)
  * @return OkStatus if successful, InvalidArgumentError if compressor is invalid
  * for MDIO
  */
-inline absl::Status transform_compressor(nlohmann::json& input /*NOLINT*/,
-                                         nlohmann::json& variable /*NOLINT*/) {
-  if (input.contains("compressor")) {
-    if (input["compressor"].contains("name")) {
-      if (input["compressor"]["name"] != "blosc") {
+inline absl::Status transform_compressor(
+    nlohmann::json& input /*NOLINT*/, nlohmann::json& variable /*NOLINT*/,
+    mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
+  if (version == mdio::zarr::ZarrVersion::kV3) {
+    // V3 uses codec pipeline
+    if (input.contains("compressor")) {
+      if (!input["compressor"].contains("name") ||
+          input["compressor"]["name"] != "blosc") {
         return absl::InvalidArgumentError("Only blosc compressor is supported");
       }
-      variable["metadata"]["compressor"]["id"] = input["compressor"]["name"];
-    } else {
-      return absl::InvalidArgumentError("Compressor name must be specified");
-    }
 
-    if (input["compressor"].contains("algorithm")) {
-      variable["metadata"]["compressor"]["cname"] =
-          input["compressor"]["algorithm"];
-    } else {  // DEFAULT
-      variable["metadata"]["compressor"]["cname"] = "lz4";
-    }
-    if (input["compressor"].contains("level")) {
-      if (input["compressor"]["level"] > 9 ||
-          input["compressor"]["level"] < 0) {
-        return absl::InvalidArgumentError(
-            "Compressor level must be between 0 and 9");
+      nlohmann::json blosc_codec = {{"name", "blosc"}};
+      blosc_codec["configuration"] = nlohmann::json::object();
+
+      if (input["compressor"].contains("algorithm")) {
+        blosc_codec["configuration"]["cname"] =
+            input["compressor"]["algorithm"];
+      } else {
+        blosc_codec["configuration"]["cname"] = "lz4";
       }
-      variable["metadata"]["compressor"]["clevel"] =
-          input["compressor"]["level"];
-    } else {  // DEFAULT
-      variable["metadata"]["compressor"]["clevel"] = 5;
-    }
-    if (input["compressor"].contains("shuffle")) {
-      variable["metadata"]["compressor"]["shuffle"] =
-          input["compressor"]["shuffle"];
-    } else {  // DEFAULT
-      variable["metadata"]["compressor"]["shuffle"] = 1;
-    }
-    if (input["compressor"].contains("blocksize")) {
-      variable["metadata"]["compressor"]["blocksize"] =
-          input["compressor"]["blocksize"];
-    } else {  // DEFAULT
-      variable["metadata"]["compressor"]["blocksize"] = 0;
+
+      if (input["compressor"].contains("level")) {
+        if (input["compressor"]["level"] > 9 ||
+            input["compressor"]["level"] < 0) {
+          return absl::InvalidArgumentError(
+              "Compressor level must be between 0 and 9");
+        }
+        blosc_codec["configuration"]["clevel"] = input["compressor"]["level"];
+      } else {
+        blosc_codec["configuration"]["clevel"] = 5;
+      }
+
+      if (input["compressor"].contains("shuffle")) {
+        blosc_codec["configuration"]["shuffle"] =
+            input["compressor"]["shuffle"];
+      } else {
+        blosc_codec["configuration"]["shuffle"] = "shuffle";
+      }
+
+      if (input["compressor"].contains("blocksize")) {
+        blosc_codec["configuration"]["blocksize"] =
+            input["compressor"]["blocksize"];
+      } else {
+        blosc_codec["configuration"]["blocksize"] = 0;
+      }
+
+      // V3 uses a codec array: bytes first, then compression
+      variable["metadata"]["codecs"] =
+          nlohmann::json::array({{{"name", "bytes"}}, blosc_codec});
     }
+    // If no compressor, use default bytes codec (already in stub)
   } else {
-    variable["metadata"]["compressor"] = nullptr;
+    // V2 uses compressor object
+    if (input.contains("compressor")) {
+      if (input["compressor"].contains("name")) {
+        if (input["compressor"]["name"] != "blosc") {
+          return absl::InvalidArgumentError(
+              "Only blosc compressor is supported");
+        }
+        variable["metadata"]["compressor"]["id"] = input["compressor"]["name"];
+      } else {
+        return absl::InvalidArgumentError("Compressor name must be specified");
+      }
+
+      if (input["compressor"].contains("algorithm")) {
+        variable["metadata"]["compressor"]["cname"] =
+            input["compressor"]["algorithm"];
+      } else {
+        variable["metadata"]["compressor"]["cname"] = "lz4";
+      }
+      if (input["compressor"].contains("level")) {
+        if (input["compressor"]["level"] > 9 ||
+            input["compressor"]["level"] < 0) {
+          return absl::InvalidArgumentError(
+              "Compressor level must be between 0 and 9");
+        }
+        variable["metadata"]["compressor"]["clevel"] =
+            input["compressor"]["level"];
+      } else {
+        variable["metadata"]["compressor"]["clevel"] = 5;
+      }
+      if (input["compressor"].contains("shuffle")) {
+        variable["metadata"]["compressor"]["shuffle"] =
+            input["compressor"]["shuffle"];
+      } else {
+        variable["metadata"]["compressor"]["shuffle"] = 1;
+      }
+      if (input["compressor"].contains("blocksize")) {
+        variable["metadata"]["compressor"]["blocksize"] =
+            input["compressor"]["blocksize"];
+      } else {
+        variable["metadata"]["compressor"]["blocksize"] = 0;
+      }
+    } else {
+      variable["metadata"]["compressor"] = nullptr;
+    }
   }
   return absl::OkStatus();
 }
@@ -178,26 +225,26 @@ inline absl::Status transform_compressor(nlohmann::json& input /*NOLINT*/,
  * @param input A MDIO Variable spec
  * @param variable A Variable stub (Will be modified)
  * @param dimensionMap A map of dimension names to sizes
+ * @param version The Zarr version to target (defaults to V2)
  * @return void -- Can only be successful because validation must always pass
  * before this step This presumes that the user does not attempt to use these
  * functions directly
  */
 inline void transform_shape(
     nlohmann::json& input /*NOLINT*/, nlohmann::json& variable /*NOLINT*/,
-    std::unordered_map<std::string, uint64_t>& dimensionMap /*NOLINT*/) {
+    std::unordered_map<std::string, uint64_t>& dimensionMap /*NOLINT*/,
+    mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
+  nlohmann::json shape = nlohmann::json::array();
   if (input["dimensions"][0].is_object()) {
-    nlohmann::json shape = nlohmann::json::array();
     for (auto& dimension : input["dimensions"]) {
       shape.emplace_back(dimensionMap[dimension["name"]]);
     }
-    variable["metadata"]["shape"] = shape;
   } else {
-    nlohmann::json shape = nlohmann::json::array();
     for (auto& dimension : input["dimensions"]) {
       shape.emplace_back(dimensionMap[dimension]);
     }
-    variable["metadata"]["shape"] = shape;
   }
+  variable["metadata"]["shape"] = shape;
 }
 
 /**
@@ -259,13 +306,49 @@ inline absl::Status transform_metadata(const std::string& path,
  * formatting Variable specs
  * @param json A MDIO Dataset Variable list element
  * @param dimensionMap A map of dimension names to sizes
+ * @param path The path for the variable
+ * @param version The Zarr version to use (defaults to V2)
  * @return A Variable spec or an error if the Variable spec is invalid
  */
 inline tensorstore::Result<nlohmann::json> from_json_to_spec(
     nlohmann::json& json /*NOLINT*/,
     std::unordered_map<std::string, uint64_t>& dimensionMap /*NOLINT*/,
-    const std::string& path) {
-  nlohmann::json variableStub = R"(
+    const std::string& path,
+    mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
+  nlohmann::json variableStub;
+
+  if (version == mdio::zarr::ZarrVersion::kV3) {
+    // Zarr V3 spec structure
+    variableStub = R"(
+        {
+            "driver": "zarr3",
+            "kvstore": {
+                "driver": "file",
+                "path": "VARIABLE_NAME"
+            },
+            "metadata": {
+                "data_type": "DATA_TYPE",
+                "shape": [],
+                "chunk_grid": {
+                    "name": "regular",
+                    "configuration": {
+                        "chunk_shape": []
+                    }
+                },
+                "chunk_key_encoding": {
+                    "name": "default",
+                    "configuration": {
+                        "separator": "/"
+                    }
+                },
+                "codecs": [{"name": "bytes"}]
+            },
+            "attributes": {}
+        }
+    )"_json;
+  } else {
+    // Zarr V2 spec structure
+    variableStub = R"(
         {
             "driver": "zarr",
             "kvstore": {
@@ -281,50 +364,70 @@ inline tensorstore::Result<nlohmann::json> from_json_to_spec(
             "attributes": {}
         }
     )"_json;
+  }
   variableStub["kvstore"]["path"] = json["name"];
 
-  auto transformStatus = transform_dtype(json, variableStub);
+  auto transformStatus = transform_dtype(json, variableStub, version);
   if (!transformStatus.ok()) {
     return transformStatus;
   }
 
-  auto compressorStatus = transform_compressor(json, variableStub);
+  auto compressorStatus = transform_compressor(json, variableStub, version);
   if (!compressorStatus.ok()) {
     return compressorStatus;
   }
 
-  transform_shape(json, variableStub, dimensionMap);
+  transform_shape(json, variableStub, dimensionMap, version);
 
   if (json.contains("metadata")) {
+    nlohmann::json chunkShape;
     if (json["metadata"].contains("chunkGrid")) {
-      variableStub["metadata"]["chunks"] =
-          json["metadata"]["chunkGrid"]["configuration"]["chunkShape"];
-    } else {  // No chunking specified
-      variableStub["metadata"]["chunks"] = variableStub["metadata"]["shape"];
+      chunkShape = json["metadata"]["chunkGrid"]["configuration"]["chunkShape"];
+    } else {
+      chunkShape = variableStub["metadata"]["shape"];
+    }
+
+    if (version == mdio::zarr::ZarrVersion::kV3) {
+      // V3 uses chunk_grid
+      variableStub["metadata"]["chunk_grid"]["configuration"]["chunk_shape"] =
+          chunkShape;
+    } else {
+      // V2 uses chunks
+      variableStub["metadata"]["chunks"] = chunkShape;
     }
 
     if (!json["dataType"].contains("fields")) {
+      std::string dtype_str = json["dataType"].get<std::string>();
       variableStub["metadata"]["fill_value"] = nlohmann::json::value_t::null;
-      if (json["dataType"] == "complex64") {
+      if (dtype_str == "complex64") {
         std::string raw(8, '\0');
-        variableStub["metadata"]["fill_value"] = encode_base64(raw);
-      } else if (json["dataType"] == "complex128") {
+        if (version == mdio::zarr::ZarrVersion::kV2) {
+          variableStub["metadata"]["fill_value"] = encode_base64(raw);
+        }
+        // V3 handles complex fill values differently
+      } else if (dtype_str == "complex128") {
         std::string raw(16, '\0');
-        variableStub["metadata"]["fill_value"] = encode_base64(raw);
-      } else if (json["dataType"].get<std::string>()[0] == 'f') {
+        if (version == mdio::zarr::ZarrVersion::kV2) {
+          variableStub["metadata"]["fill_value"] = encode_base64(raw);
+        }
+      } else if (!dtype_str.empty() && dtype_str[0] == 'f') {
         variableStub["metadata"]["fill_value"] = std::nan("");
+      } else {
+        // Provide an explicit default for integral/boolean types to satisfy the
+        // TensorStore Zarr3 parser, which rejects null fill values for numeric
+        // dtypes.
+        variableStub["metadata"]["fill_value"] = 0;
       }
-    } else {
+    } else if (version == mdio::zarr::ZarrVersion::kV2) {
+      // Structured dtypes only for V2
       // Accumulate the total number of bytes (N)
       uint16_t num_bytes = 0;
-      // We're going to use the variable dtype because it's already in byte
-      // format
       std::string dtype;
       for (auto field : variableStub["metadata"]["dtype"]) {
         dtype = field[1].get<std::string>();
         if (dtype.at(1) != 'c') {
           num_bytes += std::stoi(dtype.substr(2));
-        } else {  // Complex
+        } else {
           if (dtype.at(2) == '8') {
             num_bytes += 8;
           } else {
@@ -337,8 +440,14 @@ inline tensorstore::Result<nlohmann::json> from_json_to_spec(
     }
 
     variableStub["attributes"]["metadata"] = json["metadata"];
-  } else {  // No metadata supplied means no chunkGrid
-    variableStub["metadata"]["chunks"] = variableStub["metadata"]["shape"];
+  } else {
+    // No metadata supplied means no chunkGrid
+    if (version == mdio::zarr::ZarrVersion::kV3) {
+      variableStub["metadata"]["chunk_grid"]["configuration"]["chunk_shape"] =
+          variableStub["metadata"]["shape"];
+    } else {
+      variableStub["metadata"]["chunks"] = variableStub["metadata"]["shape"];
+    }
   }
 
   auto transform_result = transform_metadata(path, variableStub);
@@ -436,11 +545,26 @@ get_dimensions(nlohmann::json& spec /*NOLINT*/) {
  * This should be the only function called by the user to construct a Dataset
  * from a spec
  * @param spec A Dataset spec
+ * @param path The path for the dataset
+ * @param version Optional Zarr version to use. If not specified, auto-detects
+ *                from spec's "zarr_version" field, defaulting to V2.
  * @return A vector of Variable specs or an error if the Dataset spec is invalid
  */
 inline tensorstore::Result<
     std::tuple<nlohmann::json, std::vector<nlohmann::json>>>
-Construct(nlohmann::json& spec /*NOLINT*/, const std::string& path) {
+Construct(nlohmann::json& spec /*NOLINT*/, const std::string& path,
+          std::optional<mdio::zarr::ZarrVersion> version = std::nullopt) {
+  // Determine the version to use
+  mdio::zarr::ZarrVersion zarr_version = mdio::zarr::ZarrVersion::kV2;
+  if (version.has_value()) {
+    zarr_version = version.value();
+  } else if (spec.contains("zarr_version")) {
+    auto version_result = mdio::zarr::ParseVersion(spec["zarr_version"]);
+    if (version_result.ok()) {
+      zarr_version = version_result.value();
+    }
+  }
+
   // Validation should only return status codes. If it returns data then it
   // should be a "constructor"
   auto status = validate_dataset(spec);
@@ -459,7 +583,8 @@ Construct(nlohmann::json& spec /*NOLINT*/, const std::string& path) {
 
   std::vector<nlohmann::json> datasetSpec;
   for (auto& variable : spec["variables"]) {
-    auto variableSpec = from_json_to_spec(variable, dimensionMap, path);
+    auto variableSpec =
+        from_json_to_spec(variable, dimensionMap, path, zarr_version);
     if (!variableSpec.status().ok()) {
       return variableSpec.status();
     }
diff --git a/mdio/variable.h b/mdio/variable.h
index f5448f4..2ac0227 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -29,6 +29,7 @@
 #include "absl/strings/str_split.h"
 #include "mdio/impl.h"
 #include "mdio/stats.h"
+#include "mdio/zarr/zarr.h"
 #include "tensorstore/array.h"
 #include "tensorstore/driver/driver.h"
 #include "tensorstore/driver/registry.h"
@@ -247,10 +248,10 @@ inline absl::Status CheckMissingDriverStatus(const absl::Status& status) {
  * @brief Validates and processes a JSON specification for a tensorstore
  * variable.
  *
- * This function validates and processes the JSON specification for a zarr V2
- * tensorstore variable. It expects the JSON specification will have a field
- * called attributes that contains a field called dimension_names. This is a
- * specification of MDIO and is not specifically required by zarr V2
+ * This function validates and processes the JSON specification for a zarr
+ * tensorstore variable (V2 or V3). It expects the JSON specification will have
+ * a field called attributes that contains a field called dimension_names. This
+ * is a specification of MDIO and is not specifically required by zarr.
  *
  * @tparam Mode The read-write mode to use.
  * @param json_spec The JSON specification to validate and process.
@@ -276,7 +277,7 @@ Result<std::tuple<nlohmann::json, nlohmann::json>> ValidateAndProcessJson(
 
   nlohmann::json json_for_store = json_spec;
 
-  // remove attributes, the v2 store won't parse it.
+  // remove attributes, the store won't parse it.
   json_for_store.erase("attributes");
 
   // Create a new JSON and add the kvstore
@@ -288,6 +289,17 @@ Result<std::tuple<nlohmann::json, nlohmann::json>> ValidateAndProcessJson(
   return std::make_tuple(json_for_store, new_json);
 }
 
+/**
+ * @brief Gets the Zarr version from a JSON specification.
+ *
+ * @param json_spec The JSON specification.
+ * @return zarr::ZarrVersion The detected version.
+ */
+inline zarr::ZarrVersion GetZarrVersionFromSpec(
+    const nlohmann::json& json_spec) {
+  return zarr::GetVersionFromSpec(json_spec);
+}
+
 /**
  * @brief Creates a Variable object.
  *
@@ -412,18 +424,32 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
                         "Variable spec requires metadata");
   }
 
-  if (!json_spec["metadata"].contains("dtype")) {
+  // Detect Zarr version early to handle dtype field differences
+  zarr::ZarrVersion zarr_version = zarr::GetVersionFromSpec(json_spec);
+
+  // Check for dtype (V2) or data_type (V3)
+  bool has_dtype = json_spec["metadata"].contains("dtype");
+  bool has_data_type = json_spec["metadata"].contains("data_type");
+
+  if (!has_dtype && !has_data_type) {
     return absl::Status(absl::StatusCode::kInvalidArgument,
-                        "Variable metadata requires dtype");
+                        "Variable metadata requires dtype (V2) or data_type (V3)");
   }
 
-  MDIO_ASSIGN_OR_RETURN(auto zarr_dtype, tensorstore::internal_zarr::ParseDType(
-                                             json_spec["metadata"]["dtype"]))
+  // For V3, we don't use ParseDType (which is V2-specific)
+  // Instead, we handle structured arrays differently
+  bool do_handle_structarray = false;
+  tensorstore::internal_zarr::ZarrDType zarr_dtype;
+
+  if (zarr_version == zarr::ZarrVersion::kV2 && has_dtype) {
+    MDIO_ASSIGN_OR_RETURN(zarr_dtype, tensorstore::internal_zarr::ParseDType(
+                                               json_spec["metadata"]["dtype"]))
+    // Handles the use case of creating a struct array, but intending to open as
+    // void.
+    do_handle_structarray =
+        zarr_dtype.has_fields && !json_spec.contains("field");
+  }
 
-  // Handles the use case of creating a struct array, but intending to open as
-  // void.
-  auto do_handle_structarray =
-      zarr_dtype.has_fields && !json_spec.contains("field");
   auto json_spec_with_open_flag = json_spec;
   if (do_handle_structarray) {
     // pick the first name, it won't effect the .zarray json:
@@ -435,42 +461,16 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   auto future_json_store = tensorstore::MakeReadyFuture<::nlohmann::json>(
       json_spec_without_metadata);
 
-  auto publish = [](const ::nlohmann::json& json_var, bool isCloudStore,
-                    const tensorstore::TensorStore<T, R, M>& store)
+  auto publish = [zarr_version](const ::nlohmann::json& json_var,
+                                bool isCloudStore,
+                                const tensorstore::TensorStore<T, R, M>& store)
       -> Future<tensorstore::TimestampedStorageGeneration> {
-    auto output_json = json_var;
-    output_json["_ARRAY_DIMENSIONS"] = output_json["dimension_names"];
-    output_json.erase("dimension_names");
-    output_json.erase("variable_name");
-    if (output_json.contains("metadata")) {
-      output_json["metadata"].erase("chunkGrid");
-      for (auto& item : output_json["metadata"].items()) {
-        output_json[item.key()] = std::move(item.value());
-      }
-      output_json.erase("metadata");
-    }
-    if (output_json.contains("long_name")) {
-      if (output_json["long_name"] == "") {
-        output_json.erase("long_name");
-      }
-    }
-    // Case where empty array of coordinates is provided
-    if (output_json.contains("coordinates")) {
-      auto coords = output_json["coordinates"];
-      if (coords.empty() ||
-          (coords.is_string() && coords.get<std::string>() == "")) {
-        output_json.erase("coordinates");
-      }
-    }
-    // std::string outpath = "/.zattrs";
-    std::string outpath = ".zattrs";
-    if (isCloudStore) {
-      outpath = ".zattrs";
+    // Use version-specific attribute writing
+    if (zarr_version == zarr::ZarrVersion::kV3) {
+      return zarr::v3::WriteVariableAttributes(store, json_var, isCloudStore);
+    } else {
+      return zarr::v2::WriteVariableAttributes(store, json_var, isCloudStore);
     }
-    // It's important to use the store's kvstore or else we get a race condition
-    // on "mkdir".
-    return tensorstore::kvstore::Write(store.kvstore(), outpath,
-                                       absl::Cord(output_json.dump(4)));
   };
 
   // this is intended to handle the struct array where we "reopen" the store
@@ -597,19 +597,35 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
   // start by creating a kvstore future ...
   auto kvs_future = tensorstore::kvstore::Open(store_spec["kvstore"]);
 
+  // Detect Zarr version from the store spec
+  zarr::ZarrVersion zarr_version = zarr::GetVersionFromSpec(store_spec);
+
   // go read the metadata return json ...
-  auto read = [](const tensorstore::KvStore& kvstore)
+  auto read = [zarr_version](const tensorstore::KvStore& kvstore)
       -> Future<tensorstore::kvstore::ReadResult> {
-    return tensorstore::kvstore::Read(kvstore, "/.zattrs");
-    // return tensorstore::kvstore::Read(kvstore, ".zattrs");
+    if (zarr_version == zarr::ZarrVersion::kV3) {
+      // For V3, attributes are in zarr.json
+      return tensorstore::kvstore::Read(kvstore, "/zarr.json");
+    } else {
+      // For V2, attributes are in .zattrs
+      return tensorstore::kvstore::Read(kvstore, "/.zattrs");
+    }
   };
 
   // go read the attributes return json ...
-  auto parse = [](const tensorstore::kvstore::ReadResult& kvs_read,
-                  const ::nlohmann::json& spec) {
-    auto attributes =
+  auto parse = [zarr_version](const tensorstore::kvstore::ReadResult& kvs_read,
+                              const ::nlohmann::json& spec) {
+    auto parsed =
         nlohmann::json::parse(std::string(kvs_read.value), nullptr, false);
-    return attributes;
+    if (zarr_version == zarr::ZarrVersion::kV3) {
+      // For V3, extract attributes from zarr.json
+      if (parsed.contains("attributes")) {
+        return parsed["attributes"];
+      }
+      return nlohmann::json::object();
+    }
+    // For V2, the entire file is attributes
+    return parsed;
   };
 
   auto make_variable = [variable_name](
@@ -1211,15 +1227,44 @@ class Variable {
     if (!json.contains("metadata")) {
       return absl::NotFoundError("Metadata did not contain key 'metadata'.");
     }
-    if (!json["metadata"].contains("chunks")) {
-      return absl::NotFoundError(
-          "Metadata['attributes'] did not contain key 'chunks'.");
+    const auto& metadata = json["metadata"];
+
+    auto parse_chunk_array =
+        [](const nlohmann::json& chunk_json) -> Result<std::vector<long int>> {
+      if (!chunk_json.is_array()) {
+        return absl::InvalidArgumentError("Chunk shape must be an array.");
+      }
+      return chunk_json.get<std::vector<long int>>();  // NOLINT
+    };
+
+    if (metadata.contains("chunks")) {
+      return parse_chunk_array(metadata["chunks"]);
     }
-    if (!json["metadata"]["chunks"].is_array()) {
-      return absl::InvalidArgumentError("Metadata['chunks'] is not an array.");
+
+    // Zarr v3 chunk grid configuration uses chunk_shape (or chunkShape).
+    if (metadata.contains("chunk_grid") &&
+        metadata["chunk_grid"].contains("configuration")) {
+      const auto& config = metadata["chunk_grid"]["configuration"];
+      if (config.contains("chunk_shape")) {
+        return parse_chunk_array(config["chunk_shape"]);
+      }
+      if (config.contains("chunkShape")) {
+        return parse_chunk_array(config["chunkShape"]);
+      }
     }
-    return json["metadata"]["chunks"]
-        .get<std::vector<long int>>();  // NOLINT: Tensorstore convention
+
+    if (metadata.contains("chunkGrid") &&
+        metadata["chunkGrid"].contains("configuration")) {
+      const auto& config = metadata["chunkGrid"]["configuration"];
+      if (config.contains("chunk_shape")) {
+        return parse_chunk_array(config["chunk_shape"]);
+      }
+      if (config.contains("chunkShape")) {
+        return parse_chunk_array(config["chunkShape"]);
+      }
+    }
+
+    return absl::NotFoundError("Metadata did not contain chunk shape.");
   }
 
   /**
diff --git a/mdio/zarr/zarr.h b/mdio/zarr/zarr.h
new file mode 100644
index 0000000..abde076
--- /dev/null
+++ b/mdio/zarr/zarr.h
@@ -0,0 +1,199 @@
+// Copyright 2024 TGS
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef MDIO_ZARR_ZARR_H_
+#define MDIO_ZARR_ZARR_H_
+
+/**
+ * @file zarr.h
+ * @brief Unified header for Zarr support in MDIO.
+ *
+ * This header provides a unified interface for working with both Zarr V2 and
+ * Zarr V3 formats. It abstracts the differences between the two versions
+ * and provides version-agnostic operations where possible.
+ *
+ * Key features:
+ * - Zarr V2: Full support including consolidated metadata (.zmetadata)
+ * - Zarr V3: Support without consolidated metadata (as per Zarr V3 spec)
+ *
+ * Usage:
+ * @code
+ * #include "mdio/zarr/zarr.h"
+ *
+ * // Detect version from existing store
+ * auto version = mdio::zarr::DetectVersion(kvstore);
+ *
+ * // Write metadata for the appropriate version
+ * if (version == mdio::zarr::ZarrVersion::kV2) {
+ *   mdio::zarr::v2::WriteConsolidatedMetadata(metadata, variables);
+ * } else {
+ *   mdio::zarr::v3::WriteMetadata(metadata, variables);
+ * }
+ * @endcode
+ */
+
+#include "mdio/zarr/zarr_driver.h"
+#include "mdio/zarr/zarr_v2.h"
+#include "mdio/zarr/zarr_v3.h"
+
+namespace mdio {
+namespace zarr {
+
+/**
+ * @brief Writes dataset metadata using the appropriate format for the version.
+ *
+ * For V2, this writes consolidated metadata (.zmetadata, .zgroup, .zattrs).
+ * For V3, this writes only the root zarr.json (no consolidated metadata).
+ *
+ * @param version The Zarr version to use.
+ * @param dataset_metadata The metadata for the dataset.
+ * @param json_variables The JSON variables.
+ * @return An `mdio::Future<void>` representing the asynchronous write.
+ */
+inline Future<void> WriteDatasetMetadata(
+    ZarrVersion version, const ::nlohmann::json& dataset_metadata,
+    const std::vector<::nlohmann::json>& json_variables) {
+  switch (version) {
+    case ZarrVersion::kV3:
+      return v3::WriteMetadata(dataset_metadata, json_variables);
+    case ZarrVersion::kV2:
+    default:
+      return v2::WriteConsolidatedMetadata(dataset_metadata, json_variables);
+  }
+}
+
+/**
+ * @brief Reads dataset metadata using the appropriate format for the version.
+ *
+ * For V2, this reads from consolidated metadata (.zmetadata).
+ * For V3, this reads from zarr.json and discovers arrays.
+ *
+ * @param version The Zarr version to use.
+ * @param dataset_path The path to the dataset.
+ * @param kvs_future A future to the KvStore.
+ * @return A future containing dataset metadata and variable JSON specs.
+ */
+inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
+ReadDatasetMetadata(ZarrVersion version, const std::string& dataset_path,
+                    tensorstore::Future<tensorstore::KvStore> kvs_future) {
+  switch (version) {
+    case ZarrVersion::kV3:
+      return v3::ReadMetadata(dataset_path, kvs_future);
+    case ZarrVersion::kV2:
+    default:
+      return v2::ReadConsolidatedMetadata(dataset_path, kvs_future);
+  }
+}
+
+/**
+ * @brief Gets the driver name for the given version.
+ * @param version The Zarr version.
+ * @return std::string The driver name.
+ */
+inline std::string GetDriverNameForVersion(ZarrVersion version) {
+  switch (version) {
+    case ZarrVersion::kV3:
+      return std::string(v3::kDriverName);
+    case ZarrVersion::kV2:
+    default:
+      return std::string(v2::kDriverName);
+  }
+}
+
+/**
+ * @brief Converts a generic dtype string to the appropriate format.
+ *
+ * @param version The Zarr version.
+ * @param dtype The input dtype string.
+ * @return Result<nlohmann::json> The dtype in the appropriate format.
+ */
+inline Result<nlohmann::json> ConvertDtype(ZarrVersion version,
+                                           const std::string& dtype) {
+  switch (version) {
+    case ZarrVersion::kV3: {
+      MDIO_ASSIGN_OR_RETURN(auto result, v3::ToZarrDtype(dtype));
+      return result;
+    }
+    case ZarrVersion::kV2:
+    default: {
+      MDIO_ASSIGN_OR_RETURN(auto result, v2::ToZarrDtype(dtype));
+      return nlohmann::json(result);
+    }
+  }
+}
+
+/**
+ * @brief Creates a variable spec stub for the given version.
+ *
+ * @param version The Zarr version.
+ * @param variable_name The name of the variable.
+ * @param path The path prefix.
+ * @return nlohmann::json The variable spec stub.
+ */
+inline nlohmann::json CreateVariableSpec(ZarrVersion version,
+                                         const std::string& variable_name,
+                                         const std::string& path = "") {
+  switch (version) {
+    case ZarrVersion::kV3:
+      return v3::CreateVariableSpec(variable_name, path);
+    case ZarrVersion::kV2:
+    default:
+      return v2::CreateVariableSpec(variable_name, path);
+  }
+}
+
+/**
+ * @brief Checks if a JSON spec is for a Zarr V3 store.
+ *
+ * @param json_spec The JSON specification.
+ * @return bool True if the spec is for Zarr V3.
+ */
+inline bool IsV3Spec(const nlohmann::json& json_spec) {
+  if (json_spec.contains("driver")) {
+    std::string driver = json_spec["driver"].get<std::string>();
+    return driver == "zarr3";
+  }
+  return false;
+}
+
+/**
+ * @brief Extracts the Zarr version from a JSON spec.
+ *
+ * @param json_spec The JSON specification.
+ * @return ZarrVersion The detected version.
+ */
+inline ZarrVersion GetVersionFromSpec(const nlohmann::json& json_spec) {
+  if (IsV3Spec(json_spec)) {
+    return ZarrVersion::kV3;
+  }
+  return ZarrVersion::kV2;
+}
+
+/**
+ * @brief Updates a JSON spec to use the specified Zarr version.
+ *
+ * @param json_spec The JSON specification to update.
+ * @param version The target Zarr version.
+ * @return nlohmann::json The updated specification.
+ */
+inline nlohmann::json UpdateSpecVersion(nlohmann::json json_spec,
+                                        ZarrVersion version) {
+  json_spec["driver"] = GetDriverNameForVersion(version);
+  return json_spec;
+}
+
+}  // namespace zarr
+}  // namespace mdio
+
+#endif  // MDIO_ZARR_ZARR_H_
diff --git a/mdio/zarr/zarr_driver.h b/mdio/zarr/zarr_driver.h
new file mode 100644
index 0000000..38ad23c
--- /dev/null
+++ b/mdio/zarr/zarr_driver.h
@@ -0,0 +1,219 @@
+// Copyright 2024 TGS
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef MDIO_ZARR_ZARR_DRIVER_H_
+#define MDIO_ZARR_ZARR_DRIVER_H_
+
+#include <string>
+#include <vector>
+
+#include "mdio/impl.h"
+#include "tensorstore/kvstore/kvstore.h"
+#include "tensorstore/kvstore/operations.h"
+#include "tensorstore/util/future.h"
+
+// clang-format off
+#include <nlohmann/json.hpp>  // NOLINT
+// clang-format on
+
+namespace mdio {
+namespace zarr {
+
+/**
+ * @brief Enumeration representing supported Zarr format versions.
+ */
+enum class ZarrVersion {
+  kV2 = 2,  ///< Zarr V2 format
+  kV3 = 3   ///< Zarr V3 format
+};
+
+/**
+ * @brief Returns the default Zarr version to use.
+ * @return ZarrVersion The default version (V2 for backward compatibility).
+ */
+inline ZarrVersion GetDefaultVersion() { return ZarrVersion::kV2; }
+
+/**
+ * @brief Returns the TensorStore driver name for the given Zarr version.
+ * @param version The Zarr version.
+ * @return std::string The driver name ("zarr" for V2, "zarr3" for V3).
+ */
+inline std::string GetDriverName(ZarrVersion version) {
+  switch (version) {
+    case ZarrVersion::kV3:
+      return "zarr3";
+    case ZarrVersion::kV2:
+    default:
+      return "zarr";
+  }
+}
+
+/**
+ * @brief Parses a Zarr version from a string or integer.
+ * @param version_spec JSON value that may be an integer (2 or 3) or string
+ * ("2", "3", "v2", "v3").
+ * @return Result<ZarrVersion> The parsed version or an error.
+ */
+inline Result<ZarrVersion> ParseVersion(const nlohmann::json& version_spec) {
+  if (version_spec.is_number_integer()) {
+    int ver = version_spec.get<int>();
+    if (ver == 2) return ZarrVersion::kV2;
+    if (ver == 3) return ZarrVersion::kV3;
+    return absl::InvalidArgumentError(
+        "Invalid zarr version: " + std::to_string(ver) +
+        ". Supported versions are 2 and 3.");
+  }
+  if (version_spec.is_string()) {
+    std::string ver = version_spec.get<std::string>();
+    if (ver == "2" || ver == "v2" || ver == "V2") return ZarrVersion::kV2;
+    if (ver == "3" || ver == "v3" || ver == "V3") return ZarrVersion::kV3;
+    return absl::InvalidArgumentError(
+        "Invalid zarr version string: '" + ver +
+        "'. Supported versions are '2', '3', 'v2', 'v3'.");
+  }
+  return absl::InvalidArgumentError(
+      "Invalid zarr version specification. Expected integer or string.");
+}
+
+/**
+ * @brief Detects the Zarr version from an existing store by examining metadata
+ * files.
+ * @param kvstore The KvStore to examine.
+ * @return Future<ZarrVersion> The detected version or an error if unable to
+ * determine.
+ */
+inline Future<ZarrVersion> DetectVersion(
+    const tensorstore::KvStore& kvstore) {
+  // Check for zarr.json first (V3 indicator)
+  auto v3_check = tensorstore::kvstore::Read(kvstore, "zarr.json");
+
+  auto pair = tensorstore::PromiseFuturePair<ZarrVersion>::Make();
+
+  v3_check.ExecuteWhenReady(
+      [promise = pair.promise, kvstore](
+          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+              v3_result) mutable {
+        if (v3_result.result().ok() && v3_result.value().has_value()) {
+          promise.SetResult(ZarrVersion::kV3);
+          return;
+        }
+
+        // Check for .zgroup or .zmetadata (V2 indicators)
+        auto v2_check = tensorstore::kvstore::Read(kvstore, ".zgroup");
+        v2_check.ExecuteWhenReady(
+            [promise = std::move(promise)](
+                tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+                    v2_result) mutable {
+              if (v2_result.result().ok() && v2_result.value().has_value()) {
+                promise.SetResult(ZarrVersion::kV2);
+              } else {
+                // Default to V2 if we can't determine
+                promise.SetResult(ZarrVersion::kV2);
+              }
+            });
+      });
+
+  return pair.future;
+}
+
+/**
+ * @brief Base configuration for Zarr operations.
+ */
+struct ZarrConfig {
+  /// The Zarr format version to use.
+  ZarrVersion version = ZarrVersion::kV2;
+
+  /// Whether to use consolidated metadata (only applicable for V2).
+  bool use_consolidated_metadata = true;
+
+  /// The dimension separator to use.
+  std::string dimension_separator = "/";
+};
+
+/**
+ * @brief Checks if consolidated metadata is supported for the given version.
+ * @param version The Zarr version.
+ * @return bool True if consolidated metadata is supported.
+ */
+inline bool SupportsConsolidatedMetadata(ZarrVersion version) {
+  // Only Zarr V2 supports consolidated metadata
+  return version == ZarrVersion::kV2;
+}
+
+/**
+ * @brief Gets the metadata file name for the given Zarr version.
+ * @param version The Zarr version.
+ * @return std::string The metadata file name.
+ */
+inline std::string GetGroupMetadataFileName(ZarrVersion version) {
+  switch (version) {
+    case ZarrVersion::kV3:
+      return "zarr.json";
+    case ZarrVersion::kV2:
+    default:
+      return ".zgroup";
+  }
+}
+
+/**
+ * @brief Gets the array metadata file name for the given Zarr version.
+ * @param version The Zarr version.
+ * @param array_name The name of the array (used in path construction).
+ * @return std::string The array metadata file path.
+ */
+inline std::string GetArrayMetadataFileName(ZarrVersion version,
+                                            const std::string& array_name) {
+  switch (version) {
+    case ZarrVersion::kV3:
+      return array_name + "/zarr.json";
+    case ZarrVersion::kV2:
+    default:
+      return array_name + "/.zarray";
+  }
+}
+
+/**
+ * @brief Gets the attributes file name for the given Zarr version.
+ * @param version The Zarr version.
+ * @param array_name The name of the array (empty for root attributes).
+ * @return std::string The attributes file path.
+ */
+inline std::string GetAttributesFileName(ZarrVersion version,
+                                         const std::string& array_name = "") {
+  switch (version) {
+    case ZarrVersion::kV3:
+      // In V3, attributes are embedded in zarr.json
+      if (array_name.empty()) {
+        return "zarr.json";
+      }
+      return array_name + "/zarr.json";
+    case ZarrVersion::kV2:
+    default:
+      if (array_name.empty()) {
+        return ".zattrs";
+      }
+      return array_name + "/.zattrs";
+  }
+}
+
+/**
+ * @brief Gets the consolidated metadata file name (V2 only).
+ * @return std::string The consolidated metadata file name.
+ */
+inline std::string GetConsolidatedMetadataFileName() { return ".zmetadata"; }
+
+}  // namespace zarr
+}  // namespace mdio
+
+#endif  // MDIO_ZARR_ZARR_DRIVER_H_
diff --git a/mdio/zarr/zarr_test.cc b/mdio/zarr/zarr_test.cc
new file mode 100644
index 0000000..1aafe92
--- /dev/null
+++ b/mdio/zarr/zarr_test.cc
@@ -0,0 +1,517 @@
+// Copyright 2024 TGS
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "mdio/zarr/zarr.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <filesystem>
+#include <string>
+
+#include "tensorstore/kvstore/kvstore.h"
+#include "tensorstore/kvstore/operations.h"
+
+// clang-format off
+#include <nlohmann/json.hpp>  // NOLINT
+// clang-format on
+
+namespace {
+
+// =============================================================================
+// ZarrDriver Tests
+// =============================================================================
+
+namespace ZarrDriverTests {
+
+TEST(ZarrDriver, GetDefaultVersion) {
+  auto version = mdio::zarr::GetDefaultVersion();
+  EXPECT_EQ(version, mdio::zarr::ZarrVersion::kV2);
+}
+
+TEST(ZarrDriver, GetDriverName_V2) {
+  auto name = mdio::zarr::GetDriverName(mdio::zarr::ZarrVersion::kV2);
+  EXPECT_EQ(name, "zarr");
+}
+
+TEST(ZarrDriver, GetDriverName_V3) {
+  auto name = mdio::zarr::GetDriverName(mdio::zarr::ZarrVersion::kV3);
+  EXPECT_EQ(name, "zarr3");
+}
+
+TEST(ZarrDriver, ParseVersion_Integer_V2) {
+  nlohmann::json version_spec = 2;
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), mdio::zarr::ZarrVersion::kV2);
+}
+
+TEST(ZarrDriver, ParseVersion_Integer_V3) {
+  nlohmann::json version_spec = 3;
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), mdio::zarr::ZarrVersion::kV3);
+}
+
+TEST(ZarrDriver, ParseVersion_String_V2) {
+  nlohmann::json version_spec = "2";
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), mdio::zarr::ZarrVersion::kV2);
+
+  version_spec = "v2";
+  result = mdio::zarr::ParseVersion(version_spec);
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), mdio::zarr::ZarrVersion::kV2);
+}
+
+TEST(ZarrDriver, ParseVersion_String_V3) {
+  nlohmann::json version_spec = "3";
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), mdio::zarr::ZarrVersion::kV3);
+
+  version_spec = "v3";
+  result = mdio::zarr::ParseVersion(version_spec);
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), mdio::zarr::ZarrVersion::kV3);
+}
+
+TEST(ZarrDriver, ParseVersion_Invalid) {
+  nlohmann::json version_spec = 4;
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  EXPECT_FALSE(result.ok());
+
+  version_spec = "v4";
+  result = mdio::zarr::ParseVersion(version_spec);
+  EXPECT_FALSE(result.ok());
+}
+
+TEST(ZarrDriver, SupportsConsolidatedMetadata_V2) {
+  EXPECT_TRUE(
+      mdio::zarr::SupportsConsolidatedMetadata(mdio::zarr::ZarrVersion::kV2));
+}
+
+TEST(ZarrDriver, SupportsConsolidatedMetadata_V3) {
+  // V3 does NOT support consolidated metadata
+  EXPECT_FALSE(
+      mdio::zarr::SupportsConsolidatedMetadata(mdio::zarr::ZarrVersion::kV3));
+}
+
+TEST(ZarrDriver, GetGroupMetadataFileName_V2) {
+  auto filename =
+      mdio::zarr::GetGroupMetadataFileName(mdio::zarr::ZarrVersion::kV2);
+  EXPECT_EQ(filename, ".zgroup");
+}
+
+TEST(ZarrDriver, GetGroupMetadataFileName_V3) {
+  auto filename =
+      mdio::zarr::GetGroupMetadataFileName(mdio::zarr::ZarrVersion::kV3);
+  EXPECT_EQ(filename, "zarr.json");
+}
+
+TEST(ZarrDriver, GetArrayMetadataFileName_V2) {
+  auto filename = mdio::zarr::GetArrayMetadataFileName(
+      mdio::zarr::ZarrVersion::kV2, "myarray");
+  EXPECT_EQ(filename, "myarray/.zarray");
+}
+
+TEST(ZarrDriver, GetArrayMetadataFileName_V3) {
+  auto filename = mdio::zarr::GetArrayMetadataFileName(
+      mdio::zarr::ZarrVersion::kV3, "myarray");
+  EXPECT_EQ(filename, "myarray/zarr.json");
+}
+
+TEST(ZarrDriver, GetAttributesFileName_V2_Root) {
+  auto filename =
+      mdio::zarr::GetAttributesFileName(mdio::zarr::ZarrVersion::kV2);
+  EXPECT_EQ(filename, ".zattrs");
+}
+
+TEST(ZarrDriver, GetAttributesFileName_V2_Array) {
+  auto filename =
+      mdio::zarr::GetAttributesFileName(mdio::zarr::ZarrVersion::kV2, "arr");
+  EXPECT_EQ(filename, "arr/.zattrs");
+}
+
+TEST(ZarrDriver, GetAttributesFileName_V3_Root) {
+  auto filename =
+      mdio::zarr::GetAttributesFileName(mdio::zarr::ZarrVersion::kV3);
+  EXPECT_EQ(filename, "zarr.json");
+}
+
+TEST(ZarrDriver, GetAttributesFileName_V3_Array) {
+  auto filename =
+      mdio::zarr::GetAttributesFileName(mdio::zarr::ZarrVersion::kV3, "arr");
+  EXPECT_EQ(filename, "arr/zarr.json");
+}
+
+TEST(ZarrDriver, GetConsolidatedMetadataFileName) {
+  auto filename = mdio::zarr::GetConsolidatedMetadataFileName();
+  EXPECT_EQ(filename, ".zmetadata");
+}
+
+}  // namespace ZarrDriverTests
+
+// =============================================================================
+// Zarr V2 Tests
+// =============================================================================
+
+namespace ZarrV2Tests {
+
+TEST(ZarrV2, DriverName) {
+  EXPECT_EQ(mdio::zarr::v2::kDriverName, "zarr");
+}
+
+TEST(ZarrV2, ZarrFormat) { EXPECT_EQ(mdio::zarr::v2::kZarrFormat, 2); }
+
+TEST(ZarrV2, ConsolidatedFormat) {
+  EXPECT_EQ(mdio::zarr::v2::kConsolidatedFormat, 1);
+}
+
+TEST(ZarrV2, ToZarrDtype_int8) {
+  auto result = mdio::zarr::v2::ToZarrDtype("int8");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<i1");
+}
+
+TEST(ZarrV2, ToZarrDtype_int16) {
+  auto result = mdio::zarr::v2::ToZarrDtype("int16");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<i2");
+}
+
+TEST(ZarrV2, ToZarrDtype_int32) {
+  auto result = mdio::zarr::v2::ToZarrDtype("int32");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<i4");
+}
+
+TEST(ZarrV2, ToZarrDtype_int64) {
+  auto result = mdio::zarr::v2::ToZarrDtype("int64");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<i8");
+}
+
+TEST(ZarrV2, ToZarrDtype_uint8) {
+  auto result = mdio::zarr::v2::ToZarrDtype("uint8");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<u1");
+}
+
+TEST(ZarrV2, ToZarrDtype_uint16) {
+  auto result = mdio::zarr::v2::ToZarrDtype("uint16");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<u2");
+}
+
+TEST(ZarrV2, ToZarrDtype_uint32) {
+  auto result = mdio::zarr::v2::ToZarrDtype("uint32");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<u4");
+}
+
+TEST(ZarrV2, ToZarrDtype_uint64) {
+  auto result = mdio::zarr::v2::ToZarrDtype("uint64");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<u8");
+}
+
+TEST(ZarrV2, ToZarrDtype_float16) {
+  auto result = mdio::zarr::v2::ToZarrDtype("float16");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<f2");
+}
+
+TEST(ZarrV2, ToZarrDtype_float32) {
+  auto result = mdio::zarr::v2::ToZarrDtype("float32");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<f4");
+}
+
+TEST(ZarrV2, ToZarrDtype_float64) {
+  auto result = mdio::zarr::v2::ToZarrDtype("float64");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<f8");
+}
+
+TEST(ZarrV2, ToZarrDtype_bool) {
+  auto result = mdio::zarr::v2::ToZarrDtype("bool");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "|b1");
+}
+
+TEST(ZarrV2, ToZarrDtype_complex64) {
+  auto result = mdio::zarr::v2::ToZarrDtype("complex64");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<c8");
+}
+
+TEST(ZarrV2, ToZarrDtype_complex128) {
+  auto result = mdio::zarr::v2::ToZarrDtype("complex128");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<c16");
+}
+
+TEST(ZarrV2, ToZarrDtype_invalid) {
+  auto result = mdio::zarr::v2::ToZarrDtype("unknown_type");
+  EXPECT_FALSE(result.ok());
+}
+
+TEST(ZarrV2, CreateZgroup) {
+  auto zgroup = mdio::zarr::v2::CreateZgroup();
+  EXPECT_TRUE(zgroup.contains("zarr_format"));
+  EXPECT_EQ(zgroup["zarr_format"], 2);
+}
+
+TEST(ZarrV2, CreateVariableSpec) {
+  auto spec = mdio::zarr::v2::CreateVariableSpec("test_var");
+  EXPECT_TRUE(spec.contains("driver"));
+  EXPECT_EQ(spec["driver"], "zarr");
+  EXPECT_TRUE(spec.contains("kvstore"));
+  EXPECT_TRUE(spec.contains("metadata"));
+  EXPECT_TRUE(spec.contains("attributes"));
+}
+
+TEST(ZarrV2, PrepareVariableAttributes) {
+  nlohmann::json input = {
+      {"attributes",
+       {{"dimension_names", {"x", "y"}},
+        {"variable_name", "test"},
+        {"long_name", "Test Variable"},
+        {"metadata", {{"chunkGrid", "should_be_removed"}, {"key", "value"}}}}}};
+
+  auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
+
+  EXPECT_TRUE(attrs.contains("_ARRAY_DIMENSIONS"));
+  EXPECT_FALSE(attrs.contains("dimension_names"));
+  EXPECT_FALSE(attrs.contains("variable_name"));
+  EXPECT_EQ(attrs["long_name"], "Test Variable");
+  EXPECT_TRUE(attrs.contains("key"));
+  EXPECT_EQ(attrs["key"], "value");
+  EXPECT_FALSE(attrs.contains("metadata"));
+  EXPECT_FALSE(attrs.contains("chunkGrid"));
+}
+
+}  // namespace ZarrV2Tests
+
+// =============================================================================
+// Zarr V3 Tests
+// =============================================================================
+
+namespace ZarrV3Tests {
+
+TEST(ZarrV3, DriverName) {
+  EXPECT_EQ(mdio::zarr::v3::kDriverName, "zarr3");
+}
+
+TEST(ZarrV3, ZarrFormat) { EXPECT_EQ(mdio::zarr::v3::kZarrFormat, 3); }
+
+TEST(ZarrV3, NodeTypes) {
+  EXPECT_EQ(mdio::zarr::v3::kGroupNodeType, "group");
+  EXPECT_EQ(mdio::zarr::v3::kArrayNodeType, "array");
+}
+
+TEST(ZarrV3, ToZarrDtype_int8) {
+  auto result = mdio::zarr::v3::ToZarrDtype("int8");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "int8");
+}
+
+TEST(ZarrV3, ToZarrDtype_float32) {
+  auto result = mdio::zarr::v3::ToZarrDtype("float32");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "float32");
+}
+
+TEST(ZarrV3, ToZarrDtype_float64) {
+  auto result = mdio::zarr::v3::ToZarrDtype("float64");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "float64");
+}
+
+TEST(ZarrV3, ToZarrDtype_complex128) {
+  auto result = mdio::zarr::v3::ToZarrDtype("complex128");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "complex128");
+}
+
+TEST(ZarrV3, ToZarrDtype_invalid) {
+  auto result = mdio::zarr::v3::ToZarrDtype("unknown_type");
+  EXPECT_FALSE(result.ok());
+}
+
+TEST(ZarrV3, CreateGroupMetadata_Empty) {
+  auto metadata = mdio::zarr::v3::CreateGroupMetadata();
+  EXPECT_EQ(metadata["zarr_format"], 3);
+  EXPECT_EQ(metadata["node_type"], "group");
+  EXPECT_FALSE(metadata.contains("attributes"));
+}
+
+TEST(ZarrV3, CreateGroupMetadata_WithAttributes) {
+  nlohmann::json attrs = {{"name", "test"}, {"version", "1.0"}};
+  auto metadata = mdio::zarr::v3::CreateGroupMetadata(attrs);
+  EXPECT_EQ(metadata["zarr_format"], 3);
+  EXPECT_EQ(metadata["node_type"], "group");
+  EXPECT_TRUE(metadata.contains("attributes"));
+  EXPECT_EQ(metadata["attributes"]["name"], "test");
+}
+
+TEST(ZarrV3, CreateArrayMetadata) {
+  std::vector<int64_t> shape = {100, 200};
+  std::vector<int64_t> chunks = {50, 50};
+  auto metadata =
+      mdio::zarr::v3::CreateArrayMetadata(shape, chunks, "float32");
+
+  EXPECT_EQ(metadata["zarr_format"], 3);
+  EXPECT_EQ(metadata["node_type"], "array");
+  EXPECT_EQ(metadata["shape"], shape);
+  EXPECT_TRUE(metadata.contains("chunk_grid"));
+  EXPECT_EQ(metadata["chunk_grid"]["name"], "regular");
+  EXPECT_EQ(metadata["chunk_grid"]["configuration"]["chunk_shape"], chunks);
+  EXPECT_EQ(metadata["data_type"], "float32");
+  EXPECT_TRUE(metadata.contains("codecs"));
+}
+
+TEST(ZarrV3, CreateVariableSpec) {
+  auto spec = mdio::zarr::v3::CreateVariableSpec("test_var");
+  EXPECT_TRUE(spec.contains("driver"));
+  EXPECT_EQ(spec["driver"], "zarr3");
+  EXPECT_TRUE(spec.contains("kvstore"));
+  EXPECT_TRUE(spec.contains("metadata"));
+  EXPECT_TRUE(spec.contains("attributes"));
+}
+
+TEST(ZarrV3, PrepareVariableAttributes) {
+  nlohmann::json input = {
+      {"attributes",
+       {{"dimension_names", {"x", "y", "z"}},
+        {"variable_name", "test"},
+        {"long_name", ""},  // Empty should be removed
+        {"metadata",
+         {{"chunkGrid", "should_be_removed"}, {"custom", "value"}}}}}};
+
+  auto attrs = mdio::zarr::v3::PrepareVariableAttributes(input);
+
+  EXPECT_TRUE(attrs.contains("_ARRAY_DIMENSIONS"));
+  EXPECT_FALSE(attrs.contains("dimension_names"));
+  EXPECT_FALSE(attrs.contains("variable_name"));
+  EXPECT_FALSE(attrs.contains("long_name"));  // Empty removed
+  EXPECT_TRUE(attrs.contains("custom"));
+  EXPECT_EQ(attrs["custom"], "value");
+}
+
+TEST(ZarrV3, ConvertToMdioMetadata) {
+  nlohmann::json zarr_json = {
+      {"zarr_format", 3},
+      {"node_type", "array"},
+      {"attributes", {{"_ARRAY_DIMENSIONS", {"x", "y"}}, {"key", "value"}}}};
+
+  auto metadata = mdio::zarr::v3::ConvertToMdioMetadata(zarr_json);
+
+  EXPECT_TRUE(metadata.contains("dimension_names"));
+  EXPECT_FALSE(metadata.contains("_ARRAY_DIMENSIONS"));
+  EXPECT_TRUE(metadata.contains("key"));
+}
+
+}  // namespace ZarrV3Tests
+
+// =============================================================================
+// Unified Zarr Interface Tests
+// =============================================================================
+
+namespace ZarrUnifiedTests {
+
+TEST(ZarrUnified, GetDriverNameForVersion_V2) {
+  auto name =
+      mdio::zarr::GetDriverNameForVersion(mdio::zarr::ZarrVersion::kV2);
+  EXPECT_EQ(name, "zarr");
+}
+
+TEST(ZarrUnified, GetDriverNameForVersion_V3) {
+  auto name =
+      mdio::zarr::GetDriverNameForVersion(mdio::zarr::ZarrVersion::kV3);
+  EXPECT_EQ(name, "zarr3");
+}
+
+TEST(ZarrUnified, ConvertDtype_V2) {
+  auto result =
+      mdio::zarr::ConvertDtype(mdio::zarr::ZarrVersion::kV2, "float32");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "<f4");
+}
+
+TEST(ZarrUnified, ConvertDtype_V3) {
+  auto result =
+      mdio::zarr::ConvertDtype(mdio::zarr::ZarrVersion::kV3, "float32");
+  ASSERT_TRUE(result.ok()) << result.status();
+  EXPECT_EQ(result.value(), "float32");
+}
+
+TEST(ZarrUnified, CreateVariableSpec_V2) {
+  auto spec =
+      mdio::zarr::CreateVariableSpec(mdio::zarr::ZarrVersion::kV2, "var");
+  EXPECT_EQ(spec["driver"], "zarr");
+}
+
+TEST(ZarrUnified, CreateVariableSpec_V3) {
+  auto spec =
+      mdio::zarr::CreateVariableSpec(mdio::zarr::ZarrVersion::kV3, "var");
+  EXPECT_EQ(spec["driver"], "zarr3");
+}
+
+TEST(ZarrUnified, IsV3Spec_True) {
+  nlohmann::json spec = {{"driver", "zarr3"}};
+  EXPECT_TRUE(mdio::zarr::IsV3Spec(spec));
+}
+
+TEST(ZarrUnified, IsV3Spec_False) {
+  nlohmann::json spec = {{"driver", "zarr"}};
+  EXPECT_FALSE(mdio::zarr::IsV3Spec(spec));
+}
+
+TEST(ZarrUnified, IsV3Spec_NoDriver) {
+  nlohmann::json spec = {{"path", "test"}};
+  EXPECT_FALSE(mdio::zarr::IsV3Spec(spec));
+}
+
+TEST(ZarrUnified, GetVersionFromSpec_V2) {
+  nlohmann::json spec = {{"driver", "zarr"}};
+  EXPECT_EQ(mdio::zarr::GetVersionFromSpec(spec), mdio::zarr::ZarrVersion::kV2);
+}
+
+TEST(ZarrUnified, GetVersionFromSpec_V3) {
+  nlohmann::json spec = {{"driver", "zarr3"}};
+  EXPECT_EQ(mdio::zarr::GetVersionFromSpec(spec), mdio::zarr::ZarrVersion::kV3);
+}
+
+TEST(ZarrUnified, UpdateSpecVersion_ToV3) {
+  nlohmann::json spec = {{"driver", "zarr"}, {"path", "test"}};
+  auto updated =
+      mdio::zarr::UpdateSpecVersion(spec, mdio::zarr::ZarrVersion::kV3);
+  EXPECT_EQ(updated["driver"], "zarr3");
+  EXPECT_EQ(updated["path"], "test");  // Other fields preserved
+}
+
+TEST(ZarrUnified, UpdateSpecVersion_ToV2) {
+  nlohmann::json spec = {{"driver", "zarr3"}, {"path", "test"}};
+  auto updated =
+      mdio::zarr::UpdateSpecVersion(spec, mdio::zarr::ZarrVersion::kV2);
+  EXPECT_EQ(updated["driver"], "zarr");
+  EXPECT_EQ(updated["path"], "test");
+}
+
+}  // namespace ZarrUnifiedTests
+
+}  // namespace
diff --git a/mdio/zarr/zarr_v2.h b/mdio/zarr/zarr_v2.h
new file mode 100644
index 0000000..7db6059
--- /dev/null
+++ b/mdio/zarr/zarr_v2.h
@@ -0,0 +1,499 @@
+// Copyright 2024 TGS
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef MDIO_ZARR_ZARR_V2_H_
+#define MDIO_ZARR_ZARR_V2_H_
+
+#include <filesystem>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "absl/strings/str_split.h"
+#include "mdio/impl.h"
+#include "mdio/zarr/zarr_driver.h"
+#include "tensorstore/driver/zarr/metadata.h"
+#include "tensorstore/kvstore/kvstore.h"
+#include "tensorstore/kvstore/operations.h"
+#include "tensorstore/util/future.h"
+
+// clang-format off
+#include <nlohmann/json.hpp>  // NOLINT
+// clang-format on
+
+namespace mdio {
+namespace zarr {
+namespace v2 {
+
+/**
+ * @brief Gets the Zarr V2 driver name.
+ * @return constexpr std::string_view The driver name.
+ */
+constexpr std::string_view kDriverName = "zarr";
+
+/**
+ * @brief The Zarr format version for V2.
+ */
+constexpr int kZarrFormat = 2;
+
+/**
+ * @brief The consolidated metadata format version.
+ */
+constexpr int kConsolidatedFormat = 1;
+
+/**
+ * @brief Retrieves the .zarray JSON metadata from the given metadata.
+ *
+ * This function derives the .zarray JSON metadata without actually reading it.
+ *
+ * @param metadata The input JSON metadata.
+ * @return An `mdio::Result` containing the .zarray JSON metadata on success, or
+ * an error on failure.
+ */
+inline Result<nlohmann::json> GetZarray(const ::nlohmann::json& metadata) {
+  auto json = metadata;
+  nlohmann::json zarray;
+  if (!json.contains("metadata")) {
+    json["metadata"] = nlohmann::json::object();
+    json["metadata"]["attributes"] = nlohmann::json::object();
+  }
+
+  // These fields can have defaults:
+  if (!json["metadata"].contains("order")) {
+    zarray["order"] = "C";
+  } else {
+    zarray["order"] = json["metadata"]["order"];
+  }
+  if (!json["metadata"].contains("filters")) {
+    zarray["filters"] = nullptr;
+  } else {
+    zarray["filters"] = json["metadata"]["filters"];
+  }
+
+  if (!json["metadata"].contains("fill_value")) {
+    zarray["fill_value"] = nullptr;
+  } else {
+    zarray["fill_value"] = json["metadata"]["fill_value"];
+  }
+
+  if (!json["metadata"].contains("zarr_format")) {
+    zarray["zarr_format"] = kZarrFormat;
+  } else {
+    zarray["zarr_format"] = json["metadata"]["zarr_format"];
+  }
+
+  if (!json["metadata"].contains("chunks") &&
+      json["metadata"].contains("shape")) {
+    zarray["chunks"] = json["metadata"]["shape"];
+  } else {
+    zarray["chunks"] = json["metadata"]["chunks"];
+  }
+
+  if (!json["metadata"].contains("compressor")) {
+    zarray["compressor"] = nullptr;
+  } else {
+    zarray["compressor"] = json["metadata"]["compressor"];
+  }
+
+  if (!json["metadata"].contains("dimension_separator")) {
+    zarray["dimension_separator"] = "/";
+  } else {
+    zarray["dimension_separator"] = json["metadata"]["dimension_separator"];
+  }
+
+  zarray["shape"] = json["metadata"]["shape"];
+  zarray["dtype"] = json["metadata"]["dtype"];
+
+  MDIO_ASSIGN_OR_RETURN(
+      auto zarr_metadata,
+      tensorstore::internal_zarr::ZarrMetadata::FromJson(zarray))
+
+  return ::nlohmann::json(zarr_metadata);
+}
+
+/**
+ * @brief Creates the .zgroup JSON for Zarr V2.
+ * @return nlohmann::json The .zgroup content.
+ */
+inline nlohmann::json CreateZgroup() {
+  nlohmann::json zgroup;
+  zgroup["zarr_format"] = kZarrFormat;
+  return zgroup;
+}
+
+/**
+ * @brief Prepares variable attributes JSON for .zattrs file.
+ *
+ * @param json The variable JSON specification.
+ * @return nlohmann::json The prepared attributes.
+ */
+inline nlohmann::json PrepareVariableAttributes(const nlohmann::json& json) {
+  nlohmann::json fixedJson = json["attributes"];
+  fixedJson["_ARRAY_DIMENSIONS"] = fixedJson["dimension_names"];
+  fixedJson.erase("dimension_names");
+
+  // We do not want to be serializing the variable_name
+  if (fixedJson.contains("variable_name")) {
+    fixedJson.erase("variable_name");
+  }
+  if (fixedJson.contains("long_name") &&
+      fixedJson["long_name"].get<std::string>() == "") {
+    fixedJson.erase("long_name");
+  }
+  if (fixedJson.contains("metadata")) {
+    if (fixedJson["metadata"].contains("chunkGrid")) {
+      fixedJson["metadata"].erase("chunkGrid");
+    }
+    for (auto& item : fixedJson["metadata"].items()) {
+      fixedJson[item.key()] = std::move(item.value());
+    }
+    fixedJson.erase("metadata");
+  }
+  // Case where an empty array of coordinates were provided
+  if (fixedJson.contains("coordinates")) {
+    auto coords = fixedJson["coordinates"];
+    if (coords.empty() ||
+        (coords.is_string() && coords.get<std::string>() == "")) {
+      fixedJson.erase("coordinates");
+    }
+  }
+  return fixedJson;
+}
+
+/**
+ * @brief Writes the consolidated metadata (.zmetadata) for a dataset.
+ *
+ * @param dataset_metadata The metadata for the dataset.
+ * @param json_variables The JSON variables.
+ * @return An `mdio::Future<void>` representing the asynchronous write.
+ */
+inline Future<void> WriteConsolidatedMetadata(
+    const ::nlohmann::json& dataset_metadata,
+    const std::vector<::nlohmann::json>& json_variables) {
+  auto zattrs = dataset_metadata;
+  ::nlohmann::json zgroup = CreateZgroup();
+
+  // The consolidated metadata for the dataset
+  ::nlohmann::json zmetadata;
+  zmetadata["zarr_consolidated_format"] = kConsolidatedFormat;
+  zmetadata["metadata"][".zattrs"] = zattrs;
+  zmetadata["metadata"][".zgroup"] = zgroup;
+
+  std::string zarray_key;
+  std::string zattrs_key;
+  std::string driver =
+      json_variables[0]["kvstore"]["driver"].get<std::string>();
+
+  for (const auto& json : json_variables) {
+    zarray_key =
+        std::filesystem::path(json["kvstore"]["path"]).stem() / ".zarray";
+    zattrs_key =
+        std::filesystem::path(json["kvstore"]["path"]).stem() / ".zattrs";
+
+    MDIO_ASSIGN_OR_RETURN(zmetadata["metadata"][zarray_key], GetZarray(json))
+    zmetadata["metadata"][zattrs_key] = PrepareVariableAttributes(json);
+  }
+
+  nlohmann::json kvstore = nlohmann::json::object();
+  kvstore["driver"] = driver;
+  std::vector<std::string> file_parts = absl::StrSplit(
+      json_variables[0]["kvstore"]["path"].get<std::string>(), '/');
+  size_t toRemove = file_parts.back().size();
+  std::string strippedPath =
+      json_variables[0]["kvstore"]["path"].get<std::string>().substr(
+          0, json_variables[0]["kvstore"]["path"].get<std::string>().size() -
+                 toRemove - 1);
+  kvstore["path"] = strippedPath;
+
+  if (driver == "gcs" || driver == "s3") {
+    kvstore["bucket"] =
+        json_variables[0]["kvstore"]["bucket"].get<std::string>();
+    std::string cloudPath = kvstore["path"].get<std::string>();
+    kvstore["path"] = cloudPath;
+  }
+
+  auto kvs_future = tensorstore::kvstore::Open(kvstore);
+
+  auto zattrs_future = tensorstore::MapFutureValue(
+      tensorstore::InlineExecutor{},
+      [zattrs = std::move(zattrs)](const tensorstore::KvStore& kvstore) {
+        return tensorstore::kvstore::Write(kvstore, "/.zattrs",
+                                           absl::Cord(zattrs.dump(4)));
+      },
+      kvs_future);
+
+  auto zmetadata_future = tensorstore::MapFutureValue(
+      tensorstore::InlineExecutor{},
+      [zmetadata = std::move(zmetadata)](const tensorstore::KvStore& kvstore) {
+        return tensorstore::kvstore::Write(kvstore, "/.zmetadata",
+                                           absl::Cord(zmetadata.dump(4)));
+      },
+      kvs_future);
+
+  auto zgroup_future = tensorstore::MapFutureValue(
+      tensorstore::InlineExecutor{},
+      [zgroup = std::move(zgroup)](const tensorstore::KvStore& kvstore) {
+        return tensorstore::kvstore::Write(kvstore, "/.zgroup",
+                                           absl::Cord(zgroup.dump(4)));
+      },
+      kvs_future);
+
+  return tensorstore::WaitAllFuture(zattrs_future, zmetadata_future,
+                                    zgroup_future);
+}
+
+/**
+ * @brief Reads and parses the consolidated metadata from a dataset path.
+ *
+ * @param dataset_path The path to the dataset.
+ * @param kvs_future A future to the KvStore.
+ * @return A future containing dataset metadata and variable JSON specs.
+ */
+inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
+ReadConsolidatedMetadata(
+    const std::string& dataset_path,
+    tensorstore::Future<tensorstore::KvStore> kvs_future) {
+  // Normalize the dataset path once so we can safely append variable names.
+  std::string normalized_path = dataset_path;
+  if (!normalized_path.empty() && normalized_path.back() != '/') {
+    normalized_path.push_back('/');
+  }
+
+  auto pair = tensorstore::PromiseFuturePair<
+      std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>::Make();
+
+  kvs_future.ExecuteWhenReady(
+      [promise = std::move(pair.promise), dataset_path, normalized_path](
+          tensorstore::ReadyFuture<tensorstore::KvStore> ready_kvs) {
+        if (!ready_kvs.result().ok()) {
+          promise.SetResult(ready_kvs.result().status());
+          return;
+        }
+
+        auto kvs = ready_kvs.value();
+        // Infer the driver before issuing the read so we can reuse it later.
+        std::string driver = "file";
+        if (dataset_path.length() > 5) {
+          if (dataset_path.substr(0, 5) == "gs://") {
+            driver = "gcs";
+          } else if (dataset_path.substr(0, 5) == "s3://") {
+            driver = "s3";
+          }
+        }
+        std::string bucket;
+        std::string cloudPath;
+        if (driver != "file") {
+          std::string providedPath = dataset_path.substr(5);
+          size_t bucketLen = providedPath.find_first_of('/');
+          bucket = providedPath.substr(0, bucketLen);
+          cloudPath = providedPath.substr(bucketLen + 1);
+          if (!cloudPath.empty() && cloudPath.back() != '/') {
+            cloudPath.push_back('/');
+          }
+        }
+
+        auto read_future = tensorstore::kvstore::Read(kvs, ".zmetadata");
+        read_future.ExecuteWhenReady(
+            [promise = std::move(promise), dataset_path, normalized_path, driver,
+             bucket, cloudPath](tensorstore::ReadyFuture<
+                                tensorstore::kvstore::ReadResult> ready_read) {
+              if (!ready_read.result().ok()) {
+                promise.SetResult(ready_read.result().status());
+                return;
+              }
+              auto read_result = ready_read.result().value();
+
+              ::nlohmann::json zmetadata;
+              try {
+                zmetadata = ::nlohmann::json::parse(
+                    std::string(read_result.value));
+              } catch (const nlohmann::json::parse_error& e) {
+                if (!dataset_path.empty() && dataset_path.back() != '/') {
+                  promise.SetResult(absl::InvalidArgumentError(
+                      "Failed to parse .zmetadata. Try adding a trailing slash "
+                      "to the path."));
+                  return;
+                }
+                promise.SetResult(absl::InvalidArgumentError(
+                    std::string("JSON parse error: ") + e.what()));
+                return;
+              }
+
+              if (!zmetadata.contains("metadata")) {
+                promise.SetResult(absl::InvalidArgumentError(
+                    "zmetadata does not contain metadata."));
+                return;
+              }
+
+              if (!zmetadata["metadata"].contains(".zattrs")) {
+                promise.SetResult(absl::InvalidArgumentError(
+                    "zmetadata does not contain dataset metadata."));
+                return;
+              }
+
+              auto dataset_metadata = zmetadata["metadata"][".zattrs"];
+
+              zmetadata["metadata"].erase(".zattrs");
+              std::vector<nlohmann::json> json_vars_from_zmeta;
+
+              for (auto& element : zmetadata["metadata"].items()) {
+                if (element.key().substr(element.key().find_last_of(".") + 1) ==
+                    "zarray") {
+                  std::string variable_name =
+                      element.key().substr(0, element.key().find("/"));
+                  nlohmann::json new_dict = {
+                      {"driver", std::string(kDriverName)},
+                      {"kvstore",
+                       {{"driver", driver},
+                        {"path", normalized_path + variable_name}}}};
+                  if (driver != "file") {
+                    new_dict["kvstore"]["bucket"] = bucket;
+                    new_dict["kvstore"]["path"] = cloudPath + variable_name;
+                  }
+                  json_vars_from_zmeta.push_back(new_dict);
+                }
+              }
+
+              if (json_vars_from_zmeta.empty()) {
+                promise.SetResult(absl::InvalidArgumentError(
+                    "No variables found in zmetadata."));
+                return;
+              }
+
+              promise.SetResult(
+                  std::make_tuple(dataset_metadata, json_vars_from_zmeta));
+            });
+      });
+
+  return pair.future;
+}
+
+/**
+ * @brief Creates a Variable spec for Zarr V2.
+ * @param variable_name The name of the variable.
+ * @param path The path prefix.
+ * @return nlohmann::json The variable spec stub.
+ */
+inline nlohmann::json CreateVariableSpec(const std::string& variable_name,
+                                         const std::string& path = "") {
+  nlohmann::json spec = {{"driver", std::string(kDriverName)},
+                         {"kvstore",
+                          {{"driver", "file"}, {"path", variable_name}}},
+                         {"metadata",
+                          {{"dtype", "DATA_TYPE"},
+                           {"dimension_separator", "/"},
+                           {"shape", "SHAPE"},
+                           {"chunks", "CHUNKS"}}},
+                         {"attributes", nlohmann::json::object()}};
+  return spec;
+}
+
+/**
+ * @brief Writes variable attributes to .zattrs file.
+ *
+ * @param store The TensorStore to write to.
+ * @param json_var The variable attributes JSON.
+ * @param isCloudStore Whether the store is a cloud store.
+ * @return Future<tensorstore::TimestampedStorageGeneration> The write result.
+ */
+template <typename T, DimensionIndex R, ReadWriteMode M>
+Future<tensorstore::TimestampedStorageGeneration> WriteVariableAttributes(
+    const tensorstore::TensorStore<T, R, M>& store,
+    const ::nlohmann::json& json_var, bool isCloudStore) {
+  auto output_json = json_var;
+  output_json["_ARRAY_DIMENSIONS"] = output_json["dimension_names"];
+  output_json.erase("dimension_names");
+  output_json.erase("variable_name");
+
+  if (output_json.contains("metadata")) {
+    output_json["metadata"].erase("chunkGrid");
+    for (auto& item : output_json["metadata"].items()) {
+      output_json[item.key()] = std::move(item.value());
+    }
+    output_json.erase("metadata");
+  }
+  if (output_json.contains("long_name")) {
+    if (output_json["long_name"] == "") {
+      output_json.erase("long_name");
+    }
+  }
+  // Case where empty array of coordinates is provided
+  if (output_json.contains("coordinates")) {
+    auto coords = output_json["coordinates"];
+    if (coords.empty() ||
+        (coords.is_string() && coords.get<std::string>() == "")) {
+      output_json.erase("coordinates");
+    }
+  }
+
+  std::string outpath = ".zattrs";
+  return tensorstore::kvstore::Write(store.kvstore(), outpath,
+                                     absl::Cord(output_json.dump(4)));
+}
+
+/**
+ * @brief Reads variable attributes from .zattrs file.
+ *
+ * @param kvstore The KvStore to read from.
+ * @return Future<nlohmann::json> The attributes JSON.
+ */
+inline Future<nlohmann::json> ReadVariableAttributes(
+    const tensorstore::KvStore& kvstore) {
+  auto pair = tensorstore::PromiseFuturePair<nlohmann::json>::Make();
+
+  auto read_future = tensorstore::kvstore::Read(kvstore, "/.zattrs");
+  read_future.ExecuteWhenReady(
+      [promise = std::move(pair.promise)](
+          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+              ready_result) {
+        if (!ready_result.result().ok()) {
+          promise.SetResult(ready_result.result().status());
+          return;
+        }
+        auto attributes = nlohmann::json::parse(
+            std::string(ready_result.value().value), nullptr, false);
+        promise.SetResult(attributes);
+      });
+
+  return pair.future;
+}
+
+/**
+ * @brief Converts a dtype string to Zarr V2 numpy-style dtype.
+ * @param dtype The input dtype string.
+ * @return Result<std::string> The Zarr V2 dtype string.
+ */
+inline Result<std::string> ToZarrDtype(const std::string& dtype) {
+  if (dtype == "int8") return "<i1";
+  if (dtype == "int16") return "<i2";
+  if (dtype == "int32") return "<i4";
+  if (dtype == "int64") return "<i8";
+  if (dtype == "uint8") return "<u1";
+  if (dtype == "uint16") return "<u2";
+  if (dtype == "uint32") return "<u4";
+  if (dtype == "uint64") return "<u8";
+  if (dtype == "float16") return "<f2";
+  if (dtype == "float32") return "<f4";
+  if (dtype == "float64") return "<f8";
+  if (dtype == "bool") return "|b1";
+  if (dtype == "complex64") return "<c8";
+  if (dtype == "complex128") return "<c16";
+  return absl::InvalidArgumentError("Unknown dtype: " + dtype);
+}
+
+}  // namespace v2
+}  // namespace zarr
+}  // namespace mdio
+
+#endif  // MDIO_ZARR_ZARR_V2_H_
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
new file mode 100644
index 0000000..1df7f61
--- /dev/null
+++ b/mdio/zarr/zarr_v3.h
@@ -0,0 +1,514 @@
+// Copyright 2024 TGS
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef MDIO_ZARR_ZARR_V3_H_
+#define MDIO_ZARR_ZARR_V3_H_
+
+#include <filesystem>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "absl/strings/str_split.h"
+#include "mdio/impl.h"
+#include "mdio/zarr/zarr_driver.h"
+#include "tensorstore/kvstore/kvstore.h"
+#include "tensorstore/kvstore/operations.h"
+#include "tensorstore/util/future.h"
+
+// clang-format off
+#include <nlohmann/json.hpp>  // NOLINT
+// clang-format on
+
+namespace mdio {
+namespace zarr {
+namespace v3 {
+
+/**
+ * @brief Gets the Zarr V3 driver name.
+ * @return constexpr std::string_view The driver name.
+ */
+constexpr std::string_view kDriverName = "zarr3";
+
+/**
+ * @brief The Zarr format version for V3.
+ */
+constexpr int kZarrFormat = 3;
+
+/**
+ * @brief The node type for a group in Zarr V3.
+ */
+constexpr std::string_view kGroupNodeType = "group";
+
+/**
+ * @brief The node type for an array in Zarr V3.
+ */
+constexpr std::string_view kArrayNodeType = "array";
+
+/**
+ * @brief Converts a dtype string to Zarr V3 format.
+ *
+ * Zarr V3 uses a different dtype specification than V2.
+ *
+ * @param dtype The input dtype string.
+ * @return Result<nlohmann::json> The Zarr V3 dtype specification.
+ */
+inline Result<nlohmann::json> ToZarrDtype(const std::string& dtype) {
+  // Zarr V3 uses different dtype specification
+  if (dtype == "int8") return "int8";
+  if (dtype == "int16") return "int16";
+  if (dtype == "int32") return "int32";
+  if (dtype == "int64") return "int64";
+  if (dtype == "uint8") return "uint8";
+  if (dtype == "uint16") return "uint16";
+  if (dtype == "uint32") return "uint32";
+  if (dtype == "uint64") return "uint64";
+  if (dtype == "float16") return "float16";
+  if (dtype == "float32") return "float32";
+  if (dtype == "float64") return "float64";
+  if (dtype == "bool") return "bool";
+  if (dtype == "complex64") return "complex64";
+  if (dtype == "complex128") return "complex128";
+  return absl::InvalidArgumentError("Unknown dtype: " + dtype);
+}
+
+/**
+ * @brief Creates the root zarr.json for a Zarr V3 group.
+ *
+ * @param attributes Optional attributes to include.
+ * @return nlohmann::json The zarr.json content for the group.
+ */
+inline nlohmann::json CreateGroupMetadata(
+    const nlohmann::json& attributes = nlohmann::json::object()) {
+  nlohmann::json zarr_json;
+  zarr_json["zarr_format"] = kZarrFormat;
+  zarr_json["node_type"] = kGroupNodeType;
+  if (!attributes.empty()) {
+    zarr_json["attributes"] = attributes;
+  }
+  return zarr_json;
+}
+
+/**
+ * @brief Creates the zarr.json for a Zarr V3 array.
+ *
+ * @param shape The array shape.
+ * @param chunks The chunk shape.
+ * @param dtype The data type.
+ * @param attributes Optional attributes.
+ * @param fill_value Optional fill value.
+ * @param codecs Optional codec configuration.
+ * @return nlohmann::json The zarr.json content for the array.
+ */
+inline nlohmann::json CreateArrayMetadata(
+    const std::vector<int64_t>& shape, const std::vector<int64_t>& chunks,
+    const std::string& dtype,
+    const nlohmann::json& attributes = nlohmann::json::object(),
+    const nlohmann::json& fill_value = nullptr,
+    const nlohmann::json& codecs = nlohmann::json::array()) {
+  nlohmann::json zarr_json;
+  zarr_json["zarr_format"] = kZarrFormat;
+  zarr_json["node_type"] = kArrayNodeType;
+  zarr_json["shape"] = shape;
+
+  // Chunk configuration for V3
+  zarr_json["chunk_grid"] = {{"name", "regular"},
+                             {"configuration", {{"chunk_shape", chunks}}}};
+
+  // Chunk key encoding (default to slash separator)
+  zarr_json["chunk_key_encoding"] = {{"name", "default"},
+                                     {"configuration", {{"separator", "/"}}}};
+
+  auto dtype_result = ToZarrDtype(dtype);
+  if (dtype_result.ok()) {
+    zarr_json["data_type"] = dtype_result.value();
+  } else {
+    zarr_json["data_type"] = dtype;
+  }
+
+  zarr_json["fill_value"] = fill_value;
+
+  // Default codecs if not specified
+  if (codecs.empty()) {
+    zarr_json["codecs"] = nlohmann::json::array({{{"name", "bytes"}}});
+  } else {
+    zarr_json["codecs"] = codecs;
+  }
+
+  if (!attributes.empty()) {
+    zarr_json["attributes"] = attributes;
+  }
+
+  return zarr_json;
+}
+
+/**
+ * @brief Prepares MDIO attributes for Zarr V3 format.
+ *
+ * In Zarr V3, attributes are embedded directly in zarr.json.
+ *
+ * @param json The variable JSON specification.
+ * @return nlohmann::json The prepared attributes for Zarr V3.
+ */
+inline nlohmann::json PrepareVariableAttributes(const nlohmann::json& json) {
+  nlohmann::json attrs = nlohmann::json::object();
+
+  if (json.contains("attributes")) {
+    attrs = json["attributes"];
+  }
+
+  // MDIO-specific: Convert dimension_names to _ARRAY_DIMENSIONS
+  if (attrs.contains("dimension_names")) {
+    attrs["_ARRAY_DIMENSIONS"] = attrs["dimension_names"];
+    attrs.erase("dimension_names");
+  }
+
+  // Remove variable_name as it's self-describing from path
+  if (attrs.contains("variable_name")) {
+    attrs.erase("variable_name");
+  }
+
+  // Handle empty long_name
+  if (attrs.contains("long_name") &&
+      attrs["long_name"].get<std::string>() == "") {
+    attrs.erase("long_name");
+  }
+
+  // Flatten metadata
+  if (attrs.contains("metadata")) {
+    if (attrs["metadata"].contains("chunkGrid")) {
+      attrs["metadata"].erase("chunkGrid");
+    }
+    for (auto& item : attrs["metadata"].items()) {
+      attrs[item.key()] = std::move(item.value());
+    }
+    attrs.erase("metadata");
+  }
+
+  // Handle empty coordinates
+  if (attrs.contains("coordinates")) {
+    auto coords = attrs["coordinates"];
+    if (coords.empty() ||
+        (coords.is_string() && coords.get<std::string>() == "")) {
+      attrs.erase("coordinates");
+    }
+  }
+
+  return attrs;
+}
+
+/**
+ * @brief Writes metadata for a Zarr V3 dataset (NO consolidated metadata).
+ *
+ * For Zarr V3, we write individual zarr.json files for each array and the
+ * group. Consolidated metadata is NOT supported for Zarr V3.
+ *
+ * @param dataset_metadata The metadata for the dataset.
+ * @param json_variables The JSON variables.
+ * @return An `mdio::Future<void>` representing the asynchronous write.
+ */
+inline Future<void> WriteMetadata(
+    const ::nlohmann::json& dataset_metadata,
+    const std::vector<::nlohmann::json>& json_variables) {
+  // Determine the base path and driver
+  std::string driver =
+      json_variables[0]["kvstore"]["driver"].get<std::string>();
+
+  std::vector<std::string> file_parts = absl::StrSplit(
+      json_variables[0]["kvstore"]["path"].get<std::string>(), '/');
+  size_t toRemove = file_parts.back().size();
+  std::string basePath =
+      json_variables[0]["kvstore"]["path"].get<std::string>().substr(
+          0, json_variables[0]["kvstore"]["path"].get<std::string>().size() -
+                 toRemove - 1);
+
+  nlohmann::json kvstore = nlohmann::json::object();
+  kvstore["driver"] = driver;
+  kvstore["path"] = basePath;
+
+  if (driver == "gcs" || driver == "s3") {
+    kvstore["bucket"] =
+        json_variables[0]["kvstore"]["bucket"].get<std::string>();
+  }
+
+  auto kvs_future = tensorstore::kvstore::Open(kvstore);
+
+  // Write root group zarr.json with dataset attributes
+  auto root_metadata = CreateGroupMetadata(dataset_metadata);
+  auto root_future = tensorstore::MapFutureValue(
+      tensorstore::InlineExecutor{},
+      [root_metadata](const tensorstore::KvStore& kvs) {
+        return tensorstore::kvstore::Write(kvs, "/zarr.json",
+                                           absl::Cord(root_metadata.dump(4)));
+      },
+      kvs_future);
+
+  // Collect all write futures
+  std::vector<tensorstore::AnyFuture> write_futures;
+  write_futures.push_back(root_future);
+
+  // Note: Individual array zarr.json files are written by TensorStore
+  // when the variable is created, so we don't need to write them here.
+  // We only write the root group metadata.
+
+  return tensorstore::WaitAllFuture(write_futures);
+}
+
+/**
+ * @brief Reads dataset metadata from Zarr V3 format (non-consolidated).
+ *
+ * For Zarr V3, we read the root zarr.json and then discover arrays
+ * by listing the directory contents.
+ *
+ * @param dataset_path The path to the dataset.
+ * @param kvs_future A future to the KvStore.
+ * @return A future containing dataset metadata and variable JSON specs.
+ */
+inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
+ReadMetadata(const std::string& dataset_path,
+             tensorstore::Future<tensorstore::KvStore> kvs_future) {
+  auto pair = tensorstore::PromiseFuturePair<
+      std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>::Make();
+
+  kvs_future.ExecuteWhenReady(
+      [promise = std::move(pair.promise),
+       dataset_path](tensorstore::ReadyFuture<tensorstore::KvStore> ready_kvs) {
+        if (!ready_kvs.result().ok()) {
+          promise.SetResult(ready_kvs.result().status());
+          return;
+        }
+
+        auto kvs = ready_kvs.value();
+
+        // Read root zarr.json
+        auto root_read = tensorstore::kvstore::Read(kvs, "zarr.json").result();
+        if (!root_read.ok()) {
+          promise.SetResult(root_read.status());
+          return;
+        }
+
+        ::nlohmann::json root_json;
+        try {
+          root_json =
+              ::nlohmann::json::parse(std::string(root_read.value().value));
+        } catch (const nlohmann::json::parse_error& e) {
+          promise.SetResult(
+              absl::InvalidArgumentError(std::string("JSON parse error: ") +
+                                         e.what()));
+          return;
+        }
+
+        // Extract attributes as dataset metadata
+        nlohmann::json dataset_metadata = nlohmann::json::object();
+        if (root_json.contains("attributes")) {
+          dataset_metadata = root_json["attributes"];
+        }
+
+        // Infer the driver
+        std::string driver = "file";
+        std::string bucket;
+        std::string cloudPath;
+        if (dataset_path.length() > 5) {
+          if (dataset_path.substr(0, 5) == "gs://") {
+            driver = "gcs";
+          } else if (dataset_path.substr(0, 5) == "s3://") {
+            driver = "s3";
+          }
+        }
+        if (driver != "file") {
+          std::string providedPath = dataset_path.substr(5);
+          size_t bucketLen = providedPath.find_first_of('/');
+          bucket = providedPath.substr(0, bucketLen);
+          cloudPath = providedPath.substr(bucketLen + 1,
+                                          providedPath.length() - 2);
+        }
+
+        // For V3, we need to discover arrays by looking for zarr.json files
+        // in subdirectories. Since kvstore::List returns a sender (not a future),
+        // we'll use a simpler approach: check if the metadata contains array info.
+        // If not found, we return an error asking the user to specify variables.
+        
+        // For now, we'll extract variable names from the root zarr.json attributes
+        // if they contain a "variables" or similar field, or return an error.
+        std::vector<nlohmann::json> json_vars;
+        
+        // Check if dataset_metadata contains variable information
+        if (dataset_metadata.contains("variables")) {
+          for (const auto& var_name : dataset_metadata["variables"]) {
+            std::string name = var_name.get<std::string>();
+            nlohmann::json var_spec = {
+                {"driver", std::string(kDriverName)},
+                {"kvstore",
+                 {{"driver", driver}, {"path", dataset_path + name}}}};
+            if (driver != "file") {
+              var_spec["kvstore"]["bucket"] = bucket;
+              var_spec["kvstore"]["path"] = cloudPath + name;
+            }
+            json_vars.push_back(var_spec);
+          }
+        }
+
+        if (json_vars.empty()) {
+          // Return error - V3 discovery requires variable names in metadata
+          promise.SetResult(absl::InvalidArgumentError(
+              "Zarr V3 store discovery requires 'variables' list in root "
+              "zarr.json attributes. Please specify variable specs explicitly."));
+          return;
+        }
+
+        promise.SetResult(std::make_tuple(dataset_metadata, json_vars));
+      });
+
+  return pair.future;
+}
+
+/**
+ * @brief Creates a Variable spec for Zarr V3.
+ * @param variable_name The name of the variable.
+ * @param path The path prefix.
+ * @return nlohmann::json The variable spec stub.
+ */
+inline nlohmann::json CreateVariableSpec(const std::string& variable_name,
+                                         const std::string& path = "") {
+  nlohmann::json spec = {
+      {"driver", std::string(kDriverName)},
+      {"kvstore", {{"driver", "file"}, {"path", variable_name}}},
+      {"metadata",
+       {{"data_type", "DATA_TYPE"},
+        {"shape", nlohmann::json::array()},
+        {"chunk_grid",
+         {{"name", "regular"},
+          {"configuration", {{"chunk_shape", nlohmann::json::array()}}}}}}},
+      {"attributes", nlohmann::json::object()}};
+  return spec;
+}
+
+/**
+ * @brief Writes variable attributes to zarr.json (embedded in array metadata).
+ *
+ * For Zarr V3, attributes are part of the zarr.json file, not a separate
+ * .zattrs file.
+ *
+ * @param store The TensorStore to write to.
+ * @param json_var The variable attributes JSON.
+ * @param isCloudStore Whether the store is a cloud store.
+ * @return Future<tensorstore::TimestampedStorageGeneration> The write result.
+ */
+template <typename T, DimensionIndex R, ReadWriteMode M>
+Future<tensorstore::TimestampedStorageGeneration> WriteVariableAttributes(
+    const tensorstore::TensorStore<T, R, M>& store,
+    const ::nlohmann::json& json_var, bool isCloudStore) {
+  // For Zarr V3, we need to read the existing zarr.json and update attributes
+  auto read_future =
+      tensorstore::kvstore::Read(store.kvstore(), "zarr.json");
+
+  auto pair =
+      tensorstore::PromiseFuturePair<
+          tensorstore::TimestampedStorageGeneration>::Make();
+
+  read_future.ExecuteWhenReady(
+      [promise = std::move(pair.promise), store, json_var](
+          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+              ready_result) {
+        nlohmann::json zarr_json;
+        if (ready_result.result().ok() && ready_result.value().has_value()) {
+          try {
+            zarr_json = nlohmann::json::parse(
+                std::string(ready_result.value().value));
+          } catch (...) {
+            zarr_json = nlohmann::json::object();
+          }
+        }
+
+        // Prepare and update attributes
+        auto attrs = PrepareVariableAttributes(
+            nlohmann::json{{"attributes", json_var}});
+        zarr_json["attributes"] = attrs;
+
+        // Write back
+        auto write_result = tensorstore::kvstore::Write(
+            store.kvstore(), "zarr.json", absl::Cord(zarr_json.dump(4)));
+        write_result.ExecuteWhenReady(
+            [promise = std::move(promise)](
+                tensorstore::ReadyFuture<
+                    tensorstore::TimestampedStorageGeneration>
+                    write_ready) { promise.SetResult(write_ready.result()); });
+      });
+
+  return pair.future;
+}
+
+/**
+ * @brief Reads variable attributes from zarr.json.
+ *
+ * @param kvstore The KvStore to read from.
+ * @return Future<nlohmann::json> The attributes JSON.
+ */
+inline Future<nlohmann::json> ReadVariableAttributes(
+    const tensorstore::KvStore& kvstore) {
+  auto pair = tensorstore::PromiseFuturePair<nlohmann::json>::Make();
+
+  auto read_future = tensorstore::kvstore::Read(kvstore, "/zarr.json");
+  read_future.ExecuteWhenReady(
+      [promise = std::move(pair.promise)](
+          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+              ready_result) {
+        if (!ready_result.result().ok()) {
+          promise.SetResult(ready_result.result().status());
+          return;
+        }
+        try {
+          auto zarr_json = nlohmann::json::parse(
+              std::string(ready_result.value().value));
+          if (zarr_json.contains("attributes")) {
+            promise.SetResult(zarr_json["attributes"]);
+          } else {
+            promise.SetResult(nlohmann::json::object());
+          }
+        } catch (const nlohmann::json::parse_error& e) {
+          promise.SetResult(absl::InvalidArgumentError(
+              std::string("JSON parse error: ") + e.what()));
+        }
+      });
+
+  return pair.future;
+}
+
+/**
+ * @brief Helper to convert Zarr V3 metadata to MDIO-compatible format.
+ *
+ * @param zarr_json The Zarr V3 zarr.json content.
+ * @return nlohmann::json The MDIO-compatible metadata.
+ */
+inline nlohmann::json ConvertToMdioMetadata(const nlohmann::json& zarr_json) {
+  nlohmann::json mdio_metadata;
+
+  if (zarr_json.contains("attributes")) {
+    mdio_metadata = zarr_json["attributes"];
+  }
+
+  // Convert _ARRAY_DIMENSIONS back to dimension_names
+  if (mdio_metadata.contains("_ARRAY_DIMENSIONS")) {
+    mdio_metadata["dimension_names"] = mdio_metadata["_ARRAY_DIMENSIONS"];
+    mdio_metadata.erase("_ARRAY_DIMENSIONS");
+  }
+
+  return mdio_metadata;
+}
+
+}  // namespace v3
+}  // namespace zarr
+}  // namespace mdio
+
+#endif  // MDIO_ZARR_ZARR_V3_H_

From 473e475790afbd0f2dcdc60cb1a40320c951d1ba Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 12 Dec 2025 16:06:50 +0000
Subject: [PATCH 04/26] Fix reading stats from mdio-python files

---
 mdio/stats.h | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/mdio/stats.h b/mdio/stats.h
index d2d27a5..acbccdd 100644
--- a/mdio/stats.h
+++ b/mdio/stats.h
@@ -414,16 +414,32 @@ class UserAttributes {
         std::vector<internal::SummaryStats> statsCollection;
         if (j.contains("statsV1")) {
           auto statsJson = j["statsV1"];
+          // statsV1 may be stored as a serialized JSON string in some
+          // third-party Zarr stores; parse it if needed.
+          auto parse_if_string = [](const nlohmann::json& val)
+              -> mdio::Result<nlohmann::json> {
+            if (val.is_string()) {
+              try {
+                return nlohmann::json::parse(val.get<std::string>());
+              } catch (const std::exception& e) {
+                return absl::InvalidArgumentError(
+                    std::string("Error parsing statsV1 string: ") + e.what());
+              }
+            }
+            return val;
+          };
           if (statsJson.is_array()) {
             for (auto& s : statsJson) {
-              auto statsRes = internal::SummaryStats::FromJson<T>(s);
+              MDIO_ASSIGN_OR_RETURN(auto parsed, parse_if_string(s));
+              auto statsRes = internal::SummaryStats::FromJson<T>(parsed);
               if (!statsRes.status().ok()) {
                 return statsRes.status();
               }
               statsCollection.emplace_back(statsRes.value());
             }
           } else {
-            auto statsRes = internal::SummaryStats::FromJson<T>(statsJson);
+            MDIO_ASSIGN_OR_RETURN(auto parsed, parse_if_string(statsJson));
+            auto statsRes = internal::SummaryStats::FromJson<T>(parsed);
             if (!statsRes.status().ok()) {
               return statsRes.status();
             }

From 204421a036bce9e4292a6426a7b6c821aa807461 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 12 Dec 2025 16:07:22 +0000
Subject: [PATCH 05/26] Fix fill value metadata issue for boolean types

---
 mdio/dataset_factory.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/mdio/dataset_factory.h b/mdio/dataset_factory.h
index 79a1bfb..355d6cc 100644
--- a/mdio/dataset_factory.h
+++ b/mdio/dataset_factory.h
@@ -412,10 +412,9 @@ inline tensorstore::Result<nlohmann::json> from_json_to_spec(
         }
       } else if (!dtype_str.empty() && dtype_str[0] == 'f') {
         variableStub["metadata"]["fill_value"] = std::nan("");
+      } else if (dtype_str == "bool") {
+        variableStub["metadata"]["fill_value"] = false;
       } else {
-        // Provide an explicit default for integral/boolean types to satisfy the
-        // TensorStore Zarr3 parser, which rejects null fill values for numeric
-        // dtypes.
         variableStub["metadata"]["fill_value"] = 0;
       }
     } else if (version == mdio::zarr::ZarrVersion::kV2) {

From a5e5a2484d150db0cd05830f09573da27e578445 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 12 Dec 2025 16:07:33 +0000
Subject: [PATCH 06/26] Fix chunk shape in test

---
 mdio/acceptance_test_v3.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mdio/acceptance_test_v3.cc b/mdio/acceptance_test_v3.cc
index d92fe78..fb4e0bc 100644
--- a/mdio/acceptance_test_v3.cc
+++ b/mdio/acceptance_test_v3.cc
@@ -953,7 +953,7 @@ namespace DatasetTestV3 {
       "metadata": {
         "chunkGrid": {
           "name": "regular",
-          "configuration": { "chunkShape": [128, 128, 128] }
+          "configuration": { "chunkShape": [4, 512, 512] }
         }
       },
       "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]

From f05688745e70c3c20712f3c4f976d75be9b8d551 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 12 Dec 2025 16:07:47 +0000
Subject: [PATCH 07/26] Add zarr3 driver to internal dependencies

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 82fa673..f990dcb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -108,6 +108,7 @@ if(NOT CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   set(mdio_INTERNAL_DEPS
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack

From be558020d73aa89ddbf158c7784f40c71696a2ce Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Thu, 18 Dec 2025 17:15:17 +0000
Subject: [PATCH 08/26] Unity v2/3 acceptance test, add support for zarr
 version specification in

---
 mdio/CMakeLists.txt        |   23 -
 mdio/acceptance_test.cc    | 2750 ++++++++++++++++++------------------
 mdio/acceptance_test_v3.cc | 1330 -----------------
 mdio/dataset.h             |   94 +-
 mdio/dataset_test.cc       |  282 ++++
 mdio/zarr/zarr_v3.h        |  185 +--
 6 files changed, 1842 insertions(+), 2822 deletions(-)
 delete mode 100644 mdio/acceptance_test_v3.cc

diff --git a/mdio/CMakeLists.txt b/mdio/CMakeLists.txt
index f26be9e..b5b72b5 100644
--- a/mdio/CMakeLists.txt
+++ b/mdio/CMakeLists.txt
@@ -386,26 +386,3 @@ mdio_cc_test(
     nlohmann_json_schema_validator
 )
 
-mdio_cc_test(
-  NAME
-    acceptance_test_v3
-  SRCS
-    acceptance_test_v3.cc
-  COPTS
-    ${mdio_DEFAULT_COPTS} 
-  LINKOPTS
-    ${mdio_DEFAULT_LINKOPTS}
-  DEPS
-    GTest::gmock_main
-    tensorstore::driver_array
-    tensorstore::driver_zarr
-    tensorstore::driver_zarr3
-    tensorstore::driver_json
-    tensorstore::kvstore_file
-    tensorstore::stack
-    tensorstore::tensorstore
-    tensorstore::index_space_dim_expression
-    tensorstore::index_space_index_transform
-    tensorstore::util_status_testutil
-    nlohmann_json_schema_validator
-)
diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index 18198ec..231620b 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -12,1102 +12,181 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-#include <cstdlib>
-#include <filesystem>
-#include <nlohmann/json.hpp>  // NOLINT
-
-#include "mdio/dataset.h"
-#include "mdio/dataset_factory.h"
-
-namespace {
-
-constexpr char PYTHON_EXECUTABLE[] = "python3";  // Don't specify absolute path
-constexpr char PROJECT_BASE_PATH_ENV[] = "PROJECT_BASE_PATH";
-constexpr char DEFAULT_BASE_PATH[] = "../..";
-constexpr char ZARR_SCRIPT_RELATIVE_PATH[] =
-    "/mdio/regression_tests/zarr_compatibility.py";
-constexpr char XARRAY_SCRIPT_RELATIVE_PATH[] =
-    "/mdio/regression_tests/xarray_compatibility_test.py";
-constexpr char FILE_PATH_BASE[] = "./zarrs/acceptance/";
-constexpr int ERROR_CODE = EXIT_FAILURE;
-constexpr int SUCCESS_CODE = EXIT_SUCCESS;
-
 /**
- * @brief Executes the Python regression tests
- *
- * @param scriptPath Which script to run, should be either
- * ZARR_SCRIPT_RELATIVE_PATH or XARRAY_SCRIPT_RELATIVE_PATH
- * @param arg The argument to pass to the script
- * @return int The status code of the script execution
- */
-int executePythonScript(const std::string& scriptPath,
-                        const std::vector<std::string>& args) {
-  // Ensure scriptPath and args are sanitized
-  if (scriptPath.empty() || args.empty()) {
-    std::cerr << "Error: scriptPath or args are empty." << std::endl;
-    return ERROR_CODE;
-  }
-
-  // Ensure the scriptPath is an absolute path or default base path
-  if (scriptPath[0] != '/' && scriptPath.find(DEFAULT_BASE_PATH) != 0) {
-    std::cerr
-        << "Error: PROJECT_BASE_PATH must be an absolute path or not be set."
-        << std::endl;
-    return ERROR_CODE;
-  }
-
-  // Prepare arguments for execvp
-  std::vector<const char*> execArgs = {PYTHON_EXECUTABLE, scriptPath.c_str()};
-  for (const auto& arg : args) {
-    execArgs.push_back(arg.c_str());
-  }
-  execArgs.push_back(nullptr);
-
-  // Execute the Python script
-  if (execvp(execArgs[0], const_cast<char* const*>(execArgs.data())) == -1) {
-    perror("execvp failed");
-    return ERROR_CODE;
-  }
-
-  return SUCCESS_CODE;  // This line will never be reached if execvp is
-                        // successful
-}
-
-namespace VariableTesting {
-
-using float16_t = mdio::dtypes::float_16_t;
-
-// TODO(BrianMichell): Extend test coverage to include uint
-nlohmann::json i2Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/i2"
-        }
-    }
-)"_json;
-
-nlohmann::json i4Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/i4"
-        }
-    }
-)"_json;
-
-nlohmann::json i8Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/i8"
-        }
-    }
-)"_json;
-
-nlohmann::json f2Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/f2"
-        }
-    }
-)"_json;
-
-nlohmann::json f4Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/f4"
-        }
-    }
-)"_json;
-
-nlohmann::json f8Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/f8"
-        }
-    }
-)"_json;
-
-nlohmann::json voidedBase = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/voided"
-        }
-    }
-)"_json;
-
-nlohmann::json u2Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/u2"
-        }
-    }
-)"_json;
-
-nlohmann::json u4Base = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/u4"
-        }
-    }
-)"_json;
-
-// Test to set up some pre-existing elements for testing
-TEST(Variable, SETUP) {
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-  nlohmann::json i2Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/i2"
-            },
-            "metadata": {
-                "dtype": "<i2",
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "2-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
-  auto [i2Store, i2Metadata] = i2Schema;
-  auto i2 =
-      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-
-  nlohmann::json i4Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/i4"
-            },
-            "metadata": {
-                "dtype": "<i4",
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "4-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i4Schema = mdio::internal::ValidateAndProcessJson(i4Spec).value();
-  auto [i4Store, i4Metadata] = i4Schema;
-  auto i4 =
-      mdio::internal::CreateVariable(i4Store, i4Metadata, std::move(options));
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-
-  nlohmann::json i8Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/i8"
-            },
-            "metadata": {
-                "dtype": "<i8",
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "8-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i8Schema = mdio::internal::ValidateAndProcessJson(i8Spec).value();
-  auto [i8Store, i8Metadata] = i8Schema;
-  auto i8 =
-      mdio::internal::CreateVariable(i8Store, i8Metadata, std::move(options));
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-
-  nlohmann::json f2Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/f2"
-            },
-            "metadata": {
-                "dtype": "<f2",
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "2-byte float test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto f2Schema = mdio::internal::ValidateAndProcessJson(f2Spec).value();
-  auto [f2Store, f2Metadata] = f2Schema;
-  auto f2 =
-      mdio::internal::CreateVariable(f2Store, f2Metadata, std::move(options));
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-
-  nlohmann::json f4Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/f4"
-            },
-            "metadata": {
-                "dtype": "<f4",
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "4-byte float test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto f4Schema = mdio::internal::ValidateAndProcessJson(f4Spec).value();
-  auto [f4Store, f4Metadata] = f4Schema;
-  auto f4 =
-      mdio::internal::CreateVariable(f4Store, f4Metadata, std::move(options));
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-
-  nlohmann::json f8Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/f8"
-            },
-            "metadata": {
-                "dtype": "<f8",
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "long_name": "8-byte float test",
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto f8Schema = mdio::internal::ValidateAndProcessJson(f8Spec).value();
-  auto [f8Store, f8Metadata] = f8Schema;
-  auto f8 =
-      mdio::internal::CreateVariable(f8Store, f8Metadata, std::move(options));
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  nlohmann::json voidedSpec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/voided"
-            },
-            "field": "integer16",
-            "metadata": {
-                "dtype": [["integer16", "<i2"], ["float32", "<f4"], ["double", "<f8"]],
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "struct array test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto voidedSchema =
-      mdio::internal::ValidateAndProcessJson(voidedSpec).value();
-  auto [voidedStore, voidedMetadata] = voidedSchema;
-  auto voided = mdio::internal::CreateVariable(voidedStore, voidedMetadata,
-                                               std::move(options));
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-}
-
-TEST(Variable, open) {
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i2Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i4Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i8Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f2Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f4Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f8Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen).status().ok());
-}
-
-TEST(Variable, name) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_EQ(i2.value().get_variable_name(), "i2")
-      << i2.value().get_variable_name();
-  EXPECT_EQ(i4.value().get_variable_name(), "i4")
-      << i4.value().get_variable_name();
-  EXPECT_EQ(i8.value().get_variable_name(), "i8")
-      << i8.value().get_variable_name();
-  EXPECT_EQ(f2.value().get_variable_name(), "f2")
-      << f2.value().get_variable_name();
-  EXPECT_EQ(f4.value().get_variable_name(), "f4")
-      << f4.value().get_variable_name();
-  EXPECT_EQ(f8.value().get_variable_name(), "f8")
-      << f8.value().get_variable_name();
-  EXPECT_EQ(voided.value().get_variable_name(), "voided")
-      << voided.value().get_variable_name();
-}
-
-TEST(Variable, longName) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_EQ(i2.value().get_long_name(), "2-byte integer test")
-      << i2.value().get_long_name();
-  EXPECT_EQ(i4.value().get_long_name(), "4-byte integer test")
-      << i4.value().get_long_name();
-  EXPECT_EQ(i8.value().get_long_name(), "8-byte integer test")
-      << i8.value().get_long_name();
-  EXPECT_EQ(f2.value().get_long_name(), "2-byte float test")
-      << f2.value().get_long_name();
-  EXPECT_EQ(f4.value().get_long_name(), "4-byte float test")
-      << f4.value().get_long_name();
-  EXPECT_EQ(f8.value().get_long_name(), "8-byte float test")
-      << f8.value().get_long_name();
-  EXPECT_EQ(voided.value().get_long_name(), "struct array test")
-      << voided.value().get_long_name();
-}
-
-TEST(Variable, optionalAttrs) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_EQ(i2.value().GetAttributes()["attributes"]["foo"], "bar")
-      << i2.value().GetAttributes();
-  EXPECT_EQ(i4.value().GetAttributes()["attributes"]["foo"], "bar")
-      << i4.value().GetAttributes();
-  EXPECT_EQ(i8.value().GetAttributes()["attributes"]["foo"], "bar")
-      << i8.value().GetAttributes();
-  EXPECT_EQ(f2.value().GetAttributes()["attributes"]["foo"], "bar")
-      << f2.value().GetAttributes();
-  EXPECT_EQ(f4.value().GetAttributes()["attributes"]["foo"], "bar")
-      << f4.value().GetAttributes();
-  EXPECT_EQ(f8.value().GetAttributes()["attributes"]["foo"], "bar")
-      << f8.value().GetAttributes();
-  EXPECT_EQ(voided.value().GetAttributes()["attributes"]["foo"], "bar")
-      << voided.value().GetAttributes();
-}
-
-TEST(Variable, namedDimensions) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_EQ(i2.value().getMetadata()["dimension_names"].size(), 2)
-      << i2.value().getMetadata();
-  EXPECT_EQ(i4.value().getMetadata()["dimension_names"].size(), 2)
-      << i4.value().getMetadata();
-  EXPECT_EQ(i8.value().getMetadata()["dimension_names"].size(), 2)
-      << i8.value().getMetadata();
-  EXPECT_EQ(f2.value().getMetadata()["dimension_names"].size(), 2)
-      << f2.value().getMetadata();
-  EXPECT_EQ(f4.value().getMetadata()["dimension_names"].size(), 2)
-      << f4.value().getMetadata();
-  EXPECT_EQ(f8.value().getMetadata()["dimension_names"].size(), 2)
-      << f8.value().getMetadata();
-  EXPECT_EQ(voided.value().getMetadata()["dimension_names"].size(), 2)
-      << voided.value().getMetadata();
-}
-
-TEST(Variable, sliceByDimIdx) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
-
-  auto i2Slice = i2.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto i4Slice = i4.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto i8Slice = i8.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto f2Slice = f2.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto f4Slice = f4.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto f8Slice = f8.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto voidedSlice = voided.value().slice(zeroIdxSlice, oneIdxSlice);
+ * @file acceptance_test.cc
+ * @brief Unified acceptance tests for both Zarr V2 and V3 driver support.
+ *
+ * This file contains parameterized tests that verify the MDIO library works
+ * correctly with both Zarr V2 and Zarr V3 formats, including variable creation,
+ * reading, writing, and dataset operations.
+ */
 
-  EXPECT_TRUE(i2Slice.status().ok()) << i2Slice.status();
-  EXPECT_TRUE(i4Slice.status().ok()) << i4Slice.status();
-  EXPECT_TRUE(i8Slice.status().ok()) << i8Slice.status();
-  EXPECT_TRUE(f2Slice.status().ok()) << f2Slice.status();
-  EXPECT_TRUE(f4Slice.status().ok()) << f4Slice.status();
-  EXPECT_TRUE(f8Slice.status().ok()) << f8Slice.status();
-  EXPECT_TRUE(voidedSlice.status().ok()) << voidedSlice.status();
-  EXPECT_THAT(i2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i2Slice.value().dimensions();
-  EXPECT_THAT(i4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i4Slice.value().dimensions();
-  EXPECT_THAT(i8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i8Slice.value().dimensions();
-  EXPECT_THAT(f2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f2Slice.value().dimensions();
-  EXPECT_THAT(f4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f4Slice.value().dimensions();
-  EXPECT_THAT(f8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f8Slice.value().dimensions();
-  EXPECT_THAT(voidedSlice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5, 14))
-      << voidedSlice.value().dimensions();
-}
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <sys/wait.h>
+#include <unistd.h>
 
-TEST(Variable, zarrCompatibility) {
-  const char* basePath = std::getenv(PROJECT_BASE_PATH_ENV);
-  if (!basePath) {
-    std::cout << "PROJECT_BASE_PATH environment variable not set. Expecting to "
-                 "be in the 'build/mdio' directory."
-              << std::endl;
-    basePath = DEFAULT_BASE_PATH;
-  }
+#include <cstdlib>
+#include <filesystem>
+#include <nlohmann/json.hpp>  // NOLINT
 
-  // Resolve the absolute path for the script
-  std::string srcPath = std::string(basePath) + ZARR_SCRIPT_RELATIVE_PATH;
+#include "mdio/dataset.h"
+#include "mdio/dataset_factory.h"
+#include "mdio/zarr/zarr.h"
 
-  // Ensure that srcPath is valid and points to an existing file
-  if (access(srcPath.c_str(), F_OK) == -1) {
-    std::cerr << "Error: Python script not found at " << srcPath << std::endl;
-    FAIL() << "Script not found: " << srcPath;
-  }
+namespace {
 
-  std::vector<std::string> args = {"i2", "i4", "i8",    "f2",
-                                   "f4", "f8", "voided"};
-  std::vector<pid_t> pids;
+constexpr char PYTHON_EXECUTABLE[] = "python3";
+constexpr char PROJECT_BASE_PATH_ENV[] = "PROJECT_BASE_PATH";
+constexpr char DEFAULT_BASE_PATH[] = "../..";
+constexpr char ZARR_SCRIPT_RELATIVE_PATH[] =
+    "/mdio/regression_tests/zarr_compatibility.py";
+constexpr char XARRAY_SCRIPT_RELATIVE_PATH[] =
+    "/mdio/regression_tests/xarray_compatibility_test.py";
+constexpr int ERROR_CODE = EXIT_FAILURE;
+constexpr int SUCCESS_CODE = EXIT_SUCCESS;
 
-  for (const auto& arg : args) {
-    pid_t pid = fork();
-    if (pid == 0) {
-      // Child process
-      int result = executePythonScript(srcPath, {FILE_PATH_BASE + arg});
-      if (result == 0xfd00) {  // 0xfd from Python is 0xfd00 in C++
-        GTEST_SKIP() << "Zarr compatibility skipped due to import error for "
-                        "required library";
-        exit(SUCCESS_CODE);
-      }
-      exit(result);
-    } else if (pid > 0) {
-      // Parent process
-      pids.push_back(pid);
-    } else {
-      // Fork failed
-      perror("fork failed");
-      FAIL() << "fork failed";
-    }
-  }
+using float16_t = mdio::dtypes::float_16_t;
 
-  // Wait for all child processes
-  for (pid_t pid : pids) {
-    int status;
-    if (waitpid(pid, &status, 0) == -1) {
-      perror("waitpid failed");
-      FAIL() << "waitpid failed";
-    }
-    if (WIFEXITED(status) && WEXITSTATUS(status) == 0xfd00) {
-      GTEST_SKIP() << "Zarr compatibility skipped due to import error for "
-                      "required library";
-    }
-    EXPECT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0)
-        << "Failed to read one of the arguments\n\tMore detailed error "
-           "expected above...";
-  }
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
 }
 
-TEST(Variable, dimensionUnits) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_TRUE(i2.value().getMetadata().contains("dimension_units"))
-      << i2.value().getMetadata();
-  EXPECT_TRUE(i4.value().getMetadata().contains("dimension_units"))
-      << i4.value().getMetadata();
-  EXPECT_TRUE(i8.value().getMetadata().contains("dimension_units"))
-      << i8.value().getMetadata();
-  EXPECT_TRUE(f2.value().getMetadata().contains("dimension_units"))
-      << f2.value().getMetadata();
-  EXPECT_TRUE(f4.value().getMetadata().contains("dimension_units"))
-      << f4.value().getMetadata();
-  EXPECT_TRUE(f8.value().getMetadata().contains("dimension_units"))
-      << f8.value().getMetadata();
-  EXPECT_TRUE(voided.value().getMetadata().contains("dimension_units"))
-      << voided.value().getMetadata();
-}
-
-TEST(Variable, chunkSize) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_TRUE(i2.value().get_chunk_shape().status().ok())
-      << i2.value().get_chunk_shape().status();
-  EXPECT_TRUE(i4.value().get_chunk_shape().status().ok())
-      << i4.value().get_chunk_shape().status();
-  EXPECT_TRUE(i8.value().get_chunk_shape().status().ok())
-      << i8.value().get_chunk_shape().status();
-  EXPECT_TRUE(f2.value().get_chunk_shape().status().ok())
-      << f2.value().get_chunk_shape().status();
-  EXPECT_TRUE(f4.value().get_chunk_shape().status().ok())
-      << f4.value().get_chunk_shape().status();
-  EXPECT_TRUE(f8.value().get_chunk_shape().status().ok())
-      << f8.value().get_chunk_shape().status();
-  EXPECT_TRUE(voided.value().get_chunk_shape().status().ok())
-      << voided.value().get_chunk_shape().status();
-}
-
-TEST(Variable, getCompressor) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  auto i2Json = i2.value().get_spec();
-  auto i4Json = i4.value().get_spec();
-  auto i8Json = i8.value().get_spec();
-  auto f2Json = f2.value().get_spec();
-  auto f4Json = f4.value().get_spec();
-  auto f8Json = f8.value().get_spec();
-  auto voidedJson = voided.value().get_spec();
-
-  ASSERT_TRUE(i2Json.status().ok()) << i2Json.status();
-  ASSERT_TRUE(i4Json.status().ok()) << i4Json.status();
-  ASSERT_TRUE(i8Json.status().ok()) << i8Json.status();
-  ASSERT_TRUE(f2Json.status().ok()) << f2Json.status();
-  ASSERT_TRUE(f4Json.status().ok()) << f4Json.status();
-  ASSERT_TRUE(f8Json.status().ok()) << f8Json.status();
-  ASSERT_TRUE(voidedJson.status().ok()) << voidedJson.status();
-
-  EXPECT_TRUE(i2Json.value()["metadata"].contains("compressor"))
-      << i2Json.value();
-  EXPECT_TRUE(i4Json.value()["metadata"].contains("compressor"))
-      << i4Json.value();
-  EXPECT_TRUE(i8Json.value()["metadata"].contains("compressor"))
-      << i8Json.value();
-  EXPECT_TRUE(f2Json.value()["metadata"].contains("compressor"))
-      << f2Json.value();
-  EXPECT_TRUE(f4Json.value()["metadata"].contains("compressor"))
-      << f4Json.value();
-  EXPECT_TRUE(f8Json.value()["metadata"].contains("compressor"))
-      << f8Json.value();
-  EXPECT_TRUE(voidedJson.value()["metadata"].contains("compressor"))
-      << voidedJson.value();
-}
-
-TEST(Variable, shape) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_THAT(i2.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << i2.value().dimensions();
-  EXPECT_THAT(i4.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << i4.value().dimensions();
-  EXPECT_THAT(i8.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << i8.value().dimensions();
-  EXPECT_THAT(f2.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << f2.value().dimensions();
-  EXPECT_THAT(f4.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << f4.value().dimensions();
-  EXPECT_THAT(f8.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << f8.value().dimensions();
-  EXPECT_THAT(voided.value().dimensions().shape(),
-              ::testing::ElementsAre(10, 10, 14))
-      << voided.value().dimensions();
+/**
+ * @brief Returns the base path for test data based on Zarr version.
+ * Note: Does NOT include trailing slash.
+ */
+std::string GetBasePath(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "zarrs/acceptance_v3"
+                                                  : "zarrs/acceptance";
 }
 
-TEST(Variable, dtype) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  EXPECT_EQ(i2.value().dtype(), mdio::constants::kInt16) << i2.value().dtype();
-  EXPECT_EQ(i4.value().dtype(), mdio::constants::kInt32) << i4.value().dtype();
-  EXPECT_EQ(i8.value().dtype(), mdio::constants::kInt64) << i8.value().dtype();
-  EXPECT_EQ(f2.value().dtype(), mdio::constants::kFloat16)
-      << f2.value().dtype();
-  EXPECT_EQ(f4.value().dtype(), mdio::constants::kFloat32)
-      << f4.value().dtype();
-  EXPECT_EQ(f8.value().dtype(), mdio::constants::kFloat64)
-      << f8.value().dtype();
-  EXPECT_EQ(voided.value().dtype(), mdio::constants::kByte)
-      << voided.value().dtype();
-}
-
-TEST(Variable, domain) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  const mdio::Index EXPECTED_SHAPE = 10;
-  EXPECT_EQ(i2.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << i2.value().dimensions();
-  EXPECT_EQ(i4.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << i4.value().dimensions();
-  EXPECT_EQ(i8.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << i8.value().dimensions();
-  EXPECT_EQ(f2.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << f2.value().dimensions();
-  EXPECT_EQ(f4.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << f4.value().dimensions();
-  EXPECT_EQ(f8.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << f8.value().dimensions();
-  EXPECT_EQ(voided.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << voided.value().dimensions();
-
-  EXPECT_EQ(i2.value().dimensions().rank(), 2) << i2.value().dimensions();
-  EXPECT_EQ(i4.value().dimensions().rank(), 2) << i4.value().dimensions();
-  EXPECT_EQ(i8.value().dimensions().rank(), 2) << i8.value().dimensions();
-  EXPECT_EQ(f2.value().dimensions().rank(), 2) << f2.value().dimensions();
-  EXPECT_EQ(f4.value().dimensions().rank(), 2) << f4.value().dimensions();
-  EXPECT_EQ(f8.value().dimensions().rank(), 2) << f8.value().dimensions();
-  EXPECT_EQ(voided.value().dimensions().rank(), 3)
-      << voided.value().dimensions();
-}
-
-TEST(Variable, sliceByDimName) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
-  auto i2Slice = i2.value().slice(inlineSlice, crosslineSpec);
-  auto i4Slice = i4.value().slice(inlineSlice, crosslineSpec);
-  auto i8Slice = i8.value().slice(inlineSlice, crosslineSpec);
-  auto f2Slice = f2.value().slice(inlineSlice, crosslineSpec);
-  auto f4Slice = f4.value().slice(inlineSlice, crosslineSpec);
-  auto f8Slice = f8.value().slice(inlineSlice, crosslineSpec);
-  auto voidedSlice = voided.value().slice(inlineSlice, crosslineSpec);
-
-  EXPECT_TRUE(i2Slice.status().ok()) << i2.status();
-  EXPECT_TRUE(i4Slice.status().ok()) << i4Slice.status();
-  EXPECT_TRUE(i8Slice.status().ok()) << i8Slice.status();
-  EXPECT_TRUE(f2Slice.status().ok()) << f2Slice.status();
-  EXPECT_TRUE(f4Slice.status().ok()) << f4Slice.status();
-  EXPECT_TRUE(f8Slice.status().ok()) << f8Slice.status();
-  EXPECT_TRUE(voidedSlice.status().ok()) << voidedSlice.status();
-  EXPECT_THAT(i2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i2Slice.value().dimensions();
-  EXPECT_THAT(i4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i4Slice.value().dimensions();
-  EXPECT_THAT(i8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i8Slice.value().dimensions();
-  EXPECT_THAT(f2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f2Slice.value().dimensions();
-  EXPECT_THAT(f4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f4Slice.value().dimensions();
-  EXPECT_THAT(f8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f8Slice.value().dimensions();
-  EXPECT_THAT(voidedSlice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5, 14))
-      << voidedSlice.value().dimensions();
-}
-
-// A test to clean up after the test suite
-TEST(Variable, TEARDOWN) {
-  std::filesystem::remove_all("zarrs/acceptance/i2");
-  std::filesystem::remove_all("zarrs/acceptance/i4");
-  std::filesystem::remove_all("zarrs/acceptance/i8");
-  std::filesystem::remove_all("zarrs/acceptance/f2");
-  std::filesystem::remove_all("zarrs/acceptance/f4");
-  std::filesystem::remove_all("zarrs/acceptance/f8");
-  std::filesystem::remove_all("zarrs/acceptance/voided");
-  std::filesystem::remove_all("zarrs/acceptance");
-  ASSERT_TRUE(true);
+/**
+ * @brief Returns the TensorStore driver name for the given version.
+ */
+std::string GetTestDriverName(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "zarr3" : "zarr";
 }
 
-}  // namespace VariableTesting
-
-namespace VariableDataTest {
-
-template <typename T = void, mdio::DimensionIndex R = mdio::dynamic_rank,
-          mdio::ReadWriteMode M = mdio::ReadWriteMode::dynamic>
-mdio::Variable<T, R, M> getVariable() {
-  nlohmann::json i2Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/i2"
-            }
-        }
-    )"_json;
-  auto i2 = mdio::Variable<>::Open(i2Spec, (mdio::constants::kOpen));
-  if (!i2.status().ok()) {
-    std::cout << "Error opening i2: " << i2.status() << std::endl;
-    return mdio::Variable<T, R, M>();
+/**
+ * @brief Creates a variable spec for testing based on Zarr version.
+ */
+nlohmann::json CreateVariableSpec(mdio::zarr::ZarrVersion version,
+                                  const std::string& name,
+                                  const std::string& base_path) {
+  nlohmann::json spec;
+  spec["driver"] = GetTestDriverName(version);
+  spec["kvstore"]["driver"] = "file";
+  spec["kvstore"]["path"] = base_path + "/" + name;
+
+  if (version == mdio::zarr::ZarrVersion::kV3) {
+    spec["metadata"]["data_type"] = "int16";
+    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
+    spec["metadata"]["chunk_grid"]["name"] = "regular";
+    spec["metadata"]["chunk_grid"]["configuration"]["chunk_shape"] =
+        nlohmann::json::array({5, 5});
+    spec["metadata"]["chunk_key_encoding"]["name"] = "default";
+    spec["metadata"]["chunk_key_encoding"]["configuration"]["separator"] = "/";
+    nlohmann::json bytes_codec;
+    bytes_codec["name"] = "bytes";
+    spec["metadata"]["codecs"] = nlohmann::json::array({bytes_codec});
+    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
+    spec["attributes"]["long_name"] = "2-byte integer test";
+    spec["attributes"]["dimension_names"] =
+        nlohmann::json::array({"inline", "crossline"});
+    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
+  } else {
+    spec["metadata"]["dtype"] = "<i2";
+    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
+    spec["metadata"]["chunks"] = nlohmann::json::array({5, 5});
+    spec["metadata"]["dimension_separator"] = "/";
+    spec["metadata"]["compressor"]["id"] = "blosc";
+    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
+    spec["attributes"]["long_name"] = "2-byte integer test";
+    spec["attributes"]["dimension_names"] =
+        nlohmann::json::array({"inline", "crossline"});
+    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
   }
-  return i2.value();
-}
-
-TEST(VariableData, SETUP) {
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-  nlohmann::json i2Spec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/i2"
-            },
-            "metadata": {
-                "dtype": "<i2",
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "2-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
-  auto [i2Store, i2Metadata] = i2Schema;
-  auto i2 =
-      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-}
-
-TEST(VariableData, name) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.variableName, "i2") << variableData.variableName;
-}
-
-TEST(VariableData, longName) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.longName, "2-byte integer test")
-      << variableData.longName;
-}
-
-TEST(VariableData, optionalAttrs) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.metadata["metadata"]["attributes"]["foo"], "bar")
-      << variableData.metadata.dump(4);
-}
-
-TEST(VariableData, namedDimensions) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.metadata["dimension_names"].size(), 2)
-      << variableData.metadata;
-}
-
-TEST(VariableData, sliceByDimIdx) {
-  auto variableData = getVariable().Read().value();
-  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
-  auto slicedVariableData = variableData.slice(zeroIdxSlice, oneIdxSlice);
-  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
-  EXPECT_THAT(slicedVariableData.value().domain().shape(),
-              ::testing::ElementsAre(5, 5))
-      << slicedVariableData.value().domain();
-}
 
-TEST(VariableData, sliceByDimName) {
-  auto variableData = getVariable().Read().value();
-  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
-  auto slicedVariableData = variableData.slice(inlineSlice, crosslineSpec);
-  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
-  EXPECT_THAT(slicedVariableData.value().domain().shape(),
-              ::testing::ElementsAre(5, 5))
-      << slicedVariableData.value().domain();
+  return spec;
 }
 
-TEST(VariableData, writeToStore) {
-  auto variable = getVariable();
-  auto variableData = variable.Read().value();
-  auto data =
-      reinterpret_cast<int16_t*>(variableData.get_data_accessor().data());
-  data[0] = 0xff;
-  auto writeFuture = variable.Write(variableData);
-  writeFuture.result();
-  EXPECT_TRUE(writeFuture.status().ok()) << writeFuture.status();
-
-  auto variableCheck = getVariable().Read().value();
-  auto dataCheck =
-      reinterpret_cast<int16_t*>(variableCheck.get_data_accessor().data());
-  EXPECT_EQ(dataCheck[0], 0xff) << dataCheck[0];
-}
+/**
+ * @brief Creates a typed variable spec based on version and dtype.
+ */
+nlohmann::json CreateTypedVariableSpec(mdio::zarr::ZarrVersion version,
+                                       const std::string& name,
+                                       const std::string& base_path,
+                                       const std::string& dtype_v2,
+                                       const std::string& dtype_v3,
+                                       const std::string& long_name) {
+  nlohmann::json spec;
+  spec["driver"] = GetTestDriverName(version);
+  spec["kvstore"]["driver"] = "file";
+  spec["kvstore"]["path"] = base_path + "/" + name;
+
+  if (version == mdio::zarr::ZarrVersion::kV3) {
+    spec["metadata"]["data_type"] = dtype_v3;
+    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
+    spec["metadata"]["chunk_grid"]["name"] = "regular";
+    spec["metadata"]["chunk_grid"]["configuration"]["chunk_shape"] =
+        nlohmann::json::array({5, 5});
+    spec["metadata"]["chunk_key_encoding"]["name"] = "default";
+    spec["metadata"]["chunk_key_encoding"]["configuration"]["separator"] = "/";
+    nlohmann::json bytes_codec;
+    bytes_codec["name"] = "bytes";
+    spec["metadata"]["codecs"] = nlohmann::json::array({bytes_codec});
+    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
+    spec["attributes"]["long_name"] = long_name;
+    spec["attributes"]["dimension_names"] =
+        nlohmann::json::array({"inline", "crossline"});
+    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
+  } else {
+    spec["metadata"]["dtype"] = dtype_v2;
+    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
+    spec["metadata"]["chunks"] = nlohmann::json::array({5, 5});
+    spec["metadata"]["dimension_separator"] = "/";
+    spec["metadata"]["compressor"]["id"] = "blosc";
+    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
+    spec["attributes"]["long_name"] = long_name;
+    spec["attributes"]["dimension_names"] =
+        nlohmann::json::array({"inline", "crossline"});
+    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
+  }
 
-TEST(VariableData, dimensionUnits) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.metadata["dimension_units"].size(), 2)
-      << variableData.metadata;
+  return spec;
 }
 
-TEST(VariableData, TEARDOWN) {
-  std::filesystem::remove_all("zarrs/acceptance/i2");
-  ASSERT_TRUE(true);
+/**
+ * @brief Creates a base spec (for opening) based on version.
+ */
+nlohmann::json CreateBaseSpec(mdio::zarr::ZarrVersion version,
+                              const std::string& name,
+                              const std::string& base_path) {
+  nlohmann::json spec;
+  spec["driver"] = GetTestDriverName(version);
+  spec["kvstore"]["driver"] = "file";
+  spec["kvstore"]["path"] = base_path + "/" + name;
+  return spec;
 }
 
-}  // namespace VariableDataTest
-
-namespace DatasetTest {
-
-// clang-format off
-/*NOLINT*/  std::string datasetManifest = R"(
+/**
+ * @brief Returns the dataset manifest JSON for the given version.
+ */
+std::string GetDatasetManifest(mdio::zarr::ZarrVersion version) {
+  std::string name =
+      version == mdio::zarr::ZarrVersion::kV3 ? "campos_3d_v3" : "campos_3d";
+
+  // Note: V3 doesn't support struct arrays yet, so we use a slightly different
+  // manifest
+  if (version == mdio::zarr::ZarrVersion::kV3) {
+    return R"(
 {
   "metadata": {
-    "name": "campos_3d",
+    "name": "campos_3d_v3",
     "apiVersion": "1.0.0",
     "createdOn": "2023-12-12T15:02:06.413469-06:00",
     "attributes": {
@@ -1157,42 +236,23 @@ namespace DatasetTest {
           "name": "regular",
           "configuration": { "chunkShape": [128, 128, 128] }
         },
-        "unitsV1": {"speed": "m/s"}
-      },
-      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
-    },
-    {
-      "name": "image_inline",
-      "dataType": "int16",
-      "dimensions": ["inline", "crossline", "depth"],
-      "longName": "inline optimized version of 3d_stack",
-      "compressor": {"name": "blosc", "algorithm": "zstd"},
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [128, 128, 128] }
-        }
+        "unitsV1": {"speed": "m/s"}
       },
       "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
     },
     {
-      "name": "image_headers",
-      "dataType": {
-        "fields": [
-          {"name": "cdp-x", "format": "int32"},
-          {"name": "cdp-y", "format": "int32"},
-          {"name": "elevation", "format": "float16"},
-          {"name": "some_scalar", "format": "float16"}
-        ]
-      },
-      "dimensions": ["inline", "crossline"],
+      "name": "image_inline",
+      "dataType": "int16",
+      "dimensions": ["inline", "crossline", "depth"],
+      "longName": "inline optimized version of 3d_stack",
+      "compressor": {"name": "blosc", "algorithm": "zstd"},
       "metadata": {
         "chunkGrid": {
           "name": "regular",
-          "configuration": { "chunkShape": [128, 128] }
+          "configuration": { "chunkShape": [4, 512, 512] }
         }
       },
-      "coordinates": ["inline", "crossline", "cdp-x", "cdp-y"]
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
     },
     {
       "name": "inline",
@@ -1237,21 +297,8 @@ namespace DatasetTest {
   ]
 }
     )";
-// clang-format on
-
-TEST(DatasetSpec, valid) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto res = Construct(j, "zarrs/acceptance");
-  ASSERT_TRUE(res.status().ok()) << res.status();
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed = res.value();
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-  EXPECT_EQ(variables.size(), 9) << variables.size();
-}
-
-TEST(DatasetSpec, invalid) {
-  // manifest["variables"][0] missing "name" field
-  // Compressor for image_inline is also invalid
-  std::string manifest = R"(
+  } else {
+    return R"(
 {
   "metadata": {
     "name": "campos_3d",
@@ -1268,6 +315,7 @@ TEST(DatasetSpec, invalid) {
   },
   "variables": [
     {
+      "name": "image",
       "dataType": "float32",
       "dimensions": [
         {"name": "inline", "size": 256},
@@ -1296,7 +344,7 @@ TEST(DatasetSpec, invalid) {
     },
     {
       "name": "velocity",
-      "dataType": "float16",
+      "dataType": "float64",
       "dimensions": ["inline", "crossline", "depth"],
       "metadata": {
         "chunkGrid": {
@@ -1309,14 +357,14 @@ TEST(DatasetSpec, invalid) {
     },
     {
       "name": "image_inline",
-      "dataType": "float32",
+      "dataType": "int16",
       "dimensions": ["inline", "crossline", "depth"],
       "longName": "inline optimized version of 3d_stack",
-      "compressor": {"name": "zfp", "mode": "fixed_accuracy", "tolerance": 0.05},
+      "compressor": {"name": "blosc", "algorithm": "zstd"},
       "metadata": {
         "chunkGrid": {
           "name": "regular",
-          "configuration": { "chunkShape": [4, 512, 512] }
+          "configuration": { "chunkShape": [128, 128, 128] }
         }
       },
       "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
@@ -1383,76 +431,521 @@ TEST(DatasetSpec, invalid) {
   ]
 }
     )";
+  }
+}
+
+/**
+ * @brief Executes the Python regression tests
+ */
+int executePythonScript(const std::string& scriptPath,
+                        const std::vector<std::string>& args) {
+  if (scriptPath.empty() || args.empty()) {
+    std::cerr << "Error: scriptPath or args are empty." << std::endl;
+    return ERROR_CODE;
+  }
+
+  if (scriptPath[0] != '/' && scriptPath.find(DEFAULT_BASE_PATH) != 0) {
+    std::cerr
+        << "Error: PROJECT_BASE_PATH must be an absolute path or not be set."
+        << std::endl;
+    return ERROR_CODE;
+  }
+
+  std::vector<const char*> execArgs = {PYTHON_EXECUTABLE, scriptPath.c_str()};
+  for (const auto& arg : args) {
+    execArgs.push_back(arg.c_str());
+  }
+  execArgs.push_back(nullptr);
+
+  if (execvp(execArgs[0], const_cast<char* const*>(execArgs.data())) == -1) {
+    perror("execvp failed");
+    return ERROR_CODE;
+  }
+
+  return SUCCESS_CODE;
+}
+
+// ============================================================================
+// Parameterized Variable Tests
+// ============================================================================
+
+class VariableTest : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+    driver_ = GetTestDriverName(version_);
+  }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+  std::string driver_;
+};
+
+TEST_P(VariableTest, SETUP) {
+  // Ensure directory exists
+  std::filesystem::create_directories(base_path_);
+  
+  mdio::TransactionalOpenOptions options;
+  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
+
+  // Create i2 (int16)
+  auto i2Spec = CreateTypedVariableSpec(version_, "i2", base_path_, "<i2",
+                                        "int16", "2-byte integer test");
+  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
+  auto [i2Store, i2Metadata] = i2Schema;
+  auto i2 =
+      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+
+  // Create i4 (int32)
+  auto i4Spec = CreateTypedVariableSpec(version_, "i4", base_path_, "<i4",
+                                        "int32", "4-byte integer test");
+  auto i4Schema = mdio::internal::ValidateAndProcessJson(i4Spec).value();
+  auto [i4Store, i4Metadata] = i4Schema;
+  auto i4 =
+      mdio::internal::CreateVariable(i4Store, i4Metadata, std::move(options));
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+
+  // Create i8 (int64)
+  auto i8Spec = CreateTypedVariableSpec(version_, "i8", base_path_, "<i8",
+                                        "int64", "8-byte integer test");
+  auto i8Schema = mdio::internal::ValidateAndProcessJson(i8Spec).value();
+  auto [i8Store, i8Metadata] = i8Schema;
+  auto i8 =
+      mdio::internal::CreateVariable(i8Store, i8Metadata, std::move(options));
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+
+  // Create f2 (float16)
+  auto f2Spec = CreateTypedVariableSpec(version_, "f2", base_path_, "<f2",
+                                        "float16", "2-byte float test");
+  auto f2Schema = mdio::internal::ValidateAndProcessJson(f2Spec).value();
+  auto [f2Store, f2Metadata] = f2Schema;
+  auto f2 =
+      mdio::internal::CreateVariable(f2Store, f2Metadata, std::move(options));
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+
+  // Create f4 (float32)
+  auto f4Spec = CreateTypedVariableSpec(version_, "f4", base_path_, "<f4",
+                                        "float32", "4-byte float test");
+  auto f4Schema = mdio::internal::ValidateAndProcessJson(f4Spec).value();
+  auto [f4Store, f4Metadata] = f4Schema;
+  auto f4 =
+      mdio::internal::CreateVariable(f4Store, f4Metadata, std::move(options));
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+
+  // Create f8 (float64)
+  auto f8Spec = CreateTypedVariableSpec(version_, "f8", base_path_, "<f8",
+                                        "float64", "8-byte float test");
+  auto f8Schema = mdio::internal::ValidateAndProcessJson(f8Spec).value();
+  auto [f8Store, f8Metadata] = f8Schema;
+  auto f8 =
+      mdio::internal::CreateVariable(f8Store, f8Metadata, std::move(options));
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+}
+
+TEST_P(VariableTest, open) {
+  auto i2Base = CreateBaseSpec(version_, "i2", base_path_);
+  auto i4Base = CreateBaseSpec(version_, "i4", base_path_);
+  auto i8Base = CreateBaseSpec(version_, "i8", base_path_);
+  auto f2Base = CreateBaseSpec(version_, "f2", base_path_);
+  auto f4Base = CreateBaseSpec(version_, "f4", base_path_);
+  auto f8Base = CreateBaseSpec(version_, "f8", base_path_);
+
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(i2Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(i4Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(i8Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(f2Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(f4Base, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(f8Base, mdio::constants::kOpen).status().ok());
+}
+
+TEST_P(VariableTest, name) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i4", base_path_),
+                                   mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i8", base_path_),
+                                   mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f2", base_path_),
+                                   mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
+                                   mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f8", base_path_),
+                                   mdio::constants::kOpen);
+
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().get_variable_name(), "i2");
+  EXPECT_EQ(i4.value().get_variable_name(), "i4");
+  EXPECT_EQ(i8.value().get_variable_name(), "i8");
+  EXPECT_EQ(f2.value().get_variable_name(), "f2");
+  EXPECT_EQ(f4.value().get_variable_name(), "f4");
+  EXPECT_EQ(f8.value().get_variable_name(), "f8");
+}
+
+TEST_P(VariableTest, longName) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i4", base_path_),
+                                   mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i8", base_path_),
+                                   mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f2", base_path_),
+                                   mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
+                                   mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f8", base_path_),
+                                   mdio::constants::kOpen);
+
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().get_long_name(), "2-byte integer test");
+  EXPECT_EQ(i4.value().get_long_name(), "4-byte integer test");
+  EXPECT_EQ(i8.value().get_long_name(), "8-byte integer test");
+  EXPECT_EQ(f2.value().get_long_name(), "2-byte float test");
+  EXPECT_EQ(f4.value().get_long_name(), "4-byte float test");
+  EXPECT_EQ(f8.value().get_long_name(), "8-byte float test");
+}
+
+TEST_P(VariableTest, optionalAttrs) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  EXPECT_EQ(i2.value().GetAttributes()["attributes"]["foo"], "bar");
+}
+
+TEST_P(VariableTest, namedDimensions) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  EXPECT_EQ(i2.value().getMetadata()["dimension_names"].size(), 2);
+}
+
+TEST_P(VariableTest, sliceByDimIdx) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+
+  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
+
+  auto i2Slice = i2.value().slice(zeroIdxSlice, oneIdxSlice);
+  auto f4Slice = f4.value().slice(zeroIdxSlice, oneIdxSlice);
+
+  EXPECT_TRUE(i2Slice.status().ok()) << i2Slice.status();
+  EXPECT_TRUE(f4Slice.status().ok()) << f4Slice.status();
+  EXPECT_THAT(i2Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5));
+  EXPECT_THAT(f4Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5));
+}
+
+TEST_P(VariableTest, sliceByDimName) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+
+  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
+  auto i2Slice = i2.value().slice(inlineSlice, crosslineSpec);
+
+  EXPECT_TRUE(i2Slice.status().ok()) << i2Slice.status();
+  EXPECT_THAT(i2Slice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5));
+}
+
+TEST_P(VariableTest, dimensionUnits) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  EXPECT_TRUE(i2.value().getMetadata().contains("dimension_units"));
+}
+
+TEST_P(VariableTest, chunkSize) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  EXPECT_TRUE(i2.value().get_chunk_shape().status().ok());
+}
+
+TEST_P(VariableTest, shape) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  EXPECT_THAT(i2.value().dimensions().shape(), ::testing::ElementsAre(10, 10));
+}
+
+TEST_P(VariableTest, dtype) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  auto i4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i4", base_path_),
+                                   mdio::constants::kOpen);
+  auto i8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i8", base_path_),
+                                   mdio::constants::kOpen);
+  auto f2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f2", base_path_),
+                                   mdio::constants::kOpen);
+  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
+                                   mdio::constants::kOpen);
+  auto f8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f8", base_path_),
+                                   mdio::constants::kOpen);
+
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  ASSERT_TRUE(i4.status().ok()) << i4.status();
+  ASSERT_TRUE(i8.status().ok()) << i8.status();
+  ASSERT_TRUE(f2.status().ok()) << f2.status();
+  ASSERT_TRUE(f4.status().ok()) << f4.status();
+  ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  EXPECT_EQ(i2.value().dtype(), mdio::constants::kInt16);
+  EXPECT_EQ(i4.value().dtype(), mdio::constants::kInt32);
+  EXPECT_EQ(i8.value().dtype(), mdio::constants::kInt64);
+  EXPECT_EQ(f2.value().dtype(), mdio::constants::kFloat16);
+  EXPECT_EQ(f4.value().dtype(), mdio::constants::kFloat32);
+  EXPECT_EQ(f8.value().dtype(), mdio::constants::kFloat64);
+}
+
+TEST_P(VariableTest, domain) {
+  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
+                                   mdio::constants::kOpen);
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+
+  const mdio::Index EXPECTED_SHAPE = 10;
+  EXPECT_EQ(i2.value().dimensions().shape()[0], EXPECTED_SHAPE);
+  EXPECT_EQ(i2.value().dimensions().rank(), 2);
+}
+
+TEST_P(VariableTest, TEARDOWN) {
+  std::filesystem::remove_all(base_path_ + "/i2");
+  std::filesystem::remove_all(base_path_ + "/i4");
+  std::filesystem::remove_all(base_path_ + "/i8");
+  std::filesystem::remove_all(base_path_ + "/f2");
+  std::filesystem::remove_all(base_path_ + "/f4");
+  std::filesystem::remove_all(base_path_ + "/f8");
+  ASSERT_TRUE(true);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, VariableTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
+// ============================================================================
+// Parameterized VariableData Tests
+// ============================================================================
+
+class VariableDataTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+  }
+
+  mdio::Variable<> getVariable() {
+    auto spec = CreateBaseSpec(version_, "i2", base_path_);
+    auto var = mdio::Variable<>::Open(spec, mdio::constants::kOpen);
+    if (!var.status().ok()) {
+      std::cout << "Error opening i2: " << var.status() << std::endl;
+      return mdio::Variable<>();
+    }
+    return var.value();
+  }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
+
+TEST_P(VariableDataTest, SETUP) {
+  // Ensure directory exists
+  std::filesystem::create_directories(base_path_);
+  
+  mdio::TransactionalOpenOptions options;
+  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
+
+  auto i2Spec = CreateTypedVariableSpec(version_, "i2", base_path_, "<i2",
+                                        "int16", "2-byte integer test");
+  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
+  auto [i2Store, i2Metadata] = i2Schema;
+  auto i2 =
+      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
+  ASSERT_TRUE(i2.status().ok()) << i2.status();
+}
+
+TEST_P(VariableDataTest, name) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.variableName, "i2");
+}
+
+TEST_P(VariableDataTest, longName) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.longName, "2-byte integer test");
+}
+
+TEST_P(VariableDataTest, optionalAttrs) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.metadata["metadata"]["attributes"]["foo"], "bar");
+}
+
+TEST_P(VariableDataTest, namedDimensions) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.metadata["dimension_names"].size(), 2);
+}
+
+TEST_P(VariableDataTest, sliceByDimIdx) {
+  auto variableData = getVariable().Read().value();
+  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
+  auto slicedVariableData = variableData.slice(zeroIdxSlice, oneIdxSlice);
+  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
+  EXPECT_THAT(slicedVariableData.value().domain().shape(),
+              ::testing::ElementsAre(5, 5));
+}
+
+TEST_P(VariableDataTest, sliceByDimName) {
+  auto variableData = getVariable().Read().value();
+  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
+  auto slicedVariableData = variableData.slice(inlineSlice, crosslineSpec);
+  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
+  EXPECT_THAT(slicedVariableData.value().domain().shape(),
+              ::testing::ElementsAre(5, 5));
+}
+
+TEST_P(VariableDataTest, writeToStore) {
+  auto variable = getVariable();
+  auto variableData = variable.Read().value();
+  auto data =
+      reinterpret_cast<int16_t*>(variableData.get_data_accessor().data());
+  data[0] = 0xff;
+  auto writeFuture = variable.Write(variableData);
+  writeFuture.result();
+  EXPECT_TRUE(writeFuture.status().ok()) << writeFuture.status();
 
-  nlohmann::json j = nlohmann::json::parse(manifest);
-  auto res = Construct(j, "zarrs/acceptance");
-  ASSERT_FALSE(res.status().ok()) << res.status();
+  auto variableCheck = getVariable().Read().value();
+  auto dataCheck =
+      reinterpret_cast<int16_t*>(variableCheck.get_data_accessor().data());
+  EXPECT_EQ(dataCheck[0], 0xff);
 }
 
-TEST(Dataset, fillValue) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto ds = mdio::Dataset::from_json(j, "zarrs/acceptance",
-                                     mdio::constants::kCreateClean);
-  ASSERT_TRUE(ds.status().ok()) << ds.status();
+TEST_P(VariableDataTest, dimensionUnits) {
+  auto variableData = getVariable().Read().value();
+  EXPECT_EQ(variableData.metadata["dimension_units"].size(), 2);
+}
 
-  std::string key = "image_headers";
-  auto var = ds.value().get_variable(key);
-  ASSERT_TRUE(var.status().ok()) << var.status();
-  auto vdf = var.value().Read();
-  ASSERT_TRUE(vdf.status().ok()) << vdf.status();
-  auto vd = vdf.value();
+TEST_P(VariableDataTest, TEARDOWN) {
+  std::filesystem::remove_all(base_path_ + "/i2");
+  ASSERT_TRUE(true);
+}
 
-  auto data =
-      reinterpret_cast<mdio::dtypes::byte_t*>(vd.get_data_accessor().data());
-  std::byte zero = std::byte(0);
-  for (int i = 0; i < 1000000; i++) {
-    ASSERT_EQ(data[i], zero) << "Expected 0 at byte " << i << " but got "
-                             << static_cast<int>(data[i]);
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, VariableDataTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
+// ============================================================================
+// Parameterized Dataset Tests
+// ============================================================================
+
+class DatasetTest : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+    dataset_manifest_ = GetDatasetManifest(version_);
+    expected_var_count_ =
+        version_ == mdio::zarr::ZarrVersion::kV3 ? 8 : 9;  // V2 has struct array
   }
 
-  // This still doesn't work. We end up with the same empty fill values {, , , ,
-  // , , , , , , , } auto dataRes =
-  // tensorstore::StaticDataTypeCast<mdio::dtypes::byte_t>(vd.get_data_accessor());
-  // ASSERT_TRUE(dataRes.status().ok()) << dataRes.status();
-  // auto d = dataRes.value();
-  // std::cout << d[0][0] << std::endl;
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+  std::string dataset_manifest_;
+  size_t expected_var_count_;
+};
+
+TEST_P(DatasetTest, specValid) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto res = Construct(j, base_path_, version_);
+  ASSERT_TRUE(res.status().ok()) << res.status();
+  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed = res.value();
+  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+  EXPECT_EQ(variables.size(), expected_var_count_);
+
+  // Verify driver name
+  std::string expected_driver = GetTestDriverName(version_);
+  for (const auto& var : variables) {
+    EXPECT_EQ(var["driver"], expected_driver);
+  }
 }
 
-TEST(Dataset, open) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct = Construct(j, "zarrs/acceptance");
+TEST_P(DatasetTest, open) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
   ASSERT_TRUE(construct.status().ok()) << construct.status();
 
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
+  auto [metadata, variables] = construct.value();
   auto dataset =
       mdio::Dataset::Open(metadata, variables, mdio::constants::kCreateClean);
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
 }
 
-TEST(Dataset, condensed) {
-  std::string path = "zarrs/acceptance/";
-  auto ds = mdio::Dataset::Open(path, mdio::constants::kOpen);
-  ASSERT_TRUE(ds.status().ok()) << "Failed in test 1 of 2: " << ds.status();
+TEST_P(DatasetTest, condensed) {
+  // First create the dataset
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  auto [metadata, variables] = construct.value();
+  auto createDs =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kCreateClean);
+  ASSERT_TRUE(createDs.status().ok()) << createDs.status();
+
+  // Now test opening with just the path
+  auto ds = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
+  ASSERT_TRUE(ds.status().ok()) << "Failed to open with trailing slash: "
+                                << ds.status();
 
-  std::string missingSlashPath = "zarrs/acceptance";
-  auto ds2 = mdio::Dataset::Open(missingSlashPath, mdio::constants::kOpen);
-  ASSERT_TRUE(ds2.status().ok()) << "Failed in test 2 of 2: " << ds2.status();
+  // Test without trailing slash
+  std::string path_no_slash = base_path_;
+  if (!path_no_slash.empty() && path_no_slash.back() == '/') {
+    path_no_slash.pop_back();
+  }
+  auto ds2 = mdio::Dataset::Open(path_no_slash, mdio::constants::kOpen);
+  ASSERT_TRUE(ds2.status().ok()) << "Failed to open without trailing slash: "
+                                 << ds2.status();
 }
 
-TEST(Dataset, read) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct = Construct(j, "zarrs/acceptance");
+TEST_P(DatasetTest, read) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
   ASSERT_TRUE(construct.status().ok()) << construct.status();
 
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
+  auto [metadata, variables] = construct.value();
   auto dataset =
       mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
@@ -1465,43 +958,37 @@ TEST(Dataset, read) {
   }
 }
 
-TEST(Dataset, write) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct = Construct(j, "zarrs/acceptance");
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+TEST_P(DatasetTest, write) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
 
+  auto [metadata, variables] = construct.value();
   auto dataset =
       mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
   auto ds = dataset.value();
 
   std::vector<std::string> names = ds.variables.get_keys();
-
-  // Construct a vector of Variables to work with
   std::vector<mdio::Variable<>> openVariables;
   for (auto& key : names) {
     auto var = ds.get_variable(key);
     openVariables.emplace_back(var.value());
   }
 
-  // Now we can start opening all the Variables
   std::vector<mdio::Future<mdio::VariableData<>>> readVariablesFutures;
   for (auto& v : openVariables) {
-    auto read = v.Read();
-    readVariablesFutures.emplace_back(read);
+    readVariablesFutures.emplace_back(v.Read());
   }
 
-  // Now we make sure all the reads were successful
   std::vector<mdio::VariableData<>> readVariables;
   for (auto& v : readVariablesFutures) {
     ASSERT_TRUE(v.status().ok()) << v.status();
     readVariables.emplace_back(v.value());
   }
 
-  for (auto variable : readVariables) {
+  // Modify some data
+  for (auto& variable : readVariables) {
     std::string name = variable.variableName;
     mdio::DataType dtype = variable.dtype();
     if (dtype == mdio::constants::kFloat32 && name == "image") {
@@ -1515,12 +1002,6 @@ TEST(Dataset, write) {
       auto data =
           reinterpret_cast<int16_t*>(variable.get_data_accessor().data());
       data[0] = 0xff;
-    } else if (dtype == mdio::constants::kByte && name == "image_headers") {
-      auto data = reinterpret_cast<mdio::dtypes::byte_t*>(
-          variable.get_data_accessor().data());
-      for (int i = 0; i < 12; i++) {
-        data[i] = std::byte(0xff);
-      }
     } else if (name == "inline") {
       auto data =
           reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
@@ -1542,8 +1023,7 @@ TEST(Dataset, write) {
     }
   }
 
-  // Pair the Variables to the VariableData objects via name matching so we can
-  // write them out correctly This makes an assumption that the vectors are 1-1
+  // Pair and write
   std::map<std::size_t, std::size_t> variableIdxPair;
   for (std::size_t i = 0; i < openVariables.size(); i++) {
     for (std::size_t j = 0; j < readVariables.size(); j++) {
@@ -1555,177 +1035,558 @@ TEST(Dataset, write) {
     }
   }
 
-  // Now we can write the Variables back to the store
   std::vector<mdio::WriteFutures> writeFutures;
   for (auto& idxPair : variableIdxPair) {
-    auto write =
-        openVariables[idxPair.second].Write(readVariables[idxPair.first]);
-    writeFutures.emplace_back(write);
+    writeFutures.emplace_back(
+        openVariables[idxPair.second].Write(readVariables[idxPair.first]));
   }
 
-  // Now we make sure all the writes were successful
   for (auto& w : writeFutures) {
     ASSERT_TRUE(w.status().ok()) << w.status();
   }
 
-  std::string fielded = "image_headers";
-  ASSERT_TRUE(ds.SelectField(fielded, "cdp-x").status().ok());
-  auto wf = ds.get_variable(fielded).value().Write(readVariables[4]);
-  ASSERT_FALSE(wf.status().ok()) << wf.status();
+  // Verify writes
+  std::string driver = GetTestDriverName(version_);
+  nlohmann::json imageJson;
+  imageJson["driver"] = driver;
+  imageJson["kvstore"]["driver"] = "file";
+  imageJson["kvstore"]["path"] = base_path_ + "/image";
+
+  auto image = mdio::Variable<>::Open(imageJson, mdio::constants::kOpen);
+  ASSERT_TRUE(image.status().ok()) << image.status();
+
+  auto imageData = image.result()->Read();
+  ASSERT_TRUE(imageData.status().ok()) << imageData.status();
+  auto castedImage =
+      reinterpret_cast<float*>(imageData.value().get_data_accessor().data());
+  EXPECT_EQ(castedImage[0], 3.14f);
+}
+
+TEST_P(DatasetTest, name) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  auto [metadata, variables] = construct.value();
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  std::string expected_name =
+      version_ == mdio::zarr::ZarrVersion::kV3 ? "campos_3d_v3" : "campos_3d";
+  EXPECT_EQ(dataset.value().getMetadata()["name"], expected_name);
+}
+
+TEST_P(DatasetTest, optionalAttrs) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  auto [metadata, variables] = construct.value();
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  EXPECT_TRUE(dataset.value().getMetadata().contains("name"));
+}
+
+TEST_P(DatasetTest, isel) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  auto [metadata, variables] = construct.value();
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  auto ds = dataset.value();
+
+  mdio::RangeDescriptor<mdio::Index> desc1 = {"inline", 0, 5, 1};
+  auto slice = ds.isel(desc1);
+  ASSERT_TRUE(slice.status().ok()) << slice.status();
+
+  auto domain = slice->domain;
+  ASSERT_EQ(domain.rank(), 3) << "This should have a rank of 3...";
+
+  auto depthRange = domain[1];
+  EXPECT_EQ(depthRange.interval().inclusive_min(), 0);
+  EXPECT_EQ(depthRange.interval().exclusive_max(), 384);
+
+  auto crosslineRange = domain[0];
+  EXPECT_EQ(crosslineRange.interval().inclusive_min(), 0);
+  EXPECT_EQ(crosslineRange.interval().exclusive_max(), 512);
+
+  auto inlineRange = domain[2];
+  EXPECT_EQ(inlineRange.interval().inclusive_min(), 0);
+  EXPECT_EQ(inlineRange.interval().exclusive_max(), 5);
+}
+
+TEST_P(DatasetTest, listVars) {
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto construct = Construct(j, base_path_, version_);
+  ASSERT_TRUE(construct.status().ok()) << construct.status();
+
+  auto [metadata, variables] = construct.value();
+  auto dataset =
+      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  std::vector<std::string> varList = dataset.value().variables.get_keys();
+  EXPECT_EQ(varList.size(), expected_var_count_);
+}
+
+TEST_P(DatasetTest, fromJson) {
+  std::filesystem::remove_all(base_path_ + "/from_json_test");
+
+  nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
+  auto dataset = mdio::Dataset::from_json(j, base_path_ + "/from_json_test",
+                                          version_, mdio::constants::kCreateClean);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  std::vector<std::string> varList = dataset.value().variables.get_keys();
+  EXPECT_EQ(varList.size(), expected_var_count_);
+
+  std::filesystem::remove_all(base_path_ + "/from_json_test");
+}
+
+TEST_P(DatasetTest, TEARDOWN) {
+  std::filesystem::remove_all(base_path_);
+  ASSERT_TRUE(true);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, DatasetTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
+// ============================================================================
+// V2-Only Tests (Struct Arrays)
+// ============================================================================
+
+namespace V2OnlyTests {
+
+TEST(VariableV2Only, structArraySetup) {
+  mdio::TransactionalOpenOptions options;
+  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
+
+  nlohmann::json voidedSpec = R"(
+        {
+            "driver": "zarr",
+            "kvstore": {
+                "driver": "file",
+                "path": "zarrs/acceptance/voided"
+            },
+            "field": "integer16",
+            "metadata": {
+                "dtype": [["integer16", "<i2"], ["float32", "<f4"], ["double", "<f8"]],
+                "shape": [10, 10],
+                "chunks": [5, 5],
+                "dimension_separator": "/",
+                "compressor": {
+                    "id": "blosc"
+                }
+            },
+            "attributes": {
+                "metadata": {
+                    "attributes": {
+                        "foo": "bar"
+                    }
+                },
+                "long_name": "struct array test",
+                "dimension_names": ["inline", "crossline"],
+                "dimension_units": ["m", "m"]
+            }
+        }
+    )"_json;
+  auto voidedSchema =
+      mdio::internal::ValidateAndProcessJson(voidedSpec).value();
+  auto [voidedStore, voidedMetadata] = voidedSchema;
+  auto voided = mdio::internal::CreateVariable(voidedStore, voidedMetadata,
+                                               std::move(options));
+  ASSERT_TRUE(voided.status().ok()) << voided.status();
+}
+
+TEST(VariableV2Only, structArrayOpen) {
+  nlohmann::json voidedBase = R"(
+    {
+        "driver": "zarr",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance/voided"
+        }
+    }
+)"_json;
+
+  EXPECT_TRUE(
+      mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen).status().ok());
+}
+
+TEST(VariableV2Only, structArrayName) {
+  nlohmann::json voidedBase = R"(
+    {
+        "driver": "zarr",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance/voided"
+        }
+    }
+)"_json;
+
+  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  ASSERT_TRUE(voided.status().ok()) << voided.status();
+  EXPECT_EQ(voided.value().get_variable_name(), "voided");
+  EXPECT_EQ(voided.value().get_long_name(), "struct array test");
+}
+
+TEST(VariableV2Only, structArrayDtype) {
+  nlohmann::json voidedBase = R"(
+    {
+        "driver": "zarr",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance/voided"
+        }
+    }
+)"_json;
+
+  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  ASSERT_TRUE(voided.status().ok()) << voided.status();
+  EXPECT_EQ(voided.value().dtype(), mdio::constants::kByte);
+}
+
+TEST(VariableV2Only, structArrayShape) {
+  nlohmann::json voidedBase = R"(
+    {
+        "driver": "zarr",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance/voided"
+        }
+    }
+)"_json;
+
+  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  ASSERT_TRUE(voided.status().ok()) << voided.status();
+  EXPECT_THAT(voided.value().dimensions().shape(),
+              ::testing::ElementsAre(10, 10, 14));
+  EXPECT_EQ(voided.value().dimensions().rank(), 3);
+}
+
+TEST(VariableV2Only, structArraySlice) {
+  nlohmann::json voidedBase = R"(
+    {
+        "driver": "zarr",
+        "kvstore": {
+            "driver": "file",
+            "path": "zarrs/acceptance/voided"
+        }
+    }
+)"_json;
+
+  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  ASSERT_TRUE(voided.status().ok()) << voided.status();
+
+  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
+  auto voidedSlice = voided.value().slice(zeroIdxSlice, oneIdxSlice);
+  EXPECT_TRUE(voidedSlice.status().ok()) << voidedSlice.status();
+  EXPECT_THAT(voidedSlice.value().dimensions().shape(),
+              ::testing::ElementsAre(5, 5, 14));
+}
+
+TEST(VariableV2Only, structArrayTeardown) {
+  std::filesystem::remove_all("zarrs/acceptance/voided");
+  ASSERT_TRUE(true);
+}
+
+TEST(DatasetV2Only, selectField) {
+  // Create dataset first
+  std::string manifest = R"(
+{
+  "metadata": {
+    "name": "select_field_test",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00"
+  },
+  "variables": [
+    {
+      "name": "image_headers",
+      "dataType": {
+        "fields": [
+          {"name": "cdp-x", "format": "int32"},
+          {"name": "cdp-y", "format": "int32"},
+          {"name": "elevation", "format": "float16"},
+          {"name": "some_scalar", "format": "float16"}
+        ]
+      },
+      "dimensions": [
+        {"name": "inline", "size": 128},
+        {"name": "crossline", "size": 128}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [64, 64] }
+        }
+      },
+      "coordinates": ["inline", "crossline"]
+    },
+    {
+      "name": "inline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "inline", "size": 128}]
+    },
+    {
+      "name": "crossline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "crossline", "size": 128}]
+    }
+  ]
+}
+  )";
 
-  nlohmann::json imageJson = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/image"
-            }
-        }
-    )"_json;
+  std::filesystem::remove_all("zarrs/select_field_test");
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  auto dataset = mdio::Dataset::from_json(j, "zarrs/select_field_test",
+                                          mdio::constants::kCreateClean);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
 
-  nlohmann::json velocityJson = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/velocity"
-            }
-        }
-    )"_json;
+  auto ds = dataset.value();
+  std::string name = "image_headers";
 
-  nlohmann::json imageInlineJson = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/image_inline"
-            }
-        }
-    )"_json;
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte);
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3);
 
-  nlohmann::json imageHeadersJson = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/image_headers"
-            }
-        }
-    )"_json;
+  EXPECT_TRUE(ds.SelectField("image_headers", "cdp-x").status().ok());
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kInt32);
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2);
 
-  auto image = mdio::Variable<>::Open(imageJson, mdio::constants::kOpen);
-  auto velocity = mdio::Variable<>::Open(velocityJson, mdio::constants::kOpen);
-  auto imageInline =
-      mdio::Variable<>::Open(imageInlineJson, mdio::constants::kOpen);
-  auto imageHeaders =
-      mdio::Variable<>::Open(imageHeadersJson, mdio::constants::kOpen);
+  EXPECT_TRUE(ds.SelectField("image_headers", "elevation").status().ok());
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() ==
+              mdio::constants::kFloat16);
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2);
 
-  ASSERT_TRUE(image.status().ok()) << image.status();
-  ASSERT_TRUE(velocity.status().ok()) << velocity.status();
-  ASSERT_TRUE(imageInline.status().ok()) << imageInline.status();
-  ASSERT_TRUE(imageHeaders.status().ok()) << imageHeaders.status();
+  EXPECT_TRUE(ds.SelectField("image_headers", "").status().ok());
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte);
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3);
 
-  auto imageData = image.result()->Read();
-  auto velocityData = velocity.result()->Read();
-  auto imageInlineData = imageInline.result()->Read();
-  auto imageHeadersData = imageHeaders.result()->Read();
+  EXPECT_FALSE(ds.SelectField("image_headers", "NotAField").status().ok());
+  EXPECT_FALSE(ds.SelectField("NotAVariable", "NotAField").status().ok());
 
-  ASSERT_TRUE(imageData.status().ok()) << imageData.status();
-  ASSERT_TRUE(velocityData.status().ok()) << velocityData.status();
-  ASSERT_TRUE(imageInlineData.status().ok()) << imageInlineData.status();
-  ASSERT_TRUE(imageHeadersData.status().ok()) << imageHeadersData.status();
+  std::filesystem::remove_all("zarrs/select_field_test");
+}
 
-  auto castedImage =
-      reinterpret_cast<float*>(imageData.value().get_data_accessor().data());
-  auto castedVelociy = reinterpret_cast<double*>(
-      velocityData.value().get_data_accessor().data());
-  auto castedImageInline = reinterpret_cast<int16_t*>(
-      imageInlineData.value().get_data_accessor().data());
-  auto castedImageHeaders = reinterpret_cast<mdio::dtypes::byte_t*>(
-      imageHeadersData.value().get_data_accessor().data());
-
-  EXPECT_EQ(castedImage[0], 3.14f) << castedImage[0];
-  EXPECT_EQ(castedVelociy[0], 2.71828) << castedVelociy[0];
-  EXPECT_EQ(castedImageInline[0], 0xff) << castedImageInline[0];
-  // EXPECT_EQ(castedImageHeaders[0], std::byte(0xffffffffffff)) << "Struct
-  // array was not correct value";
-}
-
-TEST(Dataset, name) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct = Construct(j, "zarrs/acceptance");
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
+TEST(DatasetV2Only, fillValue) {
+  std::string manifest = R"(
+{
+  "metadata": {
+    "name": "fill_value_test",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00"
+  },
+  "variables": [
+    {
+      "name": "image_headers",
+      "dataType": {
+        "fields": [
+          {"name": "cdp-x", "format": "int32"},
+          {"name": "cdp-y", "format": "int32"},
+          {"name": "elevation", "format": "float16"},
+          {"name": "some_scalar", "format": "float16"}
+        ]
+      },
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128] }
+        }
+      }
+    },
+    {
+      "name": "inline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "inline", "size": 256}]
+    },
+    {
+      "name": "crossline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "crossline", "size": 512}]
+    }
+  ]
+}
+  )";
 
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+  std::filesystem::remove_all("zarrs/fill_value_test");
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  auto ds = mdio::Dataset::from_json(j, "zarrs/fill_value_test",
+                                     mdio::constants::kCreateClean);
+  ASSERT_TRUE(ds.status().ok()) << ds.status();
 
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  std::string key = "image_headers";
+  auto var = ds.value().get_variable(key);
+  ASSERT_TRUE(var.status().ok()) << var.status();
+  auto vdf = var.value().Read();
+  ASSERT_TRUE(vdf.status().ok()) << vdf.status();
+  auto vd = vdf.value();
 
-  auto ds = dataset.value();
+  auto data =
+      reinterpret_cast<mdio::dtypes::byte_t*>(vd.get_data_accessor().data());
+  std::byte zero = std::byte(0);
+  for (int i = 0; i < 1000; i++) {
+    ASSERT_EQ(data[i], zero) << "Expected 0 at byte " << i;
+  }
 
-  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d") << ds.getMetadata();
+  std::filesystem::remove_all("zarrs/fill_value_test");
 }
 
-TEST(Dataset, optionalAttrs) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct = Construct(j, "zarrs/acceptance");
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
+}  // namespace V2OnlyTests
 
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+// ============================================================================
+// V2 Compatibility Tests (Python)
+// ============================================================================
 
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+namespace V2CompatibilityTests {
 
-  auto ds = dataset.value();
+TEST(VariableV2Compat, zarrCompatibility) {
+  // First setup variables for testing
+  std::filesystem::remove_all("zarrs/compat_test");
+  std::filesystem::create_directories("zarrs/compat_test");
 
-  EXPECT_TRUE(ds.getMetadata().contains("name")) << ds.getMetadata();
-}
+  mdio::TransactionalOpenOptions options;
+  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
 
-TEST(Dataset, isel) {
-  std::string path = "zarrs/acceptance";
-  auto dataset = mdio::Dataset::Open(path, mdio::constants::kOpen);
+  std::vector<std::tuple<std::string, std::string, std::string>> vars = {
+      {"i2", "<i2", "2-byte integer"},   {"i4", "<i4", "4-byte integer"},
+      {"i8", "<i8", "8-byte integer"},   {"f2", "<f2", "2-byte float"},
+      {"f4", "<f4", "4-byte float"},     {"f8", "<f8", "8-byte float"},
+  };
+
+  for (const auto& [name, dtype, long_name] : vars) {
+    nlohmann::json spec;
+    spec["driver"] = "zarr";
+    spec["kvstore"]["driver"] = "file";
+    spec["kvstore"]["path"] = "zarrs/compat_test/" + name;
+    spec["metadata"]["dtype"] = dtype;
+    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
+    spec["metadata"]["chunks"] = nlohmann::json::array({5, 5});
+    spec["metadata"]["dimension_separator"] = "/";
+    spec["metadata"]["compressor"]["id"] = "blosc";
+    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
+    spec["attributes"]["long_name"] = long_name;
+    spec["attributes"]["dimension_names"] =
+        nlohmann::json::array({"inline", "crossline"});
+    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
+
+    auto schema = mdio::internal::ValidateAndProcessJson(spec).value();
+    auto [store, metadata] = schema;
+    auto var =
+        mdio::internal::CreateVariable(store, metadata, std::move(options));
+    ASSERT_TRUE(var.status().ok()) << var.status();
+  }
 
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-  auto ds = dataset.value();
+  const char* basePath = std::getenv(PROJECT_BASE_PATH_ENV);
+  if (!basePath) {
+    std::cout << "PROJECT_BASE_PATH environment variable not set. Expecting to "
+                 "be in the 'build/mdio' directory."
+              << std::endl;
+    basePath = DEFAULT_BASE_PATH;
+  }
 
-  mdio::RangeDescriptor<mdio::Index> desc1 = {"inline", 0, 5, 1};
-  auto slice = ds.isel(desc1);
-  ASSERT_TRUE(slice.status().ok());
+  std::string srcPath = std::string(basePath) + ZARR_SCRIPT_RELATIVE_PATH;
 
-  auto domain = slice->domain;
-  ASSERT_EQ(domain.rank(), 3) << "This should have a rank of 3...";
+  if (access(srcPath.c_str(), F_OK) == -1) {
+    std::cerr << "Error: Python script not found at " << srcPath << std::endl;
+    FAIL() << "Script not found: " << srcPath;
+  }
 
-  // Check depth range
-  auto depthRange = domain[1];
-  EXPECT_EQ(depthRange.interval().inclusive_min(), 0)
-      << "Depth range should start at 0";
-  EXPECT_EQ(depthRange.interval().exclusive_max(), 384)
-      << "Depth range should end at 384";
+  std::vector<std::string> args = {"i2", "i4", "i8", "f2", "f4", "f8"};
+  std::vector<pid_t> pids;
 
-  // Check crossline range
-  auto crosslineRange = domain[0];
-  EXPECT_EQ(crosslineRange.interval().inclusive_min(), 0)
-      << "Crossline range should start at 0";
-  EXPECT_EQ(crosslineRange.interval().exclusive_max(), 512)
-      << "Crossline range should end at 512";
+  for (const auto& arg : args) {
+    pid_t pid = fork();
+    if (pid == 0) {
+      int result =
+          executePythonScript(srcPath, {"zarrs/compat_test/" + arg});
+      if (result == 0xfd00) {
+        GTEST_SKIP() << "Zarr compatibility skipped due to import error";
+        exit(SUCCESS_CODE);
+      }
+      exit(result);
+    } else if (pid > 0) {
+      pids.push_back(pid);
+    } else {
+      perror("fork failed");
+      FAIL() << "fork failed";
+    }
+  }
 
-  // Check inline range
-  auto inlineRange = domain[2];
-  EXPECT_EQ(inlineRange.interval().inclusive_min(), 0)
-      << "Inline range should start at 0";
-  EXPECT_EQ(inlineRange.interval().exclusive_max(), 5)
-      << "Inline range should end at 5";
+  for (pid_t pid : pids) {
+    int status;
+    if (waitpid(pid, &status, 0) == -1) {
+      perror("waitpid failed");
+      FAIL() << "waitpid failed";
+    }
+    if (WIFEXITED(status) && WEXITSTATUS(status) == 0xfd00) {
+      GTEST_SKIP() << "Zarr compatibility skipped due to import error";
+    }
+    EXPECT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0)
+        << "Failed to read one of the arguments";
+  }
+
+  std::filesystem::remove_all("zarrs/compat_test");
+}
+
+TEST(DatasetV2Compat, xarrayCompatible) {
+  // First create a dataset
+  std::string manifest = R"(
+{
+  "metadata": {
+    "name": "xarray_compat_test",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00"
+  },
+  "variables": [
+    {
+      "name": "data",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "x", "size": 10},
+        {"name": "y", "size": 10}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [5, 5] }
+        }
+      }
+    },
+    {
+      "name": "x",
+      "dataType": "int32",
+      "dimensions": [{"name": "x", "size": 10}]
+    },
+    {
+      "name": "y",
+      "dataType": "int32",
+      "dimensions": [{"name": "y", "size": 10}]
+    }
+  ]
 }
+  )";
+
+  std::filesystem::remove_all("zarrs/xarray_compat");
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  auto ds = mdio::Dataset::from_json(j, "zarrs/xarray_compat",
+                                     mdio::constants::kCreateClean);
+  ASSERT_TRUE(ds.status().ok()) << ds.status();
 
-TEST(Dataset, xarrayCompatible) {
   const char* basePath = std::getenv(PROJECT_BASE_PATH_ENV);
   if (!basePath) {
     std::cout << "PROJECT_BASE_PATH environment variable not set. Expecting to "
@@ -1734,12 +1595,11 @@ TEST(Dataset, xarrayCompatible) {
     basePath = DEFAULT_BASE_PATH;
   }
 
-  // Resolve the absolute path for the script
   std::string srcPath = std::string(basePath) + XARRAY_SCRIPT_RELATIVE_PATH;
 
-  // Ensure that srcPath is valid and points to an existing file
   if (access(srcPath.c_str(), F_OK) == -1) {
     std::cerr << "Error: Python script not found at " << srcPath << std::endl;
+    std::filesystem::remove_all("zarrs/xarray_compat");
     FAIL() << "Script not found: " << srcPath;
   }
 
@@ -1749,25 +1609,22 @@ TEST(Dataset, xarrayCompatible) {
   for (const auto& option : metadataOptions) {
     pid_t pid = fork();
     if (pid == 0) {
-      // Child process
-      int result = executePythonScript(srcPath, {FILE_PATH_BASE, option});
-      if (result == 0xfd00) {  // 0xfd from Python is 0xfd00 in C++
+      int result =
+          executePythonScript(srcPath, {"zarrs/xarray_compat/", option});
+      if (result == 0xfd00) {
         GTEST_SKIP()
             << "Xarray compatibility skipped due to import error for xarray";
         exit(SUCCESS_CODE);
       }
       exit(result);
     } else if (pid > 0) {
-      // Parent process
       pids.push_back(pid);
     } else {
-      // Fork failed
       perror("fork failed");
       FAIL() << "fork failed";
     }
   }
 
-  // Wait for all child processes
   for (pid_t pid : pids) {
     int status;
     if (waitpid(pid, &status, 0) == -1) {
@@ -1778,80 +1635,203 @@ TEST(Dataset, xarrayCompatible) {
       GTEST_SKIP()
           << "Xarray compatibility skipped due to import error for xarray";
     }
-    ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0)
-        << "xarray compatibility test failed with one of the metadata "
-           "options\n\tThere was some expected output above...";
+    EXPECT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0)
+        << "xarray compatibility test failed";
   }
+
+  std::filesystem::remove_all("zarrs/xarray_compat");
 }
 
-TEST(Dataset, listVars) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct = Construct(j, "zarrs/acceptance");
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
+}  // namespace V2CompatibilityTests
 
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
+// ============================================================================
+// Dataset::from_json with Version Parameter Tests
+// ============================================================================
 
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+class DatasetFromJsonTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_) + "/from_json";
+    std::filesystem::remove_all(base_path_);
+  }
 
-  std::vector<std::string> varList = dataset.value().variables.get_keys();
-  EXPECT_TRUE(varList.size() == 9) << "No variables found in dataset";
+  void TearDown() override { std::filesystem::remove_all(base_path_); }
+
+  std::string GetSimpleManifest() {
+    return R"(
+{
+  "metadata": {
+    "name": "from_json_test",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00"
+  },
+  "variables": [
+    {
+      "name": "data",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "x", "size": 32},
+        {"name": "y", "size": 32}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [16, 16] }
+        }
+      }
+    },
+    {
+      "name": "x",
+      "dataType": "int32",
+      "dimensions": [{"name": "x", "size": 32}]
+    },
+    {
+      "name": "y",
+      "dataType": "int32",
+      "dimensions": [{"name": "y", "size": 32}]
+    }
+  ]
 }
+    )";
+  }
 
-TEST(Dataset, selectField) {
-  std::string path = "zarrs/acceptance";
-  auto dataset = mdio::Dataset::Open(path, mdio::constants::kOpen);
-  std::string name = "image_headers";
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
 
+TEST_P(DatasetFromJsonTest, createWithExplicitVersion) {
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto dataset = mdio::Dataset::from_json(j, base_path_, version_,
+                                          mdio::constants::kCreateClean);
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
   auto ds = dataset.value();
+  EXPECT_EQ(ds.getMetadata()["name"], "from_json_test");
+
+  std::vector<std::string> varList = ds.variables.get_keys();
+  EXPECT_EQ(varList.size(), 3);
+}
 
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte)
-      << "Failed to pull byte array from image_headers";
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3)
-      << "Expected structarray to be of rank 3";
+TEST_P(DatasetFromJsonTest, createWithOptionalVersion) {
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto dataset = mdio::Dataset::from_json(
+      j, base_path_, std::optional<mdio::zarr::ZarrVersion>(version_),
+      mdio::constants::kCreateClean);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
 
-  EXPECT_TRUE(ds.SelectField("image_headers", "cdp-x").status().ok())
-      << "Failed to pull cdp-x from image_headers";
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kInt32)
-      << "Failed to pull int32 from image_headers";
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2)
-      << "Expected cdp-x to be of rank 2";
+  auto ds = dataset.value();
+  EXPECT_EQ(ds.getMetadata()["name"], "from_json_test");
+}
 
-  EXPECT_TRUE(ds.SelectField("image_headers", "elevation").status().ok())
-      << "Failed to pull elevation from image_headers";
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() ==
-              mdio::constants::kFloat16)
-      << "Failed to pull float16 from image_headers";
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2)
-      << "Expected elevation to be of rank 2";
+TEST_P(DatasetFromJsonTest, readWrite) {
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto datasetRes = mdio::Dataset::from_json(j, base_path_, version_,
+                                             mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto ds = datasetRes.value();
 
-  EXPECT_TRUE(ds.SelectField("image_headers", "").status().ok())
-      << "Failed to set to byte array";
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte)
-      << "Failed to pull byte array from image_headers";
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3)
-      << "Expected structarray to be of rank 3";
+  auto dataVarRes = ds.variables.get<mdio::dtypes::float32_t>("data");
+  ASSERT_TRUE(dataVarRes.status().ok()) << dataVarRes.status();
+  auto dataVar = dataVarRes.value();
 
-  EXPECT_FALSE(ds.SelectField("image", "NotAField").status().ok())
-      << "Somehow pulled NotAField from image";
+  auto dataRes = dataVar.Read();
+  ASSERT_TRUE(dataRes.status().ok()) << dataRes.status();
+  auto data = dataRes.value();
 
-  EXPECT_FALSE(ds.SelectField("NotAVariable", "NotAField").status().ok())
-      << "Somehow pulled NotAField from NotAVariable";
+  auto accessor = data.get_data_accessor().data();
+  accessor[0] = 42.0f;
+  accessor[1] = 43.0f;
 
-  EXPECT_FALSE(ds.SelectField("image_headers", "NotAField").status().ok())
-      << "Somehow pulled NotAField from image_headers";
+  auto writeFut = dataVar.Write(data);
+  ASSERT_TRUE(writeFut.status().ok()) << writeFut.status();
+
+  auto rereadFut = dataVar.Read();
+  ASSERT_TRUE(rereadFut.status().ok()) << rereadFut.status();
+  auto rereadData = rereadFut.value();
+  auto rereadAccessor = rereadData.get_data_accessor().data();
+
+  EXPECT_FLOAT_EQ(rereadAccessor[0], 42.0f);
+  EXPECT_FLOAT_EQ(rereadAccessor[1], 43.0f);
 }
 
-TEST(Dataset, TEARDOWN) {
-  std::filesystem::remove_all("zarrs/acceptance");
-  ASSERT_TRUE(true);
+TEST_P(DatasetFromJsonTest, isel) {
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto datasetRes = mdio::Dataset::from_json(j, base_path_, version_,
+                                             mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto ds = datasetRes.value();
+
+  mdio::RangeDescriptor<mdio::Index> desc1 = {"x", 0, 10, 1};
+  mdio::RangeDescriptor<mdio::Index> desc2 = {"y", 5, 15, 1};
+  auto sliceRes = ds.isel(desc1, desc2);
+
+  ASSERT_TRUE(sliceRes.status().ok()) << sliceRes.status();
+  auto slice = sliceRes.value();
+
+  auto domain = slice.domain;
+  ASSERT_EQ(domain.rank(), 2);
+}
+
+TEST_P(DatasetFromJsonTest, intervals) {
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto datasetRes = mdio::Dataset::from_json(j, base_path_, version_,
+                                             mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto ds = datasetRes.value();
+
+  auto intervalRes = ds.get_intervals();
+  ASSERT_TRUE(intervalRes.ok()) << intervalRes.status();
+  auto intervals = intervalRes.value();
+
+  EXPECT_GE(intervals.size(), 2);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, DatasetFromJsonTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
+// Test nullopt version (should default to V2)
+TEST(DatasetFromJsonNullopt, createWithNulloptVersion) {
+  std::filesystem::remove_all("zarrs/from_json_nullopt");
+
+  std::string manifest = R"(
+{
+  "metadata": {
+    "name": "nullopt_test",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00"
+  },
+  "variables": [
+    {
+      "name": "data",
+      "dataType": "float32",
+      "dimensions": [{"name": "x", "size": 10}]
+    },
+    {
+      "name": "x",
+      "dataType": "int32",
+      "dimensions": [{"name": "x", "size": 10}]
+    }
+  ]
 }
+  )";
+
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  std::optional<mdio::zarr::ZarrVersion> version = std::nullopt;
+  auto dataset = mdio::Dataset::from_json(j, "zarrs/from_json_nullopt", version,
+                                          mdio::constants::kCreateClean);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+  EXPECT_EQ(ds.getMetadata()["name"], "nullopt_test");
 
-}  // namespace DatasetTest
+  std::filesystem::remove_all("zarrs/from_json_nullopt");
+}
 
 }  // namespace
diff --git a/mdio/acceptance_test_v3.cc b/mdio/acceptance_test_v3.cc
deleted file mode 100644
index fb4e0bc..0000000
--- a/mdio/acceptance_test_v3.cc
+++ /dev/null
@@ -1,1330 +0,0 @@
-// Copyright 2024 TGS
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//    http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/**
- * @file acceptance_test_v3.cc
- * @brief Acceptance tests for Zarr V3 driver support.
- *
- * This file contains tests that verify the MDIO library works correctly
- * with the Zarr V3 format, including variable creation, reading, writing,
- * and dataset operations.
- */
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <cstdlib>
-#include <filesystem>
-#include <nlohmann/json.hpp>  // NOLINT
-
-#include "mdio/dataset.h"
-#include "mdio/dataset_factory.h"
-#include "mdio/zarr/zarr.h"
-
-namespace {
-
-constexpr char FILE_PATH_BASE_V3[] = "./zarrs/acceptance_v3/";
-
-namespace VariableTestingV3 {
-
-using float16_t = mdio::dtypes::float_16_t;
-
-// Base specs for Zarr V3 variables (without full metadata - used for opening)
-nlohmann::json i2Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/i2"
-        }
-    }
-)"_json;
-
-nlohmann::json i4Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/i4"
-        }
-    }
-)"_json;
-
-nlohmann::json i8Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/i8"
-        }
-    }
-)"_json;
-
-nlohmann::json f2Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/f2"
-        }
-    }
-)"_json;
-
-nlohmann::json f4Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/f4"
-        }
-    }
-)"_json;
-
-nlohmann::json f8Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/f8"
-        }
-    }
-)"_json;
-
-nlohmann::json u2Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/u2"
-        }
-    }
-)"_json;
-
-nlohmann::json u4Base = R"(
-    {
-        "driver": "zarr3",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance_v3/u4"
-        }
-    }
-)"_json;
-
-// Test to set up some pre-existing elements for testing with Zarr V3
-TEST(VariableV3, SETUP) {
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-
-  // int16 variable - using minimal V3 spec format
-  nlohmann::json i2Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/i2"
-            },
-            "metadata": {
-                "data_type": "int16",
-                "shape": [10, 10],
-                "chunk_grid": {
-                    "name": "regular",
-                    "configuration": {"chunk_shape": [5, 5]}
-                },
-                "chunk_key_encoding": {
-                    "name": "default",
-                    "configuration": {"separator": "/"}
-                },
-                "codecs": [{"name": "bytes"}]
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "2-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
-  auto [i2Store, i2Metadata] = i2Schema;
-  auto i2 =
-      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-
-  // int32 variable
-  nlohmann::json i4Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/i4"
-            },
-            "metadata": {
-                "data_type": "int32",
-                "shape": [10, 10],
-                "chunk_grid": {
-                    "name": "regular",
-                    "configuration": {"chunk_shape": [5, 5]}
-                },
-                "chunk_key_encoding": {
-                    "name": "default",
-                    "configuration": {"separator": "/"}
-                },
-                "codecs": [{"name": "bytes"}]
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "4-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i4Schema = mdio::internal::ValidateAndProcessJson(i4Spec).value();
-  auto [i4Store, i4Metadata] = i4Schema;
-  auto i4 =
-      mdio::internal::CreateVariable(i4Store, i4Metadata, std::move(options));
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-
-  // int64 variable
-  nlohmann::json i8Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/i8"
-            },
-            "metadata": {
-                "data_type": "int64",
-                "shape": [10, 10],
-                "chunk_grid": {
-                    "name": "regular",
-                    "configuration": {"chunk_shape": [5, 5]}
-                },
-                "chunk_key_encoding": {
-                    "name": "default",
-                    "configuration": {"separator": "/"}
-                },
-                "codecs": [{"name": "bytes"}]
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "8-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i8Schema = mdio::internal::ValidateAndProcessJson(i8Spec).value();
-  auto [i8Store, i8Metadata] = i8Schema;
-  auto i8 =
-      mdio::internal::CreateVariable(i8Store, i8Metadata, std::move(options));
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-
-  // float16 variable
-  nlohmann::json f2Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/f2"
-            },
-            "metadata": {
-                "data_type": "float16",
-                "shape": [10, 10],
-                "chunk_grid": {
-                    "name": "regular",
-                    "configuration": {"chunk_shape": [5, 5]}
-                },
-                "chunk_key_encoding": {
-                    "name": "default",
-                    "configuration": {"separator": "/"}
-                },
-                "codecs": [{"name": "bytes"}]
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "2-byte float test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto f2Schema = mdio::internal::ValidateAndProcessJson(f2Spec).value();
-  auto [f2Store, f2Metadata] = f2Schema;
-  auto f2 =
-      mdio::internal::CreateVariable(f2Store, f2Metadata, std::move(options));
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-
-  // float32 variable
-  nlohmann::json f4Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/f4"
-            },
-            "metadata": {
-                "data_type": "float32",
-                "shape": [10, 10],
-                "chunk_grid": {
-                    "name": "regular",
-                    "configuration": {"chunk_shape": [5, 5]}
-                },
-                "chunk_key_encoding": {
-                    "name": "default",
-                    "configuration": {"separator": "/"}
-                },
-                "codecs": [{"name": "bytes"}]
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "4-byte float test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto f4Schema = mdio::internal::ValidateAndProcessJson(f4Spec).value();
-  auto [f4Store, f4Metadata] = f4Schema;
-  auto f4 =
-      mdio::internal::CreateVariable(f4Store, f4Metadata, std::move(options));
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-
-  // float64 variable
-  nlohmann::json f8Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/f8"
-            },
-            "metadata": {
-                "data_type": "float64",
-                "shape": [10, 10],
-                "chunk_grid": {
-                    "name": "regular",
-                    "configuration": {"chunk_shape": [5, 5]}
-                },
-                "chunk_key_encoding": {
-                    "name": "default",
-                    "configuration": {"separator": "/"}
-                },
-                "codecs": [{"name": "bytes"}]
-            },
-            "attributes": {
-                "long_name": "8-byte float test",
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto f8Schema = mdio::internal::ValidateAndProcessJson(f8Spec).value();
-  auto [f8Store, f8Metadata] = f8Schema;
-  auto f8 =
-      mdio::internal::CreateVariable(f8Store, f8Metadata, std::move(options));
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-}
-
-TEST(VariableV3, open) {
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i2Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i4Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i8Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f2Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f4Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f8Base, mdio::constants::kOpen).status().ok());
-}
-
-TEST(VariableV3, name) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_EQ(i2.value().get_variable_name(), "i2")
-      << i2.value().get_variable_name();
-  EXPECT_EQ(i4.value().get_variable_name(), "i4")
-      << i4.value().get_variable_name();
-  EXPECT_EQ(i8.value().get_variable_name(), "i8")
-      << i8.value().get_variable_name();
-  EXPECT_EQ(f2.value().get_variable_name(), "f2")
-      << f2.value().get_variable_name();
-  EXPECT_EQ(f4.value().get_variable_name(), "f4")
-      << f4.value().get_variable_name();
-  EXPECT_EQ(f8.value().get_variable_name(), "f8")
-      << f8.value().get_variable_name();
-}
-
-TEST(VariableV3, longName) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_EQ(i2.value().get_long_name(), "2-byte integer test")
-      << i2.value().get_long_name();
-  EXPECT_EQ(i4.value().get_long_name(), "4-byte integer test")
-      << i4.value().get_long_name();
-  EXPECT_EQ(i8.value().get_long_name(), "8-byte integer test")
-      << i8.value().get_long_name();
-  EXPECT_EQ(f2.value().get_long_name(), "2-byte float test")
-      << f2.value().get_long_name();
-  EXPECT_EQ(f4.value().get_long_name(), "4-byte float test")
-      << f4.value().get_long_name();
-  EXPECT_EQ(f8.value().get_long_name(), "8-byte float test")
-      << f8.value().get_long_name();
-}
-
-TEST(VariableV3, optionalAttrs) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_EQ(i2.value().GetAttributes()["attributes"]["foo"], "bar")
-      << i2.value().GetAttributes();
-  EXPECT_EQ(i4.value().GetAttributes()["attributes"]["foo"], "bar")
-      << i4.value().GetAttributes();
-  EXPECT_EQ(i8.value().GetAttributes()["attributes"]["foo"], "bar")
-      << i8.value().GetAttributes();
-  EXPECT_EQ(f2.value().GetAttributes()["attributes"]["foo"], "bar")
-      << f2.value().GetAttributes();
-  EXPECT_EQ(f4.value().GetAttributes()["attributes"]["foo"], "bar")
-      << f4.value().GetAttributes();
-  EXPECT_EQ(f8.value().GetAttributes()["attributes"]["foo"], "bar")
-      << f8.value().GetAttributes();
-}
-
-TEST(VariableV3, namedDimensions) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_EQ(i2.value().getMetadata()["dimension_names"].size(), 2)
-      << i2.value().getMetadata();
-  EXPECT_EQ(i4.value().getMetadata()["dimension_names"].size(), 2)
-      << i4.value().getMetadata();
-  EXPECT_EQ(i8.value().getMetadata()["dimension_names"].size(), 2)
-      << i8.value().getMetadata();
-  EXPECT_EQ(f2.value().getMetadata()["dimension_names"].size(), 2)
-      << f2.value().getMetadata();
-  EXPECT_EQ(f4.value().getMetadata()["dimension_names"].size(), 2)
-      << f4.value().getMetadata();
-  EXPECT_EQ(f8.value().getMetadata()["dimension_names"].size(), 2)
-      << f8.value().getMetadata();
-}
-
-TEST(VariableV3, sliceByDimIdx) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
-
-  auto i2Slice = i2.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto i4Slice = i4.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto i8Slice = i8.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto f2Slice = f2.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto f4Slice = f4.value().slice(zeroIdxSlice, oneIdxSlice);
-  auto f8Slice = f8.value().slice(zeroIdxSlice, oneIdxSlice);
-
-  EXPECT_TRUE(i2Slice.status().ok()) << i2Slice.status();
-  EXPECT_TRUE(i4Slice.status().ok()) << i4Slice.status();
-  EXPECT_TRUE(i8Slice.status().ok()) << i8Slice.status();
-  EXPECT_TRUE(f2Slice.status().ok()) << f2Slice.status();
-  EXPECT_TRUE(f4Slice.status().ok()) << f4Slice.status();
-  EXPECT_TRUE(f8Slice.status().ok()) << f8Slice.status();
-  EXPECT_THAT(i2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i2Slice.value().dimensions();
-  EXPECT_THAT(i4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i4Slice.value().dimensions();
-  EXPECT_THAT(i8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i8Slice.value().dimensions();
-  EXPECT_THAT(f2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f2Slice.value().dimensions();
-  EXPECT_THAT(f4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f4Slice.value().dimensions();
-  EXPECT_THAT(f8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f8Slice.value().dimensions();
-}
-
-TEST(VariableV3, dimensionUnits) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_TRUE(i2.value().getMetadata().contains("dimension_units"))
-      << i2.value().getMetadata();
-  EXPECT_TRUE(i4.value().getMetadata().contains("dimension_units"))
-      << i4.value().getMetadata();
-  EXPECT_TRUE(i8.value().getMetadata().contains("dimension_units"))
-      << i8.value().getMetadata();
-  EXPECT_TRUE(f2.value().getMetadata().contains("dimension_units"))
-      << f2.value().getMetadata();
-  EXPECT_TRUE(f4.value().getMetadata().contains("dimension_units"))
-      << f4.value().getMetadata();
-  EXPECT_TRUE(f8.value().getMetadata().contains("dimension_units"))
-      << f8.value().getMetadata();
-}
-
-TEST(VariableV3, chunkSize) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_TRUE(i2.value().get_chunk_shape().status().ok())
-      << i2.value().get_chunk_shape().status();
-  EXPECT_TRUE(i4.value().get_chunk_shape().status().ok())
-      << i4.value().get_chunk_shape().status();
-  EXPECT_TRUE(i8.value().get_chunk_shape().status().ok())
-      << i8.value().get_chunk_shape().status();
-  EXPECT_TRUE(f2.value().get_chunk_shape().status().ok())
-      << f2.value().get_chunk_shape().status();
-  EXPECT_TRUE(f4.value().get_chunk_shape().status().ok())
-      << f4.value().get_chunk_shape().status();
-  EXPECT_TRUE(f8.value().get_chunk_shape().status().ok())
-      << f8.value().get_chunk_shape().status();
-}
-
-TEST(VariableV3, shape) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_THAT(i2.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << i2.value().dimensions();
-  EXPECT_THAT(i4.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << i4.value().dimensions();
-  EXPECT_THAT(i8.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << i8.value().dimensions();
-  EXPECT_THAT(f2.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << f2.value().dimensions();
-  EXPECT_THAT(f4.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << f4.value().dimensions();
-  EXPECT_THAT(f8.value().dimensions().shape(), ::testing::ElementsAre(10, 10))
-      << f8.value().dimensions();
-}
-
-TEST(VariableV3, dtype) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_EQ(i2.value().dtype(), mdio::constants::kInt16) << i2.value().dtype();
-  EXPECT_EQ(i4.value().dtype(), mdio::constants::kInt32) << i4.value().dtype();
-  EXPECT_EQ(i8.value().dtype(), mdio::constants::kInt64) << i8.value().dtype();
-  EXPECT_EQ(f2.value().dtype(), mdio::constants::kFloat16)
-      << f2.value().dtype();
-  EXPECT_EQ(f4.value().dtype(), mdio::constants::kFloat32)
-      << f4.value().dtype();
-  EXPECT_EQ(f8.value().dtype(), mdio::constants::kFloat64)
-      << f8.value().dtype();
-}
-
-TEST(VariableV3, domain) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  const mdio::Index EXPECTED_SHAPE = 10;
-  EXPECT_EQ(i2.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << i2.value().dimensions();
-  EXPECT_EQ(i4.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << i4.value().dimensions();
-  EXPECT_EQ(i8.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << i8.value().dimensions();
-  EXPECT_EQ(f2.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << f2.value().dimensions();
-  EXPECT_EQ(f4.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << f4.value().dimensions();
-  EXPECT_EQ(f8.value().dimensions().shape()[0], EXPECTED_SHAPE)
-      << f8.value().dimensions();
-
-  EXPECT_EQ(i2.value().dimensions().rank(), 2) << i2.value().dimensions();
-  EXPECT_EQ(i4.value().dimensions().rank(), 2) << i4.value().dimensions();
-  EXPECT_EQ(i8.value().dimensions().rank(), 2) << i8.value().dimensions();
-  EXPECT_EQ(f2.value().dimensions().rank(), 2) << f2.value().dimensions();
-  EXPECT_EQ(f4.value().dimensions().rank(), 2) << f4.value().dimensions();
-  EXPECT_EQ(f8.value().dimensions().rank(), 2) << f8.value().dimensions();
-}
-
-TEST(VariableV3, sliceByDimName) {
-  auto i2 = mdio::Variable<>::Open(i2Base, mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(i4Base, mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(i8Base, mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(f2Base, mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(f4Base, mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(f8Base, mdio::constants::kOpen);
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
-  auto i2Slice = i2.value().slice(inlineSlice, crosslineSpec);
-  auto i4Slice = i4.value().slice(inlineSlice, crosslineSpec);
-  auto i8Slice = i8.value().slice(inlineSlice, crosslineSpec);
-  auto f2Slice = f2.value().slice(inlineSlice, crosslineSpec);
-  auto f4Slice = f4.value().slice(inlineSlice, crosslineSpec);
-  auto f8Slice = f8.value().slice(inlineSlice, crosslineSpec);
-
-  EXPECT_TRUE(i2Slice.status().ok()) << i2.status();
-  EXPECT_TRUE(i4Slice.status().ok()) << i4Slice.status();
-  EXPECT_TRUE(i8Slice.status().ok()) << i8Slice.status();
-  EXPECT_TRUE(f2Slice.status().ok()) << f2Slice.status();
-  EXPECT_TRUE(f4Slice.status().ok()) << f4Slice.status();
-  EXPECT_TRUE(f8Slice.status().ok()) << f8Slice.status();
-  EXPECT_THAT(i2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i2Slice.value().dimensions();
-  EXPECT_THAT(i4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i4Slice.value().dimensions();
-  EXPECT_THAT(i8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << i8Slice.value().dimensions();
-  EXPECT_THAT(f2Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f2Slice.value().dimensions();
-  EXPECT_THAT(f4Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f4Slice.value().dimensions();
-  EXPECT_THAT(f8Slice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5))
-      << f8Slice.value().dimensions();
-}
-
-// A test to clean up after the test suite
-TEST(VariableV3, TEARDOWN) {
-  std::filesystem::remove_all("zarrs/acceptance_v3/i2");
-  std::filesystem::remove_all("zarrs/acceptance_v3/i4");
-  std::filesystem::remove_all("zarrs/acceptance_v3/i8");
-  std::filesystem::remove_all("zarrs/acceptance_v3/f2");
-  std::filesystem::remove_all("zarrs/acceptance_v3/f4");
-  std::filesystem::remove_all("zarrs/acceptance_v3/f8");
-  std::filesystem::remove_all("zarrs/acceptance_v3");
-  ASSERT_TRUE(true);
-}
-
-}  // namespace VariableTestingV3
-
-namespace VariableDataTestV3 {
-
-template <typename T = void, mdio::DimensionIndex R = mdio::dynamic_rank,
-          mdio::ReadWriteMode M = mdio::ReadWriteMode::dynamic>
-mdio::Variable<T, R, M> getVariable() {
-  nlohmann::json i2Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/i2"
-            }
-        }
-    )"_json;
-  auto i2 = mdio::Variable<>::Open(i2Spec, (mdio::constants::kOpen));
-  if (!i2.status().ok()) {
-    std::cout << "Error opening i2: " << i2.status() << std::endl;
-    return mdio::Variable<T, R, M>();
-  }
-  return i2.value();
-}
-
-TEST(VariableDataV3, SETUP) {
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-  nlohmann::json i2Spec = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/i2"
-            },
-            "metadata": {
-                "data_type": "int16",
-                "shape": [10, 10],
-                "chunk_grid": {
-                    "name": "regular",
-                    "configuration": {"chunk_shape": [5, 5]}
-                },
-                "chunk_key_encoding": {
-                    "name": "default",
-                    "configuration": {"separator": "/"}
-                },
-                "codecs": [{"name": "bytes"}]
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "2-byte integer test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
-  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
-  auto [i2Store, i2Metadata] = i2Schema;
-  auto i2 =
-      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-}
-
-TEST(VariableDataV3, name) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.variableName, "i2") << variableData.variableName;
-}
-
-TEST(VariableDataV3, longName) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.longName, "2-byte integer test")
-      << variableData.longName;
-}
-
-TEST(VariableDataV3, optionalAttrs) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.metadata["metadata"]["attributes"]["foo"], "bar")
-      << variableData.metadata.dump(4);
-}
-
-TEST(VariableDataV3, namedDimensions) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.metadata["dimension_names"].size(), 2)
-      << variableData.metadata;
-}
-
-TEST(VariableDataV3, sliceByDimIdx) {
-  auto variableData = getVariable().Read().value();
-  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
-  auto slicedVariableData = variableData.slice(zeroIdxSlice, oneIdxSlice);
-  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
-  EXPECT_THAT(slicedVariableData.value().domain().shape(),
-              ::testing::ElementsAre(5, 5))
-      << slicedVariableData.value().domain();
-}
-
-TEST(VariableDataV3, sliceByDimName) {
-  auto variableData = getVariable().Read().value();
-  mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> crosslineSpec = {"crossline", 0, 5, 1};
-  auto slicedVariableData = variableData.slice(inlineSlice, crosslineSpec);
-  ASSERT_TRUE(slicedVariableData.status().ok()) << slicedVariableData.status();
-  EXPECT_THAT(slicedVariableData.value().domain().shape(),
-              ::testing::ElementsAre(5, 5))
-      << slicedVariableData.value().domain();
-}
-
-TEST(VariableDataV3, writeToStore) {
-  auto variable = getVariable();
-  auto variableData = variable.Read().value();
-  auto data =
-      reinterpret_cast<int16_t*>(variableData.get_data_accessor().data());
-  data[0] = 0xff;
-  auto writeFuture = variable.Write(variableData);
-  writeFuture.result();
-  EXPECT_TRUE(writeFuture.status().ok()) << writeFuture.status();
-
-  auto variableCheck = getVariable().Read().value();
-  auto dataCheck =
-      reinterpret_cast<int16_t*>(variableCheck.get_data_accessor().data());
-  EXPECT_EQ(dataCheck[0], 0xff) << dataCheck[0];
-}
-
-TEST(VariableDataV3, dimensionUnits) {
-  auto variableData = getVariable().Read().value();
-  EXPECT_EQ(variableData.metadata["dimension_units"].size(), 2)
-      << variableData.metadata;
-}
-
-TEST(VariableDataV3, TEARDOWN) {
-  std::filesystem::remove_all("zarrs/acceptance_v3/i2");
-  ASSERT_TRUE(true);
-}
-
-}  // namespace VariableDataTestV3
-
-namespace DatasetTestV3 {
-
-// clang-format off
-/*NOLINT*/  std::string datasetManifest = R"(
-{
-  "metadata": {
-    "name": "campos_3d_v3",
-    "apiVersion": "1.0.0",
-    "createdOn": "2023-12-12T15:02:06.413469-06:00",
-    "attributes": {
-      "textHeader": [
-        "C01 .......................... ",
-        "C02 .......................... ",
-        "C03 .......................... "
-      ],
-      "foo": "bar"
-    }
-  },
-  "variables": [
-    {
-      "name": "image",
-      "dataType": "float32",
-      "dimensions": [
-        {"name": "inline", "size": 256},
-        {"name": "crossline", "size": 512},
-        {"name": "depth", "size": 384}
-      ],
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [128, 128, 128] }
-        },
-        "statsV1": {
-          "count": 100,
-          "sum": 1215.1,
-          "sumSquares": 125.12,
-          "min": 5.61,
-          "max": 10.84,
-          "histogram": {"binCenters":  [1, 2], "counts":  [10, 15]}
-        },
-        "attributes": {
-          "fizz": "buzz"
-        }
-    },
-      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
-      "compressor": {"name": "blosc", "algorithm": "zstd"}
-    },
-    {
-      "name": "velocity",
-      "dataType": "float64",
-      "dimensions": ["inline", "crossline", "depth"],
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [128, 128, 128] }
-        },
-        "unitsV1": {"speed": "m/s"}
-      },
-      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
-    },
-    {
-      "name": "image_inline",
-      "dataType": "int16",
-      "dimensions": ["inline", "crossline", "depth"],
-      "longName": "inline optimized version of 3d_stack",
-      "compressor": {"name": "blosc", "algorithm": "zstd"},
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [4, 512, 512] }
-        }
-      },
-      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
-    },
-    {
-      "name": "inline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "inline", "size": 256}]
-    },
-    {
-      "name": "crossline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "crossline", "size": 512}]
-    },
-    {
-      "name": "depth",
-      "dataType": "uint32",
-      "dimensions": [{"name": "depth", "size": 384}],
-      "metadata": {
-        "unitsV1": { "length": "m" }
-      }
-    },
-    {
-      "name": "cdp-x",
-      "dataType": "float32",
-      "dimensions": [
-        {"name": "inline", "size": 256},
-        {"name": "crossline", "size": 512}
-      ],
-      "metadata": {
-        "unitsV1": { "length": "m" }
-      }
-    },
-    {
-      "name": "cdp-y",
-      "dataType": "float32",
-      "dimensions": [
-        {"name": "inline", "size": 256},
-        {"name": "crossline", "size": 512}
-      ],
-      "metadata": {
-        "unitsV1": { "length": "m" }
-      }
-    }
-  ]
-}
-    )";
-// clang-format on
-
-TEST(DatasetSpecV3, valid) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto res = Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-  ASSERT_TRUE(res.status().ok()) << res.status();
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed = res.value();
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-  // Note: 8 variables (no struct array for V3 currently)
-  EXPECT_EQ(variables.size(), 8) << variables.size();
-
-  // Verify that the specs have zarr3 driver
-  for (const auto& var : variables) {
-    EXPECT_EQ(var["driver"], "zarr3") << var.dump(2);
-  }
-}
-
-TEST(DatasetV3, open) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct =
-      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kCreateClean);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-}
-
-TEST(DatasetV3, read) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct =
-      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-  auto ds = dataset.value();
-
-  for (auto& kv : ds.coordinates) {
-    std::string key = kv.first;
-    auto var = ds.get_variable(key);
-    ASSERT_TRUE(var.status().ok()) << var.status();
-  }
-}
-
-TEST(DatasetV3, write) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct =
-      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  auto ds = dataset.value();
-
-  std::vector<std::string> names = ds.variables.get_keys();
-
-  // Construct a vector of Variables to work with
-  std::vector<mdio::Variable<>> openVariables;
-  for (auto& key : names) {
-    auto var = ds.get_variable(key);
-    openVariables.emplace_back(var.value());
-  }
-
-  // Now we can start opening all the Variables
-  std::vector<mdio::Future<mdio::VariableData<>>> readVariablesFutures;
-  for (auto& v : openVariables) {
-    auto read = v.Read();
-    readVariablesFutures.emplace_back(read);
-  }
-
-  // Now we make sure all the reads were successful
-  std::vector<mdio::VariableData<>> readVariables;
-  for (auto& v : readVariablesFutures) {
-    ASSERT_TRUE(v.status().ok()) << v.status();
-    readVariables.emplace_back(v.value());
-  }
-
-  for (auto variable : readVariables) {
-    std::string name = variable.variableName;
-    mdio::DataType dtype = variable.dtype();
-    if (dtype == mdio::constants::kFloat32 && name == "image") {
-      auto data = reinterpret_cast<float*>(variable.get_data_accessor().data());
-      data[0] = 3.14f;
-    } else if (dtype == mdio::constants::kFloat64 && name == "velocity") {
-      auto data =
-          reinterpret_cast<double*>(variable.get_data_accessor().data());
-      data[0] = 2.71828;
-    } else if (dtype == mdio::constants::kInt16 && name == "image_inline") {
-      auto data =
-          reinterpret_cast<int16_t*>(variable.get_data_accessor().data());
-      data[0] = 0xff;
-    } else if (name == "inline") {
-      auto data =
-          reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
-      for (uint32_t i = 0; i < 256; ++i) {
-        data[i] = i;
-      }
-    } else if (name == "crossline") {
-      auto data =
-          reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
-      for (uint32_t i = 0; i < 512; ++i) {
-        data[i] = i;
-      }
-    } else if (name == "depth") {
-      auto data =
-          reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
-      for (uint32_t i = 0; i < 384; ++i) {
-        data[i] = i;
-      }
-    }
-  }
-
-  // Pair the Variables to the VariableData objects via name matching so we can
-  // write them out correctly This makes an assumption that the vectors are 1-1
-  std::map<std::size_t, std::size_t> variableIdxPair;
-  for (std::size_t i = 0; i < openVariables.size(); i++) {
-    for (std::size_t j = 0; j < readVariables.size(); j++) {
-      if (openVariables[i].get_variable_name() ==
-          readVariables[j].variableName) {
-        variableIdxPair[i] = j;
-        break;
-      }
-    }
-  }
-
-  // Now we can write the Variables back to the store
-  std::vector<mdio::WriteFutures> writeFutures;
-  for (auto& idxPair : variableIdxPair) {
-    auto write =
-        openVariables[idxPair.second].Write(readVariables[idxPair.first]);
-    writeFutures.emplace_back(write);
-  }
-
-  // Now we make sure all the writes were successful
-  for (auto& w : writeFutures) {
-    ASSERT_TRUE(w.status().ok()) << w.status();
-  }
-
-  nlohmann::json imageJson = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/image"
-            }
-        }
-    )"_json;
-
-  nlohmann::json velocityJson = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/velocity"
-            }
-        }
-    )"_json;
-
-  nlohmann::json imageInlineJson = R"(
-        {
-            "driver": "zarr3",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance_v3/image_inline"
-            }
-        }
-    )"_json;
-
-  auto image = mdio::Variable<>::Open(imageJson, mdio::constants::kOpen);
-  auto velocity = mdio::Variable<>::Open(velocityJson, mdio::constants::kOpen);
-  auto imageInline =
-      mdio::Variable<>::Open(imageInlineJson, mdio::constants::kOpen);
-
-  ASSERT_TRUE(image.status().ok()) << image.status();
-  ASSERT_TRUE(velocity.status().ok()) << velocity.status();
-  ASSERT_TRUE(imageInline.status().ok()) << imageInline.status();
-
-  auto imageData = image.result()->Read();
-  auto velocityData = velocity.result()->Read();
-  auto imageInlineData = imageInline.result()->Read();
-
-  ASSERT_TRUE(imageData.status().ok()) << imageData.status();
-  ASSERT_TRUE(velocityData.status().ok()) << velocityData.status();
-  ASSERT_TRUE(imageInlineData.status().ok()) << imageInlineData.status();
-
-  auto castedImage =
-      reinterpret_cast<float*>(imageData.value().get_data_accessor().data());
-  auto castedVelociy = reinterpret_cast<double*>(
-      velocityData.value().get_data_accessor().data());
-  auto castedImageInline = reinterpret_cast<int16_t*>(
-      imageInlineData.value().get_data_accessor().data());
-
-  EXPECT_EQ(castedImage[0], 3.14f) << castedImage[0];
-  EXPECT_EQ(castedVelociy[0], 2.71828) << castedVelociy[0];
-  EXPECT_EQ(castedImageInline[0], 0xff) << castedImageInline[0];
-}
-
-TEST(DatasetV3, name) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct =
-      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-
-  auto ds = dataset.value();
-
-  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d_v3") << ds.getMetadata();
-}
-
-TEST(DatasetV3, optionalAttrs) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct =
-      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-
-  auto ds = dataset.value();
-
-  EXPECT_TRUE(ds.getMetadata().contains("name")) << ds.getMetadata();
-}
-
-TEST(DatasetV3, isel) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct =
-      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-  auto ds = dataset.value();
-
-  mdio::RangeDescriptor<mdio::Index> desc1 = {"inline", 0, 5, 1};
-  auto slice = ds.isel(desc1);
-  ASSERT_TRUE(slice.status().ok());
-
-  auto domain = slice->domain;
-  ASSERT_EQ(domain.rank(), 3) << "This should have a rank of 3...";
-
-  // Check depth range
-  auto depthRange = domain[1];
-  EXPECT_EQ(depthRange.interval().inclusive_min(), 0)
-      << "Depth range should start at 0";
-  EXPECT_EQ(depthRange.interval().exclusive_max(), 384)
-      << "Depth range should end at 384";
-
-  // Check crossline range
-  auto crosslineRange = domain[0];
-  EXPECT_EQ(crosslineRange.interval().inclusive_min(), 0)
-      << "Crossline range should start at 0";
-  EXPECT_EQ(crosslineRange.interval().exclusive_max(), 512)
-      << "Crossline range should end at 512";
-
-  // Check inline range
-  auto inlineRange = domain[2];
-  EXPECT_EQ(inlineRange.interval().inclusive_min(), 0)
-      << "Inline range should start at 0";
-  EXPECT_EQ(inlineRange.interval().exclusive_max(), 5)
-      << "Inline range should end at 5";
-}
-
-TEST(DatasetV3, listVars) {
-  nlohmann::json j = nlohmann::json::parse(datasetManifest);
-  auto construct =
-      Construct(j, "zarrs/acceptance_v3", mdio::zarr::ZarrVersion::kV3);
-  ASSERT_TRUE(construct.status().ok()) << construct.status();
-
-  std::tuple<nlohmann::json, std::vector<nlohmann::json>> parsed =
-      construct.value();
-  nlohmann::json metadata = std::get<0>(parsed);
-  std::vector<nlohmann::json> variables = std::get<1>(parsed);
-
-  auto dataset =
-      mdio::Dataset::Open(metadata, variables, mdio::constants::kOpen);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-
-  std::vector<std::string> varList = dataset.value().variables.get_keys();
-  // 8 variables (no struct array for V3)
-  EXPECT_TRUE(varList.size() == 8) << "No variables found in dataset";
-}
-
-TEST(DatasetV3, TEARDOWN) {
-  std::filesystem::remove_all("zarrs/acceptance_v3");
-  ASSERT_TRUE(true);
-}
-
-}  // namespace DatasetTestV3
-
-}  // namespace
diff --git a/mdio/dataset.h b/mdio/dataset.h
index 78d8590..5699392 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -22,6 +22,7 @@
 #include <limits>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <stdexcept>
 #include <string>
@@ -169,7 +170,6 @@ from_zmetadata(const std::string& dataset_path) {
               if (version_ready.result().ok()) {
                 version = version_ready.value();
               }
-
               auto result_future = zarr::ReadDatasetMetadata(
                   version, dataset_path,
                   tensorstore::MakeReadyFuture<tensorstore::KvStore>(kvs));
@@ -178,7 +178,9 @@ from_zmetadata(const std::string& dataset_path) {
                   [promise = std::move(promise)](
                       tensorstore::ReadyFuture<std::tuple<
                           ::nlohmann::json, std::vector<::nlohmann::json>>>
-                          result) { promise.SetResult(result.result()); });
+                          result) {
+                    promise.SetResult(result.result());
+                  });
             });
       });
 
@@ -278,13 +280,99 @@ class Dataset {
     return intervals;
   }
 
+  /**
+   * @brief Constructs a Dataset from a JSON schema with explicit Zarr version.
+   * This method will validate the JSON schema against the MDIO Dataset schema
+   * and use the specified Zarr format version.
+   * @param json_schema The JSON schema to validate.
+   * @param path The path to create/open the dataset.
+   * @param zarr_version The Zarr format version to use (kV2 or kV3).
+   * @param options Variadic options for dataset creation/opening.
+   * @details \b Usage
+   *
+   * Create a Zarr V3 dataset given a schema and a path:
+   * @code
+   * auto dataset_future = mdio::Dataset::from_json(
+   *   json_spec,
+   *   dataset_path,
+   *   mdio::zarr::ZarrVersion::kV3,
+   *   mdio::constants::kCreate
+   * );
+   * @endcode
+   *
+   * @return An `mdio::Future` resolves to a Dataset if successful, or an error
+   * if the schema is invalid.
+   */
+  template <typename... Option>
+  static Future<Dataset> from_json(::nlohmann::json& json_schema /*NOLINT*/,
+                                   const std::string& path,
+                                   zarr::ZarrVersion zarr_version,
+                                   Option&&... options) {
+    // json describing the vars ...
+    MDIO_ASSIGN_OR_RETURN(auto validated_schema,
+                          Construct(json_schema, path, zarr_version))
+    auto [dataset_metadata, json_vars] = validated_schema;
+
+    return mdio::Dataset::Open(dataset_metadata, json_vars,
+                               std::forward<Option>(options)...);
+  }
+
+  /**
+   * @brief Constructs a Dataset from a JSON schema with optional Zarr version.
+   * This method will validate the JSON schema against the MDIO Dataset schema
+   * and optionally use the specified Zarr format version.
+   * @param json_schema The JSON schema to validate.
+   * @param path The path to create/open the dataset.
+   * @param zarr_version Optional Zarr format version. If not specified,
+   *        auto-detects from the schema or defaults to V2.
+   * @param options Variadic options for dataset creation/opening.
+   * @details \b Usage
+   *
+   * Create a dataset with optional Zarr version:
+   * @code
+   * // With explicit version
+   * auto dataset_future = mdio::Dataset::from_json(
+   *   json_spec,
+   *   dataset_path,
+   *   std::optional<mdio::zarr::ZarrVersion>(mdio::zarr::ZarrVersion::kV3),
+   *   mdio::constants::kCreate
+   * );
+   *
+   * // Without version (use std::nullopt for auto-detection or default to V2)
+   * std::optional<mdio::zarr::ZarrVersion> version = std::nullopt;
+   * auto dataset_future = mdio::Dataset::from_json(
+   *   json_spec,
+   *   dataset_path,
+   *   version,
+   *   mdio::constants::kCreate
+   * );
+   * @endcode
+   *
+   * @return An `mdio::Future` resolves to a Dataset if successful, or an error
+   * if the schema is invalid.
+   */
+  template <typename... Option>
+  static Future<Dataset> from_json(
+      ::nlohmann::json& json_schema /*NOLINT*/, const std::string& path,
+      std::optional<zarr::ZarrVersion> zarr_version, Option&&... options) {
+    // json describing the vars ...
+    MDIO_ASSIGN_OR_RETURN(auto validated_schema,
+                          Construct(json_schema, path, zarr_version))
+    auto [dataset_metadata, json_vars] = validated_schema;
+
+    return mdio::Dataset::Open(dataset_metadata, json_vars,
+                               std::forward<Option>(options)...);
+  }
+
   /**
    * @brief Constructs a Dataset from a JSON schema.
    * This method will validate the JSON schema against the MDIO Dataset schema.
    * @param json_schema The JSON schema to validate.
+   * @param path The path to create/open the dataset.
+   * @param options Variadic options for dataset creation/opening.
    * @details \b Usage
    *
-   * Create  a dataset given a schema and a path, for a new dataset use options,
+   * Create a dataset given a schema and a path, for a new dataset use options,
    * @code
    * auto dataset_future = mdio::Dataset::from_json(
    *   json_spec,
diff --git a/mdio/dataset_test.cc b/mdio/dataset_test.cc
index 2ddbc41..2cc0245 100644
--- a/mdio/dataset_test.cc
+++ b/mdio/dataset_test.cc
@@ -1389,4 +1389,286 @@ TEST(Dataset, mockV0) {
       << reopenedDsFut.value();
 }
 
+// Tests for Dataset::from_json with explicit Zarr version parameter
+TEST(Dataset, fromJsonWithZarrV2) {
+  std::filesystem::remove_all("zarrs/acceptance_v2_explicit");
+  auto json_vars = GetToyExample();
+
+  // Use explicit V2 version
+  auto dataset =
+      mdio::Dataset::from_json(json_vars, "zarrs/acceptance_v2_explicit",
+                               mdio::zarr::ZarrVersion::kV2,
+                               mdio::constants::kCreateClean);
+
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d") << ds.getMetadata();
+
+  // Verify variables were created
+  std::vector<std::string> varList = ds.variables.get_keys();
+  EXPECT_EQ(varList.size(), 9) << "Expected 9 variables";
+
+  std::filesystem::remove_all("zarrs/acceptance_v2_explicit");
+}
+
+TEST(Dataset, fromJsonWithOptionalZarrVersion) {
+  std::filesystem::remove_all("zarrs/acceptance_optional_version");
+  auto json_vars = GetToyExample();
+
+  // Use optional V2 version
+  auto dataset = mdio::Dataset::from_json(
+      json_vars, "zarrs/acceptance_optional_version",
+      std::optional<mdio::zarr::ZarrVersion>(mdio::zarr::ZarrVersion::kV2),
+      mdio::constants::kCreateClean);
+
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d") << ds.getMetadata();
+
+  std::filesystem::remove_all("zarrs/acceptance_optional_version");
+}
+
+TEST(Dataset, fromJsonWithNulloptVersion) {
+  std::filesystem::remove_all("zarrs/acceptance_nullopt_version");
+  auto json_vars = GetToyExample();
+
+  // Use nullopt - should default to V2 or auto-detect
+  std::optional<mdio::zarr::ZarrVersion> version = std::nullopt;
+  auto dataset = mdio::Dataset::from_json(
+      json_vars, "zarrs/acceptance_nullopt_version", version,
+      mdio::constants::kCreateClean);
+
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d") << ds.getMetadata();
+
+  std::filesystem::remove_all("zarrs/acceptance_nullopt_version");
+}
+
+TEST(Dataset, fromJsonWithZarrV3NoStructArray) {
+  // Zarr V3 does not yet support struct arrays, so test with a schema
+  // that does not have struct arrays
+  std::string schemaNoStruct = R"(
+    {
+      "metadata": {
+        "name": "campos_3d_v3_test",
+        "apiVersion": "1.0.0",
+        "createdOn": "2023-12-12T15:02:06.413469-06:00"
+      },
+      "variables": [
+        {
+          "name": "image",
+          "dataType": "float32",
+          "dimensions": [
+            {"name": "inline", "size": 64},
+            {"name": "crossline", "size": 128},
+            {"name": "depth", "size": 96}
+          ],
+          "metadata": {
+            "chunkGrid": {
+              "name": "regular",
+              "configuration": { "chunkShape": [32, 32, 32] }
+            }
+          },
+          "coordinates": ["inline", "crossline", "depth"]
+        },
+        {
+          "name": "inline",
+          "dataType": "uint32",
+          "dimensions": [{"name": "inline", "size": 64}]
+        },
+        {
+          "name": "crossline",
+          "dataType": "uint32",
+          "dimensions": [{"name": "crossline", "size": 128}]
+        },
+        {
+          "name": "depth",
+          "dataType": "uint32",
+          "dimensions": [{"name": "depth", "size": 96}]
+        }
+      ]
+    }
+  )";
+
+  std::filesystem::remove_all("zarrs/acceptance_v3_from_json");
+  nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
+
+  // Use explicit V3 version
+  auto dataset = mdio::Dataset::from_json(json_vars, "zarrs/acceptance_v3_from_json",
+                                          mdio::zarr::ZarrVersion::kV3,
+                                          mdio::constants::kCreateClean);
+
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d_v3_test") << ds.getMetadata();
+
+  // Verify variables were created
+  std::vector<std::string> varList = ds.variables.get_keys();
+  EXPECT_EQ(varList.size(), 4) << "Expected 4 variables";
+
+  std::filesystem::remove_all("zarrs/acceptance_v3_from_json");
+}
+
+TEST(Dataset, fromJsonV3ReadWrite) {
+  std::string schemaNoStruct = R"(
+    {
+      "metadata": {
+        "name": "v3_read_write_test",
+        "apiVersion": "1.0.0",
+        "createdOn": "2023-12-12T15:02:06.413469-06:00"
+      },
+      "variables": [
+        {
+          "name": "data",
+          "dataType": "float32",
+          "dimensions": [
+            {"name": "x", "size": 16},
+            {"name": "y", "size": 16}
+          ],
+          "metadata": {
+            "chunkGrid": {
+              "name": "regular",
+              "configuration": { "chunkShape": [8, 8] }
+            }
+          }
+        },
+        {
+          "name": "x",
+          "dataType": "int32",
+          "dimensions": [{"name": "x", "size": 16}]
+        },
+        {
+          "name": "y",
+          "dataType": "int32",
+          "dimensions": [{"name": "y", "size": 16}]
+        }
+      ]
+    }
+  )";
+
+  std::filesystem::remove_all("zarrs/v3_read_write");
+  nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
+
+  // Create with V3
+  auto datasetRes = mdio::Dataset::from_json(json_vars, "zarrs/v3_read_write",
+                                             mdio::zarr::ZarrVersion::kV3,
+                                             mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto ds = datasetRes.value();
+
+  // Get the data variable and write some values
+  auto dataVarRes = ds.variables.get<mdio::dtypes::float32_t>("data");
+  ASSERT_TRUE(dataVarRes.status().ok()) << dataVarRes.status();
+  auto dataVar = dataVarRes.value();
+
+  auto dataDataRes = dataVar.Read();
+  ASSERT_TRUE(dataDataRes.status().ok()) << dataDataRes.status();
+  auto dataData = dataDataRes.value();
+
+  auto accessor = dataData.get_data_accessor().data();
+  accessor[0] = 1.5f;
+  accessor[1] = 2.5f;
+  accessor[255] = 100.0f;
+
+  auto writeFut = dataVar.Write(dataData);
+  ASSERT_TRUE(writeFut.status().ok()) << writeFut.status();
+
+  // Re-read and verify
+  auto rereadFut = dataVar.Read();
+  ASSERT_TRUE(rereadFut.status().ok()) << rereadFut.status();
+  auto rereadData = rereadFut.value();
+  auto rereadAccessor = rereadData.get_data_accessor().data();
+
+  EXPECT_FLOAT_EQ(rereadAccessor[0], 1.5f);
+  EXPECT_FLOAT_EQ(rereadAccessor[1], 2.5f);
+  EXPECT_FLOAT_EQ(rereadAccessor[255], 100.0f);
+
+  std::filesystem::remove_all("zarrs/v3_read_write");
+}
+
+TEST(Dataset, fromJsonIselV2AndV3) {
+  std::string schemaNoStruct = R"(
+    {
+      "metadata": {
+        "name": "isel_test",
+        "apiVersion": "1.0.0",
+        "createdOn": "2023-12-12T15:02:06.413469-06:00"
+      },
+      "variables": [
+        {
+          "name": "data",
+          "dataType": "float32",
+          "dimensions": [
+            {"name": "x", "size": 32},
+            {"name": "y", "size": 32},
+            {"name": "z", "size": 16}
+          ]
+        },
+        {
+          "name": "x",
+          "dataType": "int32",
+          "dimensions": [{"name": "x", "size": 32}]
+        },
+        {
+          "name": "y",
+          "dataType": "int32",
+          "dimensions": [{"name": "y", "size": 32}]
+        },
+        {
+          "name": "z",
+          "dataType": "int32",
+          "dimensions": [{"name": "z", "size": 16}]
+        }
+      ]
+    }
+  )";
+
+  // Test V2
+  {
+    std::filesystem::remove_all("zarrs/isel_v2");
+    nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
+    auto datasetRes = mdio::Dataset::from_json(json_vars, "zarrs/isel_v2",
+                                               mdio::zarr::ZarrVersion::kV2,
+                                               mdio::constants::kCreateClean);
+    ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+    auto ds = datasetRes.value();
+
+    mdio::RangeDescriptor<mdio::Index> desc1 = {"x", 0, 10, 1};
+    mdio::RangeDescriptor<mdio::Index> desc2 = {"y", 5, 20, 1};
+    auto sliceRes = ds.isel(desc1, desc2);
+    ASSERT_TRUE(sliceRes.status().ok()) << sliceRes.status();
+
+    auto slice = sliceRes.value();
+    EXPECT_EQ(slice.domain.rank(), 3);
+
+    std::filesystem::remove_all("zarrs/isel_v2");
+  }
+
+  // Test V3
+  {
+    std::filesystem::remove_all("zarrs/isel_v3");
+    nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
+    auto datasetRes = mdio::Dataset::from_json(json_vars, "zarrs/isel_v3",
+                                               mdio::zarr::ZarrVersion::kV3,
+                                               mdio::constants::kCreateClean);
+    ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+    auto ds = datasetRes.value();
+
+    mdio::RangeDescriptor<mdio::Index> desc1 = {"x", 0, 10, 1};
+    mdio::RangeDescriptor<mdio::Index> desc2 = {"y", 5, 20, 1};
+    auto sliceRes = ds.isel(desc1, desc2);
+    ASSERT_TRUE(sliceRes.status().ok()) << sliceRes.status();
+
+    auto slice = sliceRes.value();
+    EXPECT_EQ(slice.domain.rank(), 3);
+
+    std::filesystem::remove_all("zarrs/isel_v3");
+  }
+}
+
 }  // namespace
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index 1df7f61..d94af6e 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -232,6 +232,10 @@ inline Future<void> WriteMetadata(
       json_variables[0]["kvstore"]["path"].get<std::string>().substr(
           0, json_variables[0]["kvstore"]["path"].get<std::string>().size() -
                  toRemove - 1);
+  // Ensure basePath has trailing slash for directory operations
+  if (!basePath.empty() && basePath.back() != '/') {
+    basePath.push_back('/');
+  }
 
   nlohmann::json kvstore = nlohmann::json::object();
   kvstore["driver"] = driver;
@@ -244,12 +248,23 @@ inline Future<void> WriteMetadata(
 
   auto kvs_future = tensorstore::kvstore::Open(kvstore);
 
-  // Write root group zarr.json with dataset attributes
-  auto root_metadata = CreateGroupMetadata(dataset_metadata);
+  // Extract variable names from json_variables for discovery
+  nlohmann::json var_names = nlohmann::json::array();
+  for (const auto& var : json_variables) {
+    std::string path = var["kvstore"]["path"].get<std::string>();
+    std::vector<std::string> path_parts = absl::StrSplit(path, '/');
+    var_names.push_back(path_parts.back());
+  }
+
+  // Create root metadata with variables list for discovery
+  nlohmann::json root_attrs = dataset_metadata;
+  root_attrs["variables"] = var_names;
+  auto root_metadata = CreateGroupMetadata(root_attrs);
+
   auto root_future = tensorstore::MapFutureValue(
       tensorstore::InlineExecutor{},
       [root_metadata](const tensorstore::KvStore& kvs) {
-        return tensorstore::kvstore::Write(kvs, "/zarr.json",
+        return tensorstore::kvstore::Write(kvs, "zarr.json",
                                            absl::Cord(root_metadata.dump(4)));
       },
       kvs_future);
@@ -291,83 +306,91 @@ ReadMetadata(const std::string& dataset_path,
 
         auto kvs = ready_kvs.value();
 
-        // Read root zarr.json
-        auto root_read = tensorstore::kvstore::Read(kvs, "zarr.json").result();
-        if (!root_read.ok()) {
-          promise.SetResult(root_read.status());
-          return;
-        }
-
-        ::nlohmann::json root_json;
-        try {
-          root_json =
-              ::nlohmann::json::parse(std::string(root_read.value().value));
-        } catch (const nlohmann::json::parse_error& e) {
-          promise.SetResult(
-              absl::InvalidArgumentError(std::string("JSON parse error: ") +
-                                         e.what()));
-          return;
-        }
-
-        // Extract attributes as dataset metadata
-        nlohmann::json dataset_metadata = nlohmann::json::object();
-        if (root_json.contains("attributes")) {
-          dataset_metadata = root_json["attributes"];
-        }
-
-        // Infer the driver
-        std::string driver = "file";
-        std::string bucket;
-        std::string cloudPath;
-        if (dataset_path.length() > 5) {
-          if (dataset_path.substr(0, 5) == "gs://") {
-            driver = "gcs";
-          } else if (dataset_path.substr(0, 5) == "s3://") {
-            driver = "s3";
-          }
-        }
-        if (driver != "file") {
-          std::string providedPath = dataset_path.substr(5);
-          size_t bucketLen = providedPath.find_first_of('/');
-          bucket = providedPath.substr(0, bucketLen);
-          cloudPath = providedPath.substr(bucketLen + 1,
-                                          providedPath.length() - 2);
-        }
-
-        // For V3, we need to discover arrays by looking for zarr.json files
-        // in subdirectories. Since kvstore::List returns a sender (not a future),
-        // we'll use a simpler approach: check if the metadata contains array info.
-        // If not found, we return an error asking the user to specify variables.
-        
-        // For now, we'll extract variable names from the root zarr.json attributes
-        // if they contain a "variables" or similar field, or return an error.
-        std::vector<nlohmann::json> json_vars;
-        
-        // Check if dataset_metadata contains variable information
-        if (dataset_metadata.contains("variables")) {
-          for (const auto& var_name : dataset_metadata["variables"]) {
-            std::string name = var_name.get<std::string>();
-            nlohmann::json var_spec = {
-                {"driver", std::string(kDriverName)},
-                {"kvstore",
-                 {{"driver", driver}, {"path", dataset_path + name}}}};
-            if (driver != "file") {
-              var_spec["kvstore"]["bucket"] = bucket;
-              var_spec["kvstore"]["path"] = cloudPath + name;
-            }
-            json_vars.push_back(var_spec);
-          }
-        }
-
-        if (json_vars.empty()) {
-          // Return error - V3 discovery requires variable names in metadata
-          promise.SetResult(absl::InvalidArgumentError(
-              "Zarr V3 store discovery requires 'variables' list in root "
-              "zarr.json attributes. Please specify variable specs explicitly."));
-          return;
-        }
-
-        promise.SetResult(std::make_tuple(dataset_metadata, json_vars));
+        // Read root zarr.json using async chaining to avoid deadlock
+        auto root_read_future = tensorstore::kvstore::Read(kvs, "zarr.json");
+
+        root_read_future.ExecuteWhenReady(
+            [promise = std::move(promise), dataset_path](
+                tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+                    root_read_ready) {
+              if (!root_read_ready.result().ok()) {
+                promise.SetResult(root_read_ready.result().status());
+                return;
+              }
+
+              ::nlohmann::json root_json;
+              try {
+                root_json = ::nlohmann::json::parse(
+                    std::string(root_read_ready.value().value));
+              } catch (const nlohmann::json::parse_error& e) {
+                promise.SetResult(absl::InvalidArgumentError(
+                    std::string("JSON parse error: ") + e.what()));
+                return;
+              }
+
+              // Extract attributes as dataset metadata
+              nlohmann::json dataset_metadata = nlohmann::json::object();
+              if (root_json.contains("attributes")) {
+                dataset_metadata = root_json["attributes"];
+              }
+
+              // Infer the driver
+              std::string driver = "file";
+              std::string bucket;
+              std::string cloudPath;
+              if (dataset_path.length() > 5) {
+                if (dataset_path.substr(0, 5) == "gs://") {
+                  driver = "gcs";
+                } else if (dataset_path.substr(0, 5) == "s3://") {
+                  driver = "s3";
+                }
+              }
+              if (driver != "file") {
+                std::string providedPath = dataset_path.substr(5);
+                size_t bucketLen = providedPath.find_first_of('/');
+                bucket = providedPath.substr(0, bucketLen);
+                cloudPath = providedPath.substr(bucketLen + 1,
+                                                providedPath.length() - 2);
+              }
+
+              std::vector<nlohmann::json> json_vars;
+
+              // Check if dataset_metadata contains variable information
+              if (dataset_metadata.contains("variables")) {
+                for (const auto& var_name : dataset_metadata["variables"]) {
+                  std::string name = var_name.get<std::string>();
+                  // Ensure proper path separator
+                  std::string sep =
+                      (!dataset_path.empty() && dataset_path.back() != '/')
+                          ? "/"
+                          : "";
+                  nlohmann::json var_spec = {
+                      {"driver", std::string(kDriverName)},
+                      {"kvstore",
+                       {{"driver", driver},
+                        {"path", dataset_path + sep + name}}}};
+                  if (driver != "file") {
+                    var_spec["kvstore"]["bucket"] = bucket;
+                    std::string cloud_sep =
+                        (!cloudPath.empty() && cloudPath.back() != '/') ? "/"
+                                                                        : "";
+                    var_spec["kvstore"]["path"] = cloudPath + cloud_sep + name;
+                  }
+                  json_vars.push_back(var_spec);
+                }
+              }
+
+              if (json_vars.empty()) {
+                // Return error - V3 discovery requires variable names
+                promise.SetResult(absl::InvalidArgumentError(
+                    "Zarr V3 store discovery requires 'variables' list in root "
+                    "zarr.json attributes. Please specify variable specs "
+                    "explicitly."));
+                return;
+              }
+
+              promise.SetResult(std::make_tuple(dataset_metadata, json_vars));
+            });
       });
 
   return pair.future;
@@ -459,7 +482,7 @@ inline Future<nlohmann::json> ReadVariableAttributes(
     const tensorstore::KvStore& kvstore) {
   auto pair = tensorstore::PromiseFuturePair<nlohmann::json>::Make();
 
-  auto read_future = tensorstore::kvstore::Read(kvstore, "/zarr.json");
+  auto read_future = tensorstore::kvstore::Read(kvstore, "zarr.json");
   read_future.ExecuteWhenReady(
       [promise = std::move(pair.promise)](
           tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>

From b56742518b89e24d4005c4e663d385bd1dba8721 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Thu, 18 Dec 2025 17:45:36 +0000
Subject: [PATCH 09/26] Ensure all appropriate tests run for v2 and v3 drivers

---
 mdio/CMakeLists.txt              |   3 +
 mdio/coordinate_selector_test.cc |  74 ++++-
 mdio/dataset_test.cc             | 503 +++++++++++++++++--------------
 mdio/gcs_test.cc                 | 227 ++++++++++++++
 mdio/s3_test.cc                  | 227 ++++++++++++++
 mdio/utils/delete_test.cc        | 188 +++++++++++-
 mdio/utils/trim_test.cc          | 251 +++++++++++++--
 mdio/variable_test.cc            | 200 ++++++++++++
 8 files changed, 1398 insertions(+), 275 deletions(-)

diff --git a/mdio/CMakeLists.txt b/mdio/CMakeLists.txt
index b5b72b5..12cca9c 100644
--- a/mdio/CMakeLists.txt
+++ b/mdio/CMakeLists.txt
@@ -281,6 +281,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack
@@ -305,6 +306,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack
@@ -352,6 +354,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::tensorstore
diff --git a/mdio/coordinate_selector_test.cc b/mdio/coordinate_selector_test.cc
index 93eaec9..f47c2ee 100644
--- a/mdio/coordinate_selector_test.cc
+++ b/mdio/coordinate_selector_test.cc
@@ -26,6 +26,7 @@
 
 #include "mdio/dataset.h"
 #include "mdio/dataset_factory.h"
+#include "mdio/zarr/zarr.h"
 #include "tensorstore/driver/driver.h"
 #include "tensorstore/driver/registry.h"
 #include "tensorstore/index_space/dim_expression.h"
@@ -43,8 +44,25 @@
 
 namespace {
 
-mdio::Result<std::string> SetupDataset() {
-  std::string ds_path = "generic_with_coords.mdio";
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
+}
+
+/**
+ * @brief Returns the base path for test data based on Zarr version.
+ */
+std::string GetBasePath(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3
+             ? "generic_with_coords_v3.mdio"
+             : "generic_with_coords.mdio";
+}
+
+mdio::Result<std::string> SetupDataset(
+    mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
+  std::string ds_path = GetBasePath(version);
   std::string schema_str = R"(
     {
         "metadata": {
@@ -142,7 +160,7 @@ mdio::Result<std::string> SetupDataset() {
 
   auto schema = ::nlohmann::json::parse(schema_str);
   auto dsFut =
-      mdio::Dataset::from_json(schema, ds_path, mdio::constants::kCreate);
+      mdio::Dataset::from_json(schema, ds_path, version, mdio::constants::kCreateClean);
   if (!dsFut.status().ok()) {
     return ds_path;
   }
@@ -210,13 +228,31 @@ mdio::Result<std::string> SetupDataset() {
   return ds_path;
 }
 
-TEST(Intersection, SETUP) {
-  auto pathResult = SetupDataset();
+// ============================================================================
+// Parameterized Coordinate Selector Tests
+// ============================================================================
+
+class CoordinateSelectorTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+  }
+
+  void TearDown() override { std::filesystem::remove_all(base_path_); }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
+
+TEST_P(CoordinateSelectorTest, SETUP) {
+  auto pathResult = SetupDataset(version_);
   ASSERT_TRUE(pathResult.status().ok()) << pathResult.status();
 }
 
-TEST(Intersection, constructor) {
-  auto pathResult = SetupDataset();
+TEST_P(CoordinateSelectorTest, constructor) {
+  auto pathResult = SetupDataset(version_);
   ASSERT_TRUE(pathResult.status().ok()) << pathResult.status();
   auto path = pathResult.value();
 
@@ -227,8 +263,8 @@ TEST(Intersection, constructor) {
   mdio::CoordinateSelector cs(ds);
 }
 
-TEST(Intersection, add_selection) {
-  auto pathResult = SetupDataset();
+TEST_P(CoordinateSelectorTest, add_selection) {
+  auto pathResult = SetupDataset(version_);
   ASSERT_TRUE(pathResult.status().ok()) << pathResult.status();
   auto path = pathResult.value();
 
@@ -248,8 +284,8 @@ TEST(Intersection, add_selection) {
   // map but got " << selections.size();
 }
 
-TEST(Intersection, range_descriptors) {
-  auto pathResult = SetupDataset();
+TEST_P(CoordinateSelectorTest, range_descriptors) {
+  auto pathResult = SetupDataset(version_);
   ASSERT_TRUE(pathResult.status().ok()) << pathResult.status();
   auto path = pathResult.value();
 
@@ -285,8 +321,8 @@ TEST(Intersection, range_descriptors) {
   // to have a step of 1";
 }
 
-TEST(Intersection, get_inline_range) {
-  auto pathResult = SetupDataset();
+TEST_P(CoordinateSelectorTest, get_inline_range) {
+  auto pathResult = SetupDataset(version_);
   ASSERT_TRUE(pathResult.status().ok()) << pathResult.status();
   auto path = pathResult.value();
 
@@ -311,8 +347,8 @@ TEST(Intersection, get_inline_range) {
   // }
 }
 
-TEST(Intersection, get_inline_range_dead) {
-  auto pathResult = SetupDataset();
+TEST_P(CoordinateSelectorTest, get_inline_range_dead) {
+  auto pathResult = SetupDataset(version_);
   ASSERT_TRUE(pathResult.status().ok()) << pathResult.status();
   auto path = pathResult.value();
 
@@ -338,4 +374,12 @@ TEST(Intersection, get_inline_range_dead) {
   // }
 }
 
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, CoordinateSelectorTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
 }  // namespace
diff --git a/mdio/dataset_test.cc b/mdio/dataset_test.cc
index 2cc0245..44d382b 100644
--- a/mdio/dataset_test.cc
+++ b/mdio/dataset_test.cc
@@ -25,6 +25,7 @@
 #include <vector>
 
 #include "mdio/dataset_factory.h"
+#include "mdio/zarr/zarr.h"
 #include "tensorstore/driver/driver.h"
 #include "tensorstore/driver/registry.h"
 #include "tensorstore/index_space/dim_expression.h"
@@ -40,6 +41,136 @@
 #include <nlohmann/json.hpp>  // NOLINT
 // clang-format on
 namespace {
+
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
+}
+
+/**
+ * @brief Returns the base path for test data based on Zarr version.
+ */
+std::string GetBasePath(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "zarrs/dataset_test_v3"
+                                                  : "zarrs/dataset_test";
+}
+
+/**
+ * @brief Returns a schema without struct arrays (compatible with both V2 and V3).
+ */
+::nlohmann::json GetSimpleSchema() {
+  std::string schema = R"(
+    {
+      "metadata": {
+        "name": "simple_dataset",
+        "apiVersion": "1.0.0",
+        "createdOn": "2023-12-12T15:02:06.413469-06:00",
+        "attributes": {
+          "foo": "bar"
+        }
+      },
+      "variables": [
+        {
+          "name": "image",
+          "dataType": "float32",
+          "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512},
+            {"name": "depth", "size": 384}
+          ],
+          "metadata": {
+            "chunkGrid": {
+              "name": "regular",
+              "configuration": { "chunkShape": [128, 128, 128] }
+            },
+            "statsV1": {
+              "count": 100,
+              "sum": 1215.1,
+              "sumSquares": 125.12,
+              "min": 5.61,
+              "max": 10.84,
+              "histogram": {"binCenters": [1, 2], "counts": [10, 15]}
+            }
+          },
+          "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
+          "compressor": {"name": "blosc", "algorithm": "zstd"}
+        },
+        {
+          "name": "velocity",
+          "dataType": "float16",
+          "dimensions": ["inline", "crossline", "depth"],
+          "metadata": {
+            "chunkGrid": {
+              "name": "regular",
+              "configuration": { "chunkShape": [128, 128, 128] }
+            },
+            "unitsV1": {"speed": "m/s"}
+          },
+          "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+        },
+        {
+          "name": "image_inline",
+          "dataType": "float32",
+          "dimensions": ["inline", "crossline", "depth"],
+          "longName": "inline optimized version of 3d_stack",
+          "compressor": {"name": "blosc", "algorithm": "zstd"},
+          "metadata": {
+            "chunkGrid": {
+              "name": "regular",
+              "configuration": { "chunkShape": [4, 512, 512] }
+            }
+          },
+          "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+        },
+        {
+          "name": "inline",
+          "dataType": "uint32",
+          "dimensions": [{"name": "inline", "size": 256}]
+        },
+        {
+          "name": "crossline",
+          "dataType": "uint32",
+          "dimensions": [{"name": "crossline", "size": 512}]
+        },
+        {
+          "name": "depth",
+          "dataType": "uint32",
+          "dimensions": [{"name": "depth", "size": 384}],
+          "metadata": {
+            "unitsV1": { "length": "m" }
+          }
+        },
+        {
+          "name": "cdp-x",
+          "dataType": "float32",
+          "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512}
+          ],
+          "metadata": {
+            "unitsV1": { "length": "m" }
+          }
+        },
+        {
+          "name": "cdp-y",
+          "dataType": "float32",
+          "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512}
+          ],
+          "metadata": {
+            "unitsV1": { "length": "m" }
+          }
+        }
+      ]
+    }
+  )";
+  return ::nlohmann::json::parse(schema);
+}
+
+// V2-only schema with struct arrays (for backward compatibility tests)
 ::nlohmann::json GetToyExample() {
   std::string schema = R"(
         {
@@ -1389,286 +1520,192 @@ TEST(Dataset, mockV0) {
       << reopenedDsFut.value();
 }
 
-// Tests for Dataset::from_json with explicit Zarr version parameter
-TEST(Dataset, fromJsonWithZarrV2) {
-  std::filesystem::remove_all("zarrs/acceptance_v2_explicit");
-  auto json_vars = GetToyExample();
+// ============================================================================
+// Parameterized Dataset Tests for V2/V3
+// ============================================================================
+
+class DatasetVersionTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+    std::filesystem::remove_all(base_path_);
+  }
 
-  // Use explicit V2 version
-  auto dataset =
-      mdio::Dataset::from_json(json_vars, "zarrs/acceptance_v2_explicit",
-                               mdio::zarr::ZarrVersion::kV2,
-                               mdio::constants::kCreateClean);
+  void TearDown() override { std::filesystem::remove_all(base_path_); }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
+
+TEST_P(DatasetVersionTest, fromJson) {
+  auto json_vars = GetSimpleSchema();
+
+  auto dataset = mdio::Dataset::from_json(json_vars, base_path_, version_,
+                                          mdio::constants::kCreateClean);
 
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
 
   auto ds = dataset.value();
-  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d") << ds.getMetadata();
+  EXPECT_EQ(ds.getMetadata()["name"], "simple_dataset") << ds.getMetadata();
 
-  // Verify variables were created
+  // Verify variables were created (8 variables without struct array)
   std::vector<std::string> varList = ds.variables.get_keys();
-  EXPECT_EQ(varList.size(), 9) << "Expected 9 variables";
-
-  std::filesystem::remove_all("zarrs/acceptance_v2_explicit");
+  EXPECT_EQ(varList.size(), 8) << "Expected 8 variables";
 }
 
-TEST(Dataset, fromJsonWithOptionalZarrVersion) {
-  std::filesystem::remove_all("zarrs/acceptance_optional_version");
-  auto json_vars = GetToyExample();
+TEST_P(DatasetVersionTest, fromJsonWithOptionalVersion) {
+  auto json_vars = GetSimpleSchema();
 
-  // Use optional V2 version
   auto dataset = mdio::Dataset::from_json(
-      json_vars, "zarrs/acceptance_optional_version",
-      std::optional<mdio::zarr::ZarrVersion>(mdio::zarr::ZarrVersion::kV2),
+      json_vars, base_path_,
+      std::optional<mdio::zarr::ZarrVersion>(version_),
       mdio::constants::kCreateClean);
 
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  EXPECT_EQ(dataset.value().getMetadata()["name"], "simple_dataset");
+}
 
-  auto ds = dataset.value();
-  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d") << ds.getMetadata();
+TEST_P(DatasetVersionTest, readWrite) {
+  auto json_vars = GetSimpleSchema();
+  auto datasetRes = mdio::Dataset::from_json(json_vars, base_path_, version_,
+                                             mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto ds = datasetRes.value();
 
-  std::filesystem::remove_all("zarrs/acceptance_optional_version");
-}
+  // Get the image variable and write some values
+  auto imageVarRes = ds.variables.get<mdio::dtypes::float32_t>("image");
+  ASSERT_TRUE(imageVarRes.status().ok()) << imageVarRes.status();
+  auto imageVar = imageVarRes.value();
 
-TEST(Dataset, fromJsonWithNulloptVersion) {
-  std::filesystem::remove_all("zarrs/acceptance_nullopt_version");
-  auto json_vars = GetToyExample();
+  auto imageDataRes = imageVar.Read();
+  ASSERT_TRUE(imageDataRes.status().ok()) << imageDataRes.status();
+  auto imageData = imageDataRes.value();
 
-  // Use nullopt - should default to V2 or auto-detect
-  std::optional<mdio::zarr::ZarrVersion> version = std::nullopt;
-  auto dataset = mdio::Dataset::from_json(
-      json_vars, "zarrs/acceptance_nullopt_version", version,
-      mdio::constants::kCreateClean);
+  auto accessor = imageData.get_data_accessor().data();
+  accessor[0] = 1.5f;
+  accessor[1] = 2.5f;
+  accessor[100] = 42.0f;
 
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  auto writeFut = imageVar.Write(imageData);
+  ASSERT_TRUE(writeFut.status().ok()) << writeFut.status();
 
-  auto ds = dataset.value();
-  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d") << ds.getMetadata();
+  // Re-read and verify
+  auto rereadFut = imageVar.Read();
+  ASSERT_TRUE(rereadFut.status().ok()) << rereadFut.status();
+  auto rereadData = rereadFut.value();
+  auto rereadAccessor = rereadData.get_data_accessor().data();
 
-  std::filesystem::remove_all("zarrs/acceptance_nullopt_version");
+  EXPECT_FLOAT_EQ(rereadAccessor[0], 1.5f);
+  EXPECT_FLOAT_EQ(rereadAccessor[1], 2.5f);
+  EXPECT_FLOAT_EQ(rereadAccessor[100], 42.0f);
 }
 
-TEST(Dataset, fromJsonWithZarrV3NoStructArray) {
-  // Zarr V3 does not yet support struct arrays, so test with a schema
-  // that does not have struct arrays
-  std::string schemaNoStruct = R"(
-    {
-      "metadata": {
-        "name": "campos_3d_v3_test",
-        "apiVersion": "1.0.0",
-        "createdOn": "2023-12-12T15:02:06.413469-06:00"
-      },
-      "variables": [
-        {
-          "name": "image",
-          "dataType": "float32",
-          "dimensions": [
-            {"name": "inline", "size": 64},
-            {"name": "crossline", "size": 128},
-            {"name": "depth", "size": 96}
-          ],
-          "metadata": {
-            "chunkGrid": {
-              "name": "regular",
-              "configuration": { "chunkShape": [32, 32, 32] }
-            }
-          },
-          "coordinates": ["inline", "crossline", "depth"]
-        },
-        {
-          "name": "inline",
-          "dataType": "uint32",
-          "dimensions": [{"name": "inline", "size": 64}]
-        },
-        {
-          "name": "crossline",
-          "dataType": "uint32",
-          "dimensions": [{"name": "crossline", "size": 128}]
-        },
-        {
-          "name": "depth",
-          "dataType": "uint32",
-          "dimensions": [{"name": "depth", "size": 96}]
-        }
-      ]
-    }
-  )";
-
-  std::filesystem::remove_all("zarrs/acceptance_v3_from_json");
-  nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
+TEST_P(DatasetVersionTest, isel) {
+  auto json_vars = GetSimpleSchema();
+  auto datasetRes = mdio::Dataset::from_json(json_vars, base_path_, version_,
+                                             mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto ds = datasetRes.value();
 
-  // Use explicit V3 version
-  auto dataset = mdio::Dataset::from_json(json_vars, "zarrs/acceptance_v3_from_json",
-                                          mdio::zarr::ZarrVersion::kV3,
-                                          mdio::constants::kCreateClean);
+  mdio::RangeDescriptor<mdio::Index> desc1 = {"inline", 0, 10, 1};
+  mdio::RangeDescriptor<mdio::Index> desc2 = {"crossline", 5, 20, 1};
+  auto sliceRes = ds.isel(desc1, desc2);
+  ASSERT_TRUE(sliceRes.status().ok()) << sliceRes.status();
 
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  auto slice = sliceRes.value();
+  EXPECT_EQ(slice.domain.rank(), 3);
+}
 
-  auto ds = dataset.value();
-  EXPECT_EQ(ds.getMetadata()["name"], "campos_3d_v3_test") << ds.getMetadata();
+TEST_P(DatasetVersionTest, openExisting) {
+  auto json_vars = GetSimpleSchema();
+  auto datasetRes = mdio::Dataset::from_json(json_vars, base_path_, version_,
+                                             mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
 
-  // Verify variables were created
-  std::vector<std::string> varList = ds.variables.get_keys();
-  EXPECT_EQ(varList.size(), 4) << "Expected 4 variables";
+  // Close and reopen
+  auto reopenedDs = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
+  ASSERT_TRUE(reopenedDs.status().ok()) << reopenedDs.status();
 
-  std::filesystem::remove_all("zarrs/acceptance_v3_from_json");
+  EXPECT_EQ(reopenedDs.value().getMetadata()["name"], "simple_dataset");
 }
 
-TEST(Dataset, fromJsonV3ReadWrite) {
-  std::string schemaNoStruct = R"(
-    {
-      "metadata": {
-        "name": "v3_read_write_test",
-        "apiVersion": "1.0.0",
-        "createdOn": "2023-12-12T15:02:06.413469-06:00"
-      },
-      "variables": [
-        {
-          "name": "data",
-          "dataType": "float32",
-          "dimensions": [
-            {"name": "x", "size": 16},
-            {"name": "y", "size": 16}
-          ],
-          "metadata": {
-            "chunkGrid": {
-              "name": "regular",
-              "configuration": { "chunkShape": [8, 8] }
-            }
-          }
-        },
-        {
-          "name": "x",
-          "dataType": "int32",
-          "dimensions": [{"name": "x", "size": 16}]
-        },
-        {
-          "name": "y",
-          "dataType": "int32",
-          "dimensions": [{"name": "y", "size": 16}]
-        }
-      ]
-    }
-  )";
+TEST_P(DatasetVersionTest, coordinates) {
+  auto json_vars = GetSimpleSchema();
+  auto dataset = mdio::Dataset::from_json(json_vars, base_path_, version_,
+                                          mdio::constants::kCreateClean);
 
-  std::filesystem::remove_all("zarrs/v3_read_write");
-  nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  EXPECT_TRUE(dataset.value().coordinates.size() > 0)
+      << "Dataset expected to have coordinates but none were present!";
+}
 
-  // Create with V3
-  auto datasetRes = mdio::Dataset::from_json(json_vars, "zarrs/v3_read_write",
-                                             mdio::zarr::ZarrVersion::kV3,
+TEST_P(DatasetVersionTest, getIntervals) {
+  auto json_vars = GetSimpleSchema();
+  auto datasetFut = mdio::Dataset::from_json(json_vars, base_path_, version_,
                                              mdio::constants::kCreateClean);
-  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
-  auto ds = datasetRes.value();
 
-  // Get the data variable and write some values
-  auto dataVarRes = ds.variables.get<mdio::dtypes::float32_t>("data");
-  ASSERT_TRUE(dataVarRes.status().ok()) << dataVarRes.status();
-  auto dataVar = dataVarRes.value();
+  ASSERT_TRUE(datasetFut.status().ok()) << datasetFut.status();
+  auto dataset = datasetFut.value();
+  auto intervalRes = dataset.get_intervals();
+  ASSERT_TRUE(intervalRes.ok()) << intervalRes.status();
+  auto intervals = intervalRes.value();
+  EXPECT_GE(intervals.size(), 3);
+}
 
-  auto dataDataRes = dataVar.Read();
-  ASSERT_TRUE(dataDataRes.status().ok()) << dataDataRes.status();
-  auto dataData = dataDataRes.value();
+TEST_P(DatasetVersionTest, commitMetadata) {
+  auto json_vars = GetSimpleSchema();
+  auto datasetRes = mdio::Dataset::from_json(json_vars, base_path_, version_,
+                                             mdio::constants::kCreateClean);
 
-  auto accessor = dataData.get_data_accessor().data();
-  accessor[0] = 1.5f;
-  accessor[1] = 2.5f;
-  accessor[255] = 100.0f;
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto dataset = datasetRes.value();
 
-  auto writeFut = dataVar.Write(dataData);
-  ASSERT_TRUE(writeFut.status().ok()) << writeFut.status();
+  auto imageRes = dataset.variables.at("image");
+  ASSERT_TRUE(imageRes.ok()) << imageRes.status();
+  auto image = imageRes.value();
 
-  // Re-read and verify
-  auto rereadFut = dataVar.Read();
-  ASSERT_TRUE(rereadFut.status().ok()) << rereadFut.status();
-  auto rereadData = rereadFut.value();
-  auto rereadAccessor = rereadData.get_data_accessor().data();
+  auto attrs = image.GetAttributes();
+  attrs["statsV1"]["histogram"]["binCenters"] = {2, 4, 6};
+  attrs["statsV1"]["histogram"]["counts"] = {10, 15, 20};
+  auto attrsUpdateRes = image.UpdateAttributes<float>(attrs);
+  ASSERT_TRUE(attrsUpdateRes.status().ok()) << attrsUpdateRes.status();
 
-  EXPECT_FLOAT_EQ(rereadAccessor[0], 1.5f);
-  EXPECT_FLOAT_EQ(rereadAccessor[1], 2.5f);
-  EXPECT_FLOAT_EQ(rereadAccessor[255], 100.0f);
+  auto commitRes = dataset.CommitMetadata();
+  ASSERT_TRUE(commitRes.status().ok()) << commitRes.status();
 
-  std::filesystem::remove_all("zarrs/v3_read_write");
-}
+  auto newDataset = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
+  ASSERT_TRUE(newDataset.status().ok()) << newDataset.status();
 
-TEST(Dataset, fromJsonIselV2AndV3) {
-  std::string schemaNoStruct = R"(
-    {
-      "metadata": {
-        "name": "isel_test",
-        "apiVersion": "1.0.0",
-        "createdOn": "2023-12-12T15:02:06.413469-06:00"
-      },
-      "variables": [
-        {
-          "name": "data",
-          "dataType": "float32",
-          "dimensions": [
-            {"name": "x", "size": 32},
-            {"name": "y", "size": 32},
-            {"name": "z", "size": 16}
-          ]
-        },
-        {
-          "name": "x",
-          "dataType": "int32",
-          "dimensions": [{"name": "x", "size": 32}]
-        },
-        {
-          "name": "y",
-          "dataType": "int32",
-          "dimensions": [{"name": "y", "size": 32}]
-        },
-        {
-          "name": "z",
-          "dataType": "int32",
-          "dimensions": [{"name": "z", "size": 16}]
-        }
-      ]
-    }
-  )";
+  auto newImageRes = newDataset.value().variables.at("image");
+  ASSERT_TRUE(newImageRes.ok()) << newImageRes.status();
 
-  // Test V2
-  {
-    std::filesystem::remove_all("zarrs/isel_v2");
-    nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
-    auto datasetRes = mdio::Dataset::from_json(json_vars, "zarrs/isel_v2",
-                                               mdio::zarr::ZarrVersion::kV2,
-                                               mdio::constants::kCreateClean);
-    ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
-    auto ds = datasetRes.value();
-
-    mdio::RangeDescriptor<mdio::Index> desc1 = {"x", 0, 10, 1};
-    mdio::RangeDescriptor<mdio::Index> desc2 = {"y", 5, 20, 1};
-    auto sliceRes = ds.isel(desc1, desc2);
-    ASSERT_TRUE(sliceRes.status().ok()) << sliceRes.status();
+  nlohmann::json metadata = newImageRes.value().getMetadata();
+  ASSERT_TRUE(metadata.contains("metadata")) << metadata;
+}
 
-    auto slice = sliceRes.value();
-    EXPECT_EQ(slice.domain.rank(), 3);
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, DatasetVersionTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
 
-    std::filesystem::remove_all("zarrs/isel_v2");
-  }
+// Test nullopt version (should default to V2)
+TEST(DatasetVersionNullopt, fromJsonWithNulloptVersion) {
+  std::filesystem::remove_all("zarrs/nullopt_version");
+  auto json_vars = GetSimpleSchema();
 
-  // Test V3
-  {
-    std::filesystem::remove_all("zarrs/isel_v3");
-    nlohmann::json json_vars = nlohmann::json::parse(schemaNoStruct);
-    auto datasetRes = mdio::Dataset::from_json(json_vars, "zarrs/isel_v3",
-                                               mdio::zarr::ZarrVersion::kV3,
-                                               mdio::constants::kCreateClean);
-    ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
-    auto ds = datasetRes.value();
-
-    mdio::RangeDescriptor<mdio::Index> desc1 = {"x", 0, 10, 1};
-    mdio::RangeDescriptor<mdio::Index> desc2 = {"y", 5, 20, 1};
-    auto sliceRes = ds.isel(desc1, desc2);
-    ASSERT_TRUE(sliceRes.status().ok()) << sliceRes.status();
+  std::optional<mdio::zarr::ZarrVersion> version = std::nullopt;
+  auto dataset = mdio::Dataset::from_json(json_vars, "zarrs/nullopt_version",
+                                          version, mdio::constants::kCreateClean);
 
-    auto slice = sliceRes.value();
-    EXPECT_EQ(slice.domain.rank(), 3);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  EXPECT_EQ(dataset.value().getMetadata()["name"], "simple_dataset");
 
-    std::filesystem::remove_all("zarrs/isel_v3");
-  }
+  std::filesystem::remove_all("zarrs/nullopt_version");
 }
 
 }  // namespace
diff --git a/mdio/gcs_test.cc b/mdio/gcs_test.cc
index cd89d2f..6bd48a9 100644
--- a/mdio/gcs_test.cc
+++ b/mdio/gcs_test.cc
@@ -16,6 +16,7 @@
 #include <gtest/gtest.h>
 
 #include "mdio/dataset.h"
+#include "mdio/zarr/zarr.h"
 
 namespace {
 
@@ -24,6 +25,141 @@ namespace {
 // object store
 /*NOLINT*/ std::string const GCS_PATH = "gs://USER_BUCKET";
 
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
+}
+
+/**
+ * @brief Returns the GCS path suffix for test data based on Zarr version.
+ */
+std::string GetGcsPathSuffix(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "/test_v3" : "/test_v2";
+}
+
+/**
+ * @brief Returns the manifest without struct arrays (compatible with both V2 and V3).
+ */
+std::string GetSimpleManifest() {
+  return R"(
+{
+    "metadata": {
+        "name": "campos_3d",
+        "apiVersion": "1.0.0",
+        "createdOn": "2023-12-12T15:02:06.413469-06:00",
+        "attributes": {
+            "textHeader": [
+                "C01 .......................... ",
+                "C02 .......................... ",
+                "C03 .......................... "
+            ],
+            "foo": "bar"
+        }
+    },
+    "variables": [
+    {
+        "name": "image",
+        "dataType": "float32",
+        "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512},
+            {"name": "depth", "size": 384}
+        ],
+        "metadata": {
+            "chunkGrid": {
+                "name": "regular",
+                "configuration": { "chunkShape": [128, 128, 128] }
+            },
+            "statsV1": {
+            "count": 100,
+            "sum": 1215.1,
+            "sumSquares": 125.12,
+            "min": 5.61,
+            "max": 10.84,
+            "histogram": {"binCenters":  [1, 2], "counts":  [10, 15]}
+            },
+            "attributes": {
+                "fizz": "buzz"
+            }
+        },
+        "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
+        "compressor": {"name": "blosc", "algorithm": "zstd"}
+    },
+    {
+        "name": "velocity",
+        "dataType": "float64",
+        "dimensions": ["inline", "crossline", "depth"],
+        "metadata": {
+            "chunkGrid": {
+                "name": "regular",
+                "configuration": { "chunkShape": [128, 128, 128] }
+            },
+            "unitsV1": {"speed": "m/s"}
+        },
+        "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+        "name": "image_inline",
+        "dataType": "int16",
+        "dimensions": ["inline", "crossline", "depth"],
+        "longName": "inline optimized version of 3d_stack",
+        "compressor": {"name": "blosc", "algorithm": "zstd"},
+        "metadata": {
+            "chunkGrid": {
+                "name": "regular",
+                "configuration": { "chunkShape": [128, 128, 128] }
+            }
+        },
+        "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+        "name": "inline",
+        "dataType": "uint32",
+        "dimensions": [{"name": "inline", "size": 256}]
+    },
+    {
+        "name": "crossline",
+        "dataType": "uint32",
+        "dimensions": [{"name": "crossline", "size": 512}]
+    },
+    {
+        "name": "depth",
+        "dataType": "uint32",
+        "dimensions": [{"name": "depth", "size": 384}],
+        "metadata": {
+            "unitsV1": { "length": "m" }
+        }
+    },
+    {
+        "name": "cdp-x",
+        "dataType": "float32",
+        "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512}
+        ],
+        "metadata": {
+            "unitsV1": { "length": "m" }
+        }
+    },
+    {
+        "name": "cdp-y",
+        "dataType": "float32",
+        "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512}
+        ],
+        "metadata": {
+            "unitsV1": { "length": "m" }
+        }
+    }]
+}
+)";
+}
+
+// V2-only manifest with struct arrays
+
 /*NOLINT*/ std::string const fullToyManifest = R"(
 {
     "metadata": {
@@ -303,4 +439,95 @@ TEST(GCS, read) {
   ASSERT_TRUE(future.status().ok()) << future.status();
 }
 
+// ============================================================================
+// Parameterized GCS Tests for V2/V3
+// ============================================================================
+
+class GCSVersionTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    test_path_ = GCS_PATH + GetGcsPathSuffix(version_);
+  }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string test_path_;
+};
+
+TEST_P(GCSVersionTest, create) {
+  if (GCS_PATH == "gs://USER_BUCKET") {
+    GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
+                    "gcs_test.cc file.";
+  }
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto dataset = mdio::Dataset::from_json(j, test_path_, version_,
+                                          mdio::constants::kCreateClean);
+  EXPECT_TRUE(dataset.status().ok()) << dataset.status();
+}
+
+TEST_P(GCSVersionTest, open) {
+  if (GCS_PATH == "gs://USER_BUCKET") {
+    GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
+                    "gcs_test.cc file.";
+  }
+  // First create the dataset
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto createRes = mdio::Dataset::from_json(j, test_path_, version_,
+                                            mdio::constants::kCreateClean);
+  ASSERT_TRUE(createRes.status().ok()) << createRes.status();
+
+  // Then open it
+  auto dataset = mdio::Dataset::Open(test_path_, mdio::constants::kOpen);
+  EXPECT_TRUE(dataset.status().ok()) << dataset.status();
+}
+
+TEST_P(GCSVersionTest, readWrite) {
+  if (GCS_PATH == "gs://USER_BUCKET") {
+    GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
+                    "gcs_test.cc file.";
+  }
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto createRes = mdio::Dataset::from_json(j, test_path_, version_,
+                                            mdio::constants::kCreateClean);
+  ASSERT_TRUE(createRes.status().ok()) << createRes.status();
+
+  auto dataset = mdio::Dataset::Open(test_path_, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+
+  // Read and write to the image variable
+  auto imageVarRes = ds.variables.get<mdio::dtypes::float32_t>("image");
+  ASSERT_TRUE(imageVarRes.status().ok()) << imageVarRes.status();
+  auto imageVar = imageVarRes.value();
+
+  auto imageDataRes = imageVar.Read();
+  ASSERT_TRUE(imageDataRes.status().ok()) << imageDataRes.status();
+  auto imageData = imageDataRes.value();
+
+  auto accessor = imageData.get_data_accessor().data();
+  accessor[0] = 3.14f;
+  accessor[1] = 2.71f;
+
+  auto writeFut = imageVar.Write(imageData);
+  ASSERT_TRUE(writeFut.status().ok()) << writeFut.status();
+
+  // Re-read and verify
+  auto rereadRes = imageVar.Read();
+  ASSERT_TRUE(rereadRes.status().ok()) << rereadRes.status();
+  auto rereadAccessor = rereadRes.value().get_data_accessor().data();
+
+  EXPECT_FLOAT_EQ(rereadAccessor[0], 3.14f);
+  EXPECT_FLOAT_EQ(rereadAccessor[1], 2.71f);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, GCSVersionTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
 }  // namespace
diff --git a/mdio/s3_test.cc b/mdio/s3_test.cc
index 2d5e071..fdec69d 100644
--- a/mdio/s3_test.cc
+++ b/mdio/s3_test.cc
@@ -16,6 +16,7 @@
 #include <gtest/gtest.h>
 
 #include "mdio/dataset.h"
+#include "mdio/zarr/zarr.h"
 
 namespace {
 
@@ -24,6 +25,141 @@ namespace {
 // object store
 /*NOLINT*/ std::string const S3_PATH = "s3://USER_BUCKET";
 
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
+}
+
+/**
+ * @brief Returns the S3 path suffix for test data based on Zarr version.
+ */
+std::string GetS3PathSuffix(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "/test_v3" : "/test_v2";
+}
+
+/**
+ * @brief Returns the manifest without struct arrays (compatible with both V2 and V3).
+ */
+std::string GetSimpleManifest() {
+  return R"(
+{
+    "metadata": {
+        "name": "campos_3d",
+        "apiVersion": "1.0.0",
+        "createdOn": "2023-12-12T15:02:06.413469-06:00",
+        "attributes": {
+            "textHeader": [
+                "C01 .......................... ",
+                "C02 .......................... ",
+                "C03 .......................... "
+            ],
+            "foo": "bar"
+        }
+    },
+    "variables": [
+    {
+        "name": "image",
+        "dataType": "float32",
+        "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512},
+            {"name": "depth", "size": 384}
+        ],
+        "metadata": {
+            "chunkGrid": {
+                "name": "regular",
+                "configuration": { "chunkShape": [128, 128, 128] }
+            },
+            "statsV1": {
+            "count": 100,
+            "sum": 1215.1,
+            "sumSquares": 125.12,
+            "min": 5.61,
+            "max": 10.84,
+            "histogram": {"binCenters":  [1, 2], "counts":  [10, 15]}
+            },
+            "attributes": {
+                "fizz": "buzz"
+            }
+        },
+        "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
+        "compressor": {"name": "blosc", "algorithm": "zstd"}
+    },
+    {
+        "name": "velocity",
+        "dataType": "float64",
+        "dimensions": ["inline", "crossline", "depth"],
+        "metadata": {
+            "chunkGrid": {
+                "name": "regular",
+                "configuration": { "chunkShape": [128, 128, 128] }
+            },
+            "unitsV1": {"speed": "m/s"}
+        },
+        "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+        "name": "image_inline",
+        "dataType": "int16",
+        "dimensions": ["inline", "crossline", "depth"],
+        "longName": "inline optimized version of 3d_stack",
+        "compressor": {"name": "blosc", "algorithm": "zstd"},
+        "metadata": {
+            "chunkGrid": {
+                "name": "regular",
+                "configuration": { "chunkShape": [128, 128, 128] }
+            }
+        },
+        "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+        "name": "inline",
+        "dataType": "uint32",
+        "dimensions": [{"name": "inline", "size": 256}]
+    },
+    {
+        "name": "crossline",
+        "dataType": "uint32",
+        "dimensions": [{"name": "crossline", "size": 512}]
+    },
+    {
+        "name": "depth",
+        "dataType": "uint32",
+        "dimensions": [{"name": "depth", "size": 384}],
+        "metadata": {
+            "unitsV1": { "length": "m" }
+        }
+    },
+    {
+        "name": "cdp-x",
+        "dataType": "float32",
+        "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512}
+        ],
+        "metadata": {
+            "unitsV1": { "length": "m" }
+        }
+    },
+    {
+        "name": "cdp-y",
+        "dataType": "float32",
+        "dimensions": [
+            {"name": "inline", "size": 256},
+            {"name": "crossline", "size": 512}
+        ],
+        "metadata": {
+            "unitsV1": { "length": "m" }
+        }
+    }]
+}
+)";
+}
+
+// V2-only manifest with struct arrays
+
 /*NOLINT*/ std::string const fullToyManifest = R"(
 {
     "metadata": {
@@ -303,4 +439,95 @@ TEST(S3, read) {
   ASSERT_TRUE(future.status().ok()) << future.status();
 }
 
+// ============================================================================
+// Parameterized S3 Tests for V2/V3
+// ============================================================================
+
+class S3VersionTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    test_path_ = S3_PATH + GetS3PathSuffix(version_);
+  }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string test_path_;
+};
+
+TEST_P(S3VersionTest, create) {
+  if (S3_PATH == "s3://USER_BUCKET") {
+    GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
+                    "s3_test.cc file.";
+  }
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto dataset = mdio::Dataset::from_json(j, test_path_, version_,
+                                          mdio::constants::kCreateClean);
+  EXPECT_TRUE(dataset.status().ok()) << dataset.status();
+}
+
+TEST_P(S3VersionTest, open) {
+  if (S3_PATH == "s3://USER_BUCKET") {
+    GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
+                    "s3_test.cc file.";
+  }
+  // First create the dataset
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto createRes = mdio::Dataset::from_json(j, test_path_, version_,
+                                            mdio::constants::kCreateClean);
+  ASSERT_TRUE(createRes.status().ok()) << createRes.status();
+
+  // Then open it
+  auto dataset = mdio::Dataset::Open(test_path_, mdio::constants::kOpen);
+  EXPECT_TRUE(dataset.status().ok()) << dataset.status();
+}
+
+TEST_P(S3VersionTest, readWrite) {
+  if (S3_PATH == "s3://USER_BUCKET") {
+    GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
+                    "s3_test.cc file.";
+  }
+  nlohmann::json j = nlohmann::json::parse(GetSimpleManifest());
+  auto createRes = mdio::Dataset::from_json(j, test_path_, version_,
+                                            mdio::constants::kCreateClean);
+  ASSERT_TRUE(createRes.status().ok()) << createRes.status();
+
+  auto dataset = mdio::Dataset::Open(test_path_, mdio::constants::kOpen);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+
+  // Read and write to the image variable
+  auto imageVarRes = ds.variables.get<mdio::dtypes::float32_t>("image");
+  ASSERT_TRUE(imageVarRes.status().ok()) << imageVarRes.status();
+  auto imageVar = imageVarRes.value();
+
+  auto imageDataRes = imageVar.Read();
+  ASSERT_TRUE(imageDataRes.status().ok()) << imageDataRes.status();
+  auto imageData = imageDataRes.value();
+
+  auto accessor = imageData.get_data_accessor().data();
+  accessor[0] = 3.14f;
+  accessor[1] = 2.71f;
+
+  auto writeFut = imageVar.Write(imageData);
+  ASSERT_TRUE(writeFut.status().ok()) << writeFut.status();
+
+  // Re-read and verify
+  auto rereadRes = imageVar.Read();
+  ASSERT_TRUE(rereadRes.status().ok()) << rereadRes.status();
+  auto rereadAccessor = rereadRes.value().get_data_accessor().data();
+
+  EXPECT_FLOAT_EQ(rereadAccessor[0], 3.14f);
+  EXPECT_FLOAT_EQ(rereadAccessor[1], 2.71f);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, S3VersionTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
 }  // namespace
diff --git a/mdio/utils/delete_test.cc b/mdio/utils/delete_test.cc
index 8833b4f..b50c0bf 100644
--- a/mdio/utils/delete_test.cc
+++ b/mdio/utils/delete_test.cc
@@ -17,8 +17,11 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <filesystem>
 #include <string>
 
+#include "mdio/zarr/zarr.h"
+
 // clang-format off
 #include <nlohmann/json.hpp>  // NOLINT
 // clang-format on
@@ -30,10 +33,148 @@ namespace {
 
 /*NOLINT*/ const std::string kTestPath = "zarrs/testing/utils.mdio";
 
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
+}
+
+/**
+ * @brief Returns the base path for test data based on Zarr version.
+ */
+std::string GetBasePath(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3
+             ? "zarrs/testing/utils_v3.mdio"
+             : "zarrs/testing/utils.mdio";
+}
+
+/**
+ * @brief Returns manifest without struct arrays (compatible with both V2 and V3).
+ */
+std::string GetSimpleManifest() {
+  return R"(
+{
+  "metadata": {
+    "name": "campos_3d",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00",
+    "attributes": {
+      "textHeader": [
+        "C01 .......................... ",
+        "C02 .......................... ",
+        "C03 .......................... "
+      ],
+      "foo": "bar"
+    }
+  },
+  "variables": [
+    {
+      "name": "image",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512},
+        {"name": "depth", "size": 384}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        }
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
+      "compressor": {"name": "blosc", "algorithm": "zstd"}
+    },
+    {
+      "name": "velocity",
+      "dataType": "float64",
+      "dimensions": ["inline", "crossline", "depth"],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        },
+        "unitsV1": {"speed": "m/s"}
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+      "name": "image_inline",
+      "dataType": "int16",
+      "dimensions": ["inline", "crossline", "depth"],
+      "longName": "inline optimized version of 3d_stack",
+      "compressor": {"name": "blosc", "algorithm": "zstd"},
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        }
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+      "name": "inline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "inline", "size": 256}]
+    },
+    {
+      "name": "crossline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "crossline", "size": 512}]
+    },
+    {
+      "name": "depth",
+      "dataType": "uint32",
+      "dimensions": [{"name": "depth", "size": 384}],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    },
+    {
+      "name": "cdp-x",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    },
+    {
+      "name": "cdp-y",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    }
+  ]
+}
+)";
+}
+
+/**
+ * Sets up an inert dataset for testing destructive operations (V2/V3 compatible)
+ */
+mdio::Future<mdio::Dataset> SETUP(
+    const std::string& path,
+    mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
+  auto j = nlohmann::json::parse(GetSimpleManifest());
+  auto dsRes = mdio::Dataset::from_json(j, path, version,
+                                        mdio::constants::kCreateClean);
+  return dsRes;
+}
+
+// V2-only setup with struct arrays
 /**
  * Sets up an inert dataset for testing destructive operations
  */
-mdio::Future<mdio::Dataset> SETUP(const std::string& path) {
+mdio::Future<mdio::Dataset> SETUP_V2(const std::string& path) {
   std::string datasetManifest = R"(
 {
   "metadata": {
@@ -173,20 +314,21 @@ mdio::Future<mdio::Dataset> SETUP(const std::string& path) {
   return dsRes;
 }
 
-TEST(DeleteDataset, delLocal) {
-  ASSERT_TRUE(SETUP(kTestPath).status().ok());
+// V2-only tests (with struct arrays)
+TEST(DeleteDatasetV2Only, delLocal) {
+  ASSERT_TRUE(SETUP_V2(kTestPath).status().ok());
   auto res = mdio::utils::DeleteDataset(kTestPath);
   ASSERT_TRUE(res.status().ok()) << res.status();
   auto dsRes = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
   EXPECT_FALSE(dsRes.status().ok()) << dsRes.status();
 }
 
-TEST(DeleteDataset, delGCS) {
+TEST(DeleteDatasetV2Only, delGCS) {
   if (GCS_PATH == "gs://USER_BUCKET") {
     GTEST_SKIP() << "Skipping GCS deletion test.\nTo enable, please update the "
                     "GCS_PATH variable in the utils_test.cc file.";
   }
-  auto setupStatus = SETUP(GCS_PATH);
+  auto setupStatus = SETUP_V2(GCS_PATH);
   ASSERT_TRUE(setupStatus.status().ok()) << setupStatus.status();
   auto res = mdio::utils::DeleteDataset(GCS_PATH);
   ASSERT_TRUE(res.status().ok()) << res.status();
@@ -194,4 +336,40 @@ TEST(DeleteDataset, delGCS) {
   EXPECT_FALSE(dsRes.status().ok()) << dsRes.status();
 }
 
+// ============================================================================
+// Parameterized Delete Tests for V2/V3
+// ============================================================================
+
+class DeleteDatasetVersionTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+    std::filesystem::remove_all(base_path_);
+  }
+
+  void TearDown() override { std::filesystem::remove_all(base_path_); }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
+
+TEST_P(DeleteDatasetVersionTest, delLocal) {
+  auto setupRes = SETUP(base_path_, version_);
+  ASSERT_TRUE(setupRes.status().ok()) << setupRes.status();
+  auto res = mdio::utils::DeleteDataset(base_path_);
+  ASSERT_TRUE(res.status().ok()) << res.status();
+  auto dsRes = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
+  EXPECT_FALSE(dsRes.status().ok()) << dsRes.status();
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, DeleteDatasetVersionTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
 }  // namespace
diff --git a/mdio/utils/trim_test.cc b/mdio/utils/trim_test.cc
index dd5f6f9..96d7193 100644
--- a/mdio/utils/trim_test.cc
+++ b/mdio/utils/trim_test.cc
@@ -17,8 +17,11 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <filesystem>
 #include <string>
 
+#include "mdio/zarr/zarr.h"
+
 // clang-format off
 #include <nlohmann/json.hpp>  // NOLINT
 // clang-format on
@@ -27,10 +30,159 @@ namespace {
 
 /*NOLINT*/ const std::string kTestPath = "zarrs/testing/utils.mdio";
 
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
+}
+
+/**
+ * @brief Returns the base path for test data based on Zarr version.
+ */
+std::string GetBasePath(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3
+             ? "zarrs/testing/trim_v3.mdio"
+             : "zarrs/testing/trim.mdio";
+}
+
+/**
+ * @brief Returns manifest without struct arrays (compatible with both V2 and V3).
+ */
+std::string GetSimpleManifest() {
+  return R"(
+{
+  "metadata": {
+    "name": "campos_3d",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00",
+    "attributes": {
+      "textHeader": [
+        "C01 .......................... ",
+        "C02 .......................... ",
+        "C03 .......................... "
+      ],
+      "foo": "bar"
+    }
+  },
+  "variables": [
+    {
+      "name": "image",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512},
+        {"name": "depth", "size": 384}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        },
+        "statsV1": {
+          "count": 100,
+          "sum": 1215.1,
+          "sumSquares": 125.12,
+          "min": 5.61,
+          "max": 10.84,
+          "histogram": {"binCenters":  [1, 2], "counts":  [10, 15]}
+        },
+        "attributes": {
+          "fizz": "buzz"
+        }
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
+      "compressor": {"name": "blosc", "algorithm": "zstd"}
+    },
+    {
+      "name": "velocity",
+      "dataType": "float64",
+      "dimensions": ["inline", "crossline", "depth"],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        },
+        "unitsV1": {"speed": "m/s"}
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+      "name": "image_inline",
+      "dataType": "int16",
+      "dimensions": ["inline", "crossline", "depth"],
+      "longName": "inline optimized version of 3d_stack",
+      "compressor": {"name": "blosc", "algorithm": "zstd"},
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128, 128] }
+        }
+      },
+      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
+    },
+    {
+      "name": "inline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "inline", "size": 256}]
+    },
+    {
+      "name": "crossline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "crossline", "size": 512}]
+    },
+    {
+      "name": "depth",
+      "dataType": "uint32",
+      "dimensions": [{"name": "depth", "size": 384}],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    },
+    {
+      "name": "cdp-x",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    },
+    {
+      "name": "cdp-y",
+      "dataType": "float32",
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "unitsV1": { "length": "m" }
+      }
+    }
+  ]
+}
+)";
+}
+
+/**
+ * Sets up an inert dataset for testing destructive operations (V2/V3 compatible)
+ */
+mdio::Future<mdio::Dataset> SETUP(
+    const std::string& path,
+    mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
+  auto j = nlohmann::json::parse(GetSimpleManifest());
+  auto dsRes = mdio::Dataset::from_json(j, path, version,
+                                        mdio::constants::kCreateClean);
+  return dsRes;
+}
+
+// V2-only setup with struct arrays
 /**
  * Sets up an inert dataset for testing destructive operations
  */
-mdio::Future<mdio::Dataset> SETUP(const std::string& path) {
+mdio::Future<mdio::Dataset> SETUP_V2(const std::string& path) {
   std::string datasetManifest = R"(
 {
   "metadata": {
@@ -170,25 +322,72 @@ mdio::Future<mdio::Dataset> SETUP(const std::string& path) {
   return dsRes;
 }
 
-TEST(TrimDataset, noop) {
-  ASSERT_TRUE(SETUP(kTestPath).status().ok());
+// V2-only tests (with struct arrays)
+TEST(TrimDatasetV2Only, noop) {
+  ASSERT_TRUE(SETUP_V2(kTestPath).status().ok());
   auto res = mdio::utils::TrimDataset(kTestPath, false);
   EXPECT_TRUE(res.status().ok()) << res.status();
 }
 
-TEST(TrimDataset, oneSlice) {
-  ASSERT_TRUE(SETUP(kTestPath).status().ok());
+TEST(TrimDatasetV2Only, metadataConsistency) {
+  ASSERT_TRUE(SETUP_V2(kTestPath).status().ok());
+  nlohmann::json imageData;
+  {
+    auto dsFut = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
+    ASSERT_TRUE(dsFut.status().ok()) << dsFut.status();
+    auto ds = dsFut.value();
+    auto imageVarRes = ds.variables.at("image");
+    ASSERT_TRUE(imageVarRes.status().ok()) << imageVarRes.status();
+    imageData = imageVarRes.value().getMetadata();
+  }
   mdio::RangeDescriptor<mdio::Index> slice = {"inline", 0, 128, 1};
   auto res = mdio::utils::TrimDataset(kTestPath, true, slice);
   ASSERT_TRUE(res.status().ok()) << res.status();
   auto dsRes = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
   ASSERT_TRUE(dsRes.status().ok()) << dsRes.status();
+  auto imageVarRes = dsRes.value().variables.at("image");
+  ASSERT_TRUE(imageVarRes.status().ok()) << imageVarRes.status();
+  EXPECT_EQ(imageVarRes.value().getMetadata(), imageData);
+}
+
+// ============================================================================
+// Parameterized Trim Tests for V2/V3
+// ============================================================================
+
+class TrimDatasetVersionTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+    std::filesystem::remove_all(base_path_);
+  }
+
+  void TearDown() override { std::filesystem::remove_all(base_path_); }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
+
+TEST_P(TrimDatasetVersionTest, noop) {
+  ASSERT_TRUE(SETUP(base_path_, version_).status().ok());
+  auto res = mdio::utils::TrimDataset(base_path_, false);
+  EXPECT_TRUE(res.status().ok()) << res.status();
+}
+
+TEST_P(TrimDatasetVersionTest, oneSlice) {
+  ASSERT_TRUE(SETUP(base_path_, version_).status().ok());
+  mdio::RangeDescriptor<mdio::Index> slice = {"inline", 0, 128, 1};
+  auto res = mdio::utils::TrimDataset(base_path_, true, slice);
+  ASSERT_TRUE(res.status().ok()) << res.status();
+  auto dsRes = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
+  ASSERT_TRUE(dsRes.status().ok()) << dsRes.status();
 }
 
-TEST(TrimDataset, oneSliceData) {
+TEST_P(TrimDatasetVersionTest, oneSliceData) {
   // Set up the dataset
-  ASSERT_TRUE(SETUP(kTestPath).status().ok());
-  auto dsRes = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
+  ASSERT_TRUE(SETUP(base_path_, version_).status().ok());
+  auto dsRes = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
   ASSERT_TRUE(dsRes.status().ok()) << dsRes.status();
   auto ds = dsRes.value();
 
@@ -210,12 +409,12 @@ TEST(TrimDataset, oneSliceData) {
   auto writeFuture = inlineVar.Write(inlineVarData);
   ASSERT_TRUE(writeFuture.status().ok()) << writeFuture.status();
 
-  // Trim outside of a chunk boundry
+  // Trim outside of a chunk boundary
   mdio::RangeDescriptor<mdio::Index> slice = {"inline", 0, 128, 1};
-  auto res = mdio::utils::TrimDataset(kTestPath, true, slice);
+  auto res = mdio::utils::TrimDataset(base_path_, true, slice);
   ASSERT_TRUE(res.status().ok()) << res.status();
 
-  auto newDsRes = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
+  auto newDsRes = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
   ASSERT_TRUE(newDsRes.status().ok()) << newDsRes.status();
   auto newDs = newDsRes.value();
 
@@ -234,10 +433,10 @@ TEST(TrimDataset, oneSliceData) {
   }
 }
 
-TEST(TrimDataset, oneSliceDataNoDelete) {
+TEST_P(TrimDatasetVersionTest, oneSliceDataNoDelete) {
   // Set up the dataset
-  ASSERT_TRUE(SETUP(kTestPath).status().ok());
-  auto dsRes = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
+  ASSERT_TRUE(SETUP(base_path_, version_).status().ok());
+  auto dsRes = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
   ASSERT_TRUE(dsRes.status().ok()) << dsRes.status();
   auto ds = dsRes.value();
 
@@ -259,12 +458,12 @@ TEST(TrimDataset, oneSliceDataNoDelete) {
   auto writeFuture = inlineVar.Write(inlineVarData);
   ASSERT_TRUE(writeFuture.status().ok()) << writeFuture.status();
 
-  // Trim outside of a chunk boundry
+  // Trim outside of a chunk boundary
   mdio::RangeDescriptor<mdio::Index> slice = {"inline", 0, 128, 1};
-  auto res = mdio::utils::TrimDataset(kTestPath, false, slice);
+  auto res = mdio::utils::TrimDataset(base_path_, false, slice);
   ASSERT_TRUE(res.status().ok()) << res.status();
 
-  auto newDsRes = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
+  auto newDsRes = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
   ASSERT_TRUE(newDsRes.status().ok()) << newDsRes.status();
   auto newDs = newDsRes.value();
 
@@ -283,11 +482,11 @@ TEST(TrimDataset, oneSliceDataNoDelete) {
   }
 }
 
-TEST(TrimDataset, metadataConsistency) {
-  ASSERT_TRUE(SETUP(kTestPath).status().ok());
+TEST_P(TrimDatasetVersionTest, metadataConsistency) {
+  ASSERT_TRUE(SETUP(base_path_, version_).status().ok());
   nlohmann::json imageData;
   {
-    auto dsFut = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
+    auto dsFut = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
     ASSERT_TRUE(dsFut.status().ok()) << dsFut.status();
     auto ds = dsFut.value();
     auto imageVarRes = ds.variables.at("image");
@@ -295,13 +494,21 @@ TEST(TrimDataset, metadataConsistency) {
     imageData = imageVarRes.value().getMetadata();
   }
   mdio::RangeDescriptor<mdio::Index> slice = {"inline", 0, 128, 1};
-  auto res = mdio::utils::TrimDataset(kTestPath, true, slice);
+  auto res = mdio::utils::TrimDataset(base_path_, true, slice);
   ASSERT_TRUE(res.status().ok()) << res.status();
-  auto dsRes = mdio::Dataset::Open(kTestPath, mdio::constants::kOpen);
+  auto dsRes = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
   ASSERT_TRUE(dsRes.status().ok()) << dsRes.status();
   auto imageVarRes = dsRes.value().variables.at("image");
   ASSERT_TRUE(imageVarRes.status().ok()) << imageVarRes.status();
   EXPECT_EQ(imageVarRes.value().getMetadata(), imageData);
 }
 
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, TrimDatasetVersionTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
 }  // namespace
diff --git a/mdio/variable_test.cc b/mdio/variable_test.cc
index dfd188e..60a8081 100644
--- a/mdio/variable_test.cc
+++ b/mdio/variable_test.cc
@@ -24,6 +24,7 @@
 #include <string>
 #include <utility>
 
+#include "mdio/zarr/zarr.h"
 #include "tensorstore/driver/zarr/compressor.h"
 #include "tensorstore/driver/zarr/driver_impl.h"
 #include "tensorstore/driver/zarr/dtype.h"
@@ -35,6 +36,74 @@
 #include <nlohmann/json.hpp>  // NOLINT
 // clang-format on
 
+namespace {
+
+/**
+ * @brief Returns a string representation of the Zarr version for naming.
+ */
+std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "V3" : "V2";
+}
+
+/**
+ * @brief Returns the base path for test data based on Zarr version.
+ */
+std::string GetBasePath(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "variable_test_v3"
+                                                  : "variable_test";
+}
+
+/**
+ * @brief Returns the TensorStore driver name for the given version.
+ */
+std::string GetTestDriverName(mdio::zarr::ZarrVersion version) {
+  return version == mdio::zarr::ZarrVersion::kV3 ? "zarr3" : "zarr";
+}
+
+/**
+ * @brief Creates a variable spec for testing based on Zarr version.
+ */
+::nlohmann::json CreateTestVariableSpec(mdio::zarr::ZarrVersion version,
+                                        const std::string& name) {
+  nlohmann::json spec;
+  spec["driver"] = GetTestDriverName(version);
+  spec["kvstore"]["driver"] = "file";
+  spec["kvstore"]["path"] = name;
+
+  if (version == mdio::zarr::ZarrVersion::kV3) {
+    spec["metadata"]["data_type"] = "int16";
+    spec["metadata"]["shape"] = nlohmann::json::array({500, 500});
+    spec["metadata"]["chunk_grid"]["name"] = "regular";
+    spec["metadata"]["chunk_grid"]["configuration"]["chunk_shape"] =
+        nlohmann::json::array({100, 50});
+    spec["metadata"]["chunk_key_encoding"]["name"] = "default";
+    spec["metadata"]["chunk_key_encoding"]["configuration"]["separator"] = "/";
+    nlohmann::json bytes_codec;
+    bytes_codec["name"] = "bytes";
+    spec["metadata"]["codecs"] = nlohmann::json::array({bytes_codec});
+    spec["attributes"]["metadata"]["attributes"]["job status"] = "win";
+    spec["attributes"]["metadata"]["attributes"]["project code"] = "fail";
+    spec["attributes"]["metadata"]["unitsV1"] = {"m", "ft"};
+    spec["attributes"]["long_name"] = "foooooo .....";
+    spec["attributes"]["dimension_names"] = {"x", "y"};
+  } else {
+    spec["metadata"]["compressor"]["id"] = "blosc";
+    spec["metadata"]["dtype"] = "<i2";
+    spec["metadata"]["shape"] = {500, 500};
+    spec["metadata"]["chunks"] = {100, 50};
+    spec["metadata"]["dimension_separator"] = "/";
+    spec["attributes"]["metadata"]["attributes"]["job status"] = "win";
+    spec["attributes"]["metadata"]["attributes"]["project code"] = "fail";
+    spec["attributes"]["metadata"]["unitsV1"] = {"m", "ft"};
+    spec["attributes"]["long_name"] = "foooooo .....";
+    spec["attributes"]["dimension_names"] = {"x", "y"};
+  }
+
+  return spec;
+}
+
+}  // namespace
+
 // clang-format off
 ::nlohmann::json json_good = ::nlohmann::json::object({
     {"driver", "zarr"},
@@ -1289,4 +1358,135 @@ TEST(VariableData, fromVariableFillTest) {
       << variableData.value().get_data_accessor().data()[0];
 }
 
+// ============================================================================
+// Parameterized Variable Tests for V2/V3
+// ============================================================================
+
+class VariableVersionTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
+    std::filesystem::remove_all(base_path_);
+  }
+
+  void TearDown() override { std::filesystem::remove_all(base_path_); }
+
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
+
+TEST_P(VariableVersionTest, open) {
+  auto spec = CreateTestVariableSpec(version_, base_path_);
+  auto variable =
+      mdio::Variable<>::Open(spec, mdio::constants::kCreateClean).result();
+
+  ASSERT_TRUE(variable.ok()) << variable.status();
+
+  EXPECT_THAT(variable->dimensions().shape(), ::testing::ElementsAre(500, 500));
+  EXPECT_THAT(variable->dimensions().labels(),
+              ::testing::ElementsAre("x", "y"));
+  EXPECT_EQ(variable->dtype(), mdio::constants::kInt16);
+  EXPECT_EQ(variable->get_variable_name(), base_path_);
+  EXPECT_EQ(variable->get_long_name(), std::string("foooooo ....."));
+}
+
+TEST_P(VariableVersionTest, slice) {
+  auto spec = CreateTestVariableSpec(version_, base_path_);
+  auto variable =
+      mdio::Variable<>::Open(spec, mdio::constants::kCreateClean).value();
+
+  mdio::RangeDescriptor<mdio::Index> desc1 = {"x", 0, 5, 1};
+  mdio::RangeDescriptor<mdio::Index> desc2 = {"y", 5, 11, 1};
+
+  auto result = variable.slice(desc2, desc1);
+  ASSERT_TRUE(result.ok()) << result.status();
+
+  auto domain = result->dimensions();
+  EXPECT_THAT(domain.labels(), ::testing::ElementsAre("x", "y"));
+  EXPECT_THAT(domain.origin(), ::testing::ElementsAre(0, 5));
+  EXPECT_THAT(domain.shape(), ::testing::ElementsAre(5, 6));
+}
+
+TEST_P(VariableVersionTest, rank) {
+  auto spec = CreateTestVariableSpec(version_, base_path_);
+  auto variable = mdio::Variable<>::Open(spec, mdio::constants::kCreateClean);
+  ASSERT_TRUE(variable.status().ok()) << variable.status();
+  auto rank = variable.value().rank();
+  EXPECT_EQ(rank, 2);
+}
+
+TEST_P(VariableVersionTest, readWrite) {
+  auto spec = CreateTestVariableSpec(version_, base_path_);
+  auto variableRes =
+      mdio::Variable<>::Open(spec, mdio::constants::kCreateClean);
+  ASSERT_TRUE(variableRes.status().ok()) << variableRes.status();
+  auto variable = variableRes.value();
+
+  auto varDataRes = variable.Read();
+  ASSERT_TRUE(varDataRes.status().ok()) << varDataRes.status();
+  auto varData = varDataRes.value();
+
+  auto data =
+      reinterpret_cast<int16_t*>(varData.get_data_accessor().data());
+  data[0] = 1234;
+  data[1] = 5678;
+
+  auto writeFut = variable.Write(varData);
+  ASSERT_TRUE(writeFut.status().ok()) << writeFut.status();
+
+  // Re-read and verify
+  auto rereadFut = variable.Read();
+  ASSERT_TRUE(rereadFut.status().ok()) << rereadFut.status();
+  auto rereadData = rereadFut.value();
+  auto rereadPtr =
+      reinterpret_cast<int16_t*>(rereadData.get_data_accessor().data());
+
+  EXPECT_EQ(rereadPtr[0], 1234);
+  EXPECT_EQ(rereadPtr[1], 5678);
+}
+
+TEST_P(VariableVersionTest, getIntervals) {
+  auto spec = CreateTestVariableSpec(version_, base_path_);
+  auto varRes = mdio::Variable<>::Open(spec, mdio::constants::kCreateClean);
+  ASSERT_TRUE(varRes.status().ok()) << varRes.status();
+  auto var = varRes.value();
+
+  auto intervalRes = var.get_intervals();
+  ASSERT_TRUE(intervalRes.status().ok()) << intervalRes.status();
+  auto intervals = intervalRes.value();
+  ASSERT_EQ(intervals.size(), 2);
+}
+
+TEST_P(VariableVersionTest, outOfBoundsSlice) {
+  auto spec = CreateTestVariableSpec(version_, base_path_);
+  auto var = mdio::Variable<>::Open(spec, mdio::constants::kCreateClean).result();
+
+  ASSERT_TRUE(var.ok());
+  EXPECT_THAT(var->dimensions().shape(), ::testing::ElementsAre(500, 500));
+
+  mdio::RangeDescriptor<mdio::Index> x_inbounds = {"x", 100, 250, 1};
+  mdio::RangeDescriptor<mdio::Index> y_inbounds = {"y", 0, 500, 1};
+  mdio::RangeDescriptor<mdio::Index> x_outbounds = {"x", 250, 1000, 1};
+
+  auto inbounds = var.value().slice(x_inbounds, y_inbounds);
+  EXPECT_TRUE(inbounds.status().ok()) << inbounds.status();
+
+  auto outbounds = var.value().slice(x_outbounds, y_inbounds);
+  EXPECT_TRUE(outbounds.status().ok()) << outbounds.status();
+
+  auto badDomain = outbounds.value();
+  EXPECT_THAT(badDomain.dimensions().shape(), ::testing::ElementsAre(250, 500))
+      << badDomain.dimensions();
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, VariableVersionTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
+
 }  // namespace

From db8ffb92bce906511c8f8f8224dc66befbc95ca2 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 19 Dec 2025 19:48:57 +0000
Subject: [PATCH 10/26] Suppress warning output spam

---
 mdio/CMakeLists.txt |  2 ++
 mdio/s3_test.cc     | 13 +++++++++++++
 2 files changed, 15 insertions(+)

diff --git a/mdio/CMakeLists.txt b/mdio/CMakeLists.txt
index 12cca9c..baf30b9 100644
--- a/mdio/CMakeLists.txt
+++ b/mdio/CMakeLists.txt
@@ -134,6 +134,8 @@ mdio_cc_test(
     tensorstore::util_status_testutil
     nlohmann_json_schema_validator
     tensorstore::kvstore_s3
+    absl::log_initialize
+    absl::log_globals
 )
 
 mdio_cc_test(
diff --git a/mdio/s3_test.cc b/mdio/s3_test.cc
index fdec69d..3de04ef 100644
--- a/mdio/s3_test.cc
+++ b/mdio/s3_test.cc
@@ -15,11 +15,24 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "absl/log/globals.h"
+#include "absl/log/initialize.h"
+
 #include "mdio/dataset.h"
 #include "mdio/zarr/zarr.h"
 
 namespace {
 
+// Initialize Abseil logging before tests run to suppress verbose AWS logs
+struct AbslLogInit {
+  AbslLogInit() {
+    absl::InitializeLog();
+    // kError = show only errors, kInfinity = suppress all logs
+    absl::SetStderrThreshold(absl::LogSeverityAtLeast::kInfinity);
+  }
+};
+static AbslLogInit absl_log_init;
+
 // TODO(End user): User should point to their own S3 bucket here.
 // You may find the test dataset at: TODO: Upload the test dataset to a public
 // object store

From faa8393e51fcac360b1de4fe310851652fb305ac Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 19 Dec 2025 19:49:21 +0000
Subject: [PATCH 11/26] Fix driver requirements

---
 mdio/CMakeLists.txt | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/mdio/CMakeLists.txt b/mdio/CMakeLists.txt
index baf30b9..c838d3c 100644
--- a/mdio/CMakeLists.txt
+++ b/mdio/CMakeLists.txt
@@ -101,6 +101,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack
@@ -125,6 +126,7 @@ mdio_cc_test(
     GTest::gmock_main
     tensorstore::driver_array
     tensorstore::driver_zarr
+    tensorstore::driver_zarr3
     tensorstore::driver_json
     tensorstore::kvstore_file
     tensorstore::stack
@@ -331,15 +333,8 @@ mdio_cc_test(
     ${mdio_DEFAULT_LINKOPTS}
   DEPS
     GTest::gmock_main
-    tensorstore::driver_array
-    tensorstore::driver_zarr
     tensorstore::driver_json
-    tensorstore::kvstore_file
-    tensorstore::stack
     tensorstore::tensorstore
-    tensorstore::index_space_dim_expression
-    tensorstore::index_space_index_transform
-    tensorstore::util_status_testutil
     nlohmann_json_schema_validator
 )
 

From b259f6011e3242d0d759a6cb4b2bef8c69059a53 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 19 Dec 2025 19:50:43 +0000
Subject: [PATCH 12/26] Update inert bucket example to be more appropriate

---
 mdio/gcs_test.cc | 16 ++++++++--------
 mdio/s3_test.cc  | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/mdio/gcs_test.cc b/mdio/gcs_test.cc
index 6bd48a9..4b00ac3 100644
--- a/mdio/gcs_test.cc
+++ b/mdio/gcs_test.cc
@@ -23,7 +23,7 @@ namespace {
 // TODO(End user): User should point to their own GCS bucket here.
 // You may find the test dataset at: TODO: Upload the test dataset to a public
 // object store
-/*NOLINT*/ std::string const GCS_PATH = "gs://USER_BUCKET";
+/*NOLINT*/ std::string const GCS_PATH = "gs://USER_BUCKET/mdio_cpp_testing";
 
 /**
  * @brief Returns a string representation of the Zarr version for naming.
@@ -294,7 +294,7 @@ std::string GetSimpleManifest() {
 )";
 
 TEST(GCS, create) {
-  if (GCS_PATH == "gs://USER_BUCKET") {
+  if (GCS_PATH == "gs://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
                     "gcs_test.cc file.";
   }
@@ -305,7 +305,7 @@ TEST(GCS, create) {
 }
 
 TEST(GCS, open) {
-  if (GCS_PATH == "gs://USER_BUCKET") {
+  if (GCS_PATH == "gs://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
                     "gcs_test.cc file.";
   }
@@ -318,7 +318,7 @@ TEST(GCS, open) {
 }
 
 TEST(GCS, write) {
-  if (GCS_PATH == "gs://USER_BUCKET") {
+  if (GCS_PATH == "gs://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
                     "gcs_test.cc file.";
   }
@@ -420,7 +420,7 @@ TEST(GCS, write) {
 }
 
 TEST(GCS, read) {
-  if (GCS_PATH == "gs://USER_BUCKET") {
+  if (GCS_PATH == "gs://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
                     "gcs_test.cc file.";
   }
@@ -456,7 +456,7 @@ class GCSVersionTest
 };
 
 TEST_P(GCSVersionTest, create) {
-  if (GCS_PATH == "gs://USER_BUCKET") {
+  if (GCS_PATH == "gs://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
                     "gcs_test.cc file.";
   }
@@ -467,7 +467,7 @@ TEST_P(GCSVersionTest, create) {
 }
 
 TEST_P(GCSVersionTest, open) {
-  if (GCS_PATH == "gs://USER_BUCKET") {
+  if (GCS_PATH == "gs://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
                     "gcs_test.cc file.";
   }
@@ -483,7 +483,7 @@ TEST_P(GCSVersionTest, open) {
 }
 
 TEST_P(GCSVersionTest, readWrite) {
-  if (GCS_PATH == "gs://USER_BUCKET") {
+  if (GCS_PATH == "gs://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the GCS_PATH to your own bucket in the "
                     "gcs_test.cc file.";
   }
diff --git a/mdio/s3_test.cc b/mdio/s3_test.cc
index 3de04ef..3c7d4d7 100644
--- a/mdio/s3_test.cc
+++ b/mdio/s3_test.cc
@@ -36,7 +36,7 @@ static AbslLogInit absl_log_init;
 // TODO(End user): User should point to their own S3 bucket here.
 // You may find the test dataset at: TODO: Upload the test dataset to a public
 // object store
-/*NOLINT*/ std::string const S3_PATH = "s3://USER_BUCKET";
+/*NOLINT*/ std::string const S3_PATH = "s3://USER_BUCKET/mdio_cpp_testing";
 
 /**
  * @brief Returns a string representation of the Zarr version for naming.
@@ -307,7 +307,7 @@ std::string GetSimpleManifest() {
 )";
 
 TEST(S3, create) {
-  if (S3_PATH == "s3://USER_BUCKET") {
+  if (S3_PATH == "s3://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
                     "s3_test.cc file.";
   }
@@ -318,7 +318,7 @@ TEST(S3, create) {
 }
 
 TEST(S3, open) {
-  if (S3_PATH == "s3://USER_BUCKET") {
+  if (S3_PATH == "s3://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
                     "s3_test.cc file.";
   }
@@ -331,7 +331,7 @@ TEST(S3, open) {
 }
 
 TEST(S3, write) {
-  if (S3_PATH == "s3://USER_BUCKET") {
+  if (S3_PATH == "s3://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
                     "s3_test.cc file.";
   }
@@ -433,7 +433,7 @@ TEST(S3, write) {
 }
 
 TEST(S3, read) {
-  if (S3_PATH == "s3://USER_BUCKET") {
+  if (S3_PATH == "s3://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
                     "s3_test.cc file.";
   }
@@ -469,7 +469,7 @@ class S3VersionTest
 };
 
 TEST_P(S3VersionTest, create) {
-  if (S3_PATH == "s3://USER_BUCKET") {
+  if (S3_PATH == "s3://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
                     "s3_test.cc file.";
   }
@@ -480,7 +480,7 @@ TEST_P(S3VersionTest, create) {
 }
 
 TEST_P(S3VersionTest, open) {
-  if (S3_PATH == "s3://USER_BUCKET") {
+  if (S3_PATH == "s3://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
                     "s3_test.cc file.";
   }
@@ -496,7 +496,7 @@ TEST_P(S3VersionTest, open) {
 }
 
 TEST_P(S3VersionTest, readWrite) {
-  if (S3_PATH == "s3://USER_BUCKET") {
+  if (S3_PATH == "s3://USER_BUCKET/mdio_cpp_testing") {
     GTEST_SKIP() << "Please set the S3_PATH to your own bucket in the "
                     "s3_test.cc file.";
   }

From 2a09c997c3727784ae4e739d2ddf1313910ddd60 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Mon, 22 Dec 2025 21:32:50 +0000
Subject: [PATCH 13/26] Propogate context through internal objects to allow for
 credentials to be provided

---
 mdio/dataset.h      | 60 +++++++++++++++++++++++++++-----------
 mdio/utils/delete.h | 10 +++++--
 mdio/utils/trim.h   | 34 +++++++++++++++++++---
 mdio/variable.h     | 70 ++++++++++++++++++++++++++++++++++++---------
 mdio/zarr/zarr.h    |  9 ++++--
 mdio/zarr/zarr_v2.h |  6 ++--
 mdio/zarr/zarr_v3.h |  6 ++--
 7 files changed, 150 insertions(+), 45 deletions(-)

diff --git a/mdio/dataset.h b/mdio/dataset.h
index 5699392..af97192 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -74,16 +74,19 @@ inline Result<nlohmann::json> get_zarray(const ::nlohmann::json metadata) {
  *
  * @param dataset_metadata The metadata for the dataset.
  * @param json_variables The JSON variables.
+ * @param context Optional TensorStore context for credentials/configuration.
  * @return An `mdio::Future<void>` representing the asynchronous write.
  */
 inline Future<void> write_zmetadata(
     const ::nlohmann::json& dataset_metadata,
-    const std::vector<::nlohmann::json>& json_variables) {
+    const std::vector<::nlohmann::json>& json_variables,
+    tensorstore::Context context = tensorstore::Context::Default()) {
   zarr::ZarrVersion version = zarr::ZarrVersion::kV2;
   if (!json_variables.empty()) {
     version = zarr::GetVersionFromSpec(json_variables[0]);
   }
-  return zarr::WriteDatasetMetadata(version, dataset_metadata, json_variables);
+  return zarr::WriteDatasetMetadata(version, dataset_metadata, json_variables,
+                                    context);
 }
 
 /**
@@ -92,9 +95,11 @@ inline Future<void> write_zmetadata(
  * It will also attempt to infer the driver based on the prefix of the path.
  * It will default to the "file" driver if no prefix is found.
  * @param dataset_path The path to the dataset.
+ * @param context Optional TensorStore context for credentials/configuration.
  */
 inline Future<tensorstore::KvStore> dataset_kvs_store(
-    const std::string& dataset_path) {
+    const std::string& dataset_path,
+    tensorstore::Context context = tensorstore::Context::Default()) {
   // the tensorstore driver needs a bucket field
   ::nlohmann::json kvstore;
 
@@ -113,7 +118,7 @@ inline Future<tensorstore::KvStore> dataset_kvs_store(
       path.push_back('/');
     }
     kvstore["path"] = path;
-    return tensorstore::kvstore::Open(kvstore);
+    return tensorstore::kvstore::Open(kvstore, context);
   }  // FIXME - we need azure support ...
 
   std::vector<std::string> file_parts = absl::StrSplit(output_file, '/');
@@ -134,19 +139,22 @@ inline Future<tensorstore::KvStore> dataset_kvs_store(
   kvstore["bucket"] = bucket;
   kvstore["path"] = filepath;
 
-  return tensorstore::kvstore::Open(kvstore);
+  return tensorstore::kvstore::Open(kvstore, context);
 }
 
 /**
  * @brief Retrieves the metadata for the dataset with auto-detection.
  * This version auto-detects the Zarr version by checking for V3 markers first.
  * @param dataset_path The path to the dataset.
+ * @param context Optional TensorStore context for credentials/configuration.
  * @return An `mdio::Future` containing the metadata JSON on success, or an
  * error on failure.
  */
 inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
-from_zmetadata(const std::string& dataset_path) {
-  auto kvs_future = mdio::internal::dataset_kvs_store(dataset_path);
+from_zmetadata(
+    const std::string& dataset_path,
+    tensorstore::Context context = tensorstore::Context::Default()) {
+  auto kvs_future = mdio::internal::dataset_kvs_store(dataset_path, context);
 
   auto pair = tensorstore::PromiseFuturePair<
       std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>::Make();
@@ -199,11 +207,13 @@ class Dataset {
  public:
   Dataset(const nlohmann::json& metadata, const VariableCollection& variables,
           const coordinate_map& coordinates,
-          const tensorstore::IndexDomain<>& domain)
+          const tensorstore::IndexDomain<>& domain,
+          tensorstore::Context context = tensorstore::Context::Default())
       : metadata(metadata),
         variables(variables),
         coordinates(coordinates),
-        domain(domain) {}
+        domain(domain),
+        context_(context) {}
 
   friend std::ostream& operator<<(std::ostream& os, const Dataset& dataset) {
     // Output metadata
@@ -459,7 +469,7 @@ class Dataset {
                               .shape(shape)
                               .labels(labels)
                               .Finalize())
-    return Dataset{metadata, vars, coordinates, new_domain};
+    return Dataset{metadata, vars, coordinates, new_domain, context_};
   }
 
   /**
@@ -914,7 +924,7 @@ class Dataset {
       coords = {{label, coordinates.at(label)}};
     }
 
-    return Dataset{metadata, vars, coords, domain};
+    return Dataset{metadata, vars, coords, domain, context_};
   }
 
   /**
@@ -943,8 +953,12 @@ class Dataset {
                           "Open from path is only valid in open-mode.");
     }
 
-    MDIO_ASSIGN_OR_RETURN(auto params_from_zmetadata,
-                          mdio::internal::from_zmetadata(dataset_path).result());
+    // Extract context from options for metadata reading
+    tensorstore::Context context = transact_options.context;
+
+    MDIO_ASSIGN_OR_RETURN(
+        auto params_from_zmetadata,
+        mdio::internal::from_zmetadata(dataset_path, context).result());
     auto [dataset_metadata, json_vars] = params_from_zmetadata;
 
     return mdio::Dataset::Open(dataset_metadata, json_vars,
@@ -973,6 +987,9 @@ class Dataset {
     bool do_create = transact_options.open_mode == constants::kCreateClean ||
                      transact_options.open_mode == constants::kCreate;
 
+    // Extract context from options for metadata writing
+    tensorstore::Context context = transact_options.context;
+
     // FIXME - publish dataset
     std::vector<Future<mdio::Variable<>>> variables;
     std::vector<tensorstore::Promise<void>> promises;
@@ -999,7 +1016,7 @@ class Dataset {
     // here we have to publish the zmetadata ...
     if (do_create) {
       futures.push_back(
-          mdio::internal::write_zmetadata(metadata, json_variables));
+          mdio::internal::write_zmetadata(metadata, json_variables, context));
     }
 
     // ready when everything's available ...
@@ -1008,7 +1025,7 @@ class Dataset {
     auto pair = tensorstore::PromiseFuturePair<Dataset>::Make();
     all_done_future.ExecuteWhenReady(
         [promise = std::move(pair.promise), variables = std::move(variables),
-         metadata](tensorstore::ReadyFuture<void> readyFut) {
+         metadata, context](tensorstore::ReadyFuture<void> readyFut) {
           if (metadata.contains("api_version") &&
               !metadata.contains("apiVersion")) {
             promise.SetResult(
@@ -1075,7 +1092,7 @@ class Dataset {
           }
 
           Dataset new_dataset{metadata, collection, coords,
-                              dataset_domain.value()};
+                              dataset_domain.value(), context};
           promise.SetResult(std::move(new_dataset));
         });
     return pair.future;
@@ -1298,7 +1315,7 @@ class Dataset {
 
     // Now let's get the .zmetadata going.
     auto zmetadata_future =
-        mdio::internal::write_zmetadata(metadata, json_vars);
+        mdio::internal::write_zmetadata(metadata, json_vars, context_);
     // Finally we can loop through the updated Variables and update them.
 
     std::vector<tensorstore::Future<tensorstore::TimestampedStorageGeneration>>
@@ -1358,8 +1375,17 @@ class Dataset {
   /// enumerate the dimensions
   tensorstore::IndexDomain<> domain;
 
+  /**
+   * @brief Gets the context used to open this Dataset.
+   * @return The TensorStore context.
+   */
+  tensorstore::Context getContext() const { return context_; }
+
  private:
   /// the metadata associated with the dataset (root .zattrs)
   ::nlohmann::json metadata;
+
+  /// the context used to open/create this dataset
+  tensorstore::Context context_;
 };
 }  // namespace mdio
diff --git a/mdio/utils/delete.h b/mdio/utils/delete.h
index ecb5b1a..6080ec9 100644
--- a/mdio/utils/delete.h
+++ b/mdio/utils/delete.h
@@ -31,14 +31,18 @@ namespace utils {
  * deletion. This is intended to provide a safe interface to delete MDIO
  * datasets.
  * @param dataset_path The path to the dataset
+ * @param context Optional TensorStore context for credentials/configuration.
  * @return OK result if the dataset was valid and deleted successfully,
  * otherwise an error result
  */
-inline Result<void> DeleteDataset(const std::string dataset_path) {
+inline Result<void> DeleteDataset(
+    const std::string dataset_path,
+    tensorstore::Context context = tensorstore::Context::Default()) {
   // Open the dataset
   // This is to ensure that what is getting deleted by MDIO is a valid MDIO
   // dataset itself.
-  auto dsRes = mdio::Dataset::Open(dataset_path, mdio::constants::kOpen);
+  auto dsRes =
+      mdio::Dataset::Open(dataset_path, mdio::constants::kOpen, context);
   if (!dsRes.status().ok()) {
     return dsRes.status();
   }
@@ -62,7 +66,7 @@ inline Result<void> DeleteDataset(const std::string dataset_path) {
   }
   kvs["path"] = path;
 
-  auto kvsFuture = tensorstore::kvstore::Open(kvs);
+  auto kvsFuture = tensorstore::kvstore::Open(kvs, context);
   if (!kvsFuture.status().ok()) {
     return kvsFuture.status();
   }
diff --git a/mdio/utils/trim.h b/mdio/utils/trim.h
index 307a4c2..f6645f6 100644
--- a/mdio/utils/trim.h
+++ b/mdio/utils/trim.h
@@ -37,16 +37,18 @@ namespace utils {
  * @param delete_sliced_out_chunks If true, chunks that fall completely outside
  * the slice descriptors will be deleted. If false, chunks that fall completely
  * outside the slice descriptors will remain untouched but inaccessable.
+ * @param context Optional TensorStore context for credentials/configuration.
  * @param descriptors The descriptors to use for the slice. Only considers the
  * label and stop value.
  * @return A future of the trim operation.
  */
 template <typename... Descriptors>
-Future<void> TrimDataset(std::string dataset_path,
-                         bool delete_sliced_out_chunks,
-                         const Descriptors&... descriptors) {
+Future<void> TrimDataset(
+    std::string dataset_path, bool delete_sliced_out_chunks,
+    tensorstore::Context context, const Descriptors&... descriptors) {
   // Open the dataset
-  auto dsRes = mdio::Dataset::Open(dataset_path, mdio::constants::kOpen);
+  auto dsRes =
+      mdio::Dataset::Open(dataset_path, mdio::constants::kOpen, context);
   if (!dsRes.status().ok()) {
     return dsRes.status();
   }
@@ -113,6 +115,30 @@ Future<void> TrimDataset(std::string dataset_path,
   return ds.CommitMetadata();
 }
 
+/**
+ * @brief Trims the dataset to the specified dimensions (using default context).
+ * DANGER: This operation will mutate the dataset on disk. Use caution when
+ * calling this method! This function is not part of the Dataset class to avoid
+ * accidental data destruction. Additionally this function should only be used
+ * on a fully written dataset to avoid race conditions and data corruption.
+ *
+ * @tparam ...Descriptors Expects an mdio::RangeDescriptor<mdio::Index>
+ * @param dataset_path The path to the dataset to trim.
+ * @param delete_sliced_out_chunks If true, chunks that fall completely outside
+ * the slice descriptors will be deleted. If false, chunks that fall completely
+ * outside the slice descriptors will remain untouched but inaccessable.
+ * @param descriptors The descriptors to use for the slice. Only considers the
+ * label and stop value.
+ * @return A future of the trim operation.
+ */
+template <typename... Descriptors>
+Future<void> TrimDataset(std::string dataset_path,
+                         bool delete_sliced_out_chunks,
+                         const Descriptors&... descriptors) {
+  return TrimDataset(dataset_path, delete_sliced_out_chunks,
+                     tensorstore::Context::Default(), descriptors...);
+}
+
 }  // namespace utils
 }  // namespace mdio
 
diff --git a/mdio/variable.h b/mdio/variable.h
index 2ac0227..5470a9e 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -407,10 +407,10 @@ Result<Variable<T, R, M>> from_json(
  * the created variable.
  */
 template <typename T = void, DimensionIndex R = dynamic_rank,
-          ReadWriteMode M = ReadWriteMode::dynamic, typename... Option>
+          ReadWriteMode M = ReadWriteMode::dynamic>
 Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
                                          const nlohmann::json& json_var,
-                                         Option&&... options) {
+                                         TransactionalOpenOptions&& options) {
   auto spec = tensorstore::MakeReadyFuture<::nlohmann::json>(json_var);
 
   // FIXME - add schematized validation of the variable.
@@ -461,7 +461,11 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   auto future_json_store = tensorstore::MakeReadyFuture<::nlohmann::json>(
       json_spec_without_metadata);
 
-  auto publish = [zarr_version](const ::nlohmann::json& json_var,
+  // Extract context from the TransactionalOpenOptions directly
+  tensorstore::Context context = options.context;
+  tensorstore::OpenMode open_mode = options.open_mode;
+
+  auto publish = [zarr_version, context](const ::nlohmann::json& json_var,
                                 bool isCloudStore,
                                 const tensorstore::TensorStore<T, R, M>& store)
       -> Future<tensorstore::TimestampedStorageGeneration> {
@@ -476,7 +480,7 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   // this is intended to handle the struct array where we "reopen" the store
   // but this time as struct ... but we loose the capactity for forward options.
   // FIXME - strip "create/delete existing" and foward other options.
-  auto apply_reopen = [](const tensorstore::TensorStore<T, R, M>& store,
+  auto apply_reopen = [context](const tensorstore::TensorStore<T, R, M>& store,
                          const ::nlohmann::json& attributes,
                          const ::nlohmann::json& json_spec) {
     // try {
@@ -484,7 +488,8 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
         json_spec_cpy.erase("field");
         json_spec_cpy["open_as_void"] = true;
     // } catch (ex)
-    return tensorstore::Open<T, R, M>(json_spec_cpy);
+    return tensorstore::Open<T, R, M>(json_spec_cpy, context,
+                                      tensorstore::OpenMode::open);
   };
 
   auto build = [](const ::nlohmann::json& metadata,
@@ -504,9 +509,9 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
     return from_json<T, R, M>(metadata, labeled_store);
   };
 
-  // Start by creating a future for the store ...
+  // Start by creating a future for the store with explicit context
   auto future_store = tensorstore::Open<T, R, M>(
-      json_spec_with_open_flag, std::forward<Option>(options)...);
+      json_spec_with_open_flag, context, open_mode);
 
   auto handled_store = future_store;
   if (do_handle_structarray) {
@@ -549,6 +554,21 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   return pair.future;
 }
 
+/**
+ * @brief Creates a Variable from a JSON specification (variadic options version).
+ * This overload accepts individual options and converts them to TransactionalOpenOptions.
+ */
+template <typename T = void, DimensionIndex R = dynamic_rank,
+          ReadWriteMode M = ReadWriteMode::dynamic, typename... Option>
+Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
+                                         const nlohmann::json& json_var,
+                                         Option&&... options) {
+  TransactionalOpenOptions transact_options;
+  TENSORSTORE_RETURN_IF_ERROR(
+      tensorstore::internal::SetAll(transact_options, std::forward<Option>(options)...));
+  return CreateVariable<T, R, M>(json_spec, json_var, std::move(transact_options));
+}
+
 /**
  * @brief Opens a Variable from a JSON specification.
  * Provide an Open method for an existing file...
@@ -561,9 +581,9 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
  * Variable.
  */
 template <typename T = void, DimensionIndex R = dynamic_rank,
-          ReadWriteMode M = ReadWriteMode::dynamic, typename... Option>
+          ReadWriteMode M = ReadWriteMode::dynamic>
 Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
-                                       Option&&... options) {
+                                       TransactionalOpenOptions&& options) {
   // Infer the name from the path
   std::string variable_name = json_store["kvstore"]["path"].get<std::string>();
   std::vector<std::string> pathComponents = absl::StrSplit(variable_name, "/");
@@ -588,14 +608,18 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
   // option. store_spec["recheck_cached_data"] = false;  // This could become
   // problematic if we are doing read/write operations.
 
+  // Extract context directly from TransactionalOpenOptions
+  tensorstore::Context context = options.context;
+  tensorstore::OpenMode open_mode = options.open_mode;
+
   auto spec = tensorstore::MakeReadyFuture<::nlohmann::json>(store_spec);
 
-  // open a store:
+  // open a store with explicit context for credentials
   auto future_store =
-      tensorstore::Open<T, R, M>(store_spec, std::forward<Option>(options)...);
+      tensorstore::Open<T, R, M>(store_spec, context, open_mode);
 
-  // start by creating a kvstore future ...
-  auto kvs_future = tensorstore::kvstore::Open(store_spec["kvstore"]);
+  // start by creating a kvstore future with context for credentials
+  auto kvs_future = tensorstore::kvstore::Open(store_spec["kvstore"], context);
 
   // Detect Zarr version from the store spec
   zarr::ZarrVersion zarr_version = zarr::GetVersionFromSpec(store_spec);
@@ -739,7 +763,11 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
           // store_spec["open_as_void"] = true;
           auto cpy = json_store;
           cpy["open_as_void"] = true;
-          return OpenVariable<T, R, M>(cpy, std::forward<Option>(options)...);
+          // Reconstruct options for the recursive call
+          TransactionalOpenOptions retry_options;
+          retry_options.context = context;
+          retry_options.open_mode = open_mode;
+          return OpenVariable<T, R, M>(cpy, std::move(retry_options));
       }
   }
 
@@ -748,6 +776,20 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
       tensorstore::MakeReadyFuture<::nlohmann::json>(suppliedAttributes));
 }
 
+/**
+ * @brief Opens a Variable from a JSON specification (variadic options version).
+ * This overload accepts individual options and converts them to TransactionalOpenOptions.
+ */
+template <typename T = void, DimensionIndex R = dynamic_rank,
+          ReadWriteMode M = ReadWriteMode::dynamic, typename... Option>
+Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
+                                       Option&&... options) {
+  TransactionalOpenOptions transact_options;
+  TENSORSTORE_RETURN_IF_ERROR(
+      tensorstore::internal::SetAll(transact_options, std::forward<Option>(options)...));
+  return OpenVariable<T, R, M>(json_store, std::move(transact_options));
+}
+
 /**
  * @brief Opens or creates a Variable object from a JSON specification.
  * Provide an Open method for an existing file...
diff --git a/mdio/zarr/zarr.h b/mdio/zarr/zarr.h
index abde076..18521bf 100644
--- a/mdio/zarr/zarr.h
+++ b/mdio/zarr/zarr.h
@@ -59,17 +59,20 @@ namespace zarr {
  * @param version The Zarr version to use.
  * @param dataset_metadata The metadata for the dataset.
  * @param json_variables The JSON variables.
+ * @param context Optional TensorStore context for credentials/configuration.
  * @return An `mdio::Future<void>` representing the asynchronous write.
  */
 inline Future<void> WriteDatasetMetadata(
     ZarrVersion version, const ::nlohmann::json& dataset_metadata,
-    const std::vector<::nlohmann::json>& json_variables) {
+    const std::vector<::nlohmann::json>& json_variables,
+    tensorstore::Context context = tensorstore::Context::Default()) {
   switch (version) {
     case ZarrVersion::kV3:
-      return v3::WriteMetadata(dataset_metadata, json_variables);
+      return v3::WriteMetadata(dataset_metadata, json_variables, context);
     case ZarrVersion::kV2:
     default:
-      return v2::WriteConsolidatedMetadata(dataset_metadata, json_variables);
+      return v2::WriteConsolidatedMetadata(dataset_metadata, json_variables,
+                                           context);
   }
 }
 
diff --git a/mdio/zarr/zarr_v2.h b/mdio/zarr/zarr_v2.h
index 7db6059..70d151d 100644
--- a/mdio/zarr/zarr_v2.h
+++ b/mdio/zarr/zarr_v2.h
@@ -176,11 +176,13 @@ inline nlohmann::json PrepareVariableAttributes(const nlohmann::json& json) {
  *
  * @param dataset_metadata The metadata for the dataset.
  * @param json_variables The JSON variables.
+ * @param context Optional TensorStore context for credentials/configuration.
  * @return An `mdio::Future<void>` representing the asynchronous write.
  */
 inline Future<void> WriteConsolidatedMetadata(
     const ::nlohmann::json& dataset_metadata,
-    const std::vector<::nlohmann::json>& json_variables) {
+    const std::vector<::nlohmann::json>& json_variables,
+    tensorstore::Context context = tensorstore::Context::Default()) {
   auto zattrs = dataset_metadata;
   ::nlohmann::json zgroup = CreateZgroup();
 
@@ -223,7 +225,7 @@ inline Future<void> WriteConsolidatedMetadata(
     kvstore["path"] = cloudPath;
   }
 
-  auto kvs_future = tensorstore::kvstore::Open(kvstore);
+  auto kvs_future = tensorstore::kvstore::Open(kvstore, context);
 
   auto zattrs_future = tensorstore::MapFutureValue(
       tensorstore::InlineExecutor{},
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index d94af6e..4ea8dec 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -216,11 +216,13 @@ inline nlohmann::json PrepareVariableAttributes(const nlohmann::json& json) {
  *
  * @param dataset_metadata The metadata for the dataset.
  * @param json_variables The JSON variables.
+ * @param context Optional TensorStore context for credentials/configuration.
  * @return An `mdio::Future<void>` representing the asynchronous write.
  */
 inline Future<void> WriteMetadata(
     const ::nlohmann::json& dataset_metadata,
-    const std::vector<::nlohmann::json>& json_variables) {
+    const std::vector<::nlohmann::json>& json_variables,
+    tensorstore::Context context = tensorstore::Context::Default()) {
   // Determine the base path and driver
   std::string driver =
       json_variables[0]["kvstore"]["driver"].get<std::string>();
@@ -246,7 +248,7 @@ inline Future<void> WriteMetadata(
         json_variables[0]["kvstore"]["bucket"].get<std::string>();
   }
 
-  auto kvs_future = tensorstore::kvstore::Open(kvstore);
+  auto kvs_future = tensorstore::kvstore::Open(kvstore, context);
 
   // Extract variable names from json_variables for discovery
   nlohmann::json var_names = nlohmann::json::array();

From fbf46af40b99ddeba780bc315d14bdad0f62b9a9 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Tue, 30 Dec 2025 20:31:12 +0000
Subject: [PATCH 14/26] Add optional code coverage and begin expanding coverage

---
 CMakeLists.txt                       |   2 +
 cmake/CMakeHelpers/MdioHelpers.cmake |   6 +
 cmake/CodeCoverage.cmake             | 166 ++++++++++++++++++++++++++
 mdio/acceptance_test.cc              |  56 +++++++++
 mdio/dataset_factory_test.cc         | 168 +++++++++++++++++++++++++++
 mdio/dataset_test.cc                 |  78 +++++++++++++
 mdio/stats_test.cc                   |  92 +++++++++++++++
 mdio/zarr/zarr_test.cc               | 153 ++++++++++++++++++++++++
 8 files changed, 721 insertions(+)
 create mode 100644 cmake/CodeCoverage.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f990dcb..ce31c4a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -75,6 +75,8 @@ include(CMakeDependentOption)
 # provides a method to download dependencies:
 include(FetchContent)
 include(CMakeHelpers/MdioHelpers)
+# optional code coverage support:
+include(CodeCoverage)
 
 list(APPEND mdio_DEFAULT_COPTS
     "-Wno-deprecated-declarations"
diff --git a/cmake/CMakeHelpers/MdioHelpers.cmake b/cmake/CMakeHelpers/MdioHelpers.cmake
index c2162d7..e51b49f 100644
--- a/cmake/CMakeHelpers/MdioHelpers.cmake
+++ b/cmake/CMakeHelpers/MdioHelpers.cmake
@@ -297,6 +297,12 @@ function(mdio_cc_test)
     PRIVATE ${mdio_CC_TEST_COPTS}
   )
 
+  # Add coverage flags only to mdio test targets (not dependencies)
+  if(MDIO_ENABLE_COVERAGE)
+    target_compile_options(${_NAME} PRIVATE ${MDIO_COVERAGE_COMPILE_FLAGS})
+    target_link_options(${_NAME} PRIVATE ${MDIO_COVERAGE_LINK_FLAGS})
+  endif()
+
   target_link_libraries(${_NAME}
     PUBLIC ${mdio_CC_TEST_DEPS}
     PRIVATE ${mdio_CC_TEST_LINKOPTS}
diff --git a/cmake/CodeCoverage.cmake b/cmake/CodeCoverage.cmake
new file mode 100644
index 0000000..120da7f
--- /dev/null
+++ b/cmake/CodeCoverage.cmake
@@ -0,0 +1,166 @@
+# Copyright 2024 TGS
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ==============================================================================
+# Code Coverage Support (gcov + lcov)
+# ==============================================================================
+#
+# Coverage instrumentation is applied ONLY to mdio test targets, not to
+# dependencies like Tensorstore. This keeps build times and test execution fast.
+#
+# REQUIRED CMAKE FLAGS:
+#   -DMDIO_ENABLE_COVERAGE=ON    Enable coverage instrumentation
+#   -DCMAKE_BUILD_TYPE=Debug     Recommended for meaningful line coverage
+#
+# REQUIRED SYSTEM TOOLS:
+#   - gcov   (usually bundled with GCC)
+#   - lcov   (install via: apt install lcov / brew install lcov)
+#   - genhtml (included with lcov)
+#
+# USAGE:
+#   1. Configure and build with coverage enabled:
+#        cd build
+#        cmake .. -DMDIO_ENABLE_COVERAGE=ON -DCMAKE_BUILD_TYPE=Debug
+#        make
+#
+#   2. Run tests to generate coverage data (coverage accumulates across runs):
+#        ./mdio/mdio_variable_test                              # single test
+#        ./mdio/mdio_variable_test && ./mdio/mdio_dataset_test  # multiple tests
+#        ctest                                                  # all registered tests
+#
+#   3. Generate HTML coverage report:
+#        make coverage-capture
+#
+#   4. View the report:
+#        Open build/coverage_report/index.html in a browser
+#
+# AVAILABLE TARGETS:
+#   make coverage         - Reset counters, capture data, generate report
+#   make coverage-capture - Capture current data and generate report (no reset)
+#   make coverage-reset   - Zero out all coverage counters
+#
+# ==============================================================================
+
+option(MDIO_ENABLE_COVERAGE "Enable code coverage instrumentation (requires GCC or Clang)" OFF)
+
+if(MDIO_ENABLE_COVERAGE)
+  message(STATUS "Code coverage enabled")
+
+  # Check for supported compiler
+  if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    message(FATAL_ERROR "Code coverage requires GCC or Clang compiler")
+  endif()
+
+  # Coverage compiler/linker flags - exported for use in MdioHelpers.cmake
+  # These are applied only to mdio targets, not to dependencies like Tensorstore
+  set(MDIO_COVERAGE_COMPILE_FLAGS "-fprofile-arcs;-ftest-coverage" CACHE INTERNAL "Coverage compile flags")
+  set(MDIO_COVERAGE_LINK_FLAGS "--coverage" CACHE INTERNAL "Coverage link flags")
+
+  # Find required tools
+  find_program(LCOV_PATH lcov)
+  find_program(GENHTML_PATH genhtml)
+
+  if(NOT LCOV_PATH)
+    message(WARNING "lcov not found - coverage report generation will not be available")
+  endif()
+
+  if(NOT GENHTML_PATH)
+    message(WARNING "genhtml not found - coverage report generation will not be available")
+  endif()
+
+  # Create coverage report target if tools are available
+  if(LCOV_PATH AND GENHTML_PATH)
+    # Custom target to generate coverage report
+    add_custom_target(coverage
+      COMMENT "Generating code coverage report..."
+
+      # Clear previous coverage data
+      COMMAND ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --zerocounters
+
+      # Run all tests (ctest must be run separately or you can uncomment below)
+      # COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure
+
+      # Capture coverage data
+      COMMAND ${LCOV_PATH} 
+        --directory ${CMAKE_BINARY_DIR}
+        --capture
+        --output-file ${CMAKE_BINARY_DIR}/coverage.info
+        --ignore-errors mismatch,negative
+
+      # Remove coverage data for external dependencies
+      COMMAND ${LCOV_PATH}
+        --remove ${CMAKE_BINARY_DIR}/coverage.info
+        '/usr/*'
+        '${CMAKE_BINARY_DIR}/_deps/*'
+        '*/googletest/*'
+        '*/gtest/*'
+        '*/gmock/*'
+        '*_test.cc'
+        --output-file ${CMAKE_BINARY_DIR}/coverage.info
+        --ignore-errors unused,negative
+
+      # Generate HTML report
+      COMMAND ${GENHTML_PATH}
+        ${CMAKE_BINARY_DIR}/coverage.info
+        --output-directory ${CMAKE_BINARY_DIR}/coverage_report
+        --title "MDIO Code Coverage"
+        --legend
+        --show-details
+
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+    )
+
+    # Target to just capture coverage (without zeroing first)
+    add_custom_target(coverage-capture
+      COMMENT "Capturing coverage data..."
+
+      COMMAND ${LCOV_PATH} 
+        --directory ${CMAKE_BINARY_DIR}
+        --capture
+        --output-file ${CMAKE_BINARY_DIR}/coverage.info
+        --ignore-errors mismatch,negative
+
+      COMMAND ${LCOV_PATH}
+        --remove ${CMAKE_BINARY_DIR}/coverage.info
+        '/usr/*'
+        '${CMAKE_BINARY_DIR}/_deps/*'
+        '*/googletest/*'
+        '*/gtest/*'
+        '*/gmock/*'
+        '*_test.cc'
+        --output-file ${CMAKE_BINARY_DIR}/coverage.info
+        --ignore-errors unused,negative
+
+      COMMAND ${GENHTML_PATH}
+        ${CMAKE_BINARY_DIR}/coverage.info
+        --output-directory ${CMAKE_BINARY_DIR}/coverage_report
+        --title "MDIO Code Coverage"
+        --legend
+        --show-details
+
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+    )
+
+    # Target to reset coverage counters
+    add_custom_target(coverage-reset
+      COMMENT "Resetting coverage counters..."
+      COMMAND ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --zerocounters
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+    )
+
+    message(STATUS "Coverage targets available: 'coverage', 'coverage-capture', 'coverage-reset'")
+    message(STATUS "Coverage report will be generated at: ${CMAKE_BINARY_DIR}/coverage_report/index.html")
+  endif()
+endif()
+
diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index 231620b..3d1cbce 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -542,6 +542,42 @@ TEST_P(VariableTest, SETUP) {
   auto f8 =
       mdio::internal::CreateVariable(f8Store, f8Metadata, std::move(options));
   ASSERT_TRUE(f8.status().ok()) << f8.status();
+
+  // Create u1 (uint8)
+  auto u1Spec = CreateTypedVariableSpec(version_, "u1", base_path_, "<u1",
+                                        "uint8", "1-byte unsigned integer test");
+  auto u1Schema = mdio::internal::ValidateAndProcessJson(u1Spec).value();
+  auto [u1Store, u1Metadata] = u1Schema;
+  auto u1 =
+      mdio::internal::CreateVariable(u1Store, u1Metadata, std::move(options));
+  ASSERT_TRUE(u1.status().ok()) << u1.status();
+
+  // Create u2 (uint16)
+  auto u2Spec = CreateTypedVariableSpec(version_, "u2", base_path_, "<u2",
+                                        "uint16", "2-byte unsigned integer test");
+  auto u2Schema = mdio::internal::ValidateAndProcessJson(u2Spec).value();
+  auto [u2Store, u2Metadata] = u2Schema;
+  auto u2 =
+      mdio::internal::CreateVariable(u2Store, u2Metadata, std::move(options));
+  ASSERT_TRUE(u2.status().ok()) << u2.status();
+
+  // Create u8 (uint64)
+  auto u8Spec = CreateTypedVariableSpec(version_, "u8", base_path_, "<u8",
+                                        "uint64", "8-byte unsigned integer test");
+  auto u8Schema = mdio::internal::ValidateAndProcessJson(u8Spec).value();
+  auto [u8Store, u8Metadata] = u8Schema;
+  auto u8 =
+      mdio::internal::CreateVariable(u8Store, u8Metadata, std::move(options));
+  ASSERT_TRUE(u8.status().ok()) << u8.status();
+
+  // Create b1 (bool)
+  auto b1Spec = CreateTypedVariableSpec(version_, "b1", base_path_, "|b1",
+                                        "bool", "boolean test");
+  auto b1Schema = mdio::internal::ValidateAndProcessJson(b1Spec).value();
+  auto [b1Store, b1Metadata] = b1Schema;
+  auto b1 =
+      mdio::internal::CreateVariable(b1Store, b1Metadata, std::move(options));
+  ASSERT_TRUE(b1.status().ok()) << b1.status();
 }
 
 TEST_P(VariableTest, open) {
@@ -708,6 +744,14 @@ TEST_P(VariableTest, dtype) {
                                    mdio::constants::kOpen);
   auto f8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f8", base_path_),
                                    mdio::constants::kOpen);
+  auto u1 = mdio::Variable<>::Open(CreateBaseSpec(version_, "u1", base_path_),
+                                   mdio::constants::kOpen);
+  auto u2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "u2", base_path_),
+                                   mdio::constants::kOpen);
+  auto u8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "u8", base_path_),
+                                   mdio::constants::kOpen);
+  auto b1 = mdio::Variable<>::Open(CreateBaseSpec(version_, "b1", base_path_),
+                                   mdio::constants::kOpen);
 
   ASSERT_TRUE(i2.status().ok()) << i2.status();
   ASSERT_TRUE(i4.status().ok()) << i4.status();
@@ -715,6 +759,10 @@ TEST_P(VariableTest, dtype) {
   ASSERT_TRUE(f2.status().ok()) << f2.status();
   ASSERT_TRUE(f4.status().ok()) << f4.status();
   ASSERT_TRUE(f8.status().ok()) << f8.status();
+  ASSERT_TRUE(u1.status().ok()) << u1.status();
+  ASSERT_TRUE(u2.status().ok()) << u2.status();
+  ASSERT_TRUE(u8.status().ok()) << u8.status();
+  ASSERT_TRUE(b1.status().ok()) << b1.status();
 
   EXPECT_EQ(i2.value().dtype(), mdio::constants::kInt16);
   EXPECT_EQ(i4.value().dtype(), mdio::constants::kInt32);
@@ -722,6 +770,10 @@ TEST_P(VariableTest, dtype) {
   EXPECT_EQ(f2.value().dtype(), mdio::constants::kFloat16);
   EXPECT_EQ(f4.value().dtype(), mdio::constants::kFloat32);
   EXPECT_EQ(f8.value().dtype(), mdio::constants::kFloat64);
+  EXPECT_EQ(u1.value().dtype(), mdio::constants::kUint8);
+  EXPECT_EQ(u2.value().dtype(), mdio::constants::kUint16);
+  EXPECT_EQ(u8.value().dtype(), mdio::constants::kUint64);
+  EXPECT_EQ(b1.value().dtype(), mdio::constants::kBool);
 }
 
 TEST_P(VariableTest, domain) {
@@ -741,6 +793,10 @@ TEST_P(VariableTest, TEARDOWN) {
   std::filesystem::remove_all(base_path_ + "/f2");
   std::filesystem::remove_all(base_path_ + "/f4");
   std::filesystem::remove_all(base_path_ + "/f8");
+  std::filesystem::remove_all(base_path_ + "/u1");
+  std::filesystem::remove_all(base_path_ + "/u2");
+  std::filesystem::remove_all(base_path_ + "/u8");
+  std::filesystem::remove_all(base_path_ + "/b1");
   ASSERT_TRUE(true);
 }
 
diff --git a/mdio/dataset_factory_test.cc b/mdio/dataset_factory_test.cc
index 1baf703..78fc493 100644
--- a/mdio/dataset_factory_test.cc
+++ b/mdio/dataset_factory_test.cc
@@ -646,4 +646,172 @@ TEST(Xarray, open) {
   }
 }
 
+TEST(EncodeBase64, basicEncoding) {
+  std::string input = "Hello, World!";
+  std::string encoded = encode_base64(input);
+  EXPECT_EQ(encoded, "SGVsbG8sIFdvcmxkIQ==");
+}
+
+TEST(EncodeBase64, emptyString) {
+  std::string input = "";
+  std::string encoded = encode_base64(input);
+  EXPECT_EQ(encoded, "");
+}
+
+TEST(EncodeBase64, binaryData) {
+  // Test with null bytes (as used for fill_value encoding)
+  std::string input(8, '\0');
+  std::string encoded = encode_base64(input);
+  EXPECT_EQ(encoded, "AAAAAAAAAAA=");
+}
+
+TEST(ToZarrDtype, unknownDtype) {
+  auto result = to_zarr_dtype("unknown_dtype");
+  ASSERT_FALSE(result.status().ok());
+  EXPECT_THAT(result.status().message(),
+              testing::HasSubstr("Unknown dtype"));
+}
+
+TEST(ToZarrDtype, validDtypes) {
+  EXPECT_TRUE(to_zarr_dtype("float32").status().ok());
+  EXPECT_TRUE(to_zarr_dtype("float64").status().ok());
+  EXPECT_TRUE(to_zarr_dtype("int32").status().ok());
+  EXPECT_TRUE(to_zarr_dtype("uint16").status().ok());
+  EXPECT_TRUE(to_zarr_dtype("bool").status().ok());
+}
+
+TEST(TransformCompressor, nonBloscCompressorV2) {
+  nlohmann::json input = {{"compressor", {{"name", "gzip"}}}};
+  nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
+  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
+  ASSERT_FALSE(status.ok());
+  EXPECT_THAT(status.message(), testing::HasSubstr("Only blosc compressor is supported"));
+}
+
+TEST(TransformCompressor, nonBloscCompressorV3) {
+  nlohmann::json input = {{"compressor", {{"name", "gzip"}}}};
+  nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
+  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV3);
+  ASSERT_FALSE(status.ok());
+  EXPECT_THAT(status.message(), testing::HasSubstr("Only blosc compressor is supported"));
+}
+
+TEST(TransformCompressor, missingCompressorName) {
+  nlohmann::json input = {{"compressor", {{"algorithm", "zstd"}}}};
+  nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
+  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
+  ASSERT_FALSE(status.ok());
+  EXPECT_THAT(status.message(), testing::HasSubstr("Compressor name must be specified"));
+}
+
+TEST(TransformCompressor, noCompressorV2) {
+  nlohmann::json input = nlohmann::json::object();
+  nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
+  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
+  ASSERT_TRUE(status.ok());
+  EXPECT_TRUE(variable["metadata"]["compressor"].is_null());
+}
+
+TEST(TransformMetadata, gcsPath) {
+  nlohmann::json variable = {{"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
+  auto status = transform_metadata("gs://my-bucket/path/to/dataset", variable);
+  ASSERT_TRUE(status.ok()) << status;
+  EXPECT_EQ(variable["kvstore"]["driver"], "gcs");
+  EXPECT_EQ(variable["kvstore"]["bucket"], "my-bucket");
+  EXPECT_THAT(variable["kvstore"]["path"].get<std::string>(),
+              testing::HasSubstr("path/to/dataset"));
+}
+
+TEST(TransformMetadata, s3Path) {
+  nlohmann::json variable = {{"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
+  auto status = transform_metadata("s3://my-bucket/path/to/dataset", variable);
+  ASSERT_TRUE(status.ok()) << status;
+  EXPECT_EQ(variable["kvstore"]["driver"], "s3");
+  EXPECT_EQ(variable["kvstore"]["bucket"], "my-bucket");
+  EXPECT_THAT(variable["kvstore"]["path"].get<std::string>(),
+              testing::HasSubstr("path/to/dataset"));
+}
+
+TEST(TransformMetadata, localPath) {
+  nlohmann::json variable = {{"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
+  auto status = transform_metadata("/local/path/to/dataset", variable);
+  ASSERT_TRUE(status.ok()) << status;
+  EXPECT_EQ(variable["kvstore"]["driver"], "file");
+  EXPECT_FALSE(variable["kvstore"].contains("bucket"));
+  EXPECT_THAT(variable["kvstore"]["path"].get<std::string>(),
+              testing::HasSubstr("/local/path/to/dataset"));
+}
+
+TEST(GetDimensions, conflictingSizes) {
+  nlohmann::json spec = R"({
+    "variables": [
+      {
+        "name": "var1",
+        "dimensions": [
+          {"name": "x", "size": 100}
+        ]
+      },
+      {
+        "name": "var2",
+        "dimensions": [
+          {"name": "x", "size": 200}
+        ]
+      }
+    ]
+  })"_json;
+  auto result = get_dimensions(spec);
+  ASSERT_FALSE(result.status().ok());
+  EXPECT_THAT(result.status().message(),
+              testing::HasSubstr("conflicting sizes"));
+}
+
+TEST(GetDimensions, consistentSizes) {
+  nlohmann::json spec = R"({
+    "variables": [
+      {
+        "name": "var1",
+        "dimensions": [
+          {"name": "x", "size": 100},
+          {"name": "y", "size": 50}
+        ]
+      },
+      {
+        "name": "var2",
+        "dimensions": [
+          {"name": "x", "size": 100}
+        ]
+      }
+    ]
+  })"_json;
+  auto result = get_dimensions(spec);
+  ASSERT_TRUE(result.status().ok()) << result.status();
+  auto dims = result.value();
+  EXPECT_EQ(dims["x"], 100);
+  EXPECT_EQ(dims["y"], 50);
+}
+
+TEST(Construct, explicitV3Version) {
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  auto res = Construct(j, "zarrs/v3_dataset", mdio::zarr::ZarrVersion::kV3);
+  ASSERT_TRUE(res.status().ok()) << res.status();
+
+  std::vector<nlohmann::json> variables = std::get<1>(res.value());
+  // All variables should use zarr3 driver
+  for (const auto& variable : variables) {
+    EXPECT_EQ(variable["driver"], "zarr3");
+  }
+}
+
+TEST(Construct, explicitV2Version) {
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  auto res = Construct(j, "zarrs/v2_dataset", mdio::zarr::ZarrVersion::kV2);
+  ASSERT_TRUE(res.status().ok()) << res.status();
+
+  std::vector<nlohmann::json> variables = std::get<1>(res.value());
+  // All variables should use zarr driver (V2)
+  for (const auto& variable : variables) {
+    EXPECT_EQ(variable["driver"], "zarr");
+  }
+}
+
 }  // namespace
diff --git a/mdio/dataset_test.cc b/mdio/dataset_test.cc
index 44d382b..1869921 100644
--- a/mdio/dataset_test.cc
+++ b/mdio/dataset_test.cc
@@ -1708,4 +1708,82 @@ TEST(DatasetVersionNullopt, fromJsonWithNulloptVersion) {
   std::filesystem::remove_all("zarrs/nullopt_version");
 }
 
+TEST(Dataset, iselWithEmptySlicesVector) {
+  auto json_vars = GetToyExample();
+  auto dataset = mdio::Dataset::from_json(json_vars, "zarrs/acceptance",
+                                          mdio::constants::kCreateClean);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+  auto ds = dataset.value();
+
+  std::vector<mdio::RangeDescriptor<mdio::Index>> emptySlices;
+  auto sliceRes = ds.isel(emptySlices);
+  ASSERT_FALSE(sliceRes.status().ok());
+  EXPECT_THAT(sliceRes.status().message(),
+              testing::HasSubstr("No slices provided"));
+}
+
+TEST(Dataset, selWithDimensionIndex) {
+  std::string path = "zarrs/selTester.mdio";
+  auto dsRes = makePopulated(path);
+  ASSERT_TRUE(dsRes.ok()) << dsRes.status();
+  auto ds = dsRes.value();
+
+  // Using an index instead of a dimension name should fail
+  // The RangeDescriptor with index 0 instead of "inline"
+  mdio::RangeDescriptor<mdio::dtypes::int32_t> indexDesc = {0, 2, 5, 1};
+
+  auto sliceRes = ds.sel(indexDesc);
+  ASSERT_FALSE(sliceRes.status().ok());
+  EXPECT_THAT(sliceRes.status().message(),
+              testing::HasSubstr("not found"));
+}
+
+TEST(Dataset, selWithRepeatedLabels) {
+  std::string path = "zarrs/selTester.mdio";
+  auto dsRes = makePopulated(path);
+  ASSERT_TRUE(dsRes.ok()) << dsRes.status();
+  auto ds = dsRes.value();
+
+  // Using the same label twice is invalid
+  mdio::ValueDescriptor<mdio::dtypes::int32_t> desc1 = {"inline", 1};
+  mdio::ValueDescriptor<mdio::dtypes::int32_t> desc2 = {"inline", 2};
+
+  auto sliceRes = ds.sel(desc1, desc2);
+  ASSERT_FALSE(sliceRes.status().ok());
+  EXPECT_THAT(sliceRes.status().message(),
+              testing::HasSubstr("not be repeated"));
+}
+
+TEST(Dataset, commitMetadataNoChanges) {
+  const std::string path = "zarrs/acceptance_no_commit";
+  std::filesystem::remove_all(path);
+  auto json_vars = GetToyExample();
+
+  auto datasetRes =
+      mdio::Dataset::from_json(json_vars, path, mdio::constants::kCreateClean);
+  ASSERT_TRUE(datasetRes.status().ok()) << datasetRes.status();
+  auto dataset = datasetRes.value();
+
+  auto commitRes = dataset.CommitMetadata();
+  ASSERT_FALSE(commitRes.status().ok());
+  EXPECT_THAT(commitRes.status().message(),
+              testing::HasSubstr("No variables were modified"));
+
+  std::filesystem::remove_all(path);
+}
+
+TEST(Dataset, selRangeWithSameStartStop) {
+  std::string path = "zarrs/selTester.mdio";
+  auto dsRes = makePopulated(path);
+  ASSERT_TRUE(dsRes.ok()) << dsRes.status();
+  auto ds = dsRes.value();
+
+  mdio::RangeDescriptor<mdio::dtypes::int32_t> rangeDesc = {"inline", 2, 2, 1};
+
+  auto sliceRes = ds.sel(rangeDesc);
+  ASSERT_FALSE(sliceRes.status().ok());
+  EXPECT_THAT(sliceRes.status().message(),
+              testing::HasSubstr("Start and stop values must be different"));
+}
+
 }  // namespace
diff --git a/mdio/stats_test.cc b/mdio/stats_test.cc
index 468c874..403cc8c 100644
--- a/mdio/stats_test.cc
+++ b/mdio/stats_test.cc
@@ -493,4 +493,96 @@ TEST(Units, unitsFromJsonString) {
   EXPECT_EQ(ua_json["unitsV1"], "rad");
 }
 
+TEST(HistogramTest, isBindable) {
+  EXPECT_TRUE(getCenterHist()->isBindable());
+  EXPECT_TRUE(getEdgeHist()->isBindable());
+}
+
+TEST(HistogramTest, fromJsonErrorPaths) {
+  nlohmann::json noParent = {{"binCenters", {1.0, 2.0}}, {"counts", {1, 2}}};
+  auto centered = mdio::internal::CenteredBinHistogram<float>({}, {});
+  EXPECT_FALSE(centered.FromJson(noParent).status().ok());
+
+  nlohmann::json noChild = {{"histogram", {{"counts", {1, 2}}}}};
+  EXPECT_FALSE(centered.FromJson(noChild).status().ok());
+
+  nlohmann::json edgeNoParent = {{"binEdges", {0.0, 1.0}}, {"binWidths", {1.0}}, {"counts", {1}}};
+  auto edge = mdio::internal::EdgeDefinedHistogram<float>({}, {}, {});
+  EXPECT_FALSE(edge.FromJson(edgeNoParent).status().ok());
+
+  nlohmann::json edgeNoChild = {{"histogram", {{"binEdges", {0.0, 1.0}}, {"counts", {1}}}}};
+  EXPECT_FALSE(edge.FromJson(edgeNoChild).status().ok());
+}
+
+TEST(SummaryStatsTest, fromJsonEdgeHistogramAndMissingHistogram) {
+  nlohmann::json edgeStats = {
+      {"count", 50}, {"min", -500.0}, {"max", 500.0}, {"sum", 100.0}, {"sumSquares", 5000.0},
+      {"histogram", {{"binEdges", {0.0, 1.0, 2.0}}, {"binWidths", {1.0, 1.0}}, {"counts", {10, 20}}}}};
+  auto statsRes = mdio::internal::SummaryStats::FromJson(edgeStats);
+  ASSERT_TRUE(statsRes.status().ok()) << statsRes.status();
+  EXPECT_TRUE(statsRes.value().getBindable()["histogram"].contains("binEdges"));
+
+  nlohmann::json noHist = {{"count", 100}, {"min", 0.0}, {"max", 100.0}, {"sum", 50.0}, {"sumSquares", 500.0}};
+  EXPECT_FALSE(mdio::internal::SummaryStats::FromJson(noHist).status().ok());
+}
+
+TEST(UserAttributesTest, fromVariableJson) {
+  nlohmann::json centered = {
+      {"name", "test"}, {"dataType", "float32"},
+      {"metadata", {{"statsV1", {{"count", 100}, {"min", -10.0}, {"max", 10.0}, {"sum", 50.0}, {"sumSquares", 500.0},
+                                 {"histogram", {{"binCenters", {-5.0, 0.0, 5.0}}, {"counts", {30, 40, 30}}}}}}}}};
+  auto centeredRes = mdio::UserAttributes::FromVariableJson(centered);
+  ASSERT_TRUE(centeredRes.status().ok()) << centeredRes.status();
+  EXPECT_EQ(centeredRes.value().ToJson()["statsV1"]["count"], 100);
+
+  nlohmann::json edge = {
+      {"name", "test"}, {"dataType", "float32"},
+      {"metadata", {{"statsV1", {{"count", 200}, {"min", 0.0}, {"max", 100.0}, {"sum", 5000.0}, {"sumSquares", 250000.0},
+                                 {"histogram", {{"binEdges", {0.0, 50.0, 100.0}}, {"binWidths", {50.0, 50.0}}, {"counts", {100, 100}}}}}}}}};
+  auto edgeRes = mdio::UserAttributes::FromVariableJson(edge);
+  ASSERT_TRUE(edgeRes.status().ok()) << edgeRes.status();
+  EXPECT_TRUE(edgeRes.value().ToJson()["statsV1"]["histogram"].contains("binEdges"));
+
+  nlohmann::json noMeta = {{"name", "simple"}, {"dataType", "int32"}};
+  auto noMetaRes = mdio::UserAttributes::FromVariableJson(noMeta);
+  ASSERT_TRUE(noMetaRes.status().ok()) << noMetaRes.status();
+  EXPECT_EQ(noMetaRes.value().ToJson(), nlohmann::json::object());
+}
+
+TEST(UserAttributesTest, accessors) {
+  nlohmann::json full = {
+      {"statsV1", {{"count", 100}, {"min", -1000.0}, {"max", 1000.0}, {"sum", 0.0}, {"sumSquares", 0.0},
+                   {"histogram", {{"binCenters", {1.0, 2.0}}, {"counts", {50, 50}}}}}},
+      {"unitsV1", {{"length", "m"}, {"time", "s"}}},
+      {"attributes", {{"foo", "bar"}, {"count", 42}}}};
+  auto fullRes = mdio::UserAttributes::FromJson(full);
+  ASSERT_TRUE(fullRes.status().ok()) << fullRes.status();
+  auto attrs = fullRes.value();
+  EXPECT_EQ(attrs.getStatsV1()["count"], 100);
+  EXPECT_EQ(attrs.getUnitsV1().size(), 2);
+  EXPECT_EQ(attrs.getAttrs()["foo"], "bar");
+
+  nlohmann::json empty = nlohmann::json::object();
+  auto emptyRes = mdio::UserAttributes::FromJson(empty);
+  ASSERT_TRUE(emptyRes.status().ok());
+  auto emptyAttrs = emptyRes.value();
+  EXPECT_TRUE(emptyAttrs.getStatsV1().empty());
+  EXPECT_TRUE(emptyAttrs.getUnitsV1().empty());
+  EXPECT_TRUE(emptyAttrs.getAttrs().empty());
+}
+
+TEST(UserAttributesTest, statsV1AsArray) {
+  nlohmann::json arrayStats = {
+      {"name", "test"},
+      {"metadata", {{"statsV1", {
+          {{"count", 10}, {"min", 0}, {"max", 100}, {"sum", 500}, {"sumSquares", 25000},
+           {"histogram", {{"binCenters", {1, 2, 3}}, {"counts", {3, 4, 3}}}}},
+          {{"count", 20}, {"min", 0}, {"max", 200}, {"sum", 1000}, {"sumSquares", 50000},
+           {"histogram", {{"binCenters", {1, 2, 3}}, {"counts", {6, 8, 6}}}}}}
+      }}}};
+  auto res = mdio::UserAttributes::FromVariableJson(arrayStats);
+  ASSERT_TRUE(res.status().ok()) << res.status();
+  EXPECT_EQ(res.value().ToJson()["statsV1"].size(), 2);
+}
+
 }  // namespace
diff --git a/mdio/zarr/zarr_test.cc b/mdio/zarr/zarr_test.cc
index 1aafe92..033c9a3 100644
--- a/mdio/zarr/zarr_test.cc
+++ b/mdio/zarr/zarr_test.cc
@@ -98,6 +98,57 @@ TEST(ZarrDriver, ParseVersion_Invalid) {
   EXPECT_FALSE(result.ok());
 }
 
+TEST(ZarrDriver, ParseVersion_InvalidType_Array) {
+  nlohmann::json version_spec = nlohmann::json::array({2, 3});
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  EXPECT_FALSE(result.ok());
+  EXPECT_THAT(result.status().message(),
+              testing::HasSubstr("Expected integer or string"));
+}
+
+TEST(ZarrDriver, ParseVersion_InvalidType_Object) {
+  nlohmann::json version_spec = {{"version", 2}};
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  EXPECT_FALSE(result.ok());
+  EXPECT_THAT(result.status().message(),
+              testing::HasSubstr("Expected integer or string"));
+}
+
+TEST(ZarrDriver, ParseVersion_InvalidType_Null) {
+  nlohmann::json version_spec = nullptr;
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  EXPECT_FALSE(result.ok());
+  EXPECT_THAT(result.status().message(),
+              testing::HasSubstr("Expected integer or string"));
+}
+
+TEST(ZarrDriver, ParseVersion_InvalidType_Boolean) {
+  nlohmann::json version_spec = true;
+  auto result = mdio::zarr::ParseVersion(version_spec);
+  EXPECT_FALSE(result.ok());
+  EXPECT_THAT(result.status().message(),
+              testing::HasSubstr("Expected integer or string"));
+}
+
+TEST(ZarrDriver, ZarrConfig_DefaultValues) {
+  mdio::zarr::ZarrConfig config;
+
+  EXPECT_EQ(config.version, mdio::zarr::ZarrVersion::kV2);
+  EXPECT_TRUE(config.use_consolidated_metadata);
+  EXPECT_EQ(config.dimension_separator, "/");
+}
+
+TEST(ZarrDriver, ZarrConfig_CustomValues) {
+  mdio::zarr::ZarrConfig config;
+  config.version = mdio::zarr::ZarrVersion::kV3;
+  config.use_consolidated_metadata = false;
+  config.dimension_separator = ".";
+
+  EXPECT_EQ(config.version, mdio::zarr::ZarrVersion::kV3);
+  EXPECT_FALSE(config.use_consolidated_metadata);
+  EXPECT_EQ(config.dimension_separator, ".");
+}
+
 TEST(ZarrDriver, SupportsConsolidatedMetadata_V2) {
   EXPECT_TRUE(
       mdio::zarr::SupportsConsolidatedMetadata(mdio::zarr::ZarrVersion::kV2));
@@ -304,6 +355,108 @@ TEST(ZarrV2, PrepareVariableAttributes) {
   EXPECT_FALSE(attrs.contains("chunkGrid"));
 }
 
+TEST(ZarrV2, GetZarray_WithDefaults) {
+  // Test GetZarray with minimal metadata - should apply defaults
+  nlohmann::json input = {
+      {"metadata", {{"shape", {100, 200}}, {"dtype", "<f4"}}}};
+  auto result = mdio::zarr::v2::GetZarray(input);
+  ASSERT_TRUE(result.ok()) << result.status();
+
+  auto zarray = result.value();
+  EXPECT_EQ(zarray["order"], "C");
+  EXPECT_TRUE(zarray["filters"].is_null());
+  EXPECT_TRUE(zarray["fill_value"].is_null());
+  EXPECT_EQ(zarray["zarr_format"], 2);
+  EXPECT_EQ(zarray["dimension_separator"], "/");
+  // chunks should default to shape when not provided
+  EXPECT_EQ(zarray["chunks"], zarray["shape"]);
+}
+
+TEST(ZarrV2, GetZarray_WithAllFields) {
+  nlohmann::json input = {
+      {"metadata",
+       {{"shape", {100, 200}},
+        {"dtype", "<f4"},
+        {"chunks", {50, 50}},
+        {"order", "F"},
+        {"fill_value", 0.0},
+        {"zarr_format", 2},
+        {"dimension_separator", "."},
+        {"compressor", {{"id", "blosc"}}}}}};
+  auto result = mdio::zarr::v2::GetZarray(input);
+  ASSERT_TRUE(result.ok()) << result.status();
+
+  auto zarray = result.value();
+  EXPECT_EQ(zarray["order"], "F");
+  EXPECT_EQ(zarray["dimension_separator"], ".");
+  EXPECT_EQ(zarray["chunks"][0], 50);
+  EXPECT_EQ(zarray["chunks"][1], 50);
+}
+
+TEST(ZarrV2, GetZarray_NoMetadataKey) {
+  // Test GetZarray without metadata key - should create empty metadata
+  nlohmann::json input = nlohmann::json::object();
+  // Note: This will fail because shape and dtype are required
+  // but it tests the metadata initialization path
+  auto result = mdio::zarr::v2::GetZarray(input);
+  // Should fail because shape/dtype are not provided
+  EXPECT_FALSE(result.ok());
+}
+
+TEST(ZarrV2, PrepareVariableAttributes_EmptyCoordinatesString) {
+  // Test with empty string coordinates - should be removed
+  nlohmann::json input = {
+      {"attributes",
+       {{"dimension_names", {"x", "y"}},
+        {"coordinates", ""},
+        {"long_name", "Test Variable"}}}};
+
+  auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
+
+  EXPECT_TRUE(attrs.contains("_ARRAY_DIMENSIONS"));
+  EXPECT_FALSE(attrs.contains("coordinates"));
+  EXPECT_TRUE(attrs.contains("long_name"));
+}
+
+TEST(ZarrV2, PrepareVariableAttributes_EmptyCoordinatesArray) {
+  // Test with empty array coordinates - should be removed
+  nlohmann::json input = {
+      {"attributes",
+       {{"dimension_names", {"x", "y"}},
+        {"coordinates", nlohmann::json::array()},
+        {"long_name", "Test Variable"}}}};
+
+  auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
+
+  EXPECT_TRUE(attrs.contains("_ARRAY_DIMENSIONS"));
+  EXPECT_FALSE(attrs.contains("coordinates"));
+}
+
+TEST(ZarrV2, PrepareVariableAttributes_ValidCoordinates) {
+  nlohmann::json input = {
+      {"attributes",
+       {{"dimension_names", {"x", "y"}},
+        {"coordinates", "cdp-x cdp-y"},
+        {"long_name", "Test Variable"}}}};
+
+  auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
+
+  EXPECT_TRUE(attrs.contains("coordinates"));
+  EXPECT_EQ(attrs["coordinates"], "cdp-x cdp-y");
+}
+
+TEST(ZarrV2, PrepareVariableAttributes_EmptyLongName) {
+  // Test with empty long_name - should be removed
+  nlohmann::json input = {
+      {"attributes",
+       {{"dimension_names", {"x", "y"}},
+        {"long_name", ""}}}};
+
+  auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
+
+  EXPECT_FALSE(attrs.contains("long_name"));
+}
+
 }  // namespace ZarrV2Tests
 
 // =============================================================================

From bd0906fef46a4f3e68ea1f535fdd30be304811e0 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 17:57:12 +0000
Subject: [PATCH 15/26] Expand meaningful test coverage

---
 mdio/zarr/zarr_test.cc | 93 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/mdio/zarr/zarr_test.cc b/mdio/zarr/zarr_test.cc
index 033c9a3..3eec146 100644
--- a/mdio/zarr/zarr_test.cc
+++ b/mdio/zarr/zarr_test.cc
@@ -17,7 +17,9 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <cstdlib>
 #include <filesystem>
+#include <fstream>
 #include <string>
 
 #include "tensorstore/kvstore/kvstore.h"
@@ -578,6 +580,97 @@ TEST(ZarrV3, ConvertToMdioMetadata) {
   EXPECT_TRUE(metadata.contains("key"));
 }
 
+TEST(ZarrV3, PrepareVariableAttributes_EmptyCoordinates) {
+  // Test empty string coordinates - should be removed (covers line 204)
+  nlohmann::json input = {
+      {"attributes",
+       {{"dimension_names", {"x", "y"}},
+        {"coordinates", ""},
+        {"long_name", "Test Variable"}}}};
+
+  auto attrs = mdio::zarr::v3::PrepareVariableAttributes(input);
+
+  EXPECT_TRUE(attrs.contains("_ARRAY_DIMENSIONS"));
+  EXPECT_FALSE(attrs.contains("coordinates"));
+  EXPECT_TRUE(attrs.contains("long_name"));
+
+  // Also test empty array coordinates
+  nlohmann::json input2 = {
+      {"attributes",
+       {{"dimension_names", {"x", "y"}},
+        {"coordinates", nlohmann::json::array()}}}};
+
+  auto attrs2 = mdio::zarr::v3::PrepareVariableAttributes(input2);
+  EXPECT_FALSE(attrs2.contains("coordinates"));
+}
+
+TEST(ZarrV3, ReadVariableAttributes) {
+  // Create a temporary directory with a zarr.json file
+  auto tmpDir = std::filesystem::temp_directory_path() /
+                ("zarr_v3_read_attrs_" + std::to_string(std::rand()));
+  std::filesystem::create_directories(tmpDir);
+
+  // Write a test zarr.json file
+  nlohmann::json test_zarr_json = {
+      {"zarr_format", 3},
+      {"node_type", "array"},
+      {"attributes",
+       {{"_ARRAY_DIMENSIONS", {"x", "y"}}, {"units", "meters"}}}};
+
+  std::ofstream out(tmpDir / "zarr.json");
+  out << test_zarr_json.dump(4);
+  out.close();
+
+  // Open KvStore - file driver needs trailing slash for directories
+  nlohmann::json kvstore_spec = {{"driver", "file"},
+                                 {"path", tmpDir.string() + "/"}};
+
+  auto kvs_result = tensorstore::kvstore::Open(kvstore_spec).result();
+  ASSERT_TRUE(kvs_result.ok()) << kvs_result.status();
+
+  auto attrs_future =
+      mdio::zarr::v3::ReadVariableAttributes(kvs_result.value());
+  auto attrs_result = attrs_future.result();
+  ASSERT_TRUE(attrs_result.ok()) << attrs_result.status();
+
+  auto attrs = attrs_result.value();
+  EXPECT_TRUE(attrs.contains("_ARRAY_DIMENSIONS"));
+  EXPECT_EQ(attrs["units"], "meters");
+
+  // Cleanup
+  std::filesystem::remove_all(tmpDir);
+}
+
+TEST(ZarrV3, ReadVariableAttributes_NoAttributesInFile) {
+  auto tmpDir = std::filesystem::temp_directory_path() /
+                ("zarr_v3_no_attrs_" + std::to_string(std::rand()));
+  std::filesystem::create_directories(tmpDir);
+
+  // Write zarr.json without attributes field
+  nlohmann::json test_zarr_json = {{"zarr_format", 3}, {"node_type", "array"}};
+
+  std::ofstream out(tmpDir / "zarr.json");
+  out << test_zarr_json.dump(4);
+  out.close();
+
+  // File driver needs trailing slash for directories
+  nlohmann::json kvstore_spec = {{"driver", "file"},
+                                 {"path", tmpDir.string() + "/"}};
+  auto kvs_result = tensorstore::kvstore::Open(kvstore_spec).result();
+  ASSERT_TRUE(kvs_result.ok()) << kvs_result.status();
+
+  auto attrs_future =
+      mdio::zarr::v3::ReadVariableAttributes(kvs_result.value());
+  auto attrs_result = attrs_future.result();
+  ASSERT_TRUE(attrs_result.ok()) << attrs_result.status();
+
+  // Should return empty object when no attributes field
+  EXPECT_TRUE(attrs_result.value().is_object());
+  EXPECT_TRUE(attrs_result.value().empty());
+
+  std::filesystem::remove_all(tmpDir);
+}
+
 }  // namespace ZarrV3Tests
 
 // =============================================================================

From 528cab716b59531aea9d2fee44f5187cb3b3a613 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 20:04:21 +0000
Subject: [PATCH 16/26] Formatting and linting

---
 mdio/acceptance_test.cc          | 48 ++++++++++--------
 mdio/coordinate_selector_test.cc |  9 ++--
 mdio/dataset.h                   |  9 ++--
 mdio/dataset_factory.h           |  7 ++-
 mdio/dataset_factory_test.cc     | 33 +++++++-----
 mdio/dataset_test.cc             | 16 +++---
 mdio/gcs_test.cc                 |  3 +-
 mdio/s3_test.cc                  |  7 ++-
 mdio/stats.h                     |  4 +-
 mdio/stats_test.cc               | 86 +++++++++++++++++++++++--------
 mdio/utils/delete_test.cc        | 15 +++---
 mdio/utils/trim.h                |  7 +--
 mdio/utils/trim_test.cc          | 15 +++---
 mdio/variable.h                  | 75 ++++++++++++++-------------
 mdio/variable_test.cc            | 18 ++++---
 mdio/zarr/zarr.h                 |  4 ++
 mdio/zarr/zarr_driver.h          | 10 ++--
 mdio/zarr/zarr_test.cc           | 87 +++++++++++++-------------------
 mdio/zarr/zarr_v2.h              | 35 ++++++-------
 mdio/zarr/zarr_v3.h              | 66 ++++++++++++------------
 20 files changed, 303 insertions(+), 251 deletions(-)

diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index 3d1cbce..7fa977c 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -61,7 +61,7 @@ std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
  */
 std::string GetBasePath(mdio::zarr::ZarrVersion version) {
   return version == mdio::zarr::ZarrVersion::kV3 ? "zarrs/acceptance_v3"
-                                                  : "zarrs/acceptance";
+                                                 : "zarrs/acceptance";
 }
 
 /**
@@ -485,7 +485,7 @@ class VariableTest : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
 TEST_P(VariableTest, SETUP) {
   // Ensure directory exists
   std::filesystem::create_directories(base_path_);
-  
+
   mdio::TransactionalOpenOptions options;
   auto opt = options.Set(std::move(mdio::constants::kCreateClean));
 
@@ -544,8 +544,9 @@ TEST_P(VariableTest, SETUP) {
   ASSERT_TRUE(f8.status().ok()) << f8.status();
 
   // Create u1 (uint8)
-  auto u1Spec = CreateTypedVariableSpec(version_, "u1", base_path_, "<u1",
-                                        "uint8", "1-byte unsigned integer test");
+  auto u1Spec =
+      CreateTypedVariableSpec(version_, "u1", base_path_, "<u1", "uint8",
+                              "1-byte unsigned integer test");
   auto u1Schema = mdio::internal::ValidateAndProcessJson(u1Spec).value();
   auto [u1Store, u1Metadata] = u1Schema;
   auto u1 =
@@ -553,8 +554,9 @@ TEST_P(VariableTest, SETUP) {
   ASSERT_TRUE(u1.status().ok()) << u1.status();
 
   // Create u2 (uint16)
-  auto u2Spec = CreateTypedVariableSpec(version_, "u2", base_path_, "<u2",
-                                        "uint16", "2-byte unsigned integer test");
+  auto u2Spec =
+      CreateTypedVariableSpec(version_, "u2", base_path_, "<u2", "uint16",
+                              "2-byte unsigned integer test");
   auto u2Schema = mdio::internal::ValidateAndProcessJson(u2Spec).value();
   auto [u2Store, u2Metadata] = u2Schema;
   auto u2 =
@@ -562,8 +564,9 @@ TEST_P(VariableTest, SETUP) {
   ASSERT_TRUE(u2.status().ok()) << u2.status();
 
   // Create u8 (uint64)
-  auto u8Spec = CreateTypedVariableSpec(version_, "u8", base_path_, "<u8",
-                                        "uint64", "8-byte unsigned integer test");
+  auto u8Spec =
+      CreateTypedVariableSpec(version_, "u8", base_path_, "<u8", "uint64",
+                              "8-byte unsigned integer test");
   auto u8Schema = mdio::internal::ValidateAndProcessJson(u8Spec).value();
   auto [u8Store, u8Metadata] = u8Schema;
   auto u8 =
@@ -837,7 +840,7 @@ class VariableDataTest
 TEST_P(VariableDataTest, SETUP) {
   // Ensure directory exists
   std::filesystem::create_directories(base_path_);
-  
+
   mdio::TransactionalOpenOptions options;
   auto opt = options.Set(std::move(mdio::constants::kCreateClean));
 
@@ -934,8 +937,9 @@ class DatasetTest : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
     version_ = GetParam();
     base_path_ = GetBasePath(version_);
     dataset_manifest_ = GetDatasetManifest(version_);
-    expected_var_count_ =
-        version_ == mdio::zarr::ZarrVersion::kV3 ? 8 : 9;  // V2 has struct array
+    expected_var_count_ = version_ == mdio::zarr::ZarrVersion::kV3
+                              ? 8
+                              : 9;  // V2 has struct array
   }
 
   mdio::zarr::ZarrVersion version_;
@@ -983,8 +987,8 @@ TEST_P(DatasetTest, condensed) {
 
   // Now test opening with just the path
   auto ds = mdio::Dataset::Open(base_path_, mdio::constants::kOpen);
-  ASSERT_TRUE(ds.status().ok()) << "Failed to open with trailing slash: "
-                                << ds.status();
+  ASSERT_TRUE(ds.status().ok())
+      << "Failed to open with trailing slash: " << ds.status();
 
   // Test without trailing slash
   std::string path_no_slash = base_path_;
@@ -992,8 +996,8 @@ TEST_P(DatasetTest, condensed) {
     path_no_slash.pop_back();
   }
   auto ds2 = mdio::Dataset::Open(path_no_slash, mdio::constants::kOpen);
-  ASSERT_TRUE(ds2.status().ok()) << "Failed to open without trailing slash: "
-                                 << ds2.status();
+  ASSERT_TRUE(ds2.status().ok())
+      << "Failed to open without trailing slash: " << ds2.status();
 }
 
 TEST_P(DatasetTest, read) {
@@ -1195,8 +1199,9 @@ TEST_P(DatasetTest, fromJson) {
   std::filesystem::remove_all(base_path_ + "/from_json_test");
 
   nlohmann::json j = nlohmann::json::parse(dataset_manifest_);
-  auto dataset = mdio::Dataset::from_json(j, base_path_ + "/from_json_test",
-                                          version_, mdio::constants::kCreateClean);
+  auto dataset =
+      mdio::Dataset::from_json(j, base_path_ + "/from_json_test", version_,
+                               mdio::constants::kCreateClean);
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
 
   std::vector<std::string> varList = dataset.value().variables.get_keys();
@@ -1519,9 +1524,9 @@ TEST(VariableV2Compat, zarrCompatibility) {
   auto opt = options.Set(std::move(mdio::constants::kCreateClean));
 
   std::vector<std::tuple<std::string, std::string, std::string>> vars = {
-      {"i2", "<i2", "2-byte integer"},   {"i4", "<i4", "4-byte integer"},
-      {"i8", "<i8", "8-byte integer"},   {"f2", "<f2", "2-byte float"},
-      {"f4", "<f4", "4-byte float"},     {"f8", "<f8", "8-byte float"},
+      {"i2", "<i2", "2-byte integer"}, {"i4", "<i4", "4-byte integer"},
+      {"i8", "<i8", "8-byte integer"}, {"f2", "<f2", "2-byte float"},
+      {"f4", "<f4", "4-byte float"},   {"f8", "<f8", "8-byte float"},
   };
 
   for (const auto& [name, dtype, long_name] : vars) {
@@ -1568,8 +1573,7 @@ TEST(VariableV2Compat, zarrCompatibility) {
   for (const auto& arg : args) {
     pid_t pid = fork();
     if (pid == 0) {
-      int result =
-          executePythonScript(srcPath, {"zarrs/compat_test/" + arg});
+      int result = executePythonScript(srcPath, {"zarrs/compat_test/" + arg});
       if (result == 0xfd00) {
         GTEST_SKIP() << "Zarr compatibility skipped due to import error";
         exit(SUCCESS_CODE);
diff --git a/mdio/coordinate_selector_test.cc b/mdio/coordinate_selector_test.cc
index f47c2ee..7652daa 100644
--- a/mdio/coordinate_selector_test.cc
+++ b/mdio/coordinate_selector_test.cc
@@ -55,9 +55,8 @@ std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
  * @brief Returns the base path for test data based on Zarr version.
  */
 std::string GetBasePath(mdio::zarr::ZarrVersion version) {
-  return version == mdio::zarr::ZarrVersion::kV3
-             ? "generic_with_coords_v3.mdio"
-             : "generic_with_coords.mdio";
+  return version == mdio::zarr::ZarrVersion::kV3 ? "generic_with_coords_v3.mdio"
+                                                 : "generic_with_coords.mdio";
 }
 
 mdio::Result<std::string> SetupDataset(
@@ -159,8 +158,8 @@ mdio::Result<std::string> SetupDataset(
     })";
 
   auto schema = ::nlohmann::json::parse(schema_str);
-  auto dsFut =
-      mdio::Dataset::from_json(schema, ds_path, version, mdio::constants::kCreateClean);
+  auto dsFut = mdio::Dataset::from_json(schema, ds_path, version,
+                                        mdio::constants::kCreateClean);
   if (!dsFut.status().ok()) {
     return ds_path;
   }
diff --git a/mdio/dataset.h b/mdio/dataset.h
index af97192..44e20cd 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -151,9 +151,8 @@ inline Future<tensorstore::KvStore> dataset_kvs_store(
  * error on failure.
  */
 inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
-from_zmetadata(
-    const std::string& dataset_path,
-    tensorstore::Context context = tensorstore::Context::Default()) {
+from_zmetadata(const std::string& dataset_path,
+               tensorstore::Context context = tensorstore::Context::Default()) {
   auto kvs_future = mdio::internal::dataset_kvs_store(dataset_path, context);
 
   auto pair = tensorstore::PromiseFuturePair<
@@ -186,9 +185,7 @@ from_zmetadata(
                   [promise = std::move(promise)](
                       tensorstore::ReadyFuture<std::tuple<
                           ::nlohmann::json, std::vector<::nlohmann::json>>>
-                          result) {
-                    promise.SetResult(result.result());
-                  });
+                          result) { promise.SetResult(result.result()); });
             });
       });
 
diff --git a/mdio/dataset_factory.h b/mdio/dataset_factory.h
index 355d6cc..cd78082 100644
--- a/mdio/dataset_factory.h
+++ b/mdio/dataset_factory.h
@@ -22,13 +22,12 @@
 #include <unordered_map>
 #include <vector>
 
-#include "mdio/dataset_validator.h"
-#include "mdio/impl.h"
-#include "mdio/zarr/zarr.h"
-
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
+#include "mdio/dataset_validator.h"
+#include "mdio/impl.h"
+#include "mdio/zarr/zarr.h"
 
 /**
  * @brief Encodes a string in base64
diff --git a/mdio/dataset_factory_test.cc b/mdio/dataset_factory_test.cc
index 78fc493..9e3c16a 100644
--- a/mdio/dataset_factory_test.cc
+++ b/mdio/dataset_factory_test.cc
@@ -668,8 +668,7 @@ TEST(EncodeBase64, binaryData) {
 TEST(ToZarrDtype, unknownDtype) {
   auto result = to_zarr_dtype("unknown_dtype");
   ASSERT_FALSE(result.status().ok());
-  EXPECT_THAT(result.status().message(),
-              testing::HasSubstr("Unknown dtype"));
+  EXPECT_THAT(result.status().message(), testing::HasSubstr("Unknown dtype"));
 }
 
 TEST(ToZarrDtype, validDtypes) {
@@ -683,37 +682,45 @@ TEST(ToZarrDtype, validDtypes) {
 TEST(TransformCompressor, nonBloscCompressorV2) {
   nlohmann::json input = {{"compressor", {{"name", "gzip"}}}};
   nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
-  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
+  auto status =
+      transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
   ASSERT_FALSE(status.ok());
-  EXPECT_THAT(status.message(), testing::HasSubstr("Only blosc compressor is supported"));
+  EXPECT_THAT(status.message(),
+              testing::HasSubstr("Only blosc compressor is supported"));
 }
 
 TEST(TransformCompressor, nonBloscCompressorV3) {
   nlohmann::json input = {{"compressor", {{"name", "gzip"}}}};
   nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
-  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV3);
+  auto status =
+      transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV3);
   ASSERT_FALSE(status.ok());
-  EXPECT_THAT(status.message(), testing::HasSubstr("Only blosc compressor is supported"));
+  EXPECT_THAT(status.message(),
+              testing::HasSubstr("Only blosc compressor is supported"));
 }
 
 TEST(TransformCompressor, missingCompressorName) {
   nlohmann::json input = {{"compressor", {{"algorithm", "zstd"}}}};
   nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
-  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
+  auto status =
+      transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
   ASSERT_FALSE(status.ok());
-  EXPECT_THAT(status.message(), testing::HasSubstr("Compressor name must be specified"));
+  EXPECT_THAT(status.message(),
+              testing::HasSubstr("Compressor name must be specified"));
 }
 
 TEST(TransformCompressor, noCompressorV2) {
   nlohmann::json input = nlohmann::json::object();
   nlohmann::json variable = {{"metadata", nlohmann::json::object()}};
-  auto status = transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
+  auto status =
+      transform_compressor(input, variable, mdio::zarr::ZarrVersion::kV2);
   ASSERT_TRUE(status.ok());
   EXPECT_TRUE(variable["metadata"]["compressor"].is_null());
 }
 
 TEST(TransformMetadata, gcsPath) {
-  nlohmann::json variable = {{"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
+  nlohmann::json variable = {
+      {"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
   auto status = transform_metadata("gs://my-bucket/path/to/dataset", variable);
   ASSERT_TRUE(status.ok()) << status;
   EXPECT_EQ(variable["kvstore"]["driver"], "gcs");
@@ -723,7 +730,8 @@ TEST(TransformMetadata, gcsPath) {
 }
 
 TEST(TransformMetadata, s3Path) {
-  nlohmann::json variable = {{"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
+  nlohmann::json variable = {
+      {"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
   auto status = transform_metadata("s3://my-bucket/path/to/dataset", variable);
   ASSERT_TRUE(status.ok()) << status;
   EXPECT_EQ(variable["kvstore"]["driver"], "s3");
@@ -733,7 +741,8 @@ TEST(TransformMetadata, s3Path) {
 }
 
 TEST(TransformMetadata, localPath) {
-  nlohmann::json variable = {{"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
+  nlohmann::json variable = {
+      {"kvstore", {{"driver", "file"}, {"path", "myvar"}}}};
   auto status = transform_metadata("/local/path/to/dataset", variable);
   ASSERT_TRUE(status.ok()) << status;
   EXPECT_EQ(variable["kvstore"]["driver"], "file");
diff --git a/mdio/dataset_test.cc b/mdio/dataset_test.cc
index 1869921..35c41d4 100644
--- a/mdio/dataset_test.cc
+++ b/mdio/dataset_test.cc
@@ -54,11 +54,12 @@ std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
  */
 std::string GetBasePath(mdio::zarr::ZarrVersion version) {
   return version == mdio::zarr::ZarrVersion::kV3 ? "zarrs/dataset_test_v3"
-                                                  : "zarrs/dataset_test";
+                                                 : "zarrs/dataset_test";
 }
 
 /**
- * @brief Returns a schema without struct arrays (compatible with both V2 and V3).
+ * @brief Returns a schema without struct arrays (compatible with both V2 and
+ * V3).
  */
 ::nlohmann::json GetSimpleSchema() {
   std::string schema = R"(
@@ -1559,8 +1560,7 @@ TEST_P(DatasetVersionTest, fromJsonWithOptionalVersion) {
   auto json_vars = GetSimpleSchema();
 
   auto dataset = mdio::Dataset::from_json(
-      json_vars, base_path_,
-      std::optional<mdio::zarr::ZarrVersion>(version_),
+      json_vars, base_path_, std::optional<mdio::zarr::ZarrVersion>(version_),
       mdio::constants::kCreateClean);
 
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
@@ -1699,8 +1699,9 @@ TEST(DatasetVersionNullopt, fromJsonWithNulloptVersion) {
   auto json_vars = GetSimpleSchema();
 
   std::optional<mdio::zarr::ZarrVersion> version = std::nullopt;
-  auto dataset = mdio::Dataset::from_json(json_vars, "zarrs/nullopt_version",
-                                          version, mdio::constants::kCreateClean);
+  auto dataset =
+      mdio::Dataset::from_json(json_vars, "zarrs/nullopt_version", version,
+                               mdio::constants::kCreateClean);
 
   ASSERT_TRUE(dataset.status().ok()) << dataset.status();
   EXPECT_EQ(dataset.value().getMetadata()["name"], "simple_dataset");
@@ -1734,8 +1735,7 @@ TEST(Dataset, selWithDimensionIndex) {
 
   auto sliceRes = ds.sel(indexDesc);
   ASSERT_FALSE(sliceRes.status().ok());
-  EXPECT_THAT(sliceRes.status().message(),
-              testing::HasSubstr("not found"));
+  EXPECT_THAT(sliceRes.status().message(), testing::HasSubstr("not found"));
 }
 
 TEST(Dataset, selWithRepeatedLabels) {
diff --git a/mdio/gcs_test.cc b/mdio/gcs_test.cc
index 4b00ac3..28506c5 100644
--- a/mdio/gcs_test.cc
+++ b/mdio/gcs_test.cc
@@ -40,7 +40,8 @@ std::string GetGcsPathSuffix(mdio::zarr::ZarrVersion version) {
 }
 
 /**
- * @brief Returns the manifest without struct arrays (compatible with both V2 and V3).
+ * @brief Returns the manifest without struct arrays (compatible with both V2
+ * and V3).
  */
 std::string GetSimpleManifest() {
   return R"(
diff --git a/mdio/s3_test.cc b/mdio/s3_test.cc
index 3c7d4d7..0af236d 100644
--- a/mdio/s3_test.cc
+++ b/mdio/s3_test.cc
@@ -17,7 +17,6 @@
 
 #include "absl/log/globals.h"
 #include "absl/log/initialize.h"
-
 #include "mdio/dataset.h"
 #include "mdio/zarr/zarr.h"
 
@@ -53,7 +52,8 @@ std::string GetS3PathSuffix(mdio::zarr::ZarrVersion version) {
 }
 
 /**
- * @brief Returns the manifest without struct arrays (compatible with both V2 and V3).
+ * @brief Returns the manifest without struct arrays (compatible with both V2
+ * and V3).
  */
 std::string GetSimpleManifest() {
   return R"(
@@ -456,8 +456,7 @@ TEST(S3, read) {
 // Parameterized S3 Tests for V2/V3
 // ============================================================================
 
-class S3VersionTest
-    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+class S3VersionTest : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
  protected:
   void SetUp() override {
     version_ = GetParam();
diff --git a/mdio/stats.h b/mdio/stats.h
index acbccdd..6e0d81a 100644
--- a/mdio/stats.h
+++ b/mdio/stats.h
@@ -416,8 +416,8 @@ class UserAttributes {
           auto statsJson = j["statsV1"];
           // statsV1 may be stored as a serialized JSON string in some
           // third-party Zarr stores; parse it if needed.
-          auto parse_if_string = [](const nlohmann::json& val)
-              -> mdio::Result<nlohmann::json> {
+          auto parse_if_string =
+              [](const nlohmann::json& val) -> mdio::Result<nlohmann::json> {
             if (val.is_string()) {
               try {
                 return nlohmann::json::parse(val.get<std::string>());
diff --git a/mdio/stats_test.cc b/mdio/stats_test.cc
index 403cc8c..c75bbd0 100644
--- a/mdio/stats_test.cc
+++ b/mdio/stats_test.cc
@@ -506,42 +506,72 @@ TEST(HistogramTest, fromJsonErrorPaths) {
   nlohmann::json noChild = {{"histogram", {{"counts", {1, 2}}}}};
   EXPECT_FALSE(centered.FromJson(noChild).status().ok());
 
-  nlohmann::json edgeNoParent = {{"binEdges", {0.0, 1.0}}, {"binWidths", {1.0}}, {"counts", {1}}};
+  nlohmann::json edgeNoParent = {
+      {"binEdges", {0.0, 1.0}}, {"binWidths", {1.0}}, {"counts", {1}}};
   auto edge = mdio::internal::EdgeDefinedHistogram<float>({}, {}, {});
   EXPECT_FALSE(edge.FromJson(edgeNoParent).status().ok());
 
-  nlohmann::json edgeNoChild = {{"histogram", {{"binEdges", {0.0, 1.0}}, {"counts", {1}}}}};
+  nlohmann::json edgeNoChild = {
+      {"histogram", {{"binEdges", {0.0, 1.0}}, {"counts", {1}}}}};
   EXPECT_FALSE(edge.FromJson(edgeNoChild).status().ok());
 }
 
 TEST(SummaryStatsTest, fromJsonEdgeHistogramAndMissingHistogram) {
-  nlohmann::json edgeStats = {
-      {"count", 50}, {"min", -500.0}, {"max", 500.0}, {"sum", 100.0}, {"sumSquares", 5000.0},
-      {"histogram", {{"binEdges", {0.0, 1.0, 2.0}}, {"binWidths", {1.0, 1.0}}, {"counts", {10, 20}}}}};
+  nlohmann::json edgeStats = {{"count", 50},
+                              {"min", -500.0},
+                              {"max", 500.0},
+                              {"sum", 100.0},
+                              {"sumSquares", 5000.0},
+                              {"histogram",
+                               {{"binEdges", {0.0, 1.0, 2.0}},
+                                {"binWidths", {1.0, 1.0}},
+                                {"counts", {10, 20}}}}};
   auto statsRes = mdio::internal::SummaryStats::FromJson(edgeStats);
   ASSERT_TRUE(statsRes.status().ok()) << statsRes.status();
   EXPECT_TRUE(statsRes.value().getBindable()["histogram"].contains("binEdges"));
 
-  nlohmann::json noHist = {{"count", 100}, {"min", 0.0}, {"max", 100.0}, {"sum", 50.0}, {"sumSquares", 500.0}};
+  nlohmann::json noHist = {{"count", 100},
+                           {"min", 0.0},
+                           {"max", 100.0},
+                           {"sum", 50.0},
+                           {"sumSquares", 500.0}};
   EXPECT_FALSE(mdio::internal::SummaryStats::FromJson(noHist).status().ok());
 }
 
 TEST(UserAttributesTest, fromVariableJson) {
   nlohmann::json centered = {
-      {"name", "test"}, {"dataType", "float32"},
-      {"metadata", {{"statsV1", {{"count", 100}, {"min", -10.0}, {"max", 10.0}, {"sum", 50.0}, {"sumSquares", 500.0},
-                                 {"histogram", {{"binCenters", {-5.0, 0.0, 5.0}}, {"counts", {30, 40, 30}}}}}}}}};
+      {"name", "test"},
+      {"dataType", "float32"},
+      {"metadata",
+       {{"statsV1",
+         {{"count", 100},
+          {"min", -10.0},
+          {"max", 10.0},
+          {"sum", 50.0},
+          {"sumSquares", 500.0},
+          {"histogram",
+           {{"binCenters", {-5.0, 0.0, 5.0}}, {"counts", {30, 40, 30}}}}}}}}};
   auto centeredRes = mdio::UserAttributes::FromVariableJson(centered);
   ASSERT_TRUE(centeredRes.status().ok()) << centeredRes.status();
   EXPECT_EQ(centeredRes.value().ToJson()["statsV1"]["count"], 100);
 
-  nlohmann::json edge = {
-      {"name", "test"}, {"dataType", "float32"},
-      {"metadata", {{"statsV1", {{"count", 200}, {"min", 0.0}, {"max", 100.0}, {"sum", 5000.0}, {"sumSquares", 250000.0},
-                                 {"histogram", {{"binEdges", {0.0, 50.0, 100.0}}, {"binWidths", {50.0, 50.0}}, {"counts", {100, 100}}}}}}}}};
+  nlohmann::json edge = {{"name", "test"},
+                         {"dataType", "float32"},
+                         {"metadata",
+                          {{"statsV1",
+                            {{"count", 200},
+                             {"min", 0.0},
+                             {"max", 100.0},
+                             {"sum", 5000.0},
+                             {"sumSquares", 250000.0},
+                             {"histogram",
+                              {{"binEdges", {0.0, 50.0, 100.0}},
+                               {"binWidths", {50.0, 50.0}},
+                               {"counts", {100, 100}}}}}}}}};
   auto edgeRes = mdio::UserAttributes::FromVariableJson(edge);
   ASSERT_TRUE(edgeRes.status().ok()) << edgeRes.status();
-  EXPECT_TRUE(edgeRes.value().ToJson()["statsV1"]["histogram"].contains("binEdges"));
+  EXPECT_TRUE(
+      edgeRes.value().ToJson()["statsV1"]["histogram"].contains("binEdges"));
 
   nlohmann::json noMeta = {{"name", "simple"}, {"dataType", "int32"}};
   auto noMetaRes = mdio::UserAttributes::FromVariableJson(noMeta);
@@ -551,8 +581,13 @@ TEST(UserAttributesTest, fromVariableJson) {
 
 TEST(UserAttributesTest, accessors) {
   nlohmann::json full = {
-      {"statsV1", {{"count", 100}, {"min", -1000.0}, {"max", 1000.0}, {"sum", 0.0}, {"sumSquares", 0.0},
-                   {"histogram", {{"binCenters", {1.0, 2.0}}, {"counts", {50, 50}}}}}},
+      {"statsV1",
+       {{"count", 100},
+        {"min", -1000.0},
+        {"max", 1000.0},
+        {"sum", 0.0},
+        {"sumSquares", 0.0},
+        {"histogram", {{"binCenters", {1.0, 2.0}}, {"counts", {50, 50}}}}}},
       {"unitsV1", {{"length", "m"}, {"time", "s"}}},
       {"attributes", {{"foo", "bar"}, {"count", 42}}}};
   auto fullRes = mdio::UserAttributes::FromJson(full);
@@ -574,12 +609,21 @@ TEST(UserAttributesTest, accessors) {
 TEST(UserAttributesTest, statsV1AsArray) {
   nlohmann::json arrayStats = {
       {"name", "test"},
-      {"metadata", {{"statsV1", {
-          {{"count", 10}, {"min", 0}, {"max", 100}, {"sum", 500}, {"sumSquares", 25000},
+      {"metadata",
+       {{"statsV1",
+         {{{"count", 10},
+           {"min", 0},
+           {"max", 100},
+           {"sum", 500},
+           {"sumSquares", 25000},
            {"histogram", {{"binCenters", {1, 2, 3}}, {"counts", {3, 4, 3}}}}},
-          {{"count", 20}, {"min", 0}, {"max", 200}, {"sum", 1000}, {"sumSquares", 50000},
-           {"histogram", {{"binCenters", {1, 2, 3}}, {"counts", {6, 8, 6}}}}}}
-      }}}};
+          {{"count", 20},
+           {"min", 0},
+           {"max", 200},
+           {"sum", 1000},
+           {"sumSquares", 50000},
+           {"histogram",
+            {{"binCenters", {1, 2, 3}}, {"counts", {6, 8, 6}}}}}}}}}};
   auto res = mdio::UserAttributes::FromVariableJson(arrayStats);
   ASSERT_TRUE(res.status().ok()) << res.status();
   EXPECT_EQ(res.value().ToJson()["statsV1"].size(), 2);
diff --git a/mdio/utils/delete_test.cc b/mdio/utils/delete_test.cc
index b50c0bf..7211588 100644
--- a/mdio/utils/delete_test.cc
+++ b/mdio/utils/delete_test.cc
@@ -44,13 +44,13 @@ std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
  * @brief Returns the base path for test data based on Zarr version.
  */
 std::string GetBasePath(mdio::zarr::ZarrVersion version) {
-  return version == mdio::zarr::ZarrVersion::kV3
-             ? "zarrs/testing/utils_v3.mdio"
-             : "zarrs/testing/utils.mdio";
+  return version == mdio::zarr::ZarrVersion::kV3 ? "zarrs/testing/utils_v3.mdio"
+                                                 : "zarrs/testing/utils.mdio";
 }
 
 /**
- * @brief Returns manifest without struct arrays (compatible with both V2 and V3).
+ * @brief Returns manifest without struct arrays (compatible with both V2 and
+ * V3).
  */
 std::string GetSimpleManifest() {
   return R"(
@@ -159,14 +159,15 @@ std::string GetSimpleManifest() {
 }
 
 /**
- * Sets up an inert dataset for testing destructive operations (V2/V3 compatible)
+ * Sets up an inert dataset for testing destructive operations (V2/V3
+ * compatible)
  */
 mdio::Future<mdio::Dataset> SETUP(
     const std::string& path,
     mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
   auto j = nlohmann::json::parse(GetSimpleManifest());
-  auto dsRes = mdio::Dataset::from_json(j, path, version,
-                                        mdio::constants::kCreateClean);
+  auto dsRes =
+      mdio::Dataset::from_json(j, path, version, mdio::constants::kCreateClean);
   return dsRes;
 }
 
diff --git a/mdio/utils/trim.h b/mdio/utils/trim.h
index f6645f6..8b831fd 100644
--- a/mdio/utils/trim.h
+++ b/mdio/utils/trim.h
@@ -43,9 +43,10 @@ namespace utils {
  * @return A future of the trim operation.
  */
 template <typename... Descriptors>
-Future<void> TrimDataset(
-    std::string dataset_path, bool delete_sliced_out_chunks,
-    tensorstore::Context context, const Descriptors&... descriptors) {
+Future<void> TrimDataset(std::string dataset_path,
+                         bool delete_sliced_out_chunks,
+                         tensorstore::Context context,
+                         const Descriptors&... descriptors) {
   // Open the dataset
   auto dsRes =
       mdio::Dataset::Open(dataset_path, mdio::constants::kOpen, context);
diff --git a/mdio/utils/trim_test.cc b/mdio/utils/trim_test.cc
index 96d7193..5ff5099 100644
--- a/mdio/utils/trim_test.cc
+++ b/mdio/utils/trim_test.cc
@@ -41,13 +41,13 @@ std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
  * @brief Returns the base path for test data based on Zarr version.
  */
 std::string GetBasePath(mdio::zarr::ZarrVersion version) {
-  return version == mdio::zarr::ZarrVersion::kV3
-             ? "zarrs/testing/trim_v3.mdio"
-             : "zarrs/testing/trim.mdio";
+  return version == mdio::zarr::ZarrVersion::kV3 ? "zarrs/testing/trim_v3.mdio"
+                                                 : "zarrs/testing/trim.mdio";
 }
 
 /**
- * @brief Returns manifest without struct arrays (compatible with both V2 and V3).
+ * @brief Returns manifest without struct arrays (compatible with both V2 and
+ * V3).
  */
 std::string GetSimpleManifest() {
   return R"(
@@ -167,14 +167,15 @@ std::string GetSimpleManifest() {
 }
 
 /**
- * Sets up an inert dataset for testing destructive operations (V2/V3 compatible)
+ * Sets up an inert dataset for testing destructive operations (V2/V3
+ * compatible)
  */
 mdio::Future<mdio::Dataset> SETUP(
     const std::string& path,
     mdio::zarr::ZarrVersion version = mdio::zarr::ZarrVersion::kV2) {
   auto j = nlohmann::json::parse(GetSimpleManifest());
-  auto dsRes = mdio::Dataset::from_json(j, path, version,
-                                        mdio::constants::kCreateClean);
+  auto dsRes =
+      mdio::Dataset::from_json(j, path, version, mdio::constants::kCreateClean);
   return dsRes;
 }
 
diff --git a/mdio/variable.h b/mdio/variable.h
index 5470a9e..3958623 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -432,8 +432,9 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   bool has_data_type = json_spec["metadata"].contains("data_type");
 
   if (!has_dtype && !has_data_type) {
-    return absl::Status(absl::StatusCode::kInvalidArgument,
-                        "Variable metadata requires dtype (V2) or data_type (V3)");
+    return absl::Status(
+        absl::StatusCode::kInvalidArgument,
+        "Variable metadata requires dtype (V2) or data_type (V3)");
   }
 
   // For V3, we don't use ParseDType (which is V2-specific)
@@ -443,7 +444,7 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
 
   if (zarr_version == zarr::ZarrVersion::kV2 && has_dtype) {
     MDIO_ASSIGN_OR_RETURN(zarr_dtype, tensorstore::internal_zarr::ParseDType(
-                                               json_spec["metadata"]["dtype"]))
+                                          json_spec["metadata"]["dtype"]))
     // Handles the use case of creating a struct array, but intending to open as
     // void.
     do_handle_structarray =
@@ -465,9 +466,9 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   tensorstore::Context context = options.context;
   tensorstore::OpenMode open_mode = options.open_mode;
 
-  auto publish = [zarr_version, context](const ::nlohmann::json& json_var,
-                                bool isCloudStore,
-                                const tensorstore::TensorStore<T, R, M>& store)
+  auto publish = [zarr_version, context](
+                     const ::nlohmann::json& json_var, bool isCloudStore,
+                     const tensorstore::TensorStore<T, R, M>& store)
       -> Future<tensorstore::TimestampedStorageGeneration> {
     // Use version-specific attribute writing
     if (zarr_version == zarr::ZarrVersion::kV3) {
@@ -481,12 +482,12 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   // but this time as struct ... but we loose the capactity for forward options.
   // FIXME - strip "create/delete existing" and foward other options.
   auto apply_reopen = [context](const tensorstore::TensorStore<T, R, M>& store,
-                         const ::nlohmann::json& attributes,
-                         const ::nlohmann::json& json_spec) {
+                                const ::nlohmann::json& attributes,
+                                const ::nlohmann::json& json_spec) {
     // try {
     auto json_spec_cpy = json_spec;
-        json_spec_cpy.erase("field");
-        json_spec_cpy["open_as_void"] = true;
+    json_spec_cpy.erase("field");
+    json_spec_cpy["open_as_void"] = true;
     // } catch (ex)
     return tensorstore::Open<T, R, M>(json_spec_cpy, context,
                                       tensorstore::OpenMode::open);
@@ -510,8 +511,8 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
   };
 
   // Start by creating a future for the store with explicit context
-  auto future_store = tensorstore::Open<T, R, M>(
-      json_spec_with_open_flag, context, open_mode);
+  auto future_store =
+      tensorstore::Open<T, R, M>(json_spec_with_open_flag, context, open_mode);
 
   auto handled_store = future_store;
   if (do_handle_structarray) {
@@ -555,8 +556,9 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
 }
 
 /**
- * @brief Creates a Variable from a JSON specification (variadic options version).
- * This overload accepts individual options and converts them to TransactionalOpenOptions.
+ * @brief Creates a Variable from a JSON specification (variadic options
+ * version). This overload accepts individual options and converts them to
+ * TransactionalOpenOptions.
  */
 template <typename T = void, DimensionIndex R = dynamic_rank,
           ReadWriteMode M = ReadWriteMode::dynamic, typename... Option>
@@ -564,9 +566,10 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
                                          const nlohmann::json& json_var,
                                          Option&&... options) {
   TransactionalOpenOptions transact_options;
-  TENSORSTORE_RETURN_IF_ERROR(
-      tensorstore::internal::SetAll(transact_options, std::forward<Option>(options)...));
-  return CreateVariable<T, R, M>(json_spec, json_var, std::move(transact_options));
+  TENSORSTORE_RETURN_IF_ERROR(tensorstore::internal::SetAll(
+      transact_options, std::forward<Option>(options)...));
+  return CreateVariable<T, R, M>(json_spec, json_var,
+                                 std::move(transact_options));
 }
 
 /**
@@ -757,18 +760,21 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
                                               parse, kvs_read_future, spec);
 
   if (!future_store.status().ok()) {
-      std::string status_message = future_store.status().ToString();
-      if (status_message.find("Must specify a \"field\"") != std::string::npos && !store_spec.contains("open_as_void")) {
-          std::cout << "Detected a structured Variable without a field or void flag. Retrying with void flag..." << std::endl;
-          // store_spec["open_as_void"] = true;
-          auto cpy = json_store;
-          cpy["open_as_void"] = true;
-          // Reconstruct options for the recursive call
-          TransactionalOpenOptions retry_options;
-          retry_options.context = context;
-          retry_options.open_mode = open_mode;
-          return OpenVariable<T, R, M>(cpy, std::move(retry_options));
-      }
+    std::string status_message = future_store.status().ToString();
+    if (status_message.find("Must specify a \"field\"") != std::string::npos &&
+        !store_spec.contains("open_as_void")) {
+      std::cout << "Detected a structured Variable without a field or void "
+                   "flag. Retrying with void flag..."
+                << std::endl;
+      // store_spec["open_as_void"] = true;
+      auto cpy = json_store;
+      cpy["open_as_void"] = true;
+      // Reconstruct options for the recursive call
+      TransactionalOpenOptions retry_options;
+      retry_options.context = context;
+      retry_options.open_mode = open_mode;
+      return OpenVariable<T, R, M>(cpy, std::move(retry_options));
+    }
   }
 
   return tensorstore::MapFutureValue(
@@ -778,15 +784,16 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
 
 /**
  * @brief Opens a Variable from a JSON specification (variadic options version).
- * This overload accepts individual options and converts them to TransactionalOpenOptions.
+ * This overload accepts individual options and converts them to
+ * TransactionalOpenOptions.
  */
 template <typename T = void, DimensionIndex R = dynamic_rank,
           ReadWriteMode M = ReadWriteMode::dynamic, typename... Option>
 Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
                                        Option&&... options) {
   TransactionalOpenOptions transact_options;
-  TENSORSTORE_RETURN_IF_ERROR(
-      tensorstore::internal::SetAll(transact_options, std::forward<Option>(options)...));
+  TENSORSTORE_RETURN_IF_ERROR(tensorstore::internal::SetAll(
+      transact_options, std::forward<Option>(options)...));
   return OpenVariable<T, R, M>(json_store, std::move(transact_options));
 }
 
@@ -1272,11 +1279,11 @@ class Variable {
     const auto& metadata = json["metadata"];
 
     auto parse_chunk_array =
-        [](const nlohmann::json& chunk_json) -> Result<std::vector<long int>> {
+        [](const nlohmann::json& chunk_json) -> Result<std::vector<int64_t>> {
       if (!chunk_json.is_array()) {
         return absl::InvalidArgumentError("Chunk shape must be an array.");
       }
-      return chunk_json.get<std::vector<long int>>();  // NOLINT
+      return chunk_json.get<std::vector<int64_t>>();  // NOLINT
     };
 
     if (metadata.contains("chunks")) {
diff --git a/mdio/variable_test.cc b/mdio/variable_test.cc
index 60a8081..10bceca 100644
--- a/mdio/variable_test.cc
+++ b/mdio/variable_test.cc
@@ -50,7 +50,7 @@ std::string ZarrVersionToString(mdio::zarr::ZarrVersion version) {
  */
 std::string GetBasePath(mdio::zarr::ZarrVersion version) {
   return version == mdio::zarr::ZarrVersion::kV3 ? "variable_test_v3"
-                                                  : "variable_test";
+                                                 : "variable_test";
 }
 
 /**
@@ -343,10 +343,12 @@ TEST(Variable, structArray) {
   auto json_spec = GetJsonSpecStruct();
 
   // auto variable =
-  //     mdio::Variable<>::Open(json_spec, mdio::constants::kCreateClean).result();
-  auto varRes = mdio::Variable<>::Open(json_spec, mdio::constants::kCreateClean);
+  //     mdio::Variable<>::Open(json_spec,
+  //     mdio::constants::kCreateClean).result();
+  auto varRes =
+      mdio::Variable<>::Open(json_spec, mdio::constants::kCreateClean);
   if (!varRes.status().ok()) {
-      std::cout << varRes.status() << std::endl;
+    std::cout << varRes.status() << std::endl;
   }
   auto variable = varRes.result();
 
@@ -404,7 +406,7 @@ TEST(Variable, structArrayOpen) {
   // variable = mdio::Variable<>::Open(open_json_spec).result();
   auto varRes = mdio::Variable<>::Open(open_json_spec);
   if (!varRes.status().ok()) {
-      std::cout << varRes.status() << std::endl;
+    std::cout << varRes.status() << std::endl;
   }
   variable = varRes.result();
 
@@ -1428,8 +1430,7 @@ TEST_P(VariableVersionTest, readWrite) {
   ASSERT_TRUE(varDataRes.status().ok()) << varDataRes.status();
   auto varData = varDataRes.value();
 
-  auto data =
-      reinterpret_cast<int16_t*>(varData.get_data_accessor().data());
+  auto data = reinterpret_cast<int16_t*>(varData.get_data_accessor().data());
   data[0] = 1234;
   data[1] = 5678;
 
@@ -1461,7 +1462,8 @@ TEST_P(VariableVersionTest, getIntervals) {
 
 TEST_P(VariableVersionTest, outOfBoundsSlice) {
   auto spec = CreateTestVariableSpec(version_, base_path_);
-  auto var = mdio::Variable<>::Open(spec, mdio::constants::kCreateClean).result();
+  auto var =
+      mdio::Variable<>::Open(spec, mdio::constants::kCreateClean).result();
 
   ASSERT_TRUE(var.ok());
   EXPECT_THAT(var->dimensions().shape(), ::testing::ElementsAre(500, 500));
diff --git a/mdio/zarr/zarr.h b/mdio/zarr/zarr.h
index 18521bf..27377e0 100644
--- a/mdio/zarr/zarr.h
+++ b/mdio/zarr/zarr.h
@@ -43,6 +43,10 @@
  * @endcode
  */
 
+#include <string>
+#include <tuple>
+#include <vector>
+
 #include "mdio/zarr/zarr_driver.h"
 #include "mdio/zarr/zarr_v2.h"
 #include "mdio/zarr/zarr_v3.h"
diff --git a/mdio/zarr/zarr_driver.h b/mdio/zarr/zarr_driver.h
index 38ad23c..eb8459d 100644
--- a/mdio/zarr/zarr_driver.h
+++ b/mdio/zarr/zarr_driver.h
@@ -16,6 +16,7 @@
 #define MDIO_ZARR_ZARR_DRIVER_H_
 
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "mdio/impl.h"
@@ -93,17 +94,16 @@ inline Result<ZarrVersion> ParseVersion(const nlohmann::json& version_spec) {
  * @return Future<ZarrVersion> The detected version or an error if unable to
  * determine.
  */
-inline Future<ZarrVersion> DetectVersion(
-    const tensorstore::KvStore& kvstore) {
+inline Future<ZarrVersion> DetectVersion(const tensorstore::KvStore& kvstore) {
   // Check for zarr.json first (V3 indicator)
   auto v3_check = tensorstore::kvstore::Read(kvstore, "zarr.json");
 
   auto pair = tensorstore::PromiseFuturePair<ZarrVersion>::Make();
 
   v3_check.ExecuteWhenReady(
-      [promise = pair.promise, kvstore](
-          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
-              v3_result) mutable {
+      [promise = pair.promise,
+       kvstore](tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+                    v3_result) mutable {
         if (v3_result.result().ok() && v3_result.value().has_value()) {
           promise.SetResult(ZarrVersion::kV3);
           return;
diff --git a/mdio/zarr/zarr_test.cc b/mdio/zarr/zarr_test.cc
index 3eec146..be19f8b 100644
--- a/mdio/zarr/zarr_test.cc
+++ b/mdio/zarr/zarr_test.cc
@@ -21,6 +21,7 @@
 #include <filesystem>
 #include <fstream>
 #include <string>
+#include <vector>
 
 #include "tensorstore/kvstore/kvstore.h"
 #include "tensorstore/kvstore/operations.h"
@@ -223,9 +224,7 @@ TEST(ZarrDriver, GetConsolidatedMetadataFileName) {
 
 namespace ZarrV2Tests {
 
-TEST(ZarrV2, DriverName) {
-  EXPECT_EQ(mdio::zarr::v2::kDriverName, "zarr");
-}
+TEST(ZarrV2, DriverName) { EXPECT_EQ(mdio::zarr::v2::kDriverName, "zarr"); }
 
 TEST(ZarrV2, ZarrFormat) { EXPECT_EQ(mdio::zarr::v2::kZarrFormat, 2); }
 
@@ -375,16 +374,15 @@ TEST(ZarrV2, GetZarray_WithDefaults) {
 }
 
 TEST(ZarrV2, GetZarray_WithAllFields) {
-  nlohmann::json input = {
-      {"metadata",
-       {{"shape", {100, 200}},
-        {"dtype", "<f4"},
-        {"chunks", {50, 50}},
-        {"order", "F"},
-        {"fill_value", 0.0},
-        {"zarr_format", 2},
-        {"dimension_separator", "."},
-        {"compressor", {{"id", "blosc"}}}}}};
+  nlohmann::json input = {{"metadata",
+                           {{"shape", {100, 200}},
+                            {"dtype", "<f4"},
+                            {"chunks", {50, 50}},
+                            {"order", "F"},
+                            {"fill_value", 0.0},
+                            {"zarr_format", 2},
+                            {"dimension_separator", "."},
+                            {"compressor", {{"id", "blosc"}}}}}};
   auto result = mdio::zarr::v2::GetZarray(input);
   ASSERT_TRUE(result.ok()) << result.status();
 
@@ -407,11 +405,10 @@ TEST(ZarrV2, GetZarray_NoMetadataKey) {
 
 TEST(ZarrV2, PrepareVariableAttributes_EmptyCoordinatesString) {
   // Test with empty string coordinates - should be removed
-  nlohmann::json input = {
-      {"attributes",
-       {{"dimension_names", {"x", "y"}},
-        {"coordinates", ""},
-        {"long_name", "Test Variable"}}}};
+  nlohmann::json input = {{"attributes",
+                           {{"dimension_names", {"x", "y"}},
+                            {"coordinates", ""},
+                            {"long_name", "Test Variable"}}}};
 
   auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
 
@@ -422,11 +419,10 @@ TEST(ZarrV2, PrepareVariableAttributes_EmptyCoordinatesString) {
 
 TEST(ZarrV2, PrepareVariableAttributes_EmptyCoordinatesArray) {
   // Test with empty array coordinates - should be removed
-  nlohmann::json input = {
-      {"attributes",
-       {{"dimension_names", {"x", "y"}},
-        {"coordinates", nlohmann::json::array()},
-        {"long_name", "Test Variable"}}}};
+  nlohmann::json input = {{"attributes",
+                           {{"dimension_names", {"x", "y"}},
+                            {"coordinates", nlohmann::json::array()},
+                            {"long_name", "Test Variable"}}}};
 
   auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
 
@@ -435,11 +431,10 @@ TEST(ZarrV2, PrepareVariableAttributes_EmptyCoordinatesArray) {
 }
 
 TEST(ZarrV2, PrepareVariableAttributes_ValidCoordinates) {
-  nlohmann::json input = {
-      {"attributes",
-       {{"dimension_names", {"x", "y"}},
-        {"coordinates", "cdp-x cdp-y"},
-        {"long_name", "Test Variable"}}}};
+  nlohmann::json input = {{"attributes",
+                           {{"dimension_names", {"x", "y"}},
+                            {"coordinates", "cdp-x cdp-y"},
+                            {"long_name", "Test Variable"}}}};
 
   auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
 
@@ -450,9 +445,7 @@ TEST(ZarrV2, PrepareVariableAttributes_ValidCoordinates) {
 TEST(ZarrV2, PrepareVariableAttributes_EmptyLongName) {
   // Test with empty long_name - should be removed
   nlohmann::json input = {
-      {"attributes",
-       {{"dimension_names", {"x", "y"}},
-        {"long_name", ""}}}};
+      {"attributes", {{"dimension_names", {"x", "y"}}, {"long_name", ""}}}};
 
   auto attrs = mdio::zarr::v2::PrepareVariableAttributes(input);
 
@@ -467,9 +460,7 @@ TEST(ZarrV2, PrepareVariableAttributes_EmptyLongName) {
 
 namespace ZarrV3Tests {
 
-TEST(ZarrV3, DriverName) {
-  EXPECT_EQ(mdio::zarr::v3::kDriverName, "zarr3");
-}
+TEST(ZarrV3, DriverName) { EXPECT_EQ(mdio::zarr::v3::kDriverName, "zarr3"); }
 
 TEST(ZarrV3, ZarrFormat) { EXPECT_EQ(mdio::zarr::v3::kZarrFormat, 3); }
 
@@ -526,8 +517,7 @@ TEST(ZarrV3, CreateGroupMetadata_WithAttributes) {
 TEST(ZarrV3, CreateArrayMetadata) {
   std::vector<int64_t> shape = {100, 200};
   std::vector<int64_t> chunks = {50, 50};
-  auto metadata =
-      mdio::zarr::v3::CreateArrayMetadata(shape, chunks, "float32");
+  auto metadata = mdio::zarr::v3::CreateArrayMetadata(shape, chunks, "float32");
 
   EXPECT_EQ(metadata["zarr_format"], 3);
   EXPECT_EQ(metadata["node_type"], "array");
@@ -582,11 +572,10 @@ TEST(ZarrV3, ConvertToMdioMetadata) {
 
 TEST(ZarrV3, PrepareVariableAttributes_EmptyCoordinates) {
   // Test empty string coordinates - should be removed (covers line 204)
-  nlohmann::json input = {
-      {"attributes",
-       {{"dimension_names", {"x", "y"}},
-        {"coordinates", ""},
-        {"long_name", "Test Variable"}}}};
+  nlohmann::json input = {{"attributes",
+                           {{"dimension_names", {"x", "y"}},
+                            {"coordinates", ""},
+                            {"long_name", "Test Variable"}}}};
 
   auto attrs = mdio::zarr::v3::PrepareVariableAttributes(input);
 
@@ -595,10 +584,9 @@ TEST(ZarrV3, PrepareVariableAttributes_EmptyCoordinates) {
   EXPECT_TRUE(attrs.contains("long_name"));
 
   // Also test empty array coordinates
-  nlohmann::json input2 = {
-      {"attributes",
-       {{"dimension_names", {"x", "y"}},
-        {"coordinates", nlohmann::json::array()}}}};
+  nlohmann::json input2 = {{"attributes",
+                            {{"dimension_names", {"x", "y"}},
+                             {"coordinates", nlohmann::json::array()}}}};
 
   auto attrs2 = mdio::zarr::v3::PrepareVariableAttributes(input2);
   EXPECT_FALSE(attrs2.contains("coordinates"));
@@ -614,8 +602,7 @@ TEST(ZarrV3, ReadVariableAttributes) {
   nlohmann::json test_zarr_json = {
       {"zarr_format", 3},
       {"node_type", "array"},
-      {"attributes",
-       {{"_ARRAY_DIMENSIONS", {"x", "y"}}, {"units", "meters"}}}};
+      {"attributes", {{"_ARRAY_DIMENSIONS", {"x", "y"}}, {"units", "meters"}}}};
 
   std::ofstream out(tmpDir / "zarr.json");
   out << test_zarr_json.dump(4);
@@ -680,14 +667,12 @@ TEST(ZarrV3, ReadVariableAttributes_NoAttributesInFile) {
 namespace ZarrUnifiedTests {
 
 TEST(ZarrUnified, GetDriverNameForVersion_V2) {
-  auto name =
-      mdio::zarr::GetDriverNameForVersion(mdio::zarr::ZarrVersion::kV2);
+  auto name = mdio::zarr::GetDriverNameForVersion(mdio::zarr::ZarrVersion::kV2);
   EXPECT_EQ(name, "zarr");
 }
 
 TEST(ZarrUnified, GetDriverNameForVersion_V3) {
-  auto name =
-      mdio::zarr::GetDriverNameForVersion(mdio::zarr::ZarrVersion::kV3);
+  auto name = mdio::zarr::GetDriverNameForVersion(mdio::zarr::ZarrVersion::kV3);
   EXPECT_EQ(name, "zarr3");
 }
 
diff --git a/mdio/zarr/zarr_v2.h b/mdio/zarr/zarr_v2.h
index 70d151d..1d300c9 100644
--- a/mdio/zarr/zarr_v2.h
+++ b/mdio/zarr/zarr_v2.h
@@ -18,6 +18,7 @@
 #include <filesystem>
 #include <string>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include "absl/strings/str_split.h"
@@ -263,9 +264,8 @@ inline Future<void> WriteConsolidatedMetadata(
  * @return A future containing dataset metadata and variable JSON specs.
  */
 inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
-ReadConsolidatedMetadata(
-    const std::string& dataset_path,
-    tensorstore::Future<tensorstore::KvStore> kvs_future) {
+ReadConsolidatedMetadata(const std::string& dataset_path,
+                         tensorstore::Future<tensorstore::KvStore> kvs_future) {
   // Normalize the dataset path once so we can safely append variable names.
   std::string normalized_path = dataset_path;
   if (!normalized_path.empty() && normalized_path.back() != '/') {
@@ -307,9 +307,10 @@ ReadConsolidatedMetadata(
 
         auto read_future = tensorstore::kvstore::Read(kvs, ".zmetadata");
         read_future.ExecuteWhenReady(
-            [promise = std::move(promise), dataset_path, normalized_path, driver,
-             bucket, cloudPath](tensorstore::ReadyFuture<
-                                tensorstore::kvstore::ReadResult> ready_read) {
+            [promise = std::move(promise), dataset_path, normalized_path,
+             driver, bucket, cloudPath](
+                tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+                    ready_read) {
               if (!ready_read.result().ok()) {
                 promise.SetResult(ready_read.result().status());
                 return;
@@ -318,8 +319,8 @@ ReadConsolidatedMetadata(
 
               ::nlohmann::json zmetadata;
               try {
-                zmetadata = ::nlohmann::json::parse(
-                    std::string(read_result.value));
+                zmetadata =
+                    ::nlohmann::json::parse(std::string(read_result.value));
               } catch (const nlohmann::json::parse_error& e) {
                 if (!dataset_path.empty() && dataset_path.back() != '/') {
                   promise.SetResult(absl::InvalidArgumentError(
@@ -389,15 +390,15 @@ ReadConsolidatedMetadata(
  */
 inline nlohmann::json CreateVariableSpec(const std::string& variable_name,
                                          const std::string& path = "") {
-  nlohmann::json spec = {{"driver", std::string(kDriverName)},
-                         {"kvstore",
-                          {{"driver", "file"}, {"path", variable_name}}},
-                         {"metadata",
-                          {{"dtype", "DATA_TYPE"},
-                           {"dimension_separator", "/"},
-                           {"shape", "SHAPE"},
-                           {"chunks", "CHUNKS"}}},
-                         {"attributes", nlohmann::json::object()}};
+  nlohmann::json spec = {
+      {"driver", std::string(kDriverName)},
+      {"kvstore", {{"driver", "file"}, {"path", variable_name}}},
+      {"metadata",
+       {{"dtype", "DATA_TYPE"},
+        {"dimension_separator", "/"},
+        {"shape", "SHAPE"},
+        {"chunks", "CHUNKS"}}},
+      {"attributes", nlohmann::json::object()}};
   return spec;
 }
 
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index 4ea8dec..c4ccb80 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -18,6 +18,7 @@
 #include <filesystem>
 #include <string>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include "absl/strings/str_split.h"
@@ -435,41 +436,38 @@ Future<tensorstore::TimestampedStorageGeneration> WriteVariableAttributes(
     const tensorstore::TensorStore<T, R, M>& store,
     const ::nlohmann::json& json_var, bool isCloudStore) {
   // For Zarr V3, we need to read the existing zarr.json and update attributes
-  auto read_future =
-      tensorstore::kvstore::Read(store.kvstore(), "zarr.json");
+  auto read_future = tensorstore::kvstore::Read(store.kvstore(), "zarr.json");
 
-  auto pair =
-      tensorstore::PromiseFuturePair<
-          tensorstore::TimestampedStorageGeneration>::Make();
+  auto pair = tensorstore::PromiseFuturePair<
+      tensorstore::TimestampedStorageGeneration>::Make();
+
+  read_future.ExecuteWhenReady([promise = std::move(pair.promise), store,
+                                json_var](tensorstore::ReadyFuture<
+                                          tensorstore::kvstore::ReadResult>
+                                              ready_result) {
+    nlohmann::json zarr_json;
+    if (ready_result.result().ok() && ready_result.value().has_value()) {
+      try {
+        zarr_json =
+            nlohmann::json::parse(std::string(ready_result.value().value));
+      } catch (...) {
+        zarr_json = nlohmann::json::object();
+      }
+    }
 
-  read_future.ExecuteWhenReady(
-      [promise = std::move(pair.promise), store, json_var](
-          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
-              ready_result) {
-        nlohmann::json zarr_json;
-        if (ready_result.result().ok() && ready_result.value().has_value()) {
-          try {
-            zarr_json = nlohmann::json::parse(
-                std::string(ready_result.value().value));
-          } catch (...) {
-            zarr_json = nlohmann::json::object();
-          }
-        }
+    // Prepare and update attributes
+    auto attrs =
+        PrepareVariableAttributes(nlohmann::json{{"attributes", json_var}});
+    zarr_json["attributes"] = attrs;
 
-        // Prepare and update attributes
-        auto attrs = PrepareVariableAttributes(
-            nlohmann::json{{"attributes", json_var}});
-        zarr_json["attributes"] = attrs;
-
-        // Write back
-        auto write_result = tensorstore::kvstore::Write(
-            store.kvstore(), "zarr.json", absl::Cord(zarr_json.dump(4)));
-        write_result.ExecuteWhenReady(
-            [promise = std::move(promise)](
-                tensorstore::ReadyFuture<
-                    tensorstore::TimestampedStorageGeneration>
-                    write_ready) { promise.SetResult(write_ready.result()); });
-      });
+    // Write back
+    auto write_result = tensorstore::kvstore::Write(
+        store.kvstore(), "zarr.json", absl::Cord(zarr_json.dump(4)));
+    write_result.ExecuteWhenReady(
+        [promise = std::move(promise)](
+            tensorstore::ReadyFuture<tensorstore::TimestampedStorageGeneration>
+                write_ready) { promise.SetResult(write_ready.result()); });
+  });
 
   return pair.future;
 }
@@ -494,8 +492,8 @@ inline Future<nlohmann::json> ReadVariableAttributes(
           return;
         }
         try {
-          auto zarr_json = nlohmann::json::parse(
-              std::string(ready_result.value().value));
+          auto zarr_json =
+              nlohmann::json::parse(std::string(ready_result.value().value));
           if (zarr_json.contains("attributes")) {
             promise.SetResult(zarr_json["attributes"]);
           } else {

From 9d1f717eaa3676bfaff7340ed650a02dff4c770d Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 20:28:45 +0000
Subject: [PATCH 17/26] Begin re-unifying the zarr drivers

---
 mdio/acceptance_test.cc | 512 +++++++++++++++++++---------------------
 mdio/dataset_factory.h  |   8 +-
 2 files changed, 239 insertions(+), 281 deletions(-)

diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index 7fa977c..27cbbcc 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -175,133 +175,17 @@ nlohmann::json CreateBaseSpec(mdio::zarr::ZarrVersion version,
 
 /**
  * @brief Returns the dataset manifest JSON for the given version.
+ * Both versions use the same manifest structure including struct arrays.
  */
 std::string GetDatasetManifest(mdio::zarr::ZarrVersion version) {
   std::string name =
       version == mdio::zarr::ZarrVersion::kV3 ? "campos_3d_v3" : "campos_3d";
 
-  // Note: V3 doesn't support struct arrays yet, so we use a slightly different
-  // manifest
-  if (version == mdio::zarr::ZarrVersion::kV3) {
-    return R"(
-{
-  "metadata": {
-    "name": "campos_3d_v3",
-    "apiVersion": "1.0.0",
-    "createdOn": "2023-12-12T15:02:06.413469-06:00",
-    "attributes": {
-      "textHeader": [
-        "C01 .......................... ",
-        "C02 .......................... ",
-        "C03 .......................... "
-      ],
-      "foo": "bar"
-    }
-  },
-  "variables": [
-    {
-      "name": "image",
-      "dataType": "float32",
-      "dimensions": [
-        {"name": "inline", "size": 256},
-        {"name": "crossline", "size": 512},
-        {"name": "depth", "size": 384}
-      ],
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [128, 128, 128] }
-        },
-        "statsV1": {
-          "count": 100,
-          "sum": 1215.1,
-          "sumSquares": 125.12,
-          "min": 5.61,
-          "max": 10.84,
-          "histogram": {"binCenters":  [1, 2], "counts":  [10, 15]}
-        },
-        "attributes": {
-          "fizz": "buzz"
-        }
-    },
-      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"],
-      "compressor": {"name": "blosc", "algorithm": "zstd"}
-    },
-    {
-      "name": "velocity",
-      "dataType": "float64",
-      "dimensions": ["inline", "crossline", "depth"],
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [128, 128, 128] }
-        },
-        "unitsV1": {"speed": "m/s"}
-      },
-      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
-    },
-    {
-      "name": "image_inline",
-      "dataType": "int16",
-      "dimensions": ["inline", "crossline", "depth"],
-      "longName": "inline optimized version of 3d_stack",
-      "compressor": {"name": "blosc", "algorithm": "zstd"},
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [4, 512, 512] }
-        }
-      },
-      "coordinates": ["inline", "crossline", "depth", "cdp-x", "cdp-y"]
-    },
-    {
-      "name": "inline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "inline", "size": 256}]
-    },
-    {
-      "name": "crossline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "crossline", "size": 512}]
-    },
-    {
-      "name": "depth",
-      "dataType": "uint32",
-      "dimensions": [{"name": "depth", "size": 384}],
-      "metadata": {
-        "unitsV1": { "length": "m" }
-      }
-    },
-    {
-      "name": "cdp-x",
-      "dataType": "float32",
-      "dimensions": [
-        {"name": "inline", "size": 256},
-        {"name": "crossline", "size": 512}
-      ],
-      "metadata": {
-        "unitsV1": { "length": "m" }
-      }
-    },
-    {
-      "name": "cdp-y",
-      "dataType": "float32",
-      "dimensions": [
-        {"name": "inline", "size": 256},
-        {"name": "crossline", "size": 512}
-      ],
-      "metadata": {
-        "unitsV1": { "length": "m" }
-      }
-    }
-  ]
-}
-    )";
-  } else {
-    return R"(
+  // clang-format off
+  std::string manifest = R"(
 {
   "metadata": {
-    "name": "campos_3d",
+    "name": ")" + name + R"(",
     "apiVersion": "1.0.0",
     "createdOn": "2023-12-12T15:02:06.413469-06:00",
     "attributes": {
@@ -431,7 +315,8 @@ std::string GetDatasetManifest(mdio::zarr::ZarrVersion version) {
   ]
 }
     )";
-  }
+  // clang-format on
+  return manifest;
 }
 
 /**
@@ -937,9 +822,7 @@ class DatasetTest : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
     version_ = GetParam();
     base_path_ = GetBasePath(version_);
     dataset_manifest_ = GetDatasetManifest(version_);
-    expected_var_count_ = version_ == mdio::zarr::ZarrVersion::kV3
-                              ? 8
-                              : 9;  // V2 has struct array
+    expected_var_count_ = 9;  // Both versions support struct arrays
   }
 
   mdio::zarr::ZarrVersion version_;
@@ -1030,25 +913,29 @@ TEST_P(DatasetTest, write) {
   auto ds = dataset.value();
 
   std::vector<std::string> names = ds.variables.get_keys();
+
+  // Construct a vector of Variables to work with
   std::vector<mdio::Variable<>> openVariables;
   for (auto& key : names) {
     auto var = ds.get_variable(key);
     openVariables.emplace_back(var.value());
   }
 
+  // Now we can start opening all the Variables
   std::vector<mdio::Future<mdio::VariableData<>>> readVariablesFutures;
   for (auto& v : openVariables) {
-    readVariablesFutures.emplace_back(v.Read());
+    auto read = v.Read();
+    readVariablesFutures.emplace_back(read);
   }
 
+  // Now we make sure all the reads were successful
   std::vector<mdio::VariableData<>> readVariables;
   for (auto& v : readVariablesFutures) {
     ASSERT_TRUE(v.status().ok()) << v.status();
     readVariables.emplace_back(v.value());
   }
 
-  // Modify some data
-  for (auto& variable : readVariables) {
+  for (auto variable : readVariables) {
     std::string name = variable.variableName;
     mdio::DataType dtype = variable.dtype();
     if (dtype == mdio::constants::kFloat32 && name == "image") {
@@ -1062,6 +949,12 @@ TEST_P(DatasetTest, write) {
       auto data =
           reinterpret_cast<int16_t*>(variable.get_data_accessor().data());
       data[0] = 0xff;
+    } else if (dtype == mdio::constants::kByte && name == "image_headers") {
+      auto data = reinterpret_cast<mdio::dtypes::byte_t*>(
+          variable.get_data_accessor().data());
+      for (int i = 0; i < 12; i++) {
+        data[i] = std::byte(0xff);
+      }
     } else if (name == "inline") {
       auto data =
           reinterpret_cast<uint32_t*>(variable.get_data_accessor().data());
@@ -1083,7 +976,8 @@ TEST_P(DatasetTest, write) {
     }
   }
 
-  // Pair and write
+  // Pair the Variables to the VariableData objects via name matching so we can
+  // write them out correctly This makes an assumption that the vectors are 1-1
   std::map<std::size_t, std::size_t> variableIdxPair;
   for (std::size_t i = 0; i < openVariables.size(); i++) {
     for (std::size_t j = 0; j < readVariables.size(); j++) {
@@ -1095,31 +989,78 @@ TEST_P(DatasetTest, write) {
     }
   }
 
+  // Now we can write the Variables back to the store
   std::vector<mdio::WriteFutures> writeFutures;
   for (auto& idxPair : variableIdxPair) {
-    writeFutures.emplace_back(
-        openVariables[idxPair.second].Write(readVariables[idxPair.first]));
+    auto write =
+        openVariables[idxPair.second].Write(readVariables[idxPair.first]);
+    writeFutures.emplace_back(write);
   }
 
+  // Now we make sure all the writes were successful
   for (auto& w : writeFutures) {
     ASSERT_TRUE(w.status().ok()) << w.status();
   }
 
-  // Verify writes
+  // Test SelectField and negative case for struct arrays
+  std::string fielded = "image_headers";
+  ASSERT_TRUE(ds.SelectField(fielded, "cdp-x").status().ok());
+  auto wf = ds.get_variable(fielded).value().Write(readVariables[4]);
+  ASSERT_FALSE(wf.status().ok()) << wf.status();
+
   std::string driver = GetTestDriverName(version_);
   nlohmann::json imageJson;
   imageJson["driver"] = driver;
   imageJson["kvstore"]["driver"] = "file";
   imageJson["kvstore"]["path"] = base_path_ + "/image";
 
+  nlohmann::json velocityJson;
+  velocityJson["driver"] = driver;
+  velocityJson["kvstore"]["driver"] = "file";
+  velocityJson["kvstore"]["path"] = base_path_ + "/velocity";
+
+  nlohmann::json imageInlineJson;
+  imageInlineJson["driver"] = driver;
+  imageInlineJson["kvstore"]["driver"] = "file";
+  imageInlineJson["kvstore"]["path"] = base_path_ + "/image_inline";
+
+  nlohmann::json imageHeadersJson;
+  imageHeadersJson["driver"] = driver;
+  imageHeadersJson["kvstore"]["driver"] = "file";
+  imageHeadersJson["kvstore"]["path"] = base_path_ + "/image_headers";
+
   auto image = mdio::Variable<>::Open(imageJson, mdio::constants::kOpen);
+  auto velocity = mdio::Variable<>::Open(velocityJson, mdio::constants::kOpen);
+  auto imageInline =
+      mdio::Variable<>::Open(imageInlineJson, mdio::constants::kOpen);
+  auto imageHeaders =
+      mdio::Variable<>::Open(imageHeadersJson, mdio::constants::kOpen);
+
   ASSERT_TRUE(image.status().ok()) << image.status();
+  ASSERT_TRUE(velocity.status().ok()) << velocity.status();
+  ASSERT_TRUE(imageInline.status().ok()) << imageInline.status();
+  ASSERT_TRUE(imageHeaders.status().ok()) << imageHeaders.status();
 
   auto imageData = image.result()->Read();
+  auto velocityData = velocity.result()->Read();
+  auto imageInlineData = imageInline.result()->Read();
+  auto imageHeadersData = imageHeaders.result()->Read();
+
   ASSERT_TRUE(imageData.status().ok()) << imageData.status();
+  ASSERT_TRUE(velocityData.status().ok()) << velocityData.status();
+  ASSERT_TRUE(imageInlineData.status().ok()) << imageInlineData.status();
+  ASSERT_TRUE(imageHeadersData.status().ok()) << imageHeadersData.status();
+
   auto castedImage =
       reinterpret_cast<float*>(imageData.value().get_data_accessor().data());
-  EXPECT_EQ(castedImage[0], 3.14f);
+  auto castedVelociy = reinterpret_cast<double*>(
+      velocityData.value().get_data_accessor().data());
+  auto castedImageInline = reinterpret_cast<int16_t*>(
+      imageInlineData.value().get_data_accessor().data());
+
+  EXPECT_EQ(castedImage[0], 3.14f) << castedImage[0];
+  EXPECT_EQ(castedVelociy[0], 2.71828) << castedVelociy[0];
+  EXPECT_EQ(castedImageInline[0], 0xff) << castedImageInline[0];
 }
 
 TEST_P(DatasetTest, name) {
@@ -1210,6 +1151,169 @@ TEST_P(DatasetTest, fromJson) {
   std::filesystem::remove_all(base_path_ + "/from_json_test");
 }
 
+TEST_P(DatasetTest, selectField) {
+  std::string manifest = R"(
+{
+  "metadata": {
+    "name": "select_field_test",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00"
+  },
+  "variables": [
+    {
+      "name": "image_headers",
+      "dataType": {
+        "fields": [
+          {"name": "cdp-x", "format": "int32"},
+          {"name": "cdp-y", "format": "int32"},
+          {"name": "elevation", "format": "float16"},
+          {"name": "some_scalar", "format": "float16"}
+        ]
+      },
+      "dimensions": [
+        {"name": "inline", "size": 128},
+        {"name": "crossline", "size": 128}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [64, 64] }
+        }
+      },
+      "coordinates": ["inline", "crossline"]
+    },
+    {
+      "name": "inline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "inline", "size": 128}]
+    },
+    {
+      "name": "crossline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "crossline", "size": 128}]
+    }
+  ]
+}
+  )";
+
+  std::string test_path = base_path_ + "/select_field_test";
+  std::filesystem::remove_all(test_path);
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  auto dataset = mdio::Dataset::from_json(j, test_path, version_,
+                                          mdio::constants::kCreateClean);
+  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
+
+  auto ds = dataset.value();
+  std::string name = "image_headers";
+
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte)
+      << "Failed to pull byte array from image_headers";
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3)
+      << "Expected structarray to be of rank 3";
+
+  EXPECT_TRUE(ds.SelectField("image_headers", "cdp-x").status().ok())
+      << "Failed to pull cdp-x from image_headers";
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kInt32)
+      << "Failed to pull int32 from image_headers";
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2)
+      << "Expected cdp-x to be of rank 2";
+
+  EXPECT_TRUE(ds.SelectField("image_headers", "elevation").status().ok())
+      << "Failed to pull elevation from image_headers";
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() ==
+              mdio::constants::kFloat16)
+      << "Failed to pull float16 from image_headers";
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2)
+      << "Expected elevation to be of rank 2";
+
+  EXPECT_TRUE(ds.SelectField("image_headers", "").status().ok())
+      << "Failed to set to byte array";
+  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte)
+      << "Failed to pull byte array from image_headers";
+  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3)
+      << "Expected structarray to be of rank 3";
+
+  EXPECT_FALSE(ds.SelectField("image", "NotAField").status().ok())
+      << "Somehow pulled NotAField from image";
+
+  EXPECT_FALSE(ds.SelectField("NotAVariable", "NotAField").status().ok())
+      << "Somehow pulled NotAField from NotAVariable";
+
+  EXPECT_FALSE(ds.SelectField("image_headers", "NotAField").status().ok())
+      << "Somehow pulled NotAField from image_headers";
+
+  std::filesystem::remove_all(test_path);
+}
+
+TEST_P(DatasetTest, fillValue) {
+  std::string manifest = R"(
+{
+  "metadata": {
+    "name": "fill_value_test",
+    "apiVersion": "1.0.0",
+    "createdOn": "2023-12-12T15:02:06.413469-06:00"
+  },
+  "variables": [
+    {
+      "name": "image_headers",
+      "dataType": {
+        "fields": [
+          {"name": "cdp-x", "format": "int32"},
+          {"name": "cdp-y", "format": "int32"},
+          {"name": "elevation", "format": "float16"},
+          {"name": "some_scalar", "format": "float16"}
+        ]
+      },
+      "dimensions": [
+        {"name": "inline", "size": 256},
+        {"name": "crossline", "size": 512}
+      ],
+      "metadata": {
+        "chunkGrid": {
+          "name": "regular",
+          "configuration": { "chunkShape": [128, 128] }
+        }
+      }
+    },
+    {
+      "name": "inline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "inline", "size": 256}]
+    },
+    {
+      "name": "crossline",
+      "dataType": "uint32",
+      "dimensions": [{"name": "crossline", "size": 512}]
+    }
+  ]
+}
+  )";
+
+  std::string test_path = base_path_ + "/fill_value_test";
+  std::filesystem::remove_all(test_path);
+  nlohmann::json j = nlohmann::json::parse(manifest);
+  auto ds = mdio::Dataset::from_json(j, test_path, version_,
+                                     mdio::constants::kCreateClean);
+  ASSERT_TRUE(ds.status().ok()) << ds.status();
+
+  std::string key = "image_headers";
+  auto var = ds.value().get_variable(key);
+  ASSERT_TRUE(var.status().ok()) << var.status();
+  auto vdf = var.value().Read();
+  ASSERT_TRUE(vdf.status().ok()) << vdf.status();
+  auto vd = vdf.value();
+
+  auto data =
+      reinterpret_cast<mdio::dtypes::byte_t*>(vd.get_data_accessor().data());
+  std::byte zero = std::byte(0);
+  for (int i = 0; i < 1000; i++) {
+    ASSERT_EQ(data[i], zero) << "Expected 0 at byte " << i << " but got "
+                             << static_cast<int>(data[i]);
+  }
+
+  std::filesystem::remove_all(test_path);
+}
+
 TEST_P(DatasetTest, TEARDOWN) {
   std::filesystem::remove_all(base_path_);
   ASSERT_TRUE(true);
@@ -1363,149 +1467,7 @@ TEST(VariableV2Only, structArrayTeardown) {
   ASSERT_TRUE(true);
 }
 
-TEST(DatasetV2Only, selectField) {
-  // Create dataset first
-  std::string manifest = R"(
-{
-  "metadata": {
-    "name": "select_field_test",
-    "apiVersion": "1.0.0",
-    "createdOn": "2023-12-12T15:02:06.413469-06:00"
-  },
-  "variables": [
-    {
-      "name": "image_headers",
-      "dataType": {
-        "fields": [
-          {"name": "cdp-x", "format": "int32"},
-          {"name": "cdp-y", "format": "int32"},
-          {"name": "elevation", "format": "float16"},
-          {"name": "some_scalar", "format": "float16"}
-        ]
-      },
-      "dimensions": [
-        {"name": "inline", "size": 128},
-        {"name": "crossline", "size": 128}
-      ],
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [64, 64] }
-        }
-      },
-      "coordinates": ["inline", "crossline"]
-    },
-    {
-      "name": "inline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "inline", "size": 128}]
-    },
-    {
-      "name": "crossline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "crossline", "size": 128}]
-    }
-  ]
-}
-  )";
-
-  std::filesystem::remove_all("zarrs/select_field_test");
-  nlohmann::json j = nlohmann::json::parse(manifest);
-  auto dataset = mdio::Dataset::from_json(j, "zarrs/select_field_test",
-                                          mdio::constants::kCreateClean);
-  ASSERT_TRUE(dataset.status().ok()) << dataset.status();
-
-  auto ds = dataset.value();
-  std::string name = "image_headers";
-
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte);
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3);
-
-  EXPECT_TRUE(ds.SelectField("image_headers", "cdp-x").status().ok());
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kInt32);
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2);
-
-  EXPECT_TRUE(ds.SelectField("image_headers", "elevation").status().ok());
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() ==
-              mdio::constants::kFloat16);
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 2);
-
-  EXPECT_TRUE(ds.SelectField("image_headers", "").status().ok());
-  EXPECT_TRUE(ds.get_variable(name).value().dtype() == mdio::constants::kByte);
-  EXPECT_EQ(ds.get_variable(name).value().get_store().rank(), 3);
-
-  EXPECT_FALSE(ds.SelectField("image_headers", "NotAField").status().ok());
-  EXPECT_FALSE(ds.SelectField("NotAVariable", "NotAField").status().ok());
-
-  std::filesystem::remove_all("zarrs/select_field_test");
-}
-
-TEST(DatasetV2Only, fillValue) {
-  std::string manifest = R"(
-{
-  "metadata": {
-    "name": "fill_value_test",
-    "apiVersion": "1.0.0",
-    "createdOn": "2023-12-12T15:02:06.413469-06:00"
-  },
-  "variables": [
-    {
-      "name": "image_headers",
-      "dataType": {
-        "fields": [
-          {"name": "cdp-x", "format": "int32"},
-          {"name": "cdp-y", "format": "int32"},
-          {"name": "elevation", "format": "float16"},
-          {"name": "some_scalar", "format": "float16"}
-        ]
-      },
-      "dimensions": [
-        {"name": "inline", "size": 256},
-        {"name": "crossline", "size": 512}
-      ],
-      "metadata": {
-        "chunkGrid": {
-          "name": "regular",
-          "configuration": { "chunkShape": [128, 128] }
-        }
-      }
-    },
-    {
-      "name": "inline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "inline", "size": 256}]
-    },
-    {
-      "name": "crossline",
-      "dataType": "uint32",
-      "dimensions": [{"name": "crossline", "size": 512}]
-    }
-  ]
-}
-  )";
-
-  std::filesystem::remove_all("zarrs/fill_value_test");
-  nlohmann::json j = nlohmann::json::parse(manifest);
-  auto ds = mdio::Dataset::from_json(j, "zarrs/fill_value_test",
-                                     mdio::constants::kCreateClean);
-  ASSERT_TRUE(ds.status().ok()) << ds.status();
-
-  std::string key = "image_headers";
-  auto var = ds.value().get_variable(key);
-  ASSERT_TRUE(var.status().ok()) << var.status();
-  auto vdf = var.value().Read();
-  ASSERT_TRUE(vdf.status().ok()) << vdf.status();
-  auto vd = vdf.value();
-
-  auto data =
-      reinterpret_cast<mdio::dtypes::byte_t*>(vd.get_data_accessor().data());
-  std::byte zero = std::byte(0);
-  for (int i = 0; i < 1000; i++) {
-    ASSERT_EQ(data[i], zero) << "Expected 0 at byte " << i;
-  }
-
-  std::filesystem::remove_all("zarrs/fill_value_test");
-}
+// selectField and fillValue tests moved to parameterized DatasetTest
 
 }  // namespace V2OnlyTests
 
diff --git a/mdio/dataset_factory.h b/mdio/dataset_factory.h
index cd78082..0ddb1d1 100644
--- a/mdio/dataset_factory.h
+++ b/mdio/dataset_factory.h
@@ -83,14 +83,10 @@ inline absl::Status transform_dtype(
       (version == mdio::zarr::ZarrVersion::kV3) ? "data_type" : "dtype";
 
   if (input["dataType"].contains("fields")) {
-    if (version == mdio::zarr::ZarrVersion::kV3) {
-      // V3 doesn't support structured dtypes in the same way
-      return absl::InvalidArgumentError(
-          "Structured dtypes are not yet supported in Zarr V3");
-    }
+    // Structured dtypes are supported in both V2 and V3
     nlohmann::json dtypeFields = nlohmann::json::array();
     for (const auto& field : input["dataType"]["fields"]) {
-      auto dtype = to_zarr_dtype(field["format"]);
+      auto dtype = to_zarr_dtype(field["format"], version);
       if (!dtype.status().ok()) {
         return dtype.status();
       }

From d5cdcf883c79f6c1d310ddd18f51c3063cd3d6bf Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 20:36:05 +0000
Subject: [PATCH 18/26] Fix copyright date

---
 mdio/zarr/zarr.h        | 2 +-
 mdio/zarr/zarr_driver.h | 2 +-
 mdio/zarr/zarr_test.cc  | 2 +-
 mdio/zarr/zarr_v2.h     | 2 +-
 mdio/zarr/zarr_v3.h     | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/mdio/zarr/zarr.h b/mdio/zarr/zarr.h
index 27377e0..61be7e2 100644
--- a/mdio/zarr/zarr.h
+++ b/mdio/zarr/zarr.h
@@ -1,4 +1,4 @@
-// Copyright 2024 TGS
+// Copyright 2026 TGS
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
diff --git a/mdio/zarr/zarr_driver.h b/mdio/zarr/zarr_driver.h
index eb8459d..526e114 100644
--- a/mdio/zarr/zarr_driver.h
+++ b/mdio/zarr/zarr_driver.h
@@ -1,4 +1,4 @@
-// Copyright 2024 TGS
+// Copyright 2026 TGS
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
diff --git a/mdio/zarr/zarr_test.cc b/mdio/zarr/zarr_test.cc
index be19f8b..b27452b 100644
--- a/mdio/zarr/zarr_test.cc
+++ b/mdio/zarr/zarr_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2024 TGS
+// Copyright 2026 TGS
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
diff --git a/mdio/zarr/zarr_v2.h b/mdio/zarr/zarr_v2.h
index 1d300c9..c0a086f 100644
--- a/mdio/zarr/zarr_v2.h
+++ b/mdio/zarr/zarr_v2.h
@@ -1,4 +1,4 @@
-// Copyright 2024 TGS
+// Copyright 2026 TGS
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index c4ccb80..0514b3f 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -1,4 +1,4 @@
-// Copyright 2024 TGS
+// Copyright 2026 TGS
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.

From ff8fa550f5eab809852e622043d5181c9a25624f Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 20:43:53 +0000
Subject: [PATCH 19/26] Resolve logic error for serializing structarray with v3
 driver

---
 mdio/variable.h | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/mdio/variable.h b/mdio/variable.h
index 3958623..7b12adb 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -437,10 +437,10 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
         "Variable metadata requires dtype (V2) or data_type (V3)");
   }
 
-  // For V3, we don't use ParseDType (which is V2-specific)
-  // Instead, we handle structured arrays differently
+  // Handle structured arrays for both V2 and V3
   bool do_handle_structarray = false;
   tensorstore::internal_zarr::ZarrDType zarr_dtype;
+  std::string first_field_name;
 
   if (zarr_version == zarr::ZarrVersion::kV2 && has_dtype) {
     MDIO_ASSIGN_OR_RETURN(zarr_dtype, tensorstore::internal_zarr::ParseDType(
@@ -449,12 +449,25 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
     // void.
     do_handle_structarray =
         zarr_dtype.has_fields && !json_spec.contains("field");
+    if (do_handle_structarray) {
+      first_field_name = zarr_dtype.fields[0].name;
+    }
+  } else if (zarr_version == zarr::ZarrVersion::kV3 && has_data_type) {
+    // For V3, structured dtypes are represented as an array of [name, type]
+    // pairs e.g., [["cdp-x", "int32"], ["cdp-y", "int32"], ...]
+    const auto& data_type = json_spec["metadata"]["data_type"];
+    if (data_type.is_array() && !data_type.empty() &&
+        data_type[0].is_array() && !json_spec.contains("field")) {
+      do_handle_structarray = true;
+      // Extract the first field name from the structured dtype
+      first_field_name = data_type[0][0].get<std::string>();
+    }
   }
 
   auto json_spec_with_open_flag = json_spec;
   if (do_handle_structarray) {
-    // pick the first name, it won't effect the .zarray json:
-    json_spec_with_open_flag["field"] = zarr_dtype.fields[0].name;
+    // pick the first field name, it won't affect the zarr.json/zarray:
+    json_spec_with_open_flag["field"] = first_field_name;
   }
 
   auto json_spec_without_metadata = json_spec_with_open_flag;

From 74b2cabba64693f3f9d724e15ded7575195f36cf Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 20:48:03 +0000
Subject: [PATCH 20/26] Add support for field selection of v3 datasets

---
 mdio/dataset.h | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/mdio/dataset.h b/mdio/dataset.h
index 44e20cd..a60e735 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -1135,19 +1135,31 @@ class Dataset {
       return specJsonResult.status();
     }
     nlohmann::json specJson = specJsonResult.value();
-    if (!specJson["metadata"]["dtype"].is_array()) {
+
+    // Detect Zarr version from the spec and get the dtype key
+    std::string driverName = specJson.contains("driver")
+                                 ? specJson["driver"].get<std::string>()
+                                 : "zarr";
+    bool isV3 = (driverName == "zarr3");
+    std::string dtype_key = isV3 ? "data_type" : "dtype";
+
+    // Ensure that the Variable is of dtype structarray
+    if (!specJson["metadata"].contains(dtype_key) ||
+        !specJson["metadata"][dtype_key].is_array()) {
       return absl::Status(
           absl::StatusCode::kInvalidArgument,
           "Variable '" + variableName + "' is not a structured dtype.");
     }
 
+    const auto& dtype_array = specJson["metadata"][dtype_key];
+
     // Ensure the field exists in the Variable
     int found = -1;
     if (fieldName == "") {
       found = -2;
     } else {
-      for (std::size_t i = 0; i < specJson["metadata"]["dtype"].size(); i++) {
-        if (specJson["metadata"]["dtype"][i][0] == fieldName) {
+      for (std::size_t i = 0; i < dtype_array.size(); i++) {
+        if (dtype_array[i][0] == fieldName) {
           found = i;
           break;
         }
@@ -1159,11 +1171,6 @@ class Dataset {
                               variableName + "'.");
     }
 
-    // Detect Zarr version from the spec
-    std::string driverName = specJson.contains("driver")
-                                 ? specJson["driver"].get<std::string>()
-                                 : "zarr";
-
     // Create a new Variable with the selected field
     std::string baseStr = R"(
             {
@@ -1182,7 +1189,7 @@ class Dataset {
                           "Failed to parse base JSON.");
     }
     if (found >= 0) {
-      base["field"] = specJson["metadata"]["dtype"][found][0];
+      base["field"] = dtype_array[found][0];
     } else {
       base.erase("field");
     }

From 1609ff87de1d8751f0a707ec7b788b0b23558d84 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 20:54:02 +0000
Subject: [PATCH 21/26] Fix logic for fill values on v3 driver

---
 mdio/dataset_factory.h | 42 ++++++++++++++++++++++++++++++++----------
 1 file changed, 32 insertions(+), 10 deletions(-)

diff --git a/mdio/dataset_factory.h b/mdio/dataset_factory.h
index 0ddb1d1..6672ad4 100644
--- a/mdio/dataset_factory.h
+++ b/mdio/dataset_factory.h
@@ -412,20 +412,42 @@ inline tensorstore::Result<nlohmann::json> from_json_to_spec(
       } else {
         variableStub["metadata"]["fill_value"] = 0;
       }
-    } else if (version == mdio::zarr::ZarrVersion::kV2) {
-      // Structured dtypes only for V2
+    } else {
+      // Structured dtypes for both V2 and V3
       // Accumulate the total number of bytes (N)
       uint16_t num_bytes = 0;
-      std::string dtype;
-      for (auto field : variableStub["metadata"]["dtype"]) {
-        dtype = field[1].get<std::string>();
-        if (dtype.at(1) != 'c') {
-          num_bytes += std::stoi(dtype.substr(2));
+      std::string dtype_key =
+          version == mdio::zarr::ZarrVersion::kV3 ? "data_type" : "dtype";
+      for (const auto& field : variableStub["metadata"][dtype_key]) {
+        std::string dtype = field[1].get<std::string>();
+        if (version == mdio::zarr::ZarrVersion::kV2) {
+          // V2 format: "<i2", "<f4", "<c8", etc. - number is byte size
+          if (dtype.at(1) != 'c') {
+            num_bytes += std::stoi(dtype.substr(2));
+          } else {
+            // Complex types: c8 = 8 bytes, c16 = 16 bytes
+            if (dtype.at(2) == '8') {
+              num_bytes += 8;
+            } else {
+              num_bytes += 16;
+            }
+          }
         } else {
-          if (dtype.at(2) == '8') {
-            num_bytes += 8;
+          // V3 format: "int16", "float32", "complex64", etc. - number is bit
+          // size
+          if (dtype.find("complex") == 0) {
+            // complex64 = 8 bytes, complex128 = 16 bytes
+            int bits = std::stoi(dtype.substr(7));
+            num_bytes += bits / 8;
+          } else if (dtype == "bool") {
+            num_bytes += 1;
           } else {
-            num_bytes += 16;
+            // Extract the number from the end (int16 -> 16, float32 -> 32)
+            size_t pos = dtype.find_first_of("0123456789");
+            if (pos != std::string::npos) {
+              int bits = std::stoi(dtype.substr(pos));
+              num_bytes += bits / 8;
+            }
           }
         }
       }

From 1b7f8f5d61d35ff16ffc5af162291e0ba0d8a173 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 21:03:43 +0000
Subject: [PATCH 22/26] Reduce boilerplate

---
 mdio/acceptance_test.cc | 732 +++++++++++++---------------------------
 1 file changed, 229 insertions(+), 503 deletions(-)

diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index 27cbbcc..612067e 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -48,6 +48,34 @@ constexpr int SUCCESS_CODE = EXIT_SUCCESS;
 
 using float16_t = mdio::dtypes::float_16_t;
 
+/**
+ * @brief Test variable definition with dtype info for V2 and V3.
+ */
+struct TestVariableDef {
+  std::string name;
+  std::string dtype_v2;
+  std::string dtype_v3;
+  std::string long_name;
+  mdio::DataType expected_dtype;
+};
+
+// Common test variable definitions used across multiple tests
+const std::vector<TestVariableDef> kTestVariables = {
+    {"i2", "<i2", "int16", "2-byte integer test", mdio::constants::kInt16},
+    {"i4", "<i4", "int32", "4-byte integer test", mdio::constants::kInt32},
+    {"i8", "<i8", "int64", "8-byte integer test", mdio::constants::kInt64},
+    {"f2", "<f2", "float16", "2-byte float test", mdio::constants::kFloat16},
+    {"f4", "<f4", "float32", "4-byte float test", mdio::constants::kFloat32},
+    {"f8", "<f8", "float64", "8-byte float test", mdio::constants::kFloat64},
+    {"u1", "<u1", "uint8", "1-byte unsigned integer test",
+     mdio::constants::kUint8},
+    {"u2", "<u2", "uint16", "2-byte unsigned integer test",
+     mdio::constants::kUint16},
+    {"u8", "<u8", "uint64", "8-byte unsigned integer test",
+     mdio::constants::kUint64},
+    {"b1", "|b1", "bool", "boolean test", mdio::constants::kBool},
+};
+
 /**
  * @brief Returns a string representation of the Zarr version for naming.
  */
@@ -71,49 +99,6 @@ std::string GetTestDriverName(mdio::zarr::ZarrVersion version) {
   return version == mdio::zarr::ZarrVersion::kV3 ? "zarr3" : "zarr";
 }
 
-/**
- * @brief Creates a variable spec for testing based on Zarr version.
- */
-nlohmann::json CreateVariableSpec(mdio::zarr::ZarrVersion version,
-                                  const std::string& name,
-                                  const std::string& base_path) {
-  nlohmann::json spec;
-  spec["driver"] = GetTestDriverName(version);
-  spec["kvstore"]["driver"] = "file";
-  spec["kvstore"]["path"] = base_path + "/" + name;
-
-  if (version == mdio::zarr::ZarrVersion::kV3) {
-    spec["metadata"]["data_type"] = "int16";
-    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
-    spec["metadata"]["chunk_grid"]["name"] = "regular";
-    spec["metadata"]["chunk_grid"]["configuration"]["chunk_shape"] =
-        nlohmann::json::array({5, 5});
-    spec["metadata"]["chunk_key_encoding"]["name"] = "default";
-    spec["metadata"]["chunk_key_encoding"]["configuration"]["separator"] = "/";
-    nlohmann::json bytes_codec;
-    bytes_codec["name"] = "bytes";
-    spec["metadata"]["codecs"] = nlohmann::json::array({bytes_codec});
-    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
-    spec["attributes"]["long_name"] = "2-byte integer test";
-    spec["attributes"]["dimension_names"] =
-        nlohmann::json::array({"inline", "crossline"});
-    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
-  } else {
-    spec["metadata"]["dtype"] = "<i2";
-    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
-    spec["metadata"]["chunks"] = nlohmann::json::array({5, 5});
-    spec["metadata"]["dimension_separator"] = "/";
-    spec["metadata"]["compressor"]["id"] = "blosc";
-    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
-    spec["attributes"]["long_name"] = "2-byte integer test";
-    spec["attributes"]["dimension_names"] =
-        nlohmann::json::array({"inline", "crossline"});
-    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
-  }
-
-  return spec;
-}
-
 /**
  * @brief Creates a typed variable spec based on version and dtype.
  */
@@ -173,6 +158,49 @@ nlohmann::json CreateBaseSpec(mdio::zarr::ZarrVersion version,
   return spec;
 }
 
+/**
+ * @brief Creates and asserts a test variable from a definition.
+ */
+void CreateTestVariable(const TestVariableDef& def,
+                        mdio::zarr::ZarrVersion version,
+                        const std::string& base_path) {
+  mdio::TransactionalOpenOptions options;
+  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
+
+  auto spec = CreateTypedVariableSpec(version, def.name, base_path, def.dtype_v2,
+                                      def.dtype_v3, def.long_name);
+  auto schema = mdio::internal::ValidateAndProcessJson(spec).value();
+  auto [store, metadata] = schema;
+  auto var =
+      mdio::internal::CreateVariable(store, metadata, std::move(options));
+  ASSERT_TRUE(var.status().ok()) << "Failed to create " << def.name << ": "
+                                 << var.status();
+}
+
+/**
+ * @brief Opens a variable by name and returns its Future.
+ */
+mdio::Future<mdio::Variable<>> OpenTestVariable(
+    const std::string& name, mdio::zarr::ZarrVersion version,
+    const std::string& base_path) {
+  return mdio::Variable<>::Open(CreateBaseSpec(version, name, base_path),
+                                mdio::constants::kOpen);
+}
+
+/**
+ * @brief Gets the Python script base path from environment.
+ */
+const char* GetPythonBasePath() {
+  const char* basePath = std::getenv(PROJECT_BASE_PATH_ENV);
+  if (!basePath) {
+    std::cout << "PROJECT_BASE_PATH environment variable not set. Expecting to "
+                 "be in the 'build/mdio' directory."
+              << std::endl;
+    basePath = DEFAULT_BASE_PATH;
+  }
+  return basePath;
+}
+
 /**
  * @brief Returns the dataset manifest JSON for the given version.
  * Both versions use the same manifest structure including struct arrays.
@@ -350,6 +378,49 @@ int executePythonScript(const std::string& scriptPath,
   return SUCCESS_CODE;
 }
 
+/**
+ * @brief Runs Python scripts with fork/wait and checks results.
+ * @return true if all scripts passed, false otherwise.
+ */
+bool RunPythonScripts(const std::string& script_path,
+                      const std::vector<std::vector<std::string>>& arg_sets,
+                      const std::string& skip_message) {
+  std::vector<pid_t> pids;
+
+  for (const auto& args : arg_sets) {
+    pid_t pid = fork();
+    if (pid == 0) {
+      int result = executePythonScript(script_path, args);
+      if (result == 0xfd00) {
+        exit(SUCCESS_CODE);
+      }
+      exit(result);
+    } else if (pid > 0) {
+      pids.push_back(pid);
+    } else {
+      perror("fork failed");
+      return false;
+    }
+  }
+
+  bool all_passed = true;
+  for (pid_t pid : pids) {
+    int status;
+    if (waitpid(pid, &status, 0) == -1) {
+      perror("waitpid failed");
+      return false;
+    }
+    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+      if (WIFEXITED(status) && WEXITSTATUS(status) == 0xfd00) {
+        // Import error - will be handled by caller
+        continue;
+      }
+      all_passed = false;
+    }
+  }
+  return all_passed;
+}
+
 // ============================================================================
 // Parameterized Variable Tests
 // ============================================================================
@@ -368,205 +439,52 @@ class VariableTest : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
 };
 
 TEST_P(VariableTest, SETUP) {
-  // Ensure directory exists
   std::filesystem::create_directories(base_path_);
 
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-
-  // Create i2 (int16)
-  auto i2Spec = CreateTypedVariableSpec(version_, "i2", base_path_, "<i2",
-                                        "int16", "2-byte integer test");
-  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
-  auto [i2Store, i2Metadata] = i2Schema;
-  auto i2 =
-      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-
-  // Create i4 (int32)
-  auto i4Spec = CreateTypedVariableSpec(version_, "i4", base_path_, "<i4",
-                                        "int32", "4-byte integer test");
-  auto i4Schema = mdio::internal::ValidateAndProcessJson(i4Spec).value();
-  auto [i4Store, i4Metadata] = i4Schema;
-  auto i4 =
-      mdio::internal::CreateVariable(i4Store, i4Metadata, std::move(options));
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-
-  // Create i8 (int64)
-  auto i8Spec = CreateTypedVariableSpec(version_, "i8", base_path_, "<i8",
-                                        "int64", "8-byte integer test");
-  auto i8Schema = mdio::internal::ValidateAndProcessJson(i8Spec).value();
-  auto [i8Store, i8Metadata] = i8Schema;
-  auto i8 =
-      mdio::internal::CreateVariable(i8Store, i8Metadata, std::move(options));
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-
-  // Create f2 (float16)
-  auto f2Spec = CreateTypedVariableSpec(version_, "f2", base_path_, "<f2",
-                                        "float16", "2-byte float test");
-  auto f2Schema = mdio::internal::ValidateAndProcessJson(f2Spec).value();
-  auto [f2Store, f2Metadata] = f2Schema;
-  auto f2 =
-      mdio::internal::CreateVariable(f2Store, f2Metadata, std::move(options));
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-
-  // Create f4 (float32)
-  auto f4Spec = CreateTypedVariableSpec(version_, "f4", base_path_, "<f4",
-                                        "float32", "4-byte float test");
-  auto f4Schema = mdio::internal::ValidateAndProcessJson(f4Spec).value();
-  auto [f4Store, f4Metadata] = f4Schema;
-  auto f4 =
-      mdio::internal::CreateVariable(f4Store, f4Metadata, std::move(options));
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-
-  // Create f8 (float64)
-  auto f8Spec = CreateTypedVariableSpec(version_, "f8", base_path_, "<f8",
-                                        "float64", "8-byte float test");
-  auto f8Schema = mdio::internal::ValidateAndProcessJson(f8Spec).value();
-  auto [f8Store, f8Metadata] = f8Schema;
-  auto f8 =
-      mdio::internal::CreateVariable(f8Store, f8Metadata, std::move(options));
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  // Create u1 (uint8)
-  auto u1Spec =
-      CreateTypedVariableSpec(version_, "u1", base_path_, "<u1", "uint8",
-                              "1-byte unsigned integer test");
-  auto u1Schema = mdio::internal::ValidateAndProcessJson(u1Spec).value();
-  auto [u1Store, u1Metadata] = u1Schema;
-  auto u1 =
-      mdio::internal::CreateVariable(u1Store, u1Metadata, std::move(options));
-  ASSERT_TRUE(u1.status().ok()) << u1.status();
-
-  // Create u2 (uint16)
-  auto u2Spec =
-      CreateTypedVariableSpec(version_, "u2", base_path_, "<u2", "uint16",
-                              "2-byte unsigned integer test");
-  auto u2Schema = mdio::internal::ValidateAndProcessJson(u2Spec).value();
-  auto [u2Store, u2Metadata] = u2Schema;
-  auto u2 =
-      mdio::internal::CreateVariable(u2Store, u2Metadata, std::move(options));
-  ASSERT_TRUE(u2.status().ok()) << u2.status();
-
-  // Create u8 (uint64)
-  auto u8Spec =
-      CreateTypedVariableSpec(version_, "u8", base_path_, "<u8", "uint64",
-                              "8-byte unsigned integer test");
-  auto u8Schema = mdio::internal::ValidateAndProcessJson(u8Spec).value();
-  auto [u8Store, u8Metadata] = u8Schema;
-  auto u8 =
-      mdio::internal::CreateVariable(u8Store, u8Metadata, std::move(options));
-  ASSERT_TRUE(u8.status().ok()) << u8.status();
-
-  // Create b1 (bool)
-  auto b1Spec = CreateTypedVariableSpec(version_, "b1", base_path_, "|b1",
-                                        "bool", "boolean test");
-  auto b1Schema = mdio::internal::ValidateAndProcessJson(b1Spec).value();
-  auto [b1Store, b1Metadata] = b1Schema;
-  auto b1 =
-      mdio::internal::CreateVariable(b1Store, b1Metadata, std::move(options));
-  ASSERT_TRUE(b1.status().ok()) << b1.status();
+  for (const auto& def : kTestVariables) {
+    CreateTestVariable(def, version_, base_path_);
+  }
 }
 
 TEST_P(VariableTest, open) {
-  auto i2Base = CreateBaseSpec(version_, "i2", base_path_);
-  auto i4Base = CreateBaseSpec(version_, "i4", base_path_);
-  auto i8Base = CreateBaseSpec(version_, "i8", base_path_);
-  auto f2Base = CreateBaseSpec(version_, "f2", base_path_);
-  auto f4Base = CreateBaseSpec(version_, "f4", base_path_);
-  auto f8Base = CreateBaseSpec(version_, "f8", base_path_);
-
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i2Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i4Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(i8Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f2Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f4Base, mdio::constants::kOpen).status().ok());
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(f8Base, mdio::constants::kOpen).status().ok());
+  for (const auto& def : kTestVariables) {
+    auto var = OpenTestVariable(def.name, version_, base_path_);
+    EXPECT_TRUE(var.status().ok()) << "Failed to open " << def.name << ": "
+                                   << var.status();
+  }
 }
 
 TEST_P(VariableTest, name) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i4", base_path_),
-                                   mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i8", base_path_),
-                                   mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f2", base_path_),
-                                   mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
-                                   mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f8", base_path_),
-                                   mdio::constants::kOpen);
-
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_EQ(i2.value().get_variable_name(), "i2");
-  EXPECT_EQ(i4.value().get_variable_name(), "i4");
-  EXPECT_EQ(i8.value().get_variable_name(), "i8");
-  EXPECT_EQ(f2.value().get_variable_name(), "f2");
-  EXPECT_EQ(f4.value().get_variable_name(), "f4");
-  EXPECT_EQ(f8.value().get_variable_name(), "f8");
+  for (const auto& def : kTestVariables) {
+    auto var = OpenTestVariable(def.name, version_, base_path_);
+    ASSERT_TRUE(var.status().ok()) << var.status();
+    EXPECT_EQ(var.value().get_variable_name(), def.name);
+  }
 }
 
 TEST_P(VariableTest, longName) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i4", base_path_),
-                                   mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i8", base_path_),
-                                   mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f2", base_path_),
-                                   mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
-                                   mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f8", base_path_),
-                                   mdio::constants::kOpen);
-
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-
-  EXPECT_EQ(i2.value().get_long_name(), "2-byte integer test");
-  EXPECT_EQ(i4.value().get_long_name(), "4-byte integer test");
-  EXPECT_EQ(i8.value().get_long_name(), "8-byte integer test");
-  EXPECT_EQ(f2.value().get_long_name(), "2-byte float test");
-  EXPECT_EQ(f4.value().get_long_name(), "4-byte float test");
-  EXPECT_EQ(f8.value().get_long_name(), "8-byte float test");
+  for (const auto& def : kTestVariables) {
+    auto var = OpenTestVariable(def.name, version_, base_path_);
+    ASSERT_TRUE(var.status().ok()) << var.status();
+    EXPECT_EQ(var.value().get_long_name(), def.long_name);
+  }
 }
 
 TEST_P(VariableTest, optionalAttrs) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
   EXPECT_EQ(i2.value().GetAttributes()["attributes"]["foo"], "bar");
 }
 
 TEST_P(VariableTest, namedDimensions) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
   EXPECT_EQ(i2.value().getMetadata()["dimension_names"].size(), 2);
 }
 
 TEST_P(VariableTest, sliceByDimIdx) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
+  auto f4 = OpenTestVariable("f4", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
   ASSERT_TRUE(f4.status().ok()) << f4.status();
 
@@ -585,8 +503,7 @@ TEST_P(VariableTest, sliceByDimIdx) {
 }
 
 TEST_P(VariableTest, sliceByDimName) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
 
   mdio::RangeDescriptor<mdio::Index> inlineSlice = {"inline", 0, 5, 1};
@@ -599,74 +516,34 @@ TEST_P(VariableTest, sliceByDimName) {
 }
 
 TEST_P(VariableTest, dimensionUnits) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
   EXPECT_TRUE(i2.value().getMetadata().contains("dimension_units"));
 }
 
 TEST_P(VariableTest, chunkSize) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
   EXPECT_TRUE(i2.value().get_chunk_shape().status().ok());
 }
 
 TEST_P(VariableTest, shape) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
   EXPECT_THAT(i2.value().dimensions().shape(), ::testing::ElementsAre(10, 10));
 }
 
 TEST_P(VariableTest, dtype) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
-  auto i4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i4", base_path_),
-                                   mdio::constants::kOpen);
-  auto i8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i8", base_path_),
-                                   mdio::constants::kOpen);
-  auto f2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f2", base_path_),
-                                   mdio::constants::kOpen);
-  auto f4 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f4", base_path_),
-                                   mdio::constants::kOpen);
-  auto f8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "f8", base_path_),
-                                   mdio::constants::kOpen);
-  auto u1 = mdio::Variable<>::Open(CreateBaseSpec(version_, "u1", base_path_),
-                                   mdio::constants::kOpen);
-  auto u2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "u2", base_path_),
-                                   mdio::constants::kOpen);
-  auto u8 = mdio::Variable<>::Open(CreateBaseSpec(version_, "u8", base_path_),
-                                   mdio::constants::kOpen);
-  auto b1 = mdio::Variable<>::Open(CreateBaseSpec(version_, "b1", base_path_),
-                                   mdio::constants::kOpen);
-
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
-  ASSERT_TRUE(i4.status().ok()) << i4.status();
-  ASSERT_TRUE(i8.status().ok()) << i8.status();
-  ASSERT_TRUE(f2.status().ok()) << f2.status();
-  ASSERT_TRUE(f4.status().ok()) << f4.status();
-  ASSERT_TRUE(f8.status().ok()) << f8.status();
-  ASSERT_TRUE(u1.status().ok()) << u1.status();
-  ASSERT_TRUE(u2.status().ok()) << u2.status();
-  ASSERT_TRUE(u8.status().ok()) << u8.status();
-  ASSERT_TRUE(b1.status().ok()) << b1.status();
-
-  EXPECT_EQ(i2.value().dtype(), mdio::constants::kInt16);
-  EXPECT_EQ(i4.value().dtype(), mdio::constants::kInt32);
-  EXPECT_EQ(i8.value().dtype(), mdio::constants::kInt64);
-  EXPECT_EQ(f2.value().dtype(), mdio::constants::kFloat16);
-  EXPECT_EQ(f4.value().dtype(), mdio::constants::kFloat32);
-  EXPECT_EQ(f8.value().dtype(), mdio::constants::kFloat64);
-  EXPECT_EQ(u1.value().dtype(), mdio::constants::kUint8);
-  EXPECT_EQ(u2.value().dtype(), mdio::constants::kUint16);
-  EXPECT_EQ(u8.value().dtype(), mdio::constants::kUint64);
-  EXPECT_EQ(b1.value().dtype(), mdio::constants::kBool);
+  for (const auto& def : kTestVariables) {
+    auto var = OpenTestVariable(def.name, version_, base_path_);
+    ASSERT_TRUE(var.status().ok()) << var.status();
+    EXPECT_EQ(var.value().dtype(), def.expected_dtype)
+        << "dtype mismatch for " << def.name;
+  }
 }
 
 TEST_P(VariableTest, domain) {
-  auto i2 = mdio::Variable<>::Open(CreateBaseSpec(version_, "i2", base_path_),
-                                   mdio::constants::kOpen);
+  auto i2 = OpenTestVariable("i2", version_, base_path_);
   ASSERT_TRUE(i2.status().ok()) << i2.status();
 
   const mdio::Index EXPECTED_SHAPE = 10;
@@ -675,17 +552,9 @@ TEST_P(VariableTest, domain) {
 }
 
 TEST_P(VariableTest, TEARDOWN) {
-  std::filesystem::remove_all(base_path_ + "/i2");
-  std::filesystem::remove_all(base_path_ + "/i4");
-  std::filesystem::remove_all(base_path_ + "/i8");
-  std::filesystem::remove_all(base_path_ + "/f2");
-  std::filesystem::remove_all(base_path_ + "/f4");
-  std::filesystem::remove_all(base_path_ + "/f8");
-  std::filesystem::remove_all(base_path_ + "/u1");
-  std::filesystem::remove_all(base_path_ + "/u2");
-  std::filesystem::remove_all(base_path_ + "/u8");
-  std::filesystem::remove_all(base_path_ + "/b1");
-  ASSERT_TRUE(true);
+  for (const auto& def : kTestVariables) {
+    std::filesystem::remove_all(base_path_ + "/" + def.name);
+  }
 }
 
 INSTANTIATE_TEST_SUITE_P(
@@ -709,8 +578,7 @@ class VariableDataTest
   }
 
   mdio::Variable<> getVariable() {
-    auto spec = CreateBaseSpec(version_, "i2", base_path_);
-    auto var = mdio::Variable<>::Open(spec, mdio::constants::kOpen);
+    auto var = OpenTestVariable("i2", version_, base_path_);
     if (!var.status().ok()) {
       std::cout << "Error opening i2: " << var.status() << std::endl;
       return mdio::Variable<>();
@@ -723,19 +591,9 @@ class VariableDataTest
 };
 
 TEST_P(VariableDataTest, SETUP) {
-  // Ensure directory exists
   std::filesystem::create_directories(base_path_);
-
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-
-  auto i2Spec = CreateTypedVariableSpec(version_, "i2", base_path_, "<i2",
-                                        "int16", "2-byte integer test");
-  auto i2Schema = mdio::internal::ValidateAndProcessJson(i2Spec).value();
-  auto [i2Store, i2Metadata] = i2Schema;
-  auto i2 =
-      mdio::internal::CreateVariable(i2Store, i2Metadata, std::move(options));
-  ASSERT_TRUE(i2.status().ok()) << i2.status();
+  // Only create i2 for this test class
+  CreateTestVariable(kTestVariables[0], version_, base_path_);
 }
 
 TEST_P(VariableDataTest, name) {
@@ -1333,39 +1191,40 @@ INSTANTIATE_TEST_SUITE_P(
 
 namespace V2OnlyTests {
 
+constexpr char kVoidedPath[] = "zarrs/acceptance/voided";
+
+nlohmann::json GetVoidedBaseSpec() {
+  nlohmann::json spec;
+  spec["driver"] = "zarr";
+  spec["kvstore"]["driver"] = "file";
+  spec["kvstore"]["path"] = kVoidedPath;
+  return spec;
+}
+
+mdio::Future<mdio::Variable<>> OpenVoidedVariable() {
+  return mdio::Variable<>::Open(GetVoidedBaseSpec(), mdio::constants::kOpen);
+}
+
 TEST(VariableV2Only, structArraySetup) {
   mdio::TransactionalOpenOptions options;
   auto opt = options.Set(std::move(mdio::constants::kCreateClean));
 
-  nlohmann::json voidedSpec = R"(
-        {
-            "driver": "zarr",
-            "kvstore": {
-                "driver": "file",
-                "path": "zarrs/acceptance/voided"
-            },
-            "field": "integer16",
-            "metadata": {
-                "dtype": [["integer16", "<i2"], ["float32", "<f4"], ["double", "<f8"]],
-                "shape": [10, 10],
-                "chunks": [5, 5],
-                "dimension_separator": "/",
-                "compressor": {
-                    "id": "blosc"
-                }
-            },
-            "attributes": {
-                "metadata": {
-                    "attributes": {
-                        "foo": "bar"
-                    }
-                },
-                "long_name": "struct array test",
-                "dimension_names": ["inline", "crossline"],
-                "dimension_units": ["m", "m"]
-            }
-        }
-    )"_json;
+  nlohmann::json voidedSpec = GetVoidedBaseSpec();
+  voidedSpec["field"] = "integer16";
+  voidedSpec["metadata"]["dtype"] = nlohmann::json::array(
+      {nlohmann::json::array({"integer16", "<i2"}),
+       nlohmann::json::array({"float32", "<f4"}),
+       nlohmann::json::array({"double", "<f8"})});
+  voidedSpec["metadata"]["shape"] = nlohmann::json::array({10, 10});
+  voidedSpec["metadata"]["chunks"] = nlohmann::json::array({5, 5});
+  voidedSpec["metadata"]["dimension_separator"] = "/";
+  voidedSpec["metadata"]["compressor"]["id"] = "blosc";
+  voidedSpec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
+  voidedSpec["attributes"]["long_name"] = "struct array test";
+  voidedSpec["attributes"]["dimension_names"] =
+      nlohmann::json::array({"inline", "crossline"});
+  voidedSpec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
+
   auto voidedSchema =
       mdio::internal::ValidateAndProcessJson(voidedSpec).value();
   auto [voidedStore, voidedMetadata] = voidedSchema;
@@ -1375,65 +1234,24 @@ TEST(VariableV2Only, structArraySetup) {
 }
 
 TEST(VariableV2Only, structArrayOpen) {
-  nlohmann::json voidedBase = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/voided"
-        }
-    }
-)"_json;
-
-  EXPECT_TRUE(
-      mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen).status().ok());
+  EXPECT_TRUE(OpenVoidedVariable().status().ok());
 }
 
 TEST(VariableV2Only, structArrayName) {
-  nlohmann::json voidedBase = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/voided"
-        }
-    }
-)"_json;
-
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  auto voided = OpenVoidedVariable();
   ASSERT_TRUE(voided.status().ok()) << voided.status();
   EXPECT_EQ(voided.value().get_variable_name(), "voided");
   EXPECT_EQ(voided.value().get_long_name(), "struct array test");
 }
 
 TEST(VariableV2Only, structArrayDtype) {
-  nlohmann::json voidedBase = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/voided"
-        }
-    }
-)"_json;
-
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  auto voided = OpenVoidedVariable();
   ASSERT_TRUE(voided.status().ok()) << voided.status();
   EXPECT_EQ(voided.value().dtype(), mdio::constants::kByte);
 }
 
 TEST(VariableV2Only, structArrayShape) {
-  nlohmann::json voidedBase = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/voided"
-        }
-    }
-)"_json;
-
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  auto voided = OpenVoidedVariable();
   ASSERT_TRUE(voided.status().ok()) << voided.status();
   EXPECT_THAT(voided.value().dimensions().shape(),
               ::testing::ElementsAre(10, 10, 14));
@@ -1441,17 +1259,7 @@ TEST(VariableV2Only, structArrayShape) {
 }
 
 TEST(VariableV2Only, structArraySlice) {
-  nlohmann::json voidedBase = R"(
-    {
-        "driver": "zarr",
-        "kvstore": {
-            "driver": "file",
-            "path": "zarrs/acceptance/voided"
-        }
-    }
-)"_json;
-
-  auto voided = mdio::Variable<>::Open(voidedBase, mdio::constants::kOpen);
+  auto voided = OpenVoidedVariable();
   ASSERT_TRUE(voided.status().ok()) << voided.status();
 
   mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
@@ -1463,8 +1271,7 @@ TEST(VariableV2Only, structArraySlice) {
 }
 
 TEST(VariableV2Only, structArrayTeardown) {
-  std::filesystem::remove_all("zarrs/acceptance/voided");
-  ASSERT_TRUE(true);
+  std::filesystem::remove_all(kVoidedPath);
 }
 
 // selectField and fillValue tests moved to parameterized DatasetTest
@@ -1477,96 +1284,49 @@ TEST(VariableV2Only, structArrayTeardown) {
 
 namespace V2CompatibilityTests {
 
-TEST(VariableV2Compat, zarrCompatibility) {
-  // First setup variables for testing
-  std::filesystem::remove_all("zarrs/compat_test");
-  std::filesystem::create_directories("zarrs/compat_test");
-
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-
-  std::vector<std::tuple<std::string, std::string, std::string>> vars = {
-      {"i2", "<i2", "2-byte integer"}, {"i4", "<i4", "4-byte integer"},
-      {"i8", "<i8", "8-byte integer"}, {"f2", "<f2", "2-byte float"},
-      {"f4", "<f4", "4-byte float"},   {"f8", "<f8", "8-byte float"},
-  };
-
-  for (const auto& [name, dtype, long_name] : vars) {
-    nlohmann::json spec;
-    spec["driver"] = "zarr";
-    spec["kvstore"]["driver"] = "file";
-    spec["kvstore"]["path"] = "zarrs/compat_test/" + name;
-    spec["metadata"]["dtype"] = dtype;
-    spec["metadata"]["shape"] = nlohmann::json::array({10, 10});
-    spec["metadata"]["chunks"] = nlohmann::json::array({5, 5});
-    spec["metadata"]["dimension_separator"] = "/";
-    spec["metadata"]["compressor"]["id"] = "blosc";
-    spec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
-    spec["attributes"]["long_name"] = long_name;
-    spec["attributes"]["dimension_names"] =
-        nlohmann::json::array({"inline", "crossline"});
-    spec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
+constexpr char kCompatTestPath[] = "zarrs/compat_test";
+constexpr char kXarrayCompatPath[] = "zarrs/xarray_compat";
+
+// Subset of test variables for V2 compatibility testing (first 6)
+const std::vector<TestVariableDef> kCompatTestVars = {
+    {"i2", "<i2", "int16", "2-byte integer", mdio::constants::kInt16},
+    {"i4", "<i4", "int32", "4-byte integer", mdio::constants::kInt32},
+    {"i8", "<i8", "int64", "8-byte integer", mdio::constants::kInt64},
+    {"f2", "<f2", "float16", "2-byte float", mdio::constants::kFloat16},
+    {"f4", "<f4", "float32", "4-byte float", mdio::constants::kFloat32},
+    {"f8", "<f8", "float64", "8-byte float", mdio::constants::kFloat64},
+};
 
-    auto schema = mdio::internal::ValidateAndProcessJson(spec).value();
-    auto [store, metadata] = schema;
-    auto var =
-        mdio::internal::CreateVariable(store, metadata, std::move(options));
-    ASSERT_TRUE(var.status().ok()) << var.status();
-  }
+TEST(VariableV2Compat, zarrCompatibility) {
+  std::filesystem::remove_all(kCompatTestPath);
+  std::filesystem::create_directories(kCompatTestPath);
 
-  const char* basePath = std::getenv(PROJECT_BASE_PATH_ENV);
-  if (!basePath) {
-    std::cout << "PROJECT_BASE_PATH environment variable not set. Expecting to "
-                 "be in the 'build/mdio' directory."
-              << std::endl;
-    basePath = DEFAULT_BASE_PATH;
+  // Create test variables using V2 format
+  for (const auto& def : kCompatTestVars) {
+    CreateTestVariable(def, mdio::zarr::ZarrVersion::kV2, kCompatTestPath);
   }
 
-  std::string srcPath = std::string(basePath) + ZARR_SCRIPT_RELATIVE_PATH;
+  std::string srcPath =
+      std::string(GetPythonBasePath()) + ZARR_SCRIPT_RELATIVE_PATH;
 
   if (access(srcPath.c_str(), F_OK) == -1) {
     std::cerr << "Error: Python script not found at " << srcPath << std::endl;
     FAIL() << "Script not found: " << srcPath;
   }
 
-  std::vector<std::string> args = {"i2", "i4", "i8", "f2", "f4", "f8"};
-  std::vector<pid_t> pids;
-
-  for (const auto& arg : args) {
-    pid_t pid = fork();
-    if (pid == 0) {
-      int result = executePythonScript(srcPath, {"zarrs/compat_test/" + arg});
-      if (result == 0xfd00) {
-        GTEST_SKIP() << "Zarr compatibility skipped due to import error";
-        exit(SUCCESS_CODE);
-      }
-      exit(result);
-    } else if (pid > 0) {
-      pids.push_back(pid);
-    } else {
-      perror("fork failed");
-      FAIL() << "fork failed";
-    }
+  std::vector<std::vector<std::string>> arg_sets;
+  for (const auto& def : kCompatTestVars) {
+    arg_sets.push_back({std::string(kCompatTestPath) + "/" + def.name});
   }
 
-  for (pid_t pid : pids) {
-    int status;
-    if (waitpid(pid, &status, 0) == -1) {
-      perror("waitpid failed");
-      FAIL() << "waitpid failed";
-    }
-    if (WIFEXITED(status) && WEXITSTATUS(status) == 0xfd00) {
-      GTEST_SKIP() << "Zarr compatibility skipped due to import error";
-    }
-    EXPECT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0)
-        << "Failed to read one of the arguments";
-  }
+  EXPECT_TRUE(RunPythonScripts(srcPath, arg_sets,
+                               "Zarr compatibility skipped due to import error"))
+      << "Failed to read one of the arguments";
 
-  std::filesystem::remove_all("zarrs/compat_test");
+  std::filesystem::remove_all(kCompatTestPath);
 }
 
 TEST(DatasetV2Compat, xarrayCompatible) {
-  // First create a dataset
   std::string manifest = R"(
 {
   "metadata": {
@@ -1603,65 +1363,31 @@ TEST(DatasetV2Compat, xarrayCompatible) {
 }
   )";
 
-  std::filesystem::remove_all("zarrs/xarray_compat");
+  std::filesystem::remove_all(kXarrayCompatPath);
   nlohmann::json j = nlohmann::json::parse(manifest);
-  auto ds = mdio::Dataset::from_json(j, "zarrs/xarray_compat",
+  auto ds = mdio::Dataset::from_json(j, kXarrayCompatPath,
                                      mdio::constants::kCreateClean);
   ASSERT_TRUE(ds.status().ok()) << ds.status();
 
-  const char* basePath = std::getenv(PROJECT_BASE_PATH_ENV);
-  if (!basePath) {
-    std::cout << "PROJECT_BASE_PATH environment variable not set. Expecting to "
-                 "be in the 'build/mdio' directory."
-              << std::endl;
-    basePath = DEFAULT_BASE_PATH;
-  }
-
-  std::string srcPath = std::string(basePath) + XARRAY_SCRIPT_RELATIVE_PATH;
+  std::string srcPath =
+      std::string(GetPythonBasePath()) + XARRAY_SCRIPT_RELATIVE_PATH;
 
   if (access(srcPath.c_str(), F_OK) == -1) {
     std::cerr << "Error: Python script not found at " << srcPath << std::endl;
-    std::filesystem::remove_all("zarrs/xarray_compat");
+    std::filesystem::remove_all(kXarrayCompatPath);
     FAIL() << "Script not found: " << srcPath;
   }
 
-  std::vector<std::string> metadataOptions = {"False", "True"};
-  std::vector<pid_t> pids;
-
-  for (const auto& option : metadataOptions) {
-    pid_t pid = fork();
-    if (pid == 0) {
-      int result =
-          executePythonScript(srcPath, {"zarrs/xarray_compat/", option});
-      if (result == 0xfd00) {
-        GTEST_SKIP()
-            << "Xarray compatibility skipped due to import error for xarray";
-        exit(SUCCESS_CODE);
-      }
-      exit(result);
-    } else if (pid > 0) {
-      pids.push_back(pid);
-    } else {
-      perror("fork failed");
-      FAIL() << "fork failed";
-    }
-  }
+  std::vector<std::vector<std::string>> arg_sets = {
+      {std::string(kXarrayCompatPath) + "/", "False"},
+      {std::string(kXarrayCompatPath) + "/", "True"},
+  };
 
-  for (pid_t pid : pids) {
-    int status;
-    if (waitpid(pid, &status, 0) == -1) {
-      perror("waitpid failed");
-      FAIL() << "waitpid failed";
-    }
-    if (WIFEXITED(status) && WEXITSTATUS(status) == 0xfd00) {
-      GTEST_SKIP()
-          << "Xarray compatibility skipped due to import error for xarray";
-    }
-    EXPECT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0)
-        << "xarray compatibility test failed";
-  }
+  EXPECT_TRUE(RunPythonScripts(srcPath, arg_sets,
+                               "Xarray compatibility skipped due to import error"))
+      << "xarray compatibility test failed";
 
-  std::filesystem::remove_all("zarrs/xarray_compat");
+  std::filesystem::remove_all(kXarrayCompatPath);
 }
 
 }  // namespace V2CompatibilityTests

From b78d7bc4789e3719b16e477827519a1ff9e573a3 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Fri, 2 Jan 2026 22:45:39 +0000
Subject: [PATCH 23/26] Begin fixing metadata serialization errors

---
 mdio/acceptance_test.cc                       | 181 ++++--------------
 .../xarray_compatibility_test.py              |   1 +
 mdio/variable.h                               |  11 +-
 mdio/zarr/zarr_v3.h                           | 112 ++++++-----
 4 files changed, 112 insertions(+), 193 deletions(-)

diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index 612067e..5294f46 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -39,8 +39,6 @@ namespace {
 constexpr char PYTHON_EXECUTABLE[] = "python3";
 constexpr char PROJECT_BASE_PATH_ENV[] = "PROJECT_BASE_PATH";
 constexpr char DEFAULT_BASE_PATH[] = "../..";
-constexpr char ZARR_SCRIPT_RELATIVE_PATH[] =
-    "/mdio/regression_tests/zarr_compatibility.py";
 constexpr char XARRAY_SCRIPT_RELATIVE_PATH[] =
     "/mdio/regression_tests/xarray_compatibility_test.py";
 constexpr int ERROR_CODE = EXIT_FAILURE;
@@ -1186,147 +1184,24 @@ INSTANTIATE_TEST_SUITE_P(
     });
 
 // ============================================================================
-// V2-Only Tests (Struct Arrays)
+// Parameterized Python/Xarray Dataset Compatibility Tests
 // ============================================================================
 
-namespace V2OnlyTests {
-
-constexpr char kVoidedPath[] = "zarrs/acceptance/voided";
-
-nlohmann::json GetVoidedBaseSpec() {
-  nlohmann::json spec;
-  spec["driver"] = "zarr";
-  spec["kvstore"]["driver"] = "file";
-  spec["kvstore"]["path"] = kVoidedPath;
-  return spec;
-}
-
-mdio::Future<mdio::Variable<>> OpenVoidedVariable() {
-  return mdio::Variable<>::Open(GetVoidedBaseSpec(), mdio::constants::kOpen);
-}
-
-TEST(VariableV2Only, structArraySetup) {
-  mdio::TransactionalOpenOptions options;
-  auto opt = options.Set(std::move(mdio::constants::kCreateClean));
-
-  nlohmann::json voidedSpec = GetVoidedBaseSpec();
-  voidedSpec["field"] = "integer16";
-  voidedSpec["metadata"]["dtype"] = nlohmann::json::array(
-      {nlohmann::json::array({"integer16", "<i2"}),
-       nlohmann::json::array({"float32", "<f4"}),
-       nlohmann::json::array({"double", "<f8"})});
-  voidedSpec["metadata"]["shape"] = nlohmann::json::array({10, 10});
-  voidedSpec["metadata"]["chunks"] = nlohmann::json::array({5, 5});
-  voidedSpec["metadata"]["dimension_separator"] = "/";
-  voidedSpec["metadata"]["compressor"]["id"] = "blosc";
-  voidedSpec["attributes"]["metadata"]["attributes"]["foo"] = "bar";
-  voidedSpec["attributes"]["long_name"] = "struct array test";
-  voidedSpec["attributes"]["dimension_names"] =
-      nlohmann::json::array({"inline", "crossline"});
-  voidedSpec["attributes"]["dimension_units"] = nlohmann::json::array({"m", "m"});
-
-  auto voidedSchema =
-      mdio::internal::ValidateAndProcessJson(voidedSpec).value();
-  auto [voidedStore, voidedMetadata] = voidedSchema;
-  auto voided = mdio::internal::CreateVariable(voidedStore, voidedMetadata,
-                                               std::move(options));
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-}
-
-TEST(VariableV2Only, structArrayOpen) {
-  EXPECT_TRUE(OpenVoidedVariable().status().ok());
-}
-
-TEST(VariableV2Only, structArrayName) {
-  auto voided = OpenVoidedVariable();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-  EXPECT_EQ(voided.value().get_variable_name(), "voided");
-  EXPECT_EQ(voided.value().get_long_name(), "struct array test");
-}
-
-TEST(VariableV2Only, structArrayDtype) {
-  auto voided = OpenVoidedVariable();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-  EXPECT_EQ(voided.value().dtype(), mdio::constants::kByte);
-}
-
-TEST(VariableV2Only, structArrayShape) {
-  auto voided = OpenVoidedVariable();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-  EXPECT_THAT(voided.value().dimensions().shape(),
-              ::testing::ElementsAre(10, 10, 14));
-  EXPECT_EQ(voided.value().dimensions().rank(), 3);
-}
-
-TEST(VariableV2Only, structArraySlice) {
-  auto voided = OpenVoidedVariable();
-  ASSERT_TRUE(voided.status().ok()) << voided.status();
-
-  mdio::RangeDescriptor<mdio::Index> zeroIdxSlice = {0, 0, 5, 1};
-  mdio::RangeDescriptor<mdio::Index> oneIdxSlice = {1, 0, 5, 1};
-  auto voidedSlice = voided.value().slice(zeroIdxSlice, oneIdxSlice);
-  EXPECT_TRUE(voidedSlice.status().ok()) << voidedSlice.status();
-  EXPECT_THAT(voidedSlice.value().dimensions().shape(),
-              ::testing::ElementsAre(5, 5, 14));
-}
-
-TEST(VariableV2Only, structArrayTeardown) {
-  std::filesystem::remove_all(kVoidedPath);
-}
-
-// selectField and fillValue tests moved to parameterized DatasetTest
-
-}  // namespace V2OnlyTests
-
-// ============================================================================
-// V2 Compatibility Tests (Python)
-// ============================================================================
-
-namespace V2CompatibilityTests {
-
-constexpr char kCompatTestPath[] = "zarrs/compat_test";
-constexpr char kXarrayCompatPath[] = "zarrs/xarray_compat";
-
-// Subset of test variables for V2 compatibility testing (first 6)
-const std::vector<TestVariableDef> kCompatTestVars = {
-    {"i2", "<i2", "int16", "2-byte integer", mdio::constants::kInt16},
-    {"i4", "<i4", "int32", "4-byte integer", mdio::constants::kInt32},
-    {"i8", "<i8", "int64", "8-byte integer", mdio::constants::kInt64},
-    {"f2", "<f2", "float16", "2-byte float", mdio::constants::kFloat16},
-    {"f4", "<f4", "float32", "4-byte float", mdio::constants::kFloat32},
-    {"f8", "<f8", "float64", "8-byte float", mdio::constants::kFloat64},
-};
-
-TEST(VariableV2Compat, zarrCompatibility) {
-  std::filesystem::remove_all(kCompatTestPath);
-  std::filesystem::create_directories(kCompatTestPath);
-
-  // Create test variables using V2 format
-  for (const auto& def : kCompatTestVars) {
-    CreateTestVariable(def, mdio::zarr::ZarrVersion::kV2, kCompatTestPath);
-  }
-
-  std::string srcPath =
-      std::string(GetPythonBasePath()) + ZARR_SCRIPT_RELATIVE_PATH;
-
-  if (access(srcPath.c_str(), F_OK) == -1) {
-    std::cerr << "Error: Python script not found at " << srcPath << std::endl;
-    FAIL() << "Script not found: " << srcPath;
-  }
-
-  std::vector<std::vector<std::string>> arg_sets;
-  for (const auto& def : kCompatTestVars) {
-    arg_sets.push_back({std::string(kCompatTestPath) + "/" + def.name});
+class XarrayCompatibilityTest
+    : public ::testing::TestWithParam<mdio::zarr::ZarrVersion> {
+ protected:
+  void SetUp() override {
+    version_ = GetParam();
+    base_path_ = GetBasePath(version_);
   }
 
-  EXPECT_TRUE(RunPythonScripts(srcPath, arg_sets,
-                               "Zarr compatibility skipped due to import error"))
-      << "Failed to read one of the arguments";
-
-  std::filesystem::remove_all(kCompatTestPath);
-}
+  mdio::zarr::ZarrVersion version_;
+  std::string base_path_;
+};
 
-TEST(DatasetV2Compat, xarrayCompatible) {
+TEST_P(XarrayCompatibilityTest, datasetCompatible) {
+  // This test verifies that a Dataset created by MDIO can be opened by xarray.
+  // The dataset is created fresh for this test to ensure isolation.
   std::string manifest = R"(
 {
   "metadata": {
@@ -1363,9 +1238,11 @@ TEST(DatasetV2Compat, xarrayCompatible) {
 }
   )";
 
-  std::filesystem::remove_all(kXarrayCompatPath);
+  std::string test_path = base_path_ + "/xarray_compat";
+  std::filesystem::remove_all(test_path);
+
   nlohmann::json j = nlohmann::json::parse(manifest);
-  auto ds = mdio::Dataset::from_json(j, kXarrayCompatPath,
+  auto ds = mdio::Dataset::from_json(j, test_path, version_,
                                      mdio::constants::kCreateClean);
   ASSERT_TRUE(ds.status().ok()) << ds.status();
 
@@ -1374,23 +1251,35 @@ TEST(DatasetV2Compat, xarrayCompatible) {
 
   if (access(srcPath.c_str(), F_OK) == -1) {
     std::cerr << "Error: Python script not found at " << srcPath << std::endl;
-    std::filesystem::remove_all(kXarrayCompatPath);
+    std::filesystem::remove_all(test_path);
     FAIL() << "Script not found: " << srcPath;
   }
 
+  // Test without consolidated metadata (both versions)
+  // Note: Consolidated metadata is only supported for V2
   std::vector<std::vector<std::string>> arg_sets = {
-      {std::string(kXarrayCompatPath) + "/", "False"},
-      {std::string(kXarrayCompatPath) + "/", "True"},
+      {test_path + "/", "False"},
   };
+  if (version_ == mdio::zarr::ZarrVersion::kV2) {
+    // Also test with consolidated metadata for V2
+    arg_sets.push_back({test_path + "/", "True"});
+  }
 
+  std::string version_name = ZarrVersionToString(version_);
   EXPECT_TRUE(RunPythonScripts(srcPath, arg_sets,
                                "Xarray compatibility skipped due to import error"))
-      << "xarray compatibility test failed";
+      << "xarray " << version_name << " compatibility test failed";
 
-  std::filesystem::remove_all(kXarrayCompatPath);
+  // std::filesystem::remove_all(test_path);
 }
 
-}  // namespace V2CompatibilityTests
+INSTANTIATE_TEST_SUITE_P(
+    ZarrVersions, XarrayCompatibilityTest,
+    ::testing::Values(mdio::zarr::ZarrVersion::kV2,
+                      mdio::zarr::ZarrVersion::kV3),
+    [](const ::testing::TestParamInfo<mdio::zarr::ZarrVersion>& info) {
+      return ZarrVersionToString(info.param);
+    });
 
 // ============================================================================
 // Dataset::from_json with Version Parameter Tests
diff --git a/mdio/regression_tests/xarray_compatibility_test.py b/mdio/regression_tests/xarray_compatibility_test.py
index 826d865..5b2eca4 100644
--- a/mdio/regression_tests/xarray_compatibility_test.py
+++ b/mdio/regression_tests/xarray_compatibility_test.py
@@ -13,6 +13,7 @@ def test_xarray_dataset(file_path, consolidated_metadata):
   else:
     consolidated_metadata = False
   try:
+    print(f"Opening dataset: {file_path} with consolidated metadata: {consolidated_metadata}")
     ds = xr.open_zarr(
         file_path,
         consolidated=consolidated_metadata,
diff --git a/mdio/variable.h b/mdio/variable.h
index 7b12adb..3e5b414 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -659,10 +659,17 @@ Future<Variable<T, R, M>> OpenVariable(const nlohmann::json& json_store,
         nlohmann::json::parse(std::string(kvs_read.value), nullptr, false);
     if (zarr_version == zarr::ZarrVersion::kV3) {
       // For V3, extract attributes from zarr.json
+      nlohmann::json result;
       if (parsed.contains("attributes")) {
-        return parsed["attributes"];
+        result = parsed["attributes"];
+      } else {
+        result = nlohmann::json::object();
+      }
+      // For V3, dimension_names is at the root level of zarr.json
+      if (parsed.contains("dimension_names")) {
+        result["dimension_names"] = parsed["dimension_names"];
       }
-      return nlohmann::json::object();
+      return result;
     }
     // For V2, the entire file is attributes
     return parsed;
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index 0514b3f..c272b59 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -169,9 +169,10 @@ inline nlohmann::json PrepareVariableAttributes(const nlohmann::json& json) {
     attrs = json["attributes"];
   }
 
-  // MDIO-specific: Convert dimension_names to _ARRAY_DIMENSIONS
+  // For V3, dimension_names goes at the root level (not in attributes)
+  // so we remove it from attributes here - it will be added at root level
+  // in WriteVariableAttributes
   if (attrs.contains("dimension_names")) {
-    attrs["_ARRAY_DIMENSIONS"] = attrs["dimension_names"];
     attrs.erase("dimension_names");
   }
 
@@ -251,18 +252,9 @@ inline Future<void> WriteMetadata(
 
   auto kvs_future = tensorstore::kvstore::Open(kvstore, context);
 
-  // Extract variable names from json_variables for discovery
-  nlohmann::json var_names = nlohmann::json::array();
-  for (const auto& var : json_variables) {
-    std::string path = var["kvstore"]["path"].get<std::string>();
-    std::vector<std::string> path_parts = absl::StrSplit(path, '/');
-    var_names.push_back(path_parts.back());
-  }
-
-  // Create root metadata with variables list for discovery
-  nlohmann::json root_attrs = dataset_metadata;
-  root_attrs["variables"] = var_names;
-  auto root_metadata = CreateGroupMetadata(root_attrs);
+  // Create root metadata (variables are discovered via directory listing,
+  // not stored in zarr.json)
+  auto root_metadata = CreateGroupMetadata(dataset_metadata);
 
   auto root_future = tensorstore::MapFutureValue(
       tensorstore::InlineExecutor{},
@@ -358,37 +350,51 @@ ReadMetadata(const std::string& dataset_path,
 
               std::vector<nlohmann::json> json_vars;
 
-              // Check if dataset_metadata contains variable information
-              if (dataset_metadata.contains("variables")) {
-                for (const auto& var_name : dataset_metadata["variables"]) {
-                  std::string name = var_name.get<std::string>();
-                  // Ensure proper path separator
-                  std::string sep =
-                      (!dataset_path.empty() && dataset_path.back() != '/')
-                          ? "/"
-                          : "";
-                  nlohmann::json var_spec = {
-                      {"driver", std::string(kDriverName)},
-                      {"kvstore",
-                       {{"driver", driver},
-                        {"path", dataset_path + sep + name}}}};
-                  if (driver != "file") {
-                    var_spec["kvstore"]["bucket"] = bucket;
-                    std::string cloud_sep =
-                        (!cloudPath.empty() && cloudPath.back() != '/') ? "/"
-                                                                        : "";
-                    var_spec["kvstore"]["path"] = cloudPath + cloud_sep + name;
+              // For file-based stores, discover variables by scanning directory
+              if (driver == "file") {
+                // Normalize path - remove trailing slash if present
+                std::string normalized_path = dataset_path;
+                while (!normalized_path.empty() &&
+                       normalized_path.back() == '/') {
+                  normalized_path.pop_back();
+                }
+
+                // Scan directory for subdirectories containing zarr.json
+                std::error_code ec;
+                for (const auto& entry :
+                     std::filesystem::directory_iterator(normalized_path, ec)) {
+                  if (entry.is_directory()) {
+                    // Check if this directory contains a zarr.json (is a zarr
+                    // array)
+                    auto zarr_json_path = entry.path() / "zarr.json";
+                    if (std::filesystem::exists(zarr_json_path)) {
+                      std::string var_name = entry.path().filename().string();
+                      nlohmann::json var_spec = {
+                          {"driver", std::string(kDriverName)},
+                          {"kvstore",
+                           {{"driver", "file"},
+                            {"path", normalized_path + "/" + var_name}}}};
+                      json_vars.push_back(var_spec);
+                    }
                   }
-                  json_vars.push_back(var_spec);
                 }
+                if (ec) {
+                  promise.SetResult(absl::InvalidArgumentError(
+                      "Failed to scan directory: " + ec.message()));
+                  return;
+                }
+              } else {
+                // For cloud stores, fall back to requiring explicit variable
+                // specs
+                promise.SetResult(absl::InvalidArgumentError(
+                    "Zarr V3 cloud store discovery not yet supported. "
+                    "Please specify variable specs explicitly."));
+                return;
               }
 
               if (json_vars.empty()) {
-                // Return error - V3 discovery requires variable names
                 promise.SetResult(absl::InvalidArgumentError(
-                    "Zarr V3 store discovery requires 'variables' list in root "
-                    "zarr.json attributes. Please specify variable specs "
-                    "explicitly."));
+                    "No Zarr V3 arrays found in directory."));
                 return;
               }
 
@@ -455,11 +461,22 @@ Future<tensorstore::TimestampedStorageGeneration> WriteVariableAttributes(
       }
     }
 
+    // Extract dimension_names before preparing attributes (goes at root level)
+    nlohmann::json dimension_names;
+    if (json_var.contains("dimension_names")) {
+      dimension_names = json_var["dimension_names"];
+    }
+
     // Prepare and update attributes
     auto attrs =
         PrepareVariableAttributes(nlohmann::json{{"attributes", json_var}});
     zarr_json["attributes"] = attrs;
 
+    // Add dimension_names at root level (Zarr V3 spec)
+    if (!dimension_names.is_null()) {
+      zarr_json["dimension_names"] = dimension_names;
+    }
+
     // Write back
     auto write_result = tensorstore::kvstore::Write(
         store.kvstore(), "zarr.json", absl::Cord(zarr_json.dump(4)));
@@ -494,11 +511,17 @@ inline Future<nlohmann::json> ReadVariableAttributes(
         try {
           auto zarr_json =
               nlohmann::json::parse(std::string(ready_result.value().value));
+          nlohmann::json attrs;
           if (zarr_json.contains("attributes")) {
-            promise.SetResult(zarr_json["attributes"]);
+            attrs = zarr_json["attributes"];
           } else {
-            promise.SetResult(nlohmann::json::object());
+            attrs = nlohmann::json::object();
+          }
+          // Read dimension_names from root level and add to attrs for MDIO
+          if (zarr_json.contains("dimension_names")) {
+            attrs["dimension_names"] = zarr_json["dimension_names"];
           }
+          promise.SetResult(attrs);
         } catch (const nlohmann::json::parse_error& e) {
           promise.SetResult(absl::InvalidArgumentError(
               std::string("JSON parse error: ") + e.what()));
@@ -521,10 +544,9 @@ inline nlohmann::json ConvertToMdioMetadata(const nlohmann::json& zarr_json) {
     mdio_metadata = zarr_json["attributes"];
   }
 
-  // Convert _ARRAY_DIMENSIONS back to dimension_names
-  if (mdio_metadata.contains("_ARRAY_DIMENSIONS")) {
-    mdio_metadata["dimension_names"] = mdio_metadata["_ARRAY_DIMENSIONS"];
-    mdio_metadata.erase("_ARRAY_DIMENSIONS");
+  // For V3, dimension_names is at root level
+  if (zarr_json.contains("dimension_names")) {
+    mdio_metadata["dimension_names"] = zarr_json["dimension_names"];
   }
 
   return mdio_metadata;

From 19b2855898a2bf14b076917006ddff23f5329eee Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Mon, 5 Jan 2026 20:01:57 +0000
Subject: [PATCH 24/26] Resolve zarr3 outputting improper metadata, fix
 filesystem access to use Tensorstore instead of STL libraries for cloud
 native access

---
 mdio/zarr/zarr_v3.h | 182 ++++++++++++++++++++++++++++----------------
 1 file changed, 117 insertions(+), 65 deletions(-)

diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index c272b59..c7596d0 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -15,7 +15,8 @@
 #ifndef MDIO_ZARR_ZARR_V3_H_
 #define MDIO_ZARR_ZARR_V3_H_
 
-#include <filesystem>
+#include <algorithm>
+#include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -158,6 +159,7 @@ inline nlohmann::json CreateArrayMetadata(
  * @brief Prepares MDIO attributes for Zarr V3 format.
  *
  * In Zarr V3, attributes are embedded directly in zarr.json.
+ * For xarray compatibility, dimension_names is converted to _ARRAY_DIMENSIONS.
  *
  * @param json The variable JSON specification.
  * @return nlohmann::json The prepared attributes for Zarr V3.
@@ -169,10 +171,9 @@ inline nlohmann::json PrepareVariableAttributes(const nlohmann::json& json) {
     attrs = json["attributes"];
   }
 
-  // For V3, dimension_names goes at the root level (not in attributes)
-  // so we remove it from attributes here - it will be added at root level
-  // in WriteVariableAttributes
+  // Convert dimension_names to _ARRAY_DIMENSIONS for xarray compatibility
   if (attrs.contains("dimension_names")) {
+    attrs["_ARRAY_DIMENSIONS"] = attrs["dimension_names"];
     attrs.erase("dimension_names");
   }
 
@@ -279,7 +280,8 @@ inline Future<void> WriteMetadata(
  * @brief Reads dataset metadata from Zarr V3 format (non-consolidated).
  *
  * For Zarr V3, we read the root zarr.json and then discover arrays
- * by listing the directory contents.
+ * by listing the kvstore contents and checking each zarr.json for
+ * node_type="array" (skipping groups).
  *
  * @param dataset_path The path to the dataset.
  * @param kvs_future A future to the KvStore.
@@ -301,13 +303,13 @@ ReadMetadata(const std::string& dataset_path,
 
         auto kvs = ready_kvs.value();
 
-        // Read root zarr.json using async chaining to avoid deadlock
+        // Read root zarr.json
         auto root_read_future = tensorstore::kvstore::Read(kvs, "zarr.json");
 
         root_read_future.ExecuteWhenReady(
-            [promise = std::move(promise), dataset_path](
-                tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
-                    root_read_ready) {
+            [promise = std::move(promise), dataset_path,
+             kvs](tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
+                      root_read_ready) mutable {
               if (!root_read_ready.result().ok()) {
                 promise.SetResult(root_read_ready.result().status());
                 return;
@@ -329,10 +331,8 @@ ReadMetadata(const std::string& dataset_path,
                 dataset_metadata = root_json["attributes"];
               }
 
-              // Infer the driver
+              // Infer the driver from path prefix
               std::string driver = "file";
-              std::string bucket;
-              std::string cloudPath;
               if (dataset_path.length() > 5) {
                 if (dataset_path.substr(0, 5) == "gs://") {
                   driver = "gcs";
@@ -340,65 +340,109 @@ ReadMetadata(const std::string& dataset_path,
                   driver = "s3";
                 }
               }
-              if (driver != "file") {
-                std::string providedPath = dataset_path.substr(5);
-                size_t bucketLen = providedPath.find_first_of('/');
-                bucket = providedPath.substr(0, bucketLen);
-                cloudPath = providedPath.substr(bucketLen + 1,
-                                                providedPath.length() - 2);
+
+              // Normalize path - remove trailing slash if present
+              std::string normalized_path = dataset_path;
+              while (!normalized_path.empty() &&
+                     normalized_path.back() == '/') {
+                normalized_path.pop_back();
               }
 
-              std::vector<nlohmann::json> json_vars;
+              // Use kvstore List to discover child zarr.json files
+              auto list_future = tensorstore::kvstore::ListFuture(kvs);
+              list_future.ExecuteWhenReady(
+                  [promise = std::move(promise), dataset_metadata,
+                   normalized_path, driver,
+                   kvs](tensorstore::ReadyFuture<
+                        std::vector<tensorstore::kvstore::ListEntry>>
+                            list_ready) mutable {
+                    if (!list_ready.result().ok()) {
+                      promise.SetResult(list_ready.result().status());
+                      return;
+                    }
 
-              // For file-based stores, discover variables by scanning directory
-              if (driver == "file") {
-                // Normalize path - remove trailing slash if present
-                std::string normalized_path = dataset_path;
-                while (!normalized_path.empty() &&
-                       normalized_path.back() == '/') {
-                  normalized_path.pop_back();
-                }
+                    // Find all child zarr.json files (pattern: NAME/zarr.json)
+                    std::vector<std::string> candidates;
+                    for (const auto& entry : list_ready.value()) {
+                      std::string key = entry.key;
+                      // Look for pattern: something/zarr.json (one level deep)
+                      size_t slash_pos = key.find('/');
+                      if (slash_pos != std::string::npos &&
+                          key.substr(slash_pos + 1) == "zarr.json") {
+                        std::string name = key.substr(0, slash_pos);
+                        // Avoid duplicates
+                        if (std::find(candidates.begin(), candidates.end(),
+                                      name) == candidates.end()) {
+                          candidates.push_back(name);
+                        }
+                      }
+                    }
 
-                // Scan directory for subdirectories containing zarr.json
-                std::error_code ec;
-                for (const auto& entry :
-                     std::filesystem::directory_iterator(normalized_path, ec)) {
-                  if (entry.is_directory()) {
-                    // Check if this directory contains a zarr.json (is a zarr
-                    // array)
-                    auto zarr_json_path = entry.path() / "zarr.json";
-                    if (std::filesystem::exists(zarr_json_path)) {
-                      std::string var_name = entry.path().filename().string();
-                      nlohmann::json var_spec = {
-                          {"driver", std::string(kDriverName)},
-                          {"kvstore",
-                           {{"driver", "file"},
-                            {"path", normalized_path + "/" + var_name}}}};
-                      json_vars.push_back(var_spec);
+                    if (candidates.empty()) {
+                      promise.SetResult(absl::InvalidArgumentError(
+                          "No Zarr V3 arrays found in directory."));
+                      return;
                     }
-                  }
-                }
-                if (ec) {
-                  promise.SetResult(absl::InvalidArgumentError(
-                      "Failed to scan directory: " + ec.message()));
-                  return;
-                }
-              } else {
-                // For cloud stores, fall back to requiring explicit variable
-                // specs
-                promise.SetResult(absl::InvalidArgumentError(
-                    "Zarr V3 cloud store discovery not yet supported. "
-                    "Please specify variable specs explicitly."));
-                return;
-              }
 
-              if (json_vars.empty()) {
-                promise.SetResult(absl::InvalidArgumentError(
-                    "No Zarr V3 arrays found in directory."));
-                return;
-              }
+                    // Read all child zarr.json files to check node_type
+                    using ReadFuture =
+                        tensorstore::Future<tensorstore::kvstore::ReadResult>;
+                    auto read_futures =
+                        std::make_shared<std::vector<ReadFuture>>();
+                    std::vector<tensorstore::AnyFuture> any_futures;
+
+                    for (const auto& name : candidates) {
+                      auto f =
+                          tensorstore::kvstore::Read(kvs, name + "/zarr.json");
+                      read_futures->push_back(f);
+                      any_futures.push_back(std::move(f));
+                    }
 
-              promise.SetResult(std::make_tuple(dataset_metadata, json_vars));
+                    // Wait for all reads and then filter by node_type
+                    auto all_reads = tensorstore::WaitAllFuture(any_futures);
+                    all_reads.ExecuteWhenReady(
+                        [promise = std::move(promise), dataset_metadata,
+                         normalized_path, driver, candidates, read_futures](
+                            tensorstore::ReadyFuture<void>) mutable {
+                          std::vector<nlohmann::json> json_vars;
+
+                          for (size_t i = 0; i < candidates.size(); ++i) {
+                            const auto& read_result =
+                                (*read_futures)[i].result();
+                            if (!read_result.ok() ||
+                                !read_result->has_value()) {
+                              continue;
+                            }
+                            try {
+                              auto child_json = ::nlohmann::json::parse(
+                                  std::string(read_result->value));
+                              // Only include arrays, skip groups
+                              if (child_json.contains("node_type") &&
+                                  child_json["node_type"].get<std::string>() ==
+                                      "array") {
+                                nlohmann::json var_spec = {
+                                    {"driver", std::string(kDriverName)},
+                                    {"kvstore",
+                                     {{"driver", driver},
+                                      {"path", normalized_path + "/" +
+                                                   candidates[i]}}}};
+                                json_vars.push_back(var_spec);
+                              }
+                            } catch (const nlohmann::json::exception&) {
+                              // Skip malformed zarr.json
+                            }
+                          }
+
+                          if (json_vars.empty()) {
+                            promise.SetResult(absl::InvalidArgumentError(
+                                "No Zarr V3 arrays found in directory."));
+                            return;
+                          }
+
+                          promise.SetResult(
+                              std::make_tuple(dataset_metadata, json_vars));
+                        });
+                  });
             });
       });
 
@@ -534,6 +578,8 @@ inline Future<nlohmann::json> ReadVariableAttributes(
 /**
  * @brief Helper to convert Zarr V3 metadata to MDIO-compatible format.
  *
+ * Converts _ARRAY_DIMENSIONS back to dimension_names for internal MDIO use.
+ *
  * @param zarr_json The Zarr V3 zarr.json content.
  * @return nlohmann::json The MDIO-compatible metadata.
  */
@@ -544,7 +590,13 @@ inline nlohmann::json ConvertToMdioMetadata(const nlohmann::json& zarr_json) {
     mdio_metadata = zarr_json["attributes"];
   }
 
-  // For V3, dimension_names is at root level
+  // Convert _ARRAY_DIMENSIONS back to dimension_names for MDIO
+  if (mdio_metadata.contains("_ARRAY_DIMENSIONS")) {
+    mdio_metadata["dimension_names"] = mdio_metadata["_ARRAY_DIMENSIONS"];
+    mdio_metadata.erase("_ARRAY_DIMENSIONS");
+  }
+
+  // Also check root level dimension_names (V3 spec)
   if (zarr_json.contains("dimension_names")) {
     mdio_metadata["dimension_names"] = zarr_json["dimension_names"];
   }

From b1c673fec9628bfb077fb921463b5807d021eee7 Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Mon, 5 Jan 2026 21:17:25 +0000
Subject: [PATCH 25/26] Refactor metadata handling and path utilities for Zarr
 drivers

- Introduced shared utilities for inferring drivers and normalizing paths in `dataset_factory.h` and `dataset.h`.
- Updated metadata transformation logic to streamline handling of local and cloud paths.
- Added comprehensive tests for new utility functions in `zarr_test.cc` to ensure correctness.
- Improved code readability and reduced duplication across driver implementations.
---
 mdio/dataset.h          |  41 ++---
 mdio/dataset_factory.h  |  46 ++---
 mdio/variable.h         |  11 +-
 mdio/zarr/zarr_driver.h | 125 ++++++++++++++
 mdio/zarr/zarr_test.cc  | 239 ++++++++++++++++++++++++++
 mdio/zarr/zarr_v2.h     | 285 +++++++++++++++++--------------
 mdio/zarr/zarr_v3.h     | 366 ++++++++++++++++++++++++----------------
 7 files changed, 772 insertions(+), 341 deletions(-)

diff --git a/mdio/dataset.h b/mdio/dataset.h
index a60e735..23de5c1 100644
--- a/mdio/dataset.h
+++ b/mdio/dataset.h
@@ -100,44 +100,27 @@ inline Future<void> write_zmetadata(
 inline Future<tensorstore::KvStore> dataset_kvs_store(
     const std::string& dataset_path,
     tensorstore::Context context = tensorstore::Context::Default()) {
-  // the tensorstore driver needs a bucket field
   ::nlohmann::json kvstore;
 
-  absl::string_view output_file = dataset_path;
-
-  if (absl::StartsWith(output_file, "gs://")) {
-    absl::ConsumePrefix(&output_file, "gs://");
-    kvstore["driver"] = "gcs";
-  } else if (absl::StartsWith(output_file, "s3://")) {
-    absl::ConsumePrefix(&output_file, "s3://");
-    kvstore["driver"] = "s3";
-  } else {
-    kvstore["driver"] = "file";
-    std::string path = std::string(output_file);
-    if (!path.empty() && path.back() != '/') {
-      path.push_back('/');
-    }
-    kvstore["path"] = path;
+  // Use shared utility to infer driver from path prefix
+  std::string driver = zarr::InferDriverFromPath(dataset_path);
+  kvstore["driver"] = driver;
+
+  if (driver == "file") {
+    // Local file system - just normalize with trailing slash
+    kvstore["path"] = zarr::NormalizePathWithSlash(dataset_path);
     return tensorstore::kvstore::Open(kvstore, context);
-  }  // FIXME - we need azure support ...
+  }
 
-  std::vector<std::string> file_parts = absl::StrSplit(output_file, '/');
-  if (file_parts.size() < 2) {
+  // Cloud storage (GCS or S3) - extract bucket and path
+  auto [bucket, path] = zarr::ExtractCloudPath(dataset_path);
+  if (bucket.empty()) {
     return absl::InvalidArgumentError(
         "gcs/s3 drivers requires [s3/gs]://[bucket]/[path_to_file]");
   }
 
-  std::string bucket = file_parts[0];
-  std::string filepath(file_parts[1]);
-  for (std::size_t i = 2; i < file_parts.size(); ++i) {
-    filepath += "/" + file_parts[i];
-  }
-  if (!filepath.empty() && filepath.back() != '/') {
-    filepath.push_back('/');
-  }
-  // update the bucket and path ...
   kvstore["bucket"] = bucket;
-  kvstore["path"] = filepath;
+  kvstore["path"] = zarr::NormalizePathWithSlash(path);
 
   return tensorstore::kvstore::Open(kvstore, context);
 }
diff --git a/mdio/dataset_factory.h b/mdio/dataset_factory.h
index 6672ad4..0dc25ff 100644
--- a/mdio/dataset_factory.h
+++ b/mdio/dataset_factory.h
@@ -252,44 +252,26 @@ inline void transform_shape(
  */
 inline absl::Status transform_metadata(const std::string& path,
                                        nlohmann::json& variable /*NOLINT*/) {
-  std::string bucket =
-      "NULL";  // Default value, if is NULL don't add a bucket field
-  std::string driver = "file";
-  if (absl::StartsWith(path, "gs://")) {
-    driver = "gcs";
-  } else if (absl::StartsWith(path, "s3://")) {
-    driver = "s3";
-  }
+  // Use shared utilities for driver inference and path handling
+  std::string driver = mdio::zarr::InferDriverFromPath(path);
+  std::string var_name = variable["kvstore"]["path"].get<std::string>();
 
-  std::string filepath;
+  variable["kvstore"]["driver"] = driver;
 
-  if (driver != "file") {
-    std::string _path = path;
-    // Ensure _path has a trailing slash or the mdio file will not be created
-    // properly
-    if (_path.back() != '/') {
-      _path += '/';
-    }
-    _path = _path.substr(5);
-    std::vector<std::string> file_parts = absl::StrSplit(_path, '/');
-    if (file_parts.size() < 2) {
+  if (driver == "file") {
+    // Local filesystem - normalize path with trailing slash
+    variable["kvstore"]["path"] =
+        mdio::zarr::NormalizePathWithSlash(path) + var_name;
+  } else {
+    // Cloud storage (GCS or S3) - extract bucket and path
+    auto [bucket, cloud_path] = mdio::zarr::ExtractCloudPath(path);
+    if (bucket.empty()) {
       return absl::InvalidArgumentError(
           "Cloud path requires [gs/s3]://[bucket]/[path to file] name");
     }
-    bucket = file_parts[0];
-    filepath = file_parts[1];
-    for (std::size_t i = 2; i < file_parts.size(); ++i) {
-      filepath += "/" + file_parts[i];
-    }
-    filepath += variable["kvstore"]["path"].get<std::string>();
-  } else {
-    filepath = path + "/";
-    filepath += variable["kvstore"]["path"].get<std::string>();
-  }
-  variable["kvstore"]["path"] = filepath;
-  variable["kvstore"]["driver"] = driver;
-  if (bucket != "NULL") {
     variable["kvstore"]["bucket"] = bucket;
+    variable["kvstore"]["path"] =
+        mdio::zarr::NormalizePathWithSlash(cloud_path) + var_name;
   }
 
   return absl::OkStatus();
diff --git a/mdio/variable.h b/mdio/variable.h
index 3e5b414..355c861 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -15,7 +15,6 @@
 #ifndef MDIO_VARIABLE_H_
 #define MDIO_VARIABLE_H_
 
-#include <filesystem>
 #include <limits>
 #include <map>
 #include <memory>
@@ -282,9 +281,13 @@ Result<std::tuple<nlohmann::json, nlohmann::json>> ValidateAndProcessJson(
 
   // Create a new JSON and add the kvstore
   nlohmann::json new_json = json_spec["attributes"];
-  // update the variable name
-  new_json["variable_name"] =
-      std::filesystem::path(json_spec["kvstore"]["path"]).stem().string();
+  // update the variable name - extract last path component
+  std::string path = json_spec["kvstore"]["path"].get<std::string>();
+  // Remove trailing slashes
+  path = zarr::NormalizePath(path);
+  // Extract last component (variable name)
+  std::vector<std::string> path_parts = absl::StrSplit(path, '/');
+  new_json["variable_name"] = path_parts.empty() ? path : path_parts.back();
 
   return std::make_tuple(json_for_store, new_json);
 }
diff --git a/mdio/zarr/zarr_driver.h b/mdio/zarr/zarr_driver.h
index 526e114..85fb169 100644
--- a/mdio/zarr/zarr_driver.h
+++ b/mdio/zarr/zarr_driver.h
@@ -213,6 +213,131 @@ inline std::string GetAttributesFileName(ZarrVersion version,
  */
 inline std::string GetConsolidatedMetadataFileName() { return ".zmetadata"; }
 
+// ============================================================================
+// Shared Path and Driver Utilities
+// ============================================================================
+
+/**
+ * @brief Infers the kvstore driver from a path prefix.
+ * @param path The dataset path.
+ * @return The driver name ("file", "gcs", or "s3").
+ */
+inline std::string InferDriverFromPath(const std::string& path) {
+  if (path.length() > 5) {
+    if (path.substr(0, 5) == "gs://") return "gcs";
+    if (path.substr(0, 5) == "s3://") return "s3";
+  }
+  return "file";
+}
+
+/**
+ * @brief Normalizes a path by removing trailing slashes.
+ * @param path The input path.
+ * @return The normalized path without trailing slashes.
+ */
+inline std::string NormalizePath(const std::string& path) {
+  std::string result = path;
+  while (!result.empty() && result.back() == '/') {
+    result.pop_back();
+  }
+  return result;
+}
+
+/**
+ * @brief Normalizes a path by ensuring it has a trailing slash.
+ * @param path The input path.
+ * @return The normalized path with a trailing slash.
+ */
+inline std::string NormalizePathWithSlash(const std::string& path) {
+  std::string result = path;
+  if (!result.empty() && result.back() != '/') {
+    result.push_back('/');
+  }
+  return result;
+}
+
+/**
+ * @brief Extracts bucket and path from a cloud URL.
+ * @param url The full cloud URL (gs://bucket/path or s3://bucket/path).
+ * @return A pair of (bucket, path).
+ */
+inline std::pair<std::string, std::string> ExtractCloudPath(
+    const std::string& url) {
+  if (url.length() <= 5) return {"", ""};
+  std::string without_scheme = url.substr(5);
+  size_t bucket_end = without_scheme.find('/');
+  if (bucket_end == std::string::npos) {
+    return {without_scheme, ""};
+  }
+  return {without_scheme.substr(0, bucket_end),
+          without_scheme.substr(bucket_end + 1)};
+}
+
+// ============================================================================
+// Shared JSON Utilities
+// ============================================================================
+
+/**
+ * @brief Safely parses JSON from a kvstore read result.
+ * @param read_result The read result containing raw bytes.
+ * @return Result containing parsed JSON or an error.
+ */
+inline Result<nlohmann::json> ParseJsonFromReadResult(
+    const tensorstore::kvstore::ReadResult& read_result) {
+  if (!read_result.has_value()) {
+    return absl::NotFoundError("Read result has no value");
+  }
+  try {
+    return nlohmann::json::parse(std::string(read_result.value));
+  } catch (const nlohmann::json::parse_error& e) {
+    return absl::InvalidArgumentError(std::string("JSON parse error: ") +
+                                     e.what());
+  }
+}
+
+/**
+ * @brief Safely gets a string value from JSON.
+ * @param json The JSON object.
+ * @param key The key to look up.
+ * @param default_value The default if key doesn't exist.
+ * @return The string value or default.
+ */
+inline std::string GetJsonString(const nlohmann::json& json,
+                                const std::string& key,
+                                const std::string& default_value = "") {
+  if (json.contains(key) && json[key].is_string()) {
+    return json[key].get<std::string>();
+  }
+  return default_value;
+}
+
+/**
+ * @brief Safely gets a JSON object value.
+ * @param json The JSON object.
+ * @param key The key to look up.
+ * @return The object value or empty object.
+ */
+inline nlohmann::json GetJsonObject(const nlohmann::json& json,
+                                   const std::string& key) {
+  if (json.contains(key) && json[key].is_object()) {
+    return json[key];
+  }
+  return nlohmann::json::object();
+}
+
+/**
+ * @brief Extracts the variable name from a key path (e.g., "varname/.zarray").
+ * @param key The full key path.
+ * @return The variable name portion.
+ */
+inline std::string ExtractVariableName(const std::string& key) {
+  size_t slash_pos = key.find('/');
+  if (slash_pos != std::string::npos) {
+    return key.substr(0, slash_pos);
+  }
+  return key;
+}
+
 }  // namespace zarr
 }  // namespace mdio
 
diff --git a/mdio/zarr/zarr_test.cc b/mdio/zarr/zarr_test.cc
index b27452b..c2cffb3 100644
--- a/mdio/zarr/zarr_test.cc
+++ b/mdio/zarr/zarr_test.cc
@@ -216,6 +216,174 @@ TEST(ZarrDriver, GetConsolidatedMetadataFileName) {
   EXPECT_EQ(filename, ".zmetadata");
 }
 
+// =============================================================================
+// Path and Driver Utility Tests
+// =============================================================================
+
+TEST(ZarrDriver, InferDriverFromPath_LocalFile) {
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("/path/to/data"), "file");
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("relative/path"), "file");
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("./data"), "file");
+}
+
+TEST(ZarrDriver, InferDriverFromPath_GCS) {
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("gs://bucket/path"), "gcs");
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("gs://my-bucket/nested/path"),
+            "gcs");
+}
+
+TEST(ZarrDriver, InferDriverFromPath_S3) {
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("s3://bucket/path"), "s3");
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("s3://my-bucket/nested/path"),
+            "s3");
+}
+
+TEST(ZarrDriver, InferDriverFromPath_ShortPaths) {
+  // Paths shorter than 5 chars should default to file
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath("abc"), "file");
+  EXPECT_EQ(mdio::zarr::InferDriverFromPath(""), "file");
+}
+
+TEST(ZarrDriver, NormalizePath_RemovesTrailingSlash) {
+  EXPECT_EQ(mdio::zarr::NormalizePath("/path/to/data/"), "/path/to/data");
+  EXPECT_EQ(mdio::zarr::NormalizePath("/path/to/data///"), "/path/to/data");
+}
+
+TEST(ZarrDriver, NormalizePath_NoTrailingSlash) {
+  EXPECT_EQ(mdio::zarr::NormalizePath("/path/to/data"), "/path/to/data");
+}
+
+TEST(ZarrDriver, NormalizePath_EmptyPath) {
+  EXPECT_EQ(mdio::zarr::NormalizePath(""), "");
+  EXPECT_EQ(mdio::zarr::NormalizePath("/"), "");
+}
+
+TEST(ZarrDriver, NormalizePathWithSlash_AddsTrailingSlash) {
+  EXPECT_EQ(mdio::zarr::NormalizePathWithSlash("/path/to/data"),
+            "/path/to/data/");
+}
+
+TEST(ZarrDriver, NormalizePathWithSlash_AlreadyHasSlash) {
+  EXPECT_EQ(mdio::zarr::NormalizePathWithSlash("/path/to/data/"),
+            "/path/to/data/");
+}
+
+TEST(ZarrDriver, NormalizePathWithSlash_EmptyPath) {
+  EXPECT_EQ(mdio::zarr::NormalizePathWithSlash(""), "");
+}
+
+TEST(ZarrDriver, ExtractCloudPath_GCS) {
+  auto [bucket, path] = mdio::zarr::ExtractCloudPath("gs://my-bucket/path/to/data");
+  EXPECT_EQ(bucket, "my-bucket");
+  EXPECT_EQ(path, "path/to/data");
+}
+
+TEST(ZarrDriver, ExtractCloudPath_S3) {
+  auto [bucket, path] = mdio::zarr::ExtractCloudPath("s3://my-bucket/nested/path");
+  EXPECT_EQ(bucket, "my-bucket");
+  EXPECT_EQ(path, "nested/path");
+}
+
+TEST(ZarrDriver, ExtractCloudPath_BucketOnly) {
+  auto [bucket, path] = mdio::zarr::ExtractCloudPath("gs://my-bucket");
+  EXPECT_EQ(bucket, "my-bucket");
+  EXPECT_EQ(path, "");
+}
+
+TEST(ZarrDriver, ExtractCloudPath_ShortUrl) {
+  auto [bucket, path] = mdio::zarr::ExtractCloudPath("gs:/");
+  EXPECT_EQ(bucket, "");
+  EXPECT_EQ(path, "");
+}
+
+// =============================================================================
+// JSON Utility Tests
+// =============================================================================
+
+TEST(ZarrDriver, GetJsonString_ExistingKey) {
+  nlohmann::json json = {{"name", "test"}, {"version", "1.0"}};
+  EXPECT_EQ(mdio::zarr::GetJsonString(json, "name"), "test");
+  EXPECT_EQ(mdio::zarr::GetJsonString(json, "version"), "1.0");
+}
+
+TEST(ZarrDriver, GetJsonString_MissingKey) {
+  nlohmann::json json = {{"name", "test"}};
+  EXPECT_EQ(mdio::zarr::GetJsonString(json, "missing"), "");
+  EXPECT_EQ(mdio::zarr::GetJsonString(json, "missing", "default"), "default");
+}
+
+TEST(ZarrDriver, GetJsonString_NonStringValue) {
+  nlohmann::json json = {{"number", 42}, {"array", {1, 2, 3}}};
+  EXPECT_EQ(mdio::zarr::GetJsonString(json, "number"), "");
+  EXPECT_EQ(mdio::zarr::GetJsonString(json, "array", "fallback"), "fallback");
+}
+
+TEST(ZarrDriver, GetJsonObject_ExistingKey) {
+  nlohmann::json json = {{"metadata", {{"key", "value"}}}};
+  auto obj = mdio::zarr::GetJsonObject(json, "metadata");
+  EXPECT_TRUE(obj.is_object());
+  EXPECT_EQ(obj["key"], "value");
+}
+
+TEST(ZarrDriver, GetJsonObject_MissingKey) {
+  nlohmann::json json = {{"name", "test"}};
+  auto obj = mdio::zarr::GetJsonObject(json, "missing");
+  EXPECT_TRUE(obj.is_object());
+  EXPECT_TRUE(obj.empty());
+}
+
+TEST(ZarrDriver, GetJsonObject_NonObjectValue) {
+  nlohmann::json json = {{"name", "test"}, {"array", {1, 2, 3}}};
+  auto obj = mdio::zarr::GetJsonObject(json, "name");
+  EXPECT_TRUE(obj.is_object());
+  EXPECT_TRUE(obj.empty());
+}
+
+TEST(ZarrDriver, ExtractVariableName_WithSlash) {
+  EXPECT_EQ(mdio::zarr::ExtractVariableName("myvar/.zarray"), "myvar");
+  EXPECT_EQ(mdio::zarr::ExtractVariableName("data/zarr.json"), "data");
+  EXPECT_EQ(mdio::zarr::ExtractVariableName("nested/path/file"), "nested");
+}
+
+TEST(ZarrDriver, ExtractVariableName_NoSlash) {
+  EXPECT_EQ(mdio::zarr::ExtractVariableName("myvar"), "myvar");
+  EXPECT_EQ(mdio::zarr::ExtractVariableName(".zarray"), ".zarray");
+}
+
+TEST(ZarrDriver, ParseJsonFromReadResult_Valid) {
+  // Create a mock read result with valid JSON
+  tensorstore::kvstore::ReadResult result;
+  result.state = tensorstore::kvstore::ReadResult::kValue;
+  result.value = absl::Cord(R"({"key": "value", "number": 42})");
+
+  auto parsed = mdio::zarr::ParseJsonFromReadResult(result);
+  ASSERT_TRUE(parsed.ok()) << parsed.status();
+  EXPECT_EQ(parsed.value()["key"], "value");
+  EXPECT_EQ(parsed.value()["number"], 42);
+}
+
+TEST(ZarrDriver, ParseJsonFromReadResult_InvalidJson) {
+  tensorstore::kvstore::ReadResult result;
+  result.state = tensorstore::kvstore::ReadResult::kValue;
+  result.value = absl::Cord("not valid json {{{");
+
+  auto parsed = mdio::zarr::ParseJsonFromReadResult(result);
+  EXPECT_FALSE(parsed.ok());
+  EXPECT_THAT(parsed.status().message(),
+              testing::HasSubstr("JSON parse error"));
+}
+
+TEST(ZarrDriver, ParseJsonFromReadResult_NoValue) {
+  tensorstore::kvstore::ReadResult result;
+  result.state = tensorstore::kvstore::ReadResult::kMissing;
+  // value is not set
+
+  auto parsed = mdio::zarr::ParseJsonFromReadResult(result);
+  EXPECT_FALSE(parsed.ok());
+  EXPECT_THAT(parsed.status().message(),
+              testing::HasSubstr("no value"));
+}
+
 }  // namespace ZarrDriverTests
 
 // =============================================================================
@@ -658,6 +826,77 @@ TEST(ZarrV3, ReadVariableAttributes_NoAttributesInFile) {
   std::filesystem::remove_all(tmpDir);
 }
 
+// =============================================================================
+// V3 Utility Function Tests
+// =============================================================================
+
+TEST(ZarrV3, IsArrayMetadata_True) {
+  nlohmann::json array_json = {{"node_type", "array"}, {"zarr_format", 3}};
+  EXPECT_TRUE(mdio::zarr::v3::IsArrayMetadata(array_json));
+}
+
+TEST(ZarrV3, IsArrayMetadata_False_Group) {
+  nlohmann::json group_json = {{"node_type", "group"}, {"zarr_format", 3}};
+  EXPECT_FALSE(mdio::zarr::v3::IsArrayMetadata(group_json));
+}
+
+TEST(ZarrV3, IsArrayMetadata_False_NoNodeType) {
+  nlohmann::json json = {{"zarr_format", 3}};
+  EXPECT_FALSE(mdio::zarr::v3::IsArrayMetadata(json));
+}
+
+TEST(ZarrV3, ExtractChildArrayCandidates_ValidEntries) {
+  std::vector<tensorstore::kvstore::ListEntry> entries;
+  entries.push_back({"var1/zarr.json", {}});
+  entries.push_back({"var2/zarr.json", {}});
+  entries.push_back({"var3/data/chunk", {}});  // Not a zarr.json
+  entries.push_back({"zarr.json", {}});        // Root, no slash
+
+  auto candidates = mdio::zarr::v3::ExtractChildArrayCandidates(entries);
+
+  EXPECT_EQ(candidates.size(), 2);
+  EXPECT_THAT(candidates, testing::Contains("var1"));
+  EXPECT_THAT(candidates, testing::Contains("var2"));
+  EXPECT_THAT(candidates, testing::Not(testing::Contains("var3")));
+}
+
+TEST(ZarrV3, ExtractChildArrayCandidates_NoDuplicates) {
+  std::vector<tensorstore::kvstore::ListEntry> entries;
+  entries.push_back({"var1/zarr.json", {}});
+  entries.push_back({"var1/zarr.json", {}});  // Duplicate
+  entries.push_back({"var1/data", {}});
+
+  auto candidates = mdio::zarr::v3::ExtractChildArrayCandidates(entries);
+
+  EXPECT_EQ(candidates.size(), 1);
+  EXPECT_EQ(candidates[0], "var1");
+}
+
+TEST(ZarrV3, ExtractChildArrayCandidates_Empty) {
+  std::vector<tensorstore::kvstore::ListEntry> entries;
+
+  auto candidates = mdio::zarr::v3::ExtractChildArrayCandidates(entries);
+
+  EXPECT_TRUE(candidates.empty());
+}
+
+TEST(ZarrV3, BuildVariableSpec_LocalFile) {
+  auto spec = mdio::zarr::v3::BuildVariableSpec("file", "/path/to/dataset",
+                                                "myvar");
+
+  EXPECT_EQ(spec["driver"], "zarr3");
+  EXPECT_EQ(spec["kvstore"]["driver"], "file");
+  EXPECT_EQ(spec["kvstore"]["path"], "/path/to/dataset/myvar");
+}
+
+TEST(ZarrV3, BuildVariableSpec_GCS) {
+  auto spec = mdio::zarr::v3::BuildVariableSpec("gcs", "bucket/path", "myvar");
+
+  EXPECT_EQ(spec["driver"], "zarr3");
+  EXPECT_EQ(spec["kvstore"]["driver"], "gcs");
+  EXPECT_EQ(spec["kvstore"]["path"], "bucket/path/myvar");
+}
+
 }  // namespace ZarrV3Tests
 
 // =============================================================================
diff --git a/mdio/zarr/zarr_v2.h b/mdio/zarr/zarr_v2.h
index c0a086f..6eb7c35 100644
--- a/mdio/zarr/zarr_v2.h
+++ b/mdio/zarr/zarr_v2.h
@@ -15,7 +15,7 @@
 #ifndef MDIO_ZARR_ZARR_V2_H_
 #define MDIO_ZARR_ZARR_V2_H_
 
-#include <filesystem>
+#include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -193,61 +193,62 @@ inline Future<void> WriteConsolidatedMetadata(
   zmetadata["metadata"][".zattrs"] = zattrs;
   zmetadata["metadata"][".zgroup"] = zgroup;
 
-  std::string zarray_key;
-  std::string zattrs_key;
   std::string driver =
       json_variables[0]["kvstore"]["driver"].get<std::string>();
 
   for (const auto& json : json_variables) {
-    zarray_key =
-        std::filesystem::path(json["kvstore"]["path"]).stem() / ".zarray";
-    zattrs_key =
-        std::filesystem::path(json["kvstore"]["path"]).stem() / ".zattrs";
+    // Extract variable name from path (last component)
+    std::string path = json["kvstore"]["path"].get<std::string>();
+    std::vector<std::string> path_parts = absl::StrSplit(path, '/');
+    std::string var_name = path_parts.back();
+
+    std::string zarray_key = var_name + "/.zarray";
+    std::string zattrs_key = var_name + "/.zattrs";
 
     MDIO_ASSIGN_OR_RETURN(zmetadata["metadata"][zarray_key], GetZarray(json))
     zmetadata["metadata"][zattrs_key] = PrepareVariableAttributes(json);
   }
 
-  nlohmann::json kvstore = nlohmann::json::object();
-  kvstore["driver"] = driver;
+  // Extract base path by removing the last component (variable name)
   std::vector<std::string> file_parts = absl::StrSplit(
       json_variables[0]["kvstore"]["path"].get<std::string>(), '/');
   size_t toRemove = file_parts.back().size();
-  std::string strippedPath =
+  std::string basePath =
       json_variables[0]["kvstore"]["path"].get<std::string>().substr(
           0, json_variables[0]["kvstore"]["path"].get<std::string>().size() -
                  toRemove - 1);
-  kvstore["path"] = strippedPath;
+
+  nlohmann::json kvstore = nlohmann::json::object();
+  kvstore["driver"] = driver;
+  kvstore["path"] = basePath;
 
   if (driver == "gcs" || driver == "s3") {
     kvstore["bucket"] =
         json_variables[0]["kvstore"]["bucket"].get<std::string>();
-    std::string cloudPath = kvstore["path"].get<std::string>();
-    kvstore["path"] = cloudPath;
   }
 
   auto kvs_future = tensorstore::kvstore::Open(kvstore, context);
 
   auto zattrs_future = tensorstore::MapFutureValue(
       tensorstore::InlineExecutor{},
-      [zattrs = std::move(zattrs)](const tensorstore::KvStore& kvstore) {
-        return tensorstore::kvstore::Write(kvstore, "/.zattrs",
+      [zattrs = std::move(zattrs)](const tensorstore::KvStore& kvs) {
+        return tensorstore::kvstore::Write(kvs, "/.zattrs",
                                            absl::Cord(zattrs.dump(4)));
       },
       kvs_future);
 
   auto zmetadata_future = tensorstore::MapFutureValue(
       tensorstore::InlineExecutor{},
-      [zmetadata = std::move(zmetadata)](const tensorstore::KvStore& kvstore) {
-        return tensorstore::kvstore::Write(kvstore, "/.zmetadata",
+      [zmetadata = std::move(zmetadata)](const tensorstore::KvStore& kvs) {
+        return tensorstore::kvstore::Write(kvs, "/.zmetadata",
                                            absl::Cord(zmetadata.dump(4)));
       },
       kvs_future);
 
   auto zgroup_future = tensorstore::MapFutureValue(
       tensorstore::InlineExecutor{},
-      [zgroup = std::move(zgroup)](const tensorstore::KvStore& kvstore) {
-        return tensorstore::kvstore::Write(kvstore, "/.zgroup",
+      [zgroup = std::move(zgroup)](const tensorstore::KvStore& kvs) {
+        return tensorstore::kvstore::Write(kvs, "/.zgroup",
                                            absl::Cord(zgroup.dump(4)));
       },
       kvs_future);
@@ -256,6 +257,140 @@ inline Future<void> WriteConsolidatedMetadata(
                                     zgroup_future);
 }
 
+// ============================================================================
+// Async Metadata Discovery for V2
+// ============================================================================
+
+namespace internal {
+
+/**
+ * @brief State for V2 consolidated metadata reading operations.
+ *
+ * This struct holds all state needed across the async callback chain.
+ */
+struct V2MetadataState {
+  using ResultType = std::tuple<nlohmann::json, std::vector<nlohmann::json>>;
+  using PromiseType = tensorstore::Promise<ResultType>;
+
+  PromiseType promise;
+  tensorstore::KvStore kvs;
+  std::string dataset_path;
+  std::string normalized_path;
+  std::string driver;
+  std::string bucket;
+  std::string cloud_path;
+
+  explicit V2MetadataState(PromiseType p, const std::string& path)
+      : promise(std::move(p)),
+        dataset_path(path),
+        normalized_path(NormalizePathWithSlash(path)),
+        driver(InferDriverFromPath(path)) {
+    if (driver != "file") {
+      auto cloud_parts = ExtractCloudPath(path);
+      bucket = cloud_parts.first;
+      cloud_path = NormalizePathWithSlash(cloud_parts.second);
+    }
+  }
+
+  /// Completes with an error status.
+  void Fail(absl::Status status) { promise.SetResult(std::move(status)); }
+
+  /// Completes successfully.
+  void Complete(nlohmann::json metadata, std::vector<nlohmann::json> vars) {
+    promise.SetResult(std::make_tuple(std::move(metadata), std::move(vars)));
+  }
+
+  /// Builds a variable spec for the given variable name.
+  nlohmann::json BuildVariableSpec(const std::string& var_name) const {
+    nlohmann::json spec = {{"driver", std::string(kDriverName)},
+                           {"kvstore", {{"driver", driver}}}};
+    if (driver != "file") {
+      spec["kvstore"]["bucket"] = bucket;
+      spec["kvstore"]["path"] = cloud_path + var_name;
+    } else {
+      spec["kvstore"]["path"] = normalized_path + var_name;
+    }
+    return spec;
+  }
+};
+
+/// Step 2: Parse .zmetadata and build variable specs.
+inline void OnZmetadataRead(
+    std::shared_ptr<V2MetadataState> state,
+    tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult> read_ready) {
+  if (!read_ready.result().ok()) {
+    state->Fail(read_ready.result().status());
+    return;
+  }
+
+  auto parsed = ParseJsonFromReadResult(read_ready.value());
+  if (!parsed.ok()) {
+    if (!state->dataset_path.empty() && state->dataset_path.back() != '/') {
+      state->Fail(absl::InvalidArgumentError(
+          "Failed to parse .zmetadata. Try adding a trailing slash to the "
+          "path."));
+    } else {
+      state->Fail(parsed.status());
+    }
+    return;
+  }
+
+  const auto& zmetadata = parsed.value();
+
+  if (!zmetadata.contains("metadata")) {
+    state->Fail(
+        absl::InvalidArgumentError("zmetadata does not contain metadata."));
+    return;
+  }
+
+  if (!zmetadata["metadata"].contains(".zattrs")) {
+    state->Fail(absl::InvalidArgumentError(
+        "zmetadata does not contain dataset metadata."));
+    return;
+  }
+
+  auto dataset_metadata = zmetadata["metadata"][".zattrs"];
+  std::vector<nlohmann::json> json_vars;
+
+  for (const auto& element : zmetadata["metadata"].items()) {
+    const std::string& key = element.key();
+    // Skip if not a .zarray entry
+    size_t dot_pos = key.find_last_of('.');
+    if (dot_pos == std::string::npos ||
+        key.substr(dot_pos + 1) != "zarray") {
+      continue;
+    }
+    std::string var_name = ExtractVariableName(key);
+    json_vars.push_back(state->BuildVariableSpec(var_name));
+  }
+
+  if (json_vars.empty()) {
+    state->Fail(absl::InvalidArgumentError("No variables found in zmetadata."));
+    return;
+  }
+
+  state->Complete(std::move(dataset_metadata), std::move(json_vars));
+}
+
+/// Step 1: Start reading .zmetadata.
+inline void OnV2KvStoreReady(
+    std::shared_ptr<V2MetadataState> state,
+    tensorstore::ReadyFuture<tensorstore::KvStore> kvs_ready) {
+  if (!kvs_ready.result().ok()) {
+    state->Fail(kvs_ready.result().status());
+    return;
+  }
+
+  state->kvs = kvs_ready.value();
+  auto read_future = tensorstore::kvstore::Read(state->kvs, ".zmetadata");
+  read_future.ExecuteWhenReady(
+      [state](tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult> ready) {
+        OnZmetadataRead(state, std::move(ready));
+      });
+}
+
+}  // namespace internal
+
 /**
  * @brief Reads and parses the consolidated metadata from a dataset path.
  *
@@ -266,117 +401,15 @@ inline Future<void> WriteConsolidatedMetadata(
 inline Future<std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>
 ReadConsolidatedMetadata(const std::string& dataset_path,
                          tensorstore::Future<tensorstore::KvStore> kvs_future) {
-  // Normalize the dataset path once so we can safely append variable names.
-  std::string normalized_path = dataset_path;
-  if (!normalized_path.empty() && normalized_path.back() != '/') {
-    normalized_path.push_back('/');
-  }
-
   auto pair = tensorstore::PromiseFuturePair<
       std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>::Make();
 
-  kvs_future.ExecuteWhenReady(
-      [promise = std::move(pair.promise), dataset_path, normalized_path](
-          tensorstore::ReadyFuture<tensorstore::KvStore> ready_kvs) {
-        if (!ready_kvs.result().ok()) {
-          promise.SetResult(ready_kvs.result().status());
-          return;
-        }
-
-        auto kvs = ready_kvs.value();
-        // Infer the driver before issuing the read so we can reuse it later.
-        std::string driver = "file";
-        if (dataset_path.length() > 5) {
-          if (dataset_path.substr(0, 5) == "gs://") {
-            driver = "gcs";
-          } else if (dataset_path.substr(0, 5) == "s3://") {
-            driver = "s3";
-          }
-        }
-        std::string bucket;
-        std::string cloudPath;
-        if (driver != "file") {
-          std::string providedPath = dataset_path.substr(5);
-          size_t bucketLen = providedPath.find_first_of('/');
-          bucket = providedPath.substr(0, bucketLen);
-          cloudPath = providedPath.substr(bucketLen + 1);
-          if (!cloudPath.empty() && cloudPath.back() != '/') {
-            cloudPath.push_back('/');
-          }
-        }
+  auto state = std::make_shared<internal::V2MetadataState>(
+      std::move(pair.promise), dataset_path);
 
-        auto read_future = tensorstore::kvstore::Read(kvs, ".zmetadata");
-        read_future.ExecuteWhenReady(
-            [promise = std::move(promise), dataset_path, normalized_path,
-             driver, bucket, cloudPath](
-                tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
-                    ready_read) {
-              if (!ready_read.result().ok()) {
-                promise.SetResult(ready_read.result().status());
-                return;
-              }
-              auto read_result = ready_read.result().value();
-
-              ::nlohmann::json zmetadata;
-              try {
-                zmetadata =
-                    ::nlohmann::json::parse(std::string(read_result.value));
-              } catch (const nlohmann::json::parse_error& e) {
-                if (!dataset_path.empty() && dataset_path.back() != '/') {
-                  promise.SetResult(absl::InvalidArgumentError(
-                      "Failed to parse .zmetadata. Try adding a trailing slash "
-                      "to the path."));
-                  return;
-                }
-                promise.SetResult(absl::InvalidArgumentError(
-                    std::string("JSON parse error: ") + e.what()));
-                return;
-              }
-
-              if (!zmetadata.contains("metadata")) {
-                promise.SetResult(absl::InvalidArgumentError(
-                    "zmetadata does not contain metadata."));
-                return;
-              }
-
-              if (!zmetadata["metadata"].contains(".zattrs")) {
-                promise.SetResult(absl::InvalidArgumentError(
-                    "zmetadata does not contain dataset metadata."));
-                return;
-              }
-
-              auto dataset_metadata = zmetadata["metadata"][".zattrs"];
-
-              zmetadata["metadata"].erase(".zattrs");
-              std::vector<nlohmann::json> json_vars_from_zmeta;
-
-              for (auto& element : zmetadata["metadata"].items()) {
-                if (element.key().substr(element.key().find_last_of(".") + 1) ==
-                    "zarray") {
-                  std::string variable_name =
-                      element.key().substr(0, element.key().find("/"));
-                  nlohmann::json new_dict = {
-                      {"driver", std::string(kDriverName)},
-                      {"kvstore",
-                       {{"driver", driver},
-                        {"path", normalized_path + variable_name}}}};
-                  if (driver != "file") {
-                    new_dict["kvstore"]["bucket"] = bucket;
-                    new_dict["kvstore"]["path"] = cloudPath + variable_name;
-                  }
-                  json_vars_from_zmeta.push_back(new_dict);
-                }
-              }
-
-              if (json_vars_from_zmeta.empty()) {
-                promise.SetResult(absl::InvalidArgumentError(
-                    "No variables found in zmetadata."));
-                return;
-              }
-
-              promise.SetResult(
-                  std::make_tuple(dataset_metadata, json_vars_from_zmeta));
-            });
+  kvs_future.ExecuteWhenReady(
+      [state](tensorstore::ReadyFuture<tensorstore::KvStore> ready) {
+        internal::OnV2KvStoreReady(state, std::move(ready));
       });
 
   return pair.future;
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index c7596d0..4459f8e 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -58,6 +58,67 @@ constexpr std::string_view kGroupNodeType = "group";
  */
 constexpr std::string_view kArrayNodeType = "array";
 
+// ============================================================================
+// V3-Specific JSON Utilities
+// ============================================================================
+
+/**
+ * @brief Checks if a JSON object represents a Zarr V3 array.
+ * @param json The zarr.json content.
+ * @return True if node_type is "array".
+ */
+inline bool IsArrayMetadata(const nlohmann::json& json) {
+  return GetJsonString(json, "node_type") == std::string(kArrayNodeType);
+}
+
+// ============================================================================
+// Variable Discovery Utilities
+// ============================================================================
+
+/**
+ * @brief Extracts child array names from kvstore list entries.
+ *
+ * Looks for entries matching pattern "NAME/zarr.json" and returns unique NAMEs.
+ *
+ * @param entries The list entries from kvstore.
+ * @return Vector of unique child directory names.
+ */
+inline std::vector<std::string> ExtractChildArrayCandidates(
+    const std::vector<tensorstore::kvstore::ListEntry>& entries) {
+  std::vector<std::string> candidates;
+  for (const auto& entry : entries) {
+    const std::string& key = entry.key;
+    size_t slash_pos = key.find('/');
+    if (slash_pos != std::string::npos &&
+        key.substr(slash_pos + 1) == "zarr.json") {
+      std::string name = key.substr(0, slash_pos);
+      if (std::find(candidates.begin(), candidates.end(), name) ==
+          candidates.end()) {
+        candidates.push_back(name);
+      }
+    }
+  }
+  return candidates;
+}
+
+/**
+ * @brief Builds a variable spec for a Zarr V3 array.
+ * @param driver The kvstore driver name.
+ * @param base_path The base dataset path.
+ * @param var_name The variable/array name.
+ * @return The JSON spec for opening this variable.
+ */
+inline nlohmann::json BuildVariableSpec(const std::string& driver,
+                                        const std::string& base_path,
+                                        const std::string& var_name) {
+  return {{"driver", std::string(kDriverName)},
+          {"kvstore", {{"driver", driver}, {"path", base_path + "/" + var_name}}}};
+}
+
+// ============================================================================
+// Dtype Conversion
+// ============================================================================
+
 /**
  * @brief Converts a dtype string to Zarr V3 format.
  *
@@ -276,6 +337,156 @@ inline Future<void> WriteMetadata(
   return tensorstore::WaitAllFuture(write_futures);
 }
 
+// ============================================================================
+// Async Metadata Discovery
+// ============================================================================
+
+namespace internal {
+
+/**
+ * @brief State for V3 async metadata discovery operations.
+ *
+ * This struct holds all state needed across the async callback chain,
+ * avoiding deeply nested lambdas and making the flow clearer.
+ */
+struct V3MetadataState {
+  using ResultType = std::tuple<nlohmann::json, std::vector<nlohmann::json>>;
+  using PromiseType = tensorstore::Promise<ResultType>;
+  using ReadFuture = tensorstore::Future<tensorstore::kvstore::ReadResult>;
+
+  PromiseType promise;
+  tensorstore::KvStore kvs;
+  nlohmann::json dataset_metadata;
+  std::string dataset_path;
+  std::string driver;
+  std::string normalized_path;
+  std::vector<std::string> candidates;
+  std::shared_ptr<std::vector<ReadFuture>> read_futures;
+
+  explicit V3MetadataState(PromiseType p, const std::string& path)
+      : promise(std::move(p)),
+        dataset_path(path),
+        driver(InferDriverFromPath(path)),
+        normalized_path(NormalizePath(path)) {}
+
+  /// Completes with an error status.
+  void Fail(absl::Status status) { promise.SetResult(std::move(status)); }
+
+  /// Completes successfully with the discovered metadata and variables.
+  void Complete(std::vector<nlohmann::json> json_vars) {
+    promise.SetResult(std::make_tuple(dataset_metadata, std::move(json_vars)));
+  }
+
+  /// Builds a variable spec for the given variable name.
+  nlohmann::json MakeVariableSpec(const std::string& var_name) const {
+    return BuildVariableSpec(driver, normalized_path, var_name);
+  }
+
+  /// Filters read results to build variable specs for arrays only.
+  std::vector<nlohmann::json> BuildVariableSpecs() const {
+    std::vector<nlohmann::json> json_vars;
+    for (size_t i = 0; i < candidates.size(); ++i) {
+      const auto& result = (*read_futures)[i].result();
+      if (!result.ok() || !result->has_value()) continue;
+
+      auto parsed = ParseJsonFromReadResult(*result);
+      if (parsed.ok() && IsArrayMetadata(parsed.value())) {
+        json_vars.push_back(MakeVariableSpec(candidates[i]));
+      }
+    }
+    return json_vars;
+  }
+};
+
+/// Step 4: Process read results and complete.
+inline void OnV3ChildReadsComplete(std::shared_ptr<V3MetadataState> state,
+                                   tensorstore::ReadyFuture<void>) {
+  auto json_vars = state->BuildVariableSpecs();
+  if (json_vars.empty()) {
+    state->Fail(absl::InvalidArgumentError("No Zarr V3 arrays found."));
+    return;
+  }
+  state->Complete(std::move(json_vars));
+}
+
+/// Step 3: Read all child zarr.json files and filter by node_type.
+inline void OnV3ListComplete(
+    std::shared_ptr<V3MetadataState> state,
+    tensorstore::ReadyFuture<std::vector<tensorstore::kvstore::ListEntry>>
+        list_ready) {
+  if (!list_ready.result().ok()) {
+    state->Fail(list_ready.result().status());
+    return;
+  }
+
+  state->candidates = ExtractChildArrayCandidates(list_ready.value());
+  if (state->candidates.empty()) {
+    state->Fail(absl::InvalidArgumentError("No Zarr V3 arrays found."));
+    return;
+  }
+
+  // Read all child zarr.json files
+  state->read_futures =
+      std::make_shared<std::vector<V3MetadataState::ReadFuture>>();
+  std::vector<tensorstore::AnyFuture> any_futures;
+
+  for (const auto& name : state->candidates) {
+    auto f = tensorstore::kvstore::Read(state->kvs, name + "/zarr.json");
+    state->read_futures->push_back(f);
+    any_futures.push_back(std::move(f));
+  }
+
+  auto all_reads = tensorstore::WaitAllFuture(any_futures);
+  all_reads.ExecuteWhenReady([state](tensorstore::ReadyFuture<void> ready) {
+    OnV3ChildReadsComplete(state, std::move(ready));
+  });
+}
+
+/// Step 2: Parse root metadata and list kvstore contents.
+inline void OnV3RootReadComplete(
+    std::shared_ptr<V3MetadataState> state,
+    tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult> root_ready) {
+  if (!root_ready.result().ok()) {
+    state->Fail(root_ready.result().status());
+    return;
+  }
+
+  auto root_json = ParseJsonFromReadResult(root_ready.value());
+  if (!root_json.ok()) {
+    state->Fail(root_json.status());
+    return;
+  }
+
+  state->dataset_metadata = GetJsonObject(root_json.value(), "attributes");
+
+  auto list_future = tensorstore::kvstore::ListFuture(state->kvs);
+  list_future.ExecuteWhenReady(
+      [state](tensorstore::ReadyFuture<
+              std::vector<tensorstore::kvstore::ListEntry>> ready) {
+        OnV3ListComplete(state, std::move(ready));
+      });
+}
+
+/// Step 1: Start reading root zarr.json.
+inline void OnV3KvStoreReady(
+    std::shared_ptr<V3MetadataState> state,
+    tensorstore::ReadyFuture<tensorstore::KvStore> kvs_ready) {
+  if (!kvs_ready.result().ok()) {
+    state->Fail(kvs_ready.result().status());
+    return;
+  }
+
+  state->kvs = kvs_ready.value();
+  auto root_read = tensorstore::kvstore::Read(state->kvs, "zarr.json");
+  root_read.ExecuteWhenReady(
+      [state](
+          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult> ready) {
+        OnV3RootReadComplete(state, std::move(ready));
+      });
+}
+
+}  // namespace internal
+
 /**
  * @brief Reads dataset metadata from Zarr V3 format (non-consolidated).
  *
@@ -293,157 +504,12 @@ ReadMetadata(const std::string& dataset_path,
   auto pair = tensorstore::PromiseFuturePair<
       std::tuple<::nlohmann::json, std::vector<::nlohmann::json>>>::Make();
 
-  kvs_future.ExecuteWhenReady(
-      [promise = std::move(pair.promise),
-       dataset_path](tensorstore::ReadyFuture<tensorstore::KvStore> ready_kvs) {
-        if (!ready_kvs.result().ok()) {
-          promise.SetResult(ready_kvs.result().status());
-          return;
-        }
+  auto state = std::make_shared<internal::V3MetadataState>(
+      std::move(pair.promise), dataset_path);
 
-        auto kvs = ready_kvs.value();
-
-        // Read root zarr.json
-        auto root_read_future = tensorstore::kvstore::Read(kvs, "zarr.json");
-
-        root_read_future.ExecuteWhenReady(
-            [promise = std::move(promise), dataset_path,
-             kvs](tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult>
-                      root_read_ready) mutable {
-              if (!root_read_ready.result().ok()) {
-                promise.SetResult(root_read_ready.result().status());
-                return;
-              }
-
-              ::nlohmann::json root_json;
-              try {
-                root_json = ::nlohmann::json::parse(
-                    std::string(root_read_ready.value().value));
-              } catch (const nlohmann::json::parse_error& e) {
-                promise.SetResult(absl::InvalidArgumentError(
-                    std::string("JSON parse error: ") + e.what()));
-                return;
-              }
-
-              // Extract attributes as dataset metadata
-              nlohmann::json dataset_metadata = nlohmann::json::object();
-              if (root_json.contains("attributes")) {
-                dataset_metadata = root_json["attributes"];
-              }
-
-              // Infer the driver from path prefix
-              std::string driver = "file";
-              if (dataset_path.length() > 5) {
-                if (dataset_path.substr(0, 5) == "gs://") {
-                  driver = "gcs";
-                } else if (dataset_path.substr(0, 5) == "s3://") {
-                  driver = "s3";
-                }
-              }
-
-              // Normalize path - remove trailing slash if present
-              std::string normalized_path = dataset_path;
-              while (!normalized_path.empty() &&
-                     normalized_path.back() == '/') {
-                normalized_path.pop_back();
-              }
-
-              // Use kvstore List to discover child zarr.json files
-              auto list_future = tensorstore::kvstore::ListFuture(kvs);
-              list_future.ExecuteWhenReady(
-                  [promise = std::move(promise), dataset_metadata,
-                   normalized_path, driver,
-                   kvs](tensorstore::ReadyFuture<
-                        std::vector<tensorstore::kvstore::ListEntry>>
-                            list_ready) mutable {
-                    if (!list_ready.result().ok()) {
-                      promise.SetResult(list_ready.result().status());
-                      return;
-                    }
-
-                    // Find all child zarr.json files (pattern: NAME/zarr.json)
-                    std::vector<std::string> candidates;
-                    for (const auto& entry : list_ready.value()) {
-                      std::string key = entry.key;
-                      // Look for pattern: something/zarr.json (one level deep)
-                      size_t slash_pos = key.find('/');
-                      if (slash_pos != std::string::npos &&
-                          key.substr(slash_pos + 1) == "zarr.json") {
-                        std::string name = key.substr(0, slash_pos);
-                        // Avoid duplicates
-                        if (std::find(candidates.begin(), candidates.end(),
-                                      name) == candidates.end()) {
-                          candidates.push_back(name);
-                        }
-                      }
-                    }
-
-                    if (candidates.empty()) {
-                      promise.SetResult(absl::InvalidArgumentError(
-                          "No Zarr V3 arrays found in directory."));
-                      return;
-                    }
-
-                    // Read all child zarr.json files to check node_type
-                    using ReadFuture =
-                        tensorstore::Future<tensorstore::kvstore::ReadResult>;
-                    auto read_futures =
-                        std::make_shared<std::vector<ReadFuture>>();
-                    std::vector<tensorstore::AnyFuture> any_futures;
-
-                    for (const auto& name : candidates) {
-                      auto f =
-                          tensorstore::kvstore::Read(kvs, name + "/zarr.json");
-                      read_futures->push_back(f);
-                      any_futures.push_back(std::move(f));
-                    }
-
-                    // Wait for all reads and then filter by node_type
-                    auto all_reads = tensorstore::WaitAllFuture(any_futures);
-                    all_reads.ExecuteWhenReady(
-                        [promise = std::move(promise), dataset_metadata,
-                         normalized_path, driver, candidates, read_futures](
-                            tensorstore::ReadyFuture<void>) mutable {
-                          std::vector<nlohmann::json> json_vars;
-
-                          for (size_t i = 0; i < candidates.size(); ++i) {
-                            const auto& read_result =
-                                (*read_futures)[i].result();
-                            if (!read_result.ok() ||
-                                !read_result->has_value()) {
-                              continue;
-                            }
-                            try {
-                              auto child_json = ::nlohmann::json::parse(
-                                  std::string(read_result->value));
-                              // Only include arrays, skip groups
-                              if (child_json.contains("node_type") &&
-                                  child_json["node_type"].get<std::string>() ==
-                                      "array") {
-                                nlohmann::json var_spec = {
-                                    {"driver", std::string(kDriverName)},
-                                    {"kvstore",
-                                     {{"driver", driver},
-                                      {"path", normalized_path + "/" +
-                                                   candidates[i]}}}};
-                                json_vars.push_back(var_spec);
-                              }
-                            } catch (const nlohmann::json::exception&) {
-                              // Skip malformed zarr.json
-                            }
-                          }
-
-                          if (json_vars.empty()) {
-                            promise.SetResult(absl::InvalidArgumentError(
-                                "No Zarr V3 arrays found in directory."));
-                            return;
-                          }
-
-                          promise.SetResult(
-                              std::make_tuple(dataset_metadata, json_vars));
-                        });
-                  });
-            });
+  kvs_future.ExecuteWhenReady(
+      [state](tensorstore::ReadyFuture<tensorstore::KvStore> ready) {
+        internal::OnV3KvStoreReady(state, std::move(ready));
       });
 
   return pair.future;

From dc65f2aab515739695aa2d11f34772fe3138e43e Mon Sep 17 00:00:00 2001
From: BrianMichell <brianm314@comcast.net>
Date: Mon, 5 Jan 2026 21:21:05 +0000
Subject: [PATCH 26/26] Linting

---
 mdio/acceptance_test.cc | 22 +++++++++++-----------
 mdio/variable.h         |  4 ++--
 mdio/zarr/zarr_driver.h |  8 ++++----
 mdio/zarr/zarr_test.cc  | 13 +++++++------
 mdio/zarr/zarr_v2.h     |  6 +++---
 mdio/zarr/zarr_v3.h     | 12 ++++++------
 6 files changed, 33 insertions(+), 32 deletions(-)

diff --git a/mdio/acceptance_test.cc b/mdio/acceptance_test.cc
index 5294f46..6691dc7 100644
--- a/mdio/acceptance_test.cc
+++ b/mdio/acceptance_test.cc
@@ -165,22 +165,22 @@ void CreateTestVariable(const TestVariableDef& def,
   mdio::TransactionalOpenOptions options;
   auto opt = options.Set(std::move(mdio::constants::kCreateClean));
 
-  auto spec = CreateTypedVariableSpec(version, def.name, base_path, def.dtype_v2,
-                                      def.dtype_v3, def.long_name);
+  auto spec = CreateTypedVariableSpec(
+      version, def.name, base_path, def.dtype_v2, def.dtype_v3, def.long_name);
   auto schema = mdio::internal::ValidateAndProcessJson(spec).value();
   auto [store, metadata] = schema;
   auto var =
       mdio::internal::CreateVariable(store, metadata, std::move(options));
-  ASSERT_TRUE(var.status().ok()) << "Failed to create " << def.name << ": "
-                                 << var.status();
+  ASSERT_TRUE(var.status().ok())
+      << "Failed to create " << def.name << ": " << var.status();
 }
 
 /**
  * @brief Opens a variable by name and returns its Future.
  */
-mdio::Future<mdio::Variable<>> OpenTestVariable(
-    const std::string& name, mdio::zarr::ZarrVersion version,
-    const std::string& base_path) {
+mdio::Future<mdio::Variable<>> OpenTestVariable(const std::string& name,
+                                                mdio::zarr::ZarrVersion version,
+                                                const std::string& base_path) {
   return mdio::Variable<>::Open(CreateBaseSpec(version, name, base_path),
                                 mdio::constants::kOpen);
 }
@@ -447,8 +447,8 @@ TEST_P(VariableTest, SETUP) {
 TEST_P(VariableTest, open) {
   for (const auto& def : kTestVariables) {
     auto var = OpenTestVariable(def.name, version_, base_path_);
-    EXPECT_TRUE(var.status().ok()) << "Failed to open " << def.name << ": "
-                                   << var.status();
+    EXPECT_TRUE(var.status().ok())
+        << "Failed to open " << def.name << ": " << var.status();
   }
 }
 
@@ -1266,8 +1266,8 @@ TEST_P(XarrayCompatibilityTest, datasetCompatible) {
   }
 
   std::string version_name = ZarrVersionToString(version_);
-  EXPECT_TRUE(RunPythonScripts(srcPath, arg_sets,
-                               "Xarray compatibility skipped due to import error"))
+  EXPECT_TRUE(RunPythonScripts(
+      srcPath, arg_sets, "Xarray compatibility skipped due to import error"))
       << "xarray " << version_name << " compatibility test failed";
 
   // std::filesystem::remove_all(test_path);
diff --git a/mdio/variable.h b/mdio/variable.h
index 355c861..d96c49f 100644
--- a/mdio/variable.h
+++ b/mdio/variable.h
@@ -459,8 +459,8 @@ Future<Variable<T, R, M>> CreateVariable(const nlohmann::json& json_spec,
     // For V3, structured dtypes are represented as an array of [name, type]
     // pairs e.g., [["cdp-x", "int32"], ["cdp-y", "int32"], ...]
     const auto& data_type = json_spec["metadata"]["data_type"];
-    if (data_type.is_array() && !data_type.empty() &&
-        data_type[0].is_array() && !json_spec.contains("field")) {
+    if (data_type.is_array() && !data_type.empty() && data_type[0].is_array() &&
+        !json_spec.contains("field")) {
       do_handle_structarray = true;
       // Extract the first field name from the structured dtype
       first_field_name = data_type[0][0].get<std::string>();
diff --git a/mdio/zarr/zarr_driver.h b/mdio/zarr/zarr_driver.h
index 85fb169..de40e2c 100644
--- a/mdio/zarr/zarr_driver.h
+++ b/mdio/zarr/zarr_driver.h
@@ -291,7 +291,7 @@ inline Result<nlohmann::json> ParseJsonFromReadResult(
     return nlohmann::json::parse(std::string(read_result.value));
   } catch (const nlohmann::json::parse_error& e) {
     return absl::InvalidArgumentError(std::string("JSON parse error: ") +
-                                     e.what());
+                                      e.what());
   }
 }
 
@@ -303,8 +303,8 @@ inline Result<nlohmann::json> ParseJsonFromReadResult(
  * @return The string value or default.
  */
 inline std::string GetJsonString(const nlohmann::json& json,
-                                const std::string& key,
-                                const std::string& default_value = "") {
+                                 const std::string& key,
+                                 const std::string& default_value = "") {
   if (json.contains(key) && json[key].is_string()) {
     return json[key].get<std::string>();
   }
@@ -318,7 +318,7 @@ inline std::string GetJsonString(const nlohmann::json& json,
  * @return The object value or empty object.
  */
 inline nlohmann::json GetJsonObject(const nlohmann::json& json,
-                                   const std::string& key) {
+                                    const std::string& key) {
   if (json.contains(key) && json[key].is_object()) {
     return json[key];
   }
diff --git a/mdio/zarr/zarr_test.cc b/mdio/zarr/zarr_test.cc
index c2cffb3..92143bc 100644
--- a/mdio/zarr/zarr_test.cc
+++ b/mdio/zarr/zarr_test.cc
@@ -273,13 +273,15 @@ TEST(ZarrDriver, NormalizePathWithSlash_EmptyPath) {
 }
 
 TEST(ZarrDriver, ExtractCloudPath_GCS) {
-  auto [bucket, path] = mdio::zarr::ExtractCloudPath("gs://my-bucket/path/to/data");
+  auto [bucket, path] =
+      mdio::zarr::ExtractCloudPath("gs://my-bucket/path/to/data");
   EXPECT_EQ(bucket, "my-bucket");
   EXPECT_EQ(path, "path/to/data");
 }
 
 TEST(ZarrDriver, ExtractCloudPath_S3) {
-  auto [bucket, path] = mdio::zarr::ExtractCloudPath("s3://my-bucket/nested/path");
+  auto [bucket, path] =
+      mdio::zarr::ExtractCloudPath("s3://my-bucket/nested/path");
   EXPECT_EQ(bucket, "my-bucket");
   EXPECT_EQ(path, "nested/path");
 }
@@ -380,8 +382,7 @@ TEST(ZarrDriver, ParseJsonFromReadResult_NoValue) {
 
   auto parsed = mdio::zarr::ParseJsonFromReadResult(result);
   EXPECT_FALSE(parsed.ok());
-  EXPECT_THAT(parsed.status().message(),
-              testing::HasSubstr("no value"));
+  EXPECT_THAT(parsed.status().message(), testing::HasSubstr("no value"));
 }
 
 }  // namespace ZarrDriverTests
@@ -881,8 +882,8 @@ TEST(ZarrV3, ExtractChildArrayCandidates_Empty) {
 }
 
 TEST(ZarrV3, BuildVariableSpec_LocalFile) {
-  auto spec = mdio::zarr::v3::BuildVariableSpec("file", "/path/to/dataset",
-                                                "myvar");
+  auto spec =
+      mdio::zarr::v3::BuildVariableSpec("file", "/path/to/dataset", "myvar");
 
   EXPECT_EQ(spec["driver"], "zarr3");
   EXPECT_EQ(spec["kvstore"]["driver"], "file");
diff --git a/mdio/zarr/zarr_v2.h b/mdio/zarr/zarr_v2.h
index 6eb7c35..3f32e30 100644
--- a/mdio/zarr/zarr_v2.h
+++ b/mdio/zarr/zarr_v2.h
@@ -356,8 +356,7 @@ inline void OnZmetadataRead(
     const std::string& key = element.key();
     // Skip if not a .zarray entry
     size_t dot_pos = key.find_last_of('.');
-    if (dot_pos == std::string::npos ||
-        key.substr(dot_pos + 1) != "zarray") {
+    if (dot_pos == std::string::npos || key.substr(dot_pos + 1) != "zarray") {
       continue;
     }
     std::string var_name = ExtractVariableName(key);
@@ -384,7 +383,8 @@ inline void OnV2KvStoreReady(
   state->kvs = kvs_ready.value();
   auto read_future = tensorstore::kvstore::Read(state->kvs, ".zmetadata");
   read_future.ExecuteWhenReady(
-      [state](tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult> ready) {
+      [state](
+          tensorstore::ReadyFuture<tensorstore::kvstore::ReadResult> ready) {
         OnZmetadataRead(state, std::move(ready));
       });
 }
diff --git a/mdio/zarr/zarr_v3.h b/mdio/zarr/zarr_v3.h
index 4459f8e..ef58bad 100644
--- a/mdio/zarr/zarr_v3.h
+++ b/mdio/zarr/zarr_v3.h
@@ -111,8 +111,9 @@ inline std::vector<std::string> ExtractChildArrayCandidates(
 inline nlohmann::json BuildVariableSpec(const std::string& driver,
                                         const std::string& base_path,
                                         const std::string& var_name) {
-  return {{"driver", std::string(kDriverName)},
-          {"kvstore", {{"driver", driver}, {"path", base_path + "/" + var_name}}}};
+  return {
+      {"driver", std::string(kDriverName)},
+      {"kvstore", {{"driver", driver}, {"path", base_path + "/" + var_name}}}};
 }
 
 // ============================================================================
@@ -461,10 +462,9 @@ inline void OnV3RootReadComplete(
 
   auto list_future = tensorstore::kvstore::ListFuture(state->kvs);
   list_future.ExecuteWhenReady(
-      [state](tensorstore::ReadyFuture<
-              std::vector<tensorstore::kvstore::ListEntry>> ready) {
-        OnV3ListComplete(state, std::move(ready));
-      });
+      [state](
+          tensorstore::ReadyFuture<std::vector<tensorstore::kvstore::ListEntry>>
+              ready) { OnV3ListComplete(state, std::move(ready)); });
 }
 
 /// Step 1: Start reading root zarr.json.