diff --git a/.github/workflows/check-bioc.yml b/.github/workflows/check-bioc.yml
index 996b6f31..da719a29 100644
--- a/.github/workflows/check-bioc.yml
+++ b/.github/workflows/check-bioc.yml
@@ -22,7 +22,6 @@
 
 on:
   push:
-  pull_request:
 
 name: R-CMD-check-bioc
 
@@ -52,9 +51,10 @@ jobs:
       fail-fast: false
       matrix:
         config:
-          - { os: ubuntu-latest, r: '4.5', bioc: 'devel', cont: "bioconductor/bioconductor_docker:devel", rspm: "https://packagemanager.rstudio.com/cran/__linux__/jammy/latest" }
-#          - { os: macOS-latest, r: '4.5', bioc: 'devel'}
-#          - { os: windows-latest, r: '4.5', bioc: 'devel'}
+          #- { os: ubuntu-latest, r: '4.5', bioc: '3.22', cont: "bioconductor/bioconductor_docker:RELEASE_3_22", rspm: "https://p3m.dev/cran/__linux__/noble/latest" }
+          - { os: ubuntu-latest, r: 'devel', bioc: 'devel', cont: "bioconductor/bioconductor_docker:devel", rspm: "https://p3m.dev/cran/__linux__/noble/latest" }
+          - { os: macOS-latest, r: 'devel', bioc: 'devel'}
+          #- { os: windows-latest, r: 'devel', bioc: 'devel'}
           ## Check https://github.com/r-lib/actions/tree/master/examples
           ## for examples using the http-user-agent
     env:
@@ -116,13 +116,6 @@ jobs:
           key: ${{ env.cache-version }}-${{ runner.os }}-biocversion-devel-r-4.5-${{ hashFiles('.github/depends.Rds') }}
           restore-keys: ${{ env.cache-version }}-${{ runner.os }}-biocversion-devel-r-4.5-
 
-      # - name: Install Linux system dependencies
-      #   if: runner.os == 'Linux'
-      #   run: |
-      #     sysreqs=$(Rscript -e 'cat("apt-get update -y && apt-get install -y", paste(gsub("apt-get install -y ", "", remotes::system_requirements("ubuntu", "20.04")), collapse = " "))')
-      #     echo $sysreqs
-      #     sudo -s eval "$sysreqs"
-
       - name: Install macOS system dependencies
         if: matrix.config.os == 'macOS-latest'
         run: |
@@ -130,10 +123,6 @@ jobs:
           brew install libxml2
           echo "XML_CONFIG=/usr/local/opt/libxml2/bin/xml2-config" >> $GITHUB_ENV
 
-          ## Required to install magick as noted at
-          ## https://github.com/r-lib/usethis/commit/f1f1e0d10c1ebc75fd4c18fa7e2de4551fd9978f#diff-9bfee71065492f63457918efcd912cf2
-          brew install imagemagick@6
-
           ## For textshaping, required by ragg, and required by pkgdown
           brew install harfbuzz fribidi
 
@@ -171,7 +160,11 @@ jobs:
 
           ## For running the checks
           message(paste('****', Sys.time(), 'installing rcmdcheck and BiocCheck ****'))
-          install.packages(c("rcmdcheck", "BiocCheck"), repos = BiocManager::repositories())
+          install.packages(c("rcmdcheck", "BiocCheck", "remotes"), repos = BiocManager::repositories())
+          
+          ## TEMP REMOVE LATER:
+          ## For now install Rarr from github since ZarrArray needs >= 1.11.33
+          remotes::install_github("Huber-group-EMBL/Rarr")
 
           ## Pass #1 at installing dependencies
           message(paste('****', Sys.time(), 'pass number 1 at installing dependencies: local dependencies ****'))
@@ -183,7 +176,7 @@ jobs:
         run: |
           ## Pass #2 at installing dependencies
           message(paste('****', Sys.time(), 'pass number 2 at installing dependencies: any remaining dependencies ****'))
-          remotes::install_local(dependencies = TRUE, repos = BiocManager::repositories(), build_vignettes = TRUE, upgrade = TRUE, force = TRUE)
+          remotes::install_local(dependencies = TRUE, repos = BiocManager::repositories(), build_vignettes = FALSE, upgrade = TRUE, force = TRUE)
         shell: Rscript {0}
 
       - name: Install BiocGenerics
diff --git a/.gitignore b/.gitignore
index 7ac4af56..a110dd34 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ inst/extdata/xenium1.zarr
 inst/extdata/visiumhd.zarr
 *.Rproj
 *.html
+R/_*
diff --git a/DESCRIPTION b/DESCRIPTION
index 1ee9afac..57838bf6 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,9 +1,9 @@
 Package: SpatialData
 Title: Representation of Python's SpatialData in R
-Depends: R (>= 4.4)
-Version: 0.99.23
+Depends: R (>= 4.6)
+Version: 0.99.29
 Description: Interface to Python's 'SpatialData', currently including:
-    reticulate-based use of 'spatialdata-io' for reading of manufracturer
+    reticulate-based use of 'spatialdata-io' for reading of manufacturer
     data and writing to .zarr, on-disk representation of images/labels as
     'ZarrArray's ('Rarr') and shapes/points as 'arrow' objects, and method 
     drafts for visualization and coordinate system handling.
@@ -38,27 +38,28 @@ Imports:
     BiocGenerics,
     DelayedArray,
     dplyr,
+    EBImage,
     geoarrow,
     graph,
-    jsonlite,
     Matrix,
     methods,
+    ZarrArray,
     Rarr,
     RBGL,
     reticulate,
+    anndataR,
     sf,
     S4Arrays,
     S4Vectors,
     SingleCellExperiment,
     SummarizedExperiment,
-    zellkonverter,
     EBImage,
-    stringr
+    stringr,
+    jsonlite
 Suggests:
     BiocStyle,
     ggnewscale,
     knitr,
-    magick,
     patchwork,
     paws,
     Rgraphviz,
@@ -71,7 +72,6 @@ Enhances:
     anndataR,
     pizzarr
 Remotes:
-    keller-mark/pizzarr,
     keller-mark/anndataR@spatialdata,
     HelenaLC/SpatialData.data,
     HelenaLC/SpatialData.plot
diff --git a/NAMESPACE b/NAMESPACE
index 14b7aeff..661f76de 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -7,6 +7,7 @@ S3method(.DollarNames,Zattrs)
 S3method(filter,PointFrame)
 S3method(select,PointFrame)
 export(.SpatialData)
+export(CTplot)
 export(ImageArray)
 export(LabelArray)
 export(PointFrame)
@@ -17,20 +18,17 @@ export(create_zarr)
 export(create_zarr_group)
 export(do_tx_to_ext)
 export(mask)
-export(plotCoordGraph)
 export(readImage)
 export(readLabel)
 export(readPoint)
 export(readShape)
 export(readSpatialData)
 export(readTable)
-export(read_zattrs)
 export(writeImage)
 export(writeLabel)
 export(writePoint)
 export(writeShape)
 export(writeSpatialData)
-export(write_zattrs)
 exportClasses(SpatialData)
 exportMethods("$")
 exportMethods("[")
@@ -48,22 +46,31 @@ exportMethods("table<-")
 exportMethods("tables<-")
 exportMethods(CTdata)
 exportMethods(CTgraph)
+exportMethods(CTlist)
 exportMethods(CTname)
 exportMethods(CTpath)
 exportMethods(CTtype)
 exportMethods(addCT)
 exportMethods(as.data.frame)
 exportMethods(axes)
+exportMethods(centroids)
 exportMethods(channels)
 exportMethods(colnames)
 exportMethods(data)
+exportMethods(data_type)
 exportMethods(dim)
 exportMethods(element)
+exportMethods(extent)
+exportMethods(feature_key)
+exportMethods(flip)
+exportMethods(flop)
+exportMethods(geom_type)
 exportMethods(getTable)
 exportMethods(hasTable)
 exportMethods(image)
 exportMethods(imageNames)
 exportMethods(images)
+exportMethods(instance_key)
 exportMethods(label)
 exportMethods(labelNames)
 exportMethods(labels)
@@ -71,11 +78,14 @@ exportMethods(layer)
 exportMethods(length)
 exportMethods(mask)
 exportMethods(meta)
+exportMethods(mirror)
 exportMethods(names)
 exportMethods(point)
 exportMethods(pointNames)
 exportMethods(points)
 exportMethods(query)
+exportMethods(region)
+exportMethods(region_key)
 exportMethods(rmvCT)
 exportMethods(rotate)
 exportMethods(rownames)
@@ -89,6 +99,7 @@ exportMethods(tableNames)
 exportMethods(tables)
 exportMethods(translation)
 exportMethods(valTable)
+import(anndataR)
 import(geoarrow)
 importClassesFrom(S4Arrays,Array)
 importClassesFrom(S4Vectors,DFrame)
@@ -98,12 +109,16 @@ importFrom(BiocGenerics,rownames)
 importFrom(DelayedArray,DelayedArray)
 importFrom(DelayedArray,realize)
 importFrom(EBImage,resize)
+importFrom(EBImage,rotate)
+importFrom(EBImage,translate)
 importFrom(Matrix,rowSums)
+importFrom(Matrix,sparseMatrix)
 importFrom(Matrix,sparseVector)
+importFrom(Matrix,summary)
 importFrom(Matrix,t)
 importFrom(RBGL,sp.between)
-importFrom(Rarr,ZarrArray)
-importFrom(S4Arrays,as.array.Array)
+importFrom(Rarr,read_zarr_attributes)
+importFrom(Rarr,zarr_overview)
 importFrom(S4Vectors,"metadata<-")
 importFrom(S4Vectors,coolcat)
 importFrom(S4Vectors,isSequence)
@@ -115,9 +130,14 @@ importFrom(SingleCellExperiment,"int_metadata<-")
 importFrom(SingleCellExperiment,SingleCellExperiment)
 importFrom(SingleCellExperiment,int_colData)
 importFrom(SingleCellExperiment,int_metadata)
+importFrom(SummarizedExperiment,"assay<-")
+importFrom(SummarizedExperiment,"assayNames<-")
 importFrom(SummarizedExperiment,"colData<-")
 importFrom(SummarizedExperiment,assay)
 importFrom(SummarizedExperiment,colData)
+importFrom(ZarrArray,ZarrArray)
+importFrom(ZarrArray,path)
+importFrom(ZarrArray,type)
 importFrom(arrow,open_dataset)
 importFrom(basilisk,BasiliskEnvironment)
 importFrom(basilisk,basiliskRun)
@@ -142,7 +162,6 @@ importFrom(graph,graphAM)
 importFrom(graph,nodeData)
 importFrom(graph,nodes)
 importFrom(jsonlite,fromJSON)
-importFrom(jsonlite,read_json)
 importFrom(jsonlite,toJSON)
 importFrom(methods,as)
 importFrom(methods,callNextMethod)
@@ -153,16 +172,15 @@ importFrom(methods,setReplaceMethod)
 importFrom(reticulate,import)
 importFrom(sf,"st_geometry<-")
 importFrom(sf,st_as_sf)
+importFrom(sf,st_bbox)
 importFrom(sf,st_coordinates)
+importFrom(sf,st_crop)
 importFrom(sf,st_distance)
 importFrom(sf,st_geometry)
 importFrom(sf,st_geometry_type)
-importFrom(sf,st_point)
-importFrom(sf,st_sfc)
+importFrom(sf,st_intersects)
+importFrom(sf,st_polygon)
 importFrom(stats,setNames)
-importFrom(stringr,str_extract)
-importFrom(stringr,str_remove)
 importFrom(utils,.DollarNames)
 importFrom(utils,head)
 importFrom(utils,tail)
-importFrom(zellkonverter,AnnData2SCE)
diff --git a/R/AllGenerics.R b/R/AllGenerics.R
index 6e0a9488..62ae3d87 100644
--- a/R/AllGenerics.R
+++ b/R/AllGenerics.R
@@ -22,18 +22,6 @@ setGeneric("shapeNames", \(x, ...) standardGeneric("shapeNames"))
 setGeneric("pointNames", \(x, ...) standardGeneric("pointNames"))
 setGeneric("tableNames", \(x, ...) standardGeneric("tableNames"))
 
-setMethod("images", "SpatialData", \(x) x$images)
-setMethod("labels", "SpatialData", \(x) x$labels)
-setMethod("shapes", "SpatialData", \(x) x$shapes)
-setMethod("points", "SpatialData", \(x) x$points)
-setMethod("tables", "SpatialData", \(x) x$tables)
-
-setMethod("imageNames", "SpatialData", \(x) names(images(x)))
-setMethod("labelNames", "SpatialData", \(x) names(labels(x)))
-setMethod("shapeNames", "SpatialData", \(x) names(shapes(x)))
-setMethod("pointNames", "SpatialData", \(x) names(points(x)))
-setMethod("tableNames", "SpatialData", \(x) names(tables(x)))
-
 # set one -----
 
 setGeneric("image<-", \(x, i, ..., value) standardGeneric("image<-"))
@@ -52,7 +40,7 @@ setGeneric("tables<-", \(x, value) standardGeneric("tables<-"))
 
 # trs ----
 
-setGeneric("axes", \(x, ...) standardGeneric("axes"))
+setGeneric("CTlist", \(x, ...) standardGeneric("CTlist"))
 setGeneric("CTdata", \(x, ...) standardGeneric("CTdata"))
 setGeneric("CTname", \(x, ...) standardGeneric("CTname"))
 setGeneric("CTtype", \(x, ...) standardGeneric("CTtype"))
@@ -68,6 +56,17 @@ setGeneric("rotate", \(x, t, ...) standardGeneric("rotate"))
 setGeneric("transform", \(x, ...) standardGeneric("transform"))
 setGeneric("translation", \(x, t, ...) standardGeneric("translation"))
 
+setGeneric("flip", \(x, ...) standardGeneric("flip"))
+setGeneric("flop", \(x, ...) standardGeneric("flop"))
+setGeneric("mirror", \(x, ...) standardGeneric("mirror"))
+
+# sda ----
+
+setGeneric("region", \(x, ...) standardGeneric("region"))
+setGeneric("region_key", \(x, ...) standardGeneric("region_key"))
+setGeneric("feature_key", \(x, ...) standardGeneric("feature_key"))
+setGeneric("instance_key", \(x, ...) standardGeneric("instance_key"))
+
 # uts ----
 
 setGeneric("layer", \(x, i, ...) standardGeneric("layer"))
@@ -79,7 +78,13 @@ setGeneric("meta", \(x, ...) standardGeneric("meta"))
 setGeneric("query", \(x, ...) standardGeneric("query"))
 setGeneric("mask", \(x, i, j, ...) standardGeneric("mask"))
 
+setGeneric("axes", \(x, ...) standardGeneric("axes"))
+setGeneric("extent", \(x, ...) standardGeneric("extent"))
 setGeneric("channels", \(x, ...) standardGeneric("channels"))
+setGeneric("centroids", \(x, ...) standardGeneric("centroids"))
+setGeneric("data_type", \(x, ...) standardGeneric("data_type"))
+setGeneric("geom_type", \(x, ...) standardGeneric("geom_type"))
+setGeneric("multiscales", \(x, ...) standardGeneric("multiscales"))
 
 # tbl ----
 
diff --git a/R/CTgraph.R b/R/CTgraph.R
new file mode 100644
index 00000000..a1a2dd40
--- /dev/null
+++ b/R/CTgraph.R
@@ -0,0 +1,181 @@
+#' @name CTgraph
+#' @title Coord. trans. graph
+#' @aliases CTgraph CTpath CTplot
+#' 
+#' @param x \code{SpatialData}, an element, or \code{Zattrs}.
+#' @param i character string; name of source node.
+#' @param j character string; name of target coordinate space.
+#' @param g base R graph; extracted with \code{CTgraph}.
+#' @param cex scalar numeric; controls fontsize of node labels.
+#' @param fac,max scalar numeric; node labels with \code{nchar>max}
+#'   are split and hyphenated at position \code{floor(nchar/fac)}
+#' 
+#' @returns
+#' \itemize{
+#' \item \code{CTgraph}: 
+#'   \code{graph::graphAM} object with nodes for each element and
+#'   coordinate space, and edges for each transformation (if specified)
+#' \item \code{CTpath}: 
+#'   list of transformations from \code{i} to \code{j};
+#'   length > 1 if \code{type} is \code{"sequential"}, length-1 otherwise;
+#'   each element specifies \code{type} and \code{data} of the transformation
+#' \item \code{CTplot}: 
+#'   visualizes the element-coordinate space graph with \code{Rgraphviz}
+#' }
+#' 
+#' @examples
+#' x <- file.path("extdata", "blobs.zarr")
+#' x <- system.file(x, package="SpatialData")
+#' x <- readSpatialData(x, tables=FALSE)
+#' 
+#' # object-wide
+#' g <- CTgraph(x)
+#' CTplot(g)   
+#' 
+#' # one element
+#' y <- label(x)
+#' g <- CTgraph(y)
+#' CTplot(g) 
+#' 
+#' # retrieve transformation(s) 
+#' # from element to target space
+#' CTpath(x, "blobs_labels", "sequence")
+NULL
+
+#' @rdname CTgraph
+#' @export
+setMethod("CTgraph", "SpatialData", \(x) {
+    names(ls) <- ls <- setdiff(.LAYERS, "tables")
+    md <- lapply(ls, \(l) {
+        names(es) <- es <- names(x[[l]])
+        lapply(es, \(e) meta(x[[l]][[e]]))
+    })
+    .make_g(md)
+})
+
+#' @rdname CTgraph
+#' @export
+setMethod("CTgraph", "SpatialDataElement", \(x) 
+    .make_g(list("mock"=list("self"=meta(x)))))
+
+#' @rdname CTgraph
+#' @export
+setMethod("CTgraph", "ANY", \(x) stop("'x' should be a", 
+    " 'SpatialData' object, or a non-'table' element"))
+
+#' @importFrom graph graphAM nodeDataDefaults<- edgeDataDefaults<-
+.init_g <- \() {
+    g <- graphAM(edgemode="directed")
+    edgeDataDefaults(g, "data") <- list()
+    edgeDataDefaults(g, "type") <- character()
+    nodeDataDefaults(g, "type") <- character()
+    return(g)
+}
+
+#' @importFrom graph nodes addNode addEdge nodeData<- edgeData<- 
+.make_g <- \(md) {
+    g <- .init_g()
+    for (l in names(md)) for (e in names(md[[l]])) {
+        .md <- md[[l]][[e]]
+        ms <- .md$multiscales
+        if (!is.null(ms)) .md <- ms[[1]]
+        ct <- .md$coordinateTransformations
+        g <- addNode(e, g)
+        nodeData(g, e, "type") <- "element"
+        for (i in seq_along(ct)) {
+            n <- ct[[i]]$output$name
+            if (!n %in% nodes(g)) {
+                g <- addNode(n, g)
+                nodeData(g, n, "type") <- "space"
+            }
+            t <- ct[[i]]$type
+            if (t == "sequence") {
+                sq <- ct[[i]]$transformations
+                . <- e
+                for (j in seq_along(sq)) {
+                    if (j == length(sq)) {
+                        m <- n
+                    } else {
+                        m <- paste(e, n, j, sep="_")
+                        g <- addNode(m, g)
+                        nodeData(g, m, "type") <- "none"
+                    }
+                    t <- sq[[j]]$type
+                    d <- sq[[j]][[t]]
+                    g <- addEdge(., m, g)
+                    edgeData(g, ., m, "type") <- t
+                    edgeData(g, ., m, "data") <- list(d)
+                    . <- m
+                }
+            } else {
+                g <- addEdge(e, n, g)
+                d <- ct[[i]][[ct[[i]]$type]]
+                edgeData(g, e, n, "type") <- t
+                edgeData(g, e, n, "data") <- list(d)
+            }
+        }
+    }
+    return(g)
+}
+
+# path ----
+
+#' @importFrom graph edgeData
+#' @importFrom RBGL sp.between
+.path_ij <- \(g, i, j) {
+    p <- sp.between(g, i, j)
+    p <- p[[1]]$path_detail
+    n <- length(p)-1
+    lapply(seq_len(n), \(.) edgeData(g, p[.], p[.+1])[[1]])
+}
+
+#' @rdname CTgraph
+#' @export
+setMethod("CTpath", "SpatialData", \(x, i, j) {
+    g <- CTgraph(x)
+    .path_ij(g, i, j)
+})
+
+#' @rdname CTgraph
+#' @export
+setMethod("CTpath", "SpatialDataElement", \(x, j) {
+    g <- CTgraph(x)
+    .path_ij(g, "self", j)
+})
+
+#' @rdname CTgraph
+#' @export
+setMethod("CTpath", "ANY", \(x) stop("'x' should be a", 
+    " 'SpatialData' object, or a non-'table' element"))
+
+# plot ----
+
+#' @importFrom graph nodes nodes<- graph.par
+#' @rdname CTgraph
+#' @export
+CTplot <- \(g, cex=0.5, fac=2, max=10) {
+    if (!requireNamespace("Rgraphviz", quietly=TRUE))
+        stop("Install 'Rgraphviz' to use this function")
+    g2view <- g # leave 'g' alone
+    nodes(g2view) <- .nodefix(nodes(g2view), fac=fac, max=max)
+    graph.par(list(nodes=list(shape="plaintext", cex=cex)))
+    g2view <- Rgraphviz::layoutGraph(g2view)
+    Rgraphviz::renderGraph(g2view)
+}
+
+.nodefix <- \(x, fac=2, max=10) {
+    fix <- nchar(x) > max
+    if (!any(fix)) return(x)
+    x[fix] <- .fixup(x[fix], fac)
+    x
+}
+
+.fixup <- \(x, fac) {
+    xs <- strsplit(x, "")
+    nc <- floor(nchar(x)/fac)
+    vapply(seq_along(xs), \(i) {
+        j <- seq_len(nc[i])
+        y <- c(xs[[i]][j], "-\n", xs[[i]][-j])
+        paste(y, collapse="")
+    }, character(1))
+}
diff --git a/R/CTutils.R b/R/CTutils.R
new file mode 100644
index 00000000..124c0929
--- /dev/null
+++ b/R/CTutils.R
@@ -0,0 +1,227 @@
+#' @name CTutils
+#' @title Coord. trans. utilities
+#' @aliases axes CTlist CTname CTtype CTdata addCT rmvCT
+#' 
+#' @param x \code{SpatialData}, an element, or \code{Zattrs}.
+#' @param i for \code{CTpath}, source node label; else, string or 
+#'   scalar integer giving the name or index of a coordinate space.
+#' @param name character(1); name of coordinate space
+#' @param type character(1); type of transformation
+#' @param data transformation data; size and shape depend on transformation and
+#'   element type (e.g., numeric(1) for rotation, numeric(2) for scaling in 2D)
+#' @param ... option arguments passed to and from other methods.
+#' 
+#' @returns
+#' \itemize{
+#' \item \code{CTname}: character string; 
+#'   transformation name (e.g., "global")
+#' \item \code{CTtype}: character string; 
+#'   transformation type (e.g., "affine")
+#' \item \code{CTdata}: list;
+#'   transformation data (e.g., scalar numeric for rotation)
+#' \item \code{CTlist}: list;
+#'   list of transformation specifications per OME-NGFF spec
+#' \item \code{add/rmvCT}: 
+#'   \code{SpatialDataElement} or \code{Zattrs} 
+#'   with transformation(s) added/removed
+#' \item \code{axes}: list; 
+#'   each element is a character string (name), or list 
+#'   with axis name and type (e.g., "space" or "channel")
+#' }
+#' 
+#' @examples
+#' x <- file.path("extdata", "blobs.zarr")
+#' x <- system.file(x, package="SpatialData")
+#' x <- readSpatialData(x, tables=FALSE)
+#' 
+#' # view available target coordinate systems
+#' CTname(z <- meta(label(x)))
+#'
+#' # add
+#' addCT(z, "scale", "scale", c(12, 34)) # overwrite
+#' CTname(addCT(z, "new", "translation", c(12, 34)))
+#' 
+#' # rmv
+#' CTname(rmvCT(z, 2))        # by index
+#' CTname(rmvCT(z, "scale"))  # by name
+#' CTname(rmvCT(z, "global")) # identity is protected
+NULL
+
+# TODO: currently applying transformations only on 'data.frame's for plotting,
+# not the actual data (e.g., image)... but this might be necessary for queries?
+
+# TODO: for all layers, implement all transformations 
+# (translate, scale, rotate, affine, and sequential)
+
+# axes() ----
+
+#' @rdname CTutils
+#' @export
+setMethod("axes", "Zattrs", \(x, ...) {
+    ms <- multiscales(x)
+    if (!is.null(ms)) x <- ms[[1]]
+    if (is.null(x <- x$axes)) stop("couldn't find 'axes'") 
+    return(x)
+})
+
+#' @rdname CTutils
+#' @export
+setMethod("axes", "SpatialDataElement", \(x, ...) axes(meta(x)))
+
+# CTlist/data/type/name() ----
+
+#' @rdname CTutils
+#' @export
+setMethod("CTlist", "Zattrs", \(x, ...) {
+    ms <- multiscales(x)
+    ct <- "coordinateTransformations"
+    if (is.null(ms)) return(x[[ct]])
+    ms[[1]][[ct]]
+})
+
+#' @rdname CTutils
+#' @export
+setMethod("CTdata", "Zattrs", \(x, i=1, ...) {
+    stopifnot(length(i) == 1)
+    if (is.character(i)) {
+        match.arg(i, CTname(x))
+        i <- match(i, CTname(x))
+    } else if (is.numeric(i)) {
+        stopifnot(
+            i == round(i), 
+            i %in% seq_along(CTlist(x)))
+    } else stop("Invalid 'i'; should be a scalar character or integer")
+    t <- CTtype(x)[i]
+    if (t != "sequence") 
+        return(CTlist(x)[[i]][[t]])
+    ts <- CTlist(x)[[i]]$transformations
+    names(ts) <- vapply(ts, \(.) .$type, character(1))
+    mapply(x=ts, i=names(ts), \(x, i) x[[i]], SIMPLIFY=FALSE)
+})
+
+#' @rdname CTutils
+#' @export
+setMethod("CTtype", "Zattrs", \(x, ...) {
+    vapply(CTlist(x), \(.) .$type, character(1))
+})
+
+#' @rdname CTutils
+#' @export
+setMethod("CTname", "Zattrs", \(x, ...) {
+    vapply(CTlist(x), \(.) .$output$name, character(1))
+})
+
+#' @rdname CTutils
+#' @export
+setMethod("CTlist", "SpatialDataElement", \(x, ...) CTlist(meta(x)))
+
+#' @rdname CTutils
+#' @export
+setMethod("CTdata", "SpatialDataElement", \(x, i=1, ...) CTdata(meta(x), i))
+
+#' @rdname CTutils
+#' @export
+setMethod("CTtype", "SpatialDataElement", \(x, ...) CTtype(meta(x)))
+
+#' @rdname CTutils
+#' @export
+setMethod("CTname", "SpatialDataElement", \(x, ...) CTname(meta(x)))
+
+#' @rdname CTutils
+#' @export
+setMethod("CTname", "SpatialData", \(x, ...) {
+    g <- CTgraph(x)
+    t <- nodeData(g, nodes(g), "type")
+    names(t)[unlist(t) == "space"]
+})
+
+# rmv ----
+
+#' @rdname CTutils
+#' @export
+setMethod("rmvCT", "SpatialDataElement", 
+    \(x, i) { x@meta <- rmvCT(meta(x), i); x })
+
+#' @rdname CTutils
+#' @export
+setMethod("rmvCT", "Zattrs", \(x, i) {
+    nms <- CTname(x)
+    if (is.numeric(i)) {
+        if (any(i > length(nms)))
+            stop("invalid 'i'")
+        i <- nms[i]
+    }
+    nan <- setdiff(i, nms)
+    if (length(nan)) stop(
+        "couldn't find 'coordTrans' of name(s) ", 
+        paste(dQuote(nan), collapse=","))
+    i <- match(i, nms)
+    # protect against dropping identity
+    i <- i[CTtype(x)[i] != "identity"]
+    if (!length(i)) {
+        warning("can't drop identity")
+        return(x)
+    }
+    ms <- "multiscales"
+    ct <- "coordinateTransformations"
+    if (length(i)) {
+        if (is.null(x[[ms]])) {
+            x[[ct]] <- x[[ct]][-i]
+        } else {
+            y <- x[[ms]][[1]][[ct]][-i]
+            x[[ms]][[1]][[ct]] <- y
+        }
+    }
+    return(x)
+})
+
+# add ----
+
+#' @rdname CTutils
+#' @export
+setMethod("addCT", "SpatialDataElement", \(x, name, type, data) {
+    x@meta <- addCT(meta(x), name, type, data); x })
+
+.check_ct <- \(x, type, data) {
+    d <- length(axes(x))
+    f <- \(t) stop("invalid 'data' for transformation of 'type' ", dQuote(t))
+    t <- match.arg(type, c("identity", "scale", "rotate", "translation", "affine"))
+    . <- switch(t, 
+        identity=is.null(data),
+        translation=length(data) == d & is.numeric(data),
+        rotate=length(data) == 1 & is.numeric(data) & data > 0,
+        scale=length(data) == d & is.numeric(data) & all(data > 0),
+        TRUE)
+    if (!.) f(t)
+}
+
+#' @rdname CTutils
+#' @export
+setMethod("addCT", "Zattrs", \(x, name, type="identity", data=NULL) {
+    stopifnot(
+        is.character(name), length(name) == 1,
+        is.character(type), length(type) == 1)
+    .check_ct(x, type, data)
+    # use existing as skeleton
+    old <- CTlist(x)
+    new <- old[[1]][c("input", "output", "type")]
+    new$type <- type
+    new$output$name <- name
+    new[[new$type]] <- list(data)
+    # append/overwrite & stash
+    ms <- "multiscales"
+    ct <- "coordinateTransformations"
+    i <- match(name, CTname(x))
+    if (is.na(i)) {
+        new <- c(old, list(new))
+    } else {
+        old[[i]] <- new
+        new <- old
+    }
+    if (is.null(x[[ms]])) {
+        x[[ct]] <- new
+    } else {
+        x[[ms]][[1]][[ct]] <- new
+    }
+    return(x)
+})
diff --git a/R/ImageArray.R b/R/ImageArray.R
index 7f67b987..a0e9f812 100644
--- a/R/ImageArray.R
+++ b/R/ImageArray.R
@@ -2,7 +2,7 @@
 #' @title The `ImageArray` class
 #' 
 #' @param x \code{ImageArray}
-#' @param data list of \code{\link[Rarr]{ZarrArray}}s
+#' @param data list of \code{\link[ZarrArray]{ZarrArray}}s
 #' @param meta \code{\link{Zattrs}}
 #' @param metadata optional list of arbitrary 
 #'   content describing the overall object.
@@ -18,17 +18,18 @@
 #'
 #' @examples
 #' library(SpatialData.data)
-#' dir.create(td <- tempfile())
-#' pa <- SpatialData.data:::.unzip_merfish_demo(td)
-#' pa <- file.path(pa, "images", "rasterized")
+#' zs <- get_demo_SDdata("merfish")
+#' pa <- file.path(zs, "images", "rasterized")
 #' (ia <- readImage(pa))
 #'
 #' @importFrom S4Vectors metadata<-
 #' @importFrom methods new
 #' @importFrom DelayedArray DelayedArray
 #' @export
-ImageArray <- function(data=list(), meta=Zattrs(), metadata=list(), 
+ImageArray <- function(data=list(), meta=Zattrs(), metadata=list(),
                        multiscale=FALSE, axes = NULL, ...) {
+    if (!missing(data) && is.list(data) && length(data) == 0)
+        stop("'data' must not be an empty list; use ImageArray() for an empty placeholder")
     if(!is.list(data)){
       if(multiscale){
         data <- .generate_multiscale(data, axes = axes, method = "image")
@@ -36,11 +37,11 @@ ImageArray <- function(data=list(), meta=Zattrs(), metadata=list(),
         data <- list(DelayedArray::DelayedArray(data))
       }
     }
-    if(length(meta) < 1){
-      meta <- .make_image_meta(data, 
-                               version = 0.4, 
+    if(length(meta) < 1 && length(data) > 0){
+      meta <- .make_image_meta(data,
+                               version = 0.4,
                                axes = axes)
-    } 
+    }
     x <- .ImageArray(data=data, meta=meta, ...)
     metadata(x) <- metadata
     return(x)
@@ -49,60 +50,58 @@ ImageArray <- function(data=list(), meta=Zattrs(), metadata=list(),
 #' @rdname ImageArray
 #' @aliases channels
 #' @export
-setMethod("channels", "ImageArray", \(x, ...) meta(x)$omero$channels$label)
+setMethod("channels", "Zattrs", \(x, ...) {
+    v <- x$spatialdata_attrs$version
+    if (!length(v)) stop("couldn't find 'version' in 'spatialdata_attrs'")
+    if (v == "0.3") x <- x$ome
+    unlist(x$omero$channels)
+})
+
+#' @rdname ImageArray
+#' @aliases channels
+#' @export
+setMethod("channels", "ImageArray", \(x, ...) channels(meta(x)))
 
 #' @rdname ImageArray
 #' @export
 setMethod("channels", "ANY", \(x, ...) stop("only 'images' have channels"))
 
 #' @importFrom S4Vectors isSequence
-.get_multiscales_dataset_paths <- function(md) {
-  
-    # validate multiscales attributes
-    .validate_multiscales_dataset_path(md)
-  
-    # get paths
-    paths <- md$multiscales$datasets[[1]]$path
-    paths <- suppressWarnings({as.numeric(sort(paths, decreasing=FALSE))})
-  
-    # TODO: how to check if a vector of values here are integers
-    # check paths and return
-    # if(all(paths %% 0 == 0)){
-    #   if(S4Vectors::isSequence(paths))
-    #     return(paths) 
-    # }
-    return(paths)
-  
-    # stop if not a sequence of integers
-    stop("ImageArray paths are ill-defined, should be e.g. 0,1,2, ..., n")
+.get_multiscales_dataset_paths <- function(za) {
+    # validate 'multiscales'
+    ms <- .check_ms(za)
+    # get & validate 'path's
+    ds <- ms[[1]]$datasets
+    ps <- vapply(ds, \(.) .$path, character(1))
+    ps <- suppressWarnings(as.numeric(sort(ps, decreasing=FALSE)))
+    if (length(ps)) {
+        qs <- seq(min(ps), max(ps))
+        if (!isTRUE(all.equal(ps, qs)))
+            stop("ImageArray paths are ill-defined, should",
+                " be an integer sequence, e.g., 0,1,...,n")
+    }
+    return(ps)
 }
 
-#' @noRd
-.validate_multiscales_dataset_path <- function(md) {
-    # validate 'multiscales' 
-    if ("multiscales" %in% names(md)) {
-        ms <- md[["multiscales"]]
-    
+.check_ms <- \(za) {
+    # validate 'multiscales'
+    ms <- multiscales(za)
+    if (!is.null(ms)) {
         # validate 'datasets' 
-        if("datasets" %in% names(ms)) {
-          ds <- ms[["datasets"]]
-          
-          # validate 'paths'
-          valid <- vapply(ds, \(ds) "path" %in% colnames(ds), logical(1))
-          
-          if (!all(valid)) {
-            stop("'ImageArray' paths are ill-defined,",
-                " no 'path' attribute under 'multiscale-datasets'")
-          } 
-          
-        } else {
-            stop("'ImageArray' paths are ill-defined,",
-                " no 'datasets' attribute under 'multiscale'")
-        }
-    } else {
-        stop("'ImageArray' paths are ill-defined,",
-            " no 'multiscales' attribute under '.zattrs'")
-    }
+        ds <- ms[[1]]$datasets
+        if (!is.null(ds)) {
+            # validate 'paths'
+            ok <- vapply(ds, \(.) !is.null(.$path), logical(1))
+            if (!all(ok))
+                stop("'ImageArray' paths are ill-defined,",
+                    " no 'path' attribute under 'multiscale-datasets'")
+        } else stop(
+            "'ImageArray' paths are ill-defined,",
+            " no 'datasets' attribute under 'multiscale'")
+    } else stop( 
+        "'ImageArray' paths are ill-defined,",
+        " no 'multiscales' attribute under '.zattrs'")
+    return(ms)
 }
 
 .check_jk <- \(x, .) {
diff --git a/R/LabelArray.R b/R/LabelArray.R
index c67bdfda..1da4cee2 100644
--- a/R/LabelArray.R
+++ b/R/LabelArray.R
@@ -14,7 +14,7 @@
 #' }
 #'
 #' @param x \code{LabelArray}
-#' @param data list of \code{\link[Rarr]{ZarrArray}}s
+#' @param data list of \code{\link[ZarrArray]{ZarrArray}}s
 #' @param meta \code{\link{Zattrs}}
 #' @param metadata optional list of arbitrary 
 #'   content describing the overall object.
@@ -28,13 +28,21 @@
 #' @return \code{LabelArray}
 #'
 #' @examples
-#' # TODO
+#' x <- file.path("extdata", "blobs.zarr")
+#' x <- system.file(x, package="SpatialData")
+#' x <- file.path(x, "labels", "blobs_labels")
+#' 
+#' (y <- readLabel(x))
+#' y[1:10, 1:10]
+#' meta(y)
 #'
 #' @importFrom S4Vectors metadata<-
 #' @importFrom methods new
 #' @export
-LabelArray <- function(data=array(), meta=Zattrs(), metadata=list(), 
+LabelArray <- function(data=list(), meta=Zattrs(), metadata=list(),
                        multiscale = FALSE, axes = NULL, ...) {
+    if (!missing(data) && is.list(data) && length(data) == 0)
+        stop("'data' must not be an empty list; use LabelArray() for an empty placeholder")
     if(!is.list(data)){
       if(multiscale){
         data <- .generate_multiscale(data, axes = axes, method = "label")
@@ -42,11 +50,11 @@ LabelArray <- function(data=array(), meta=Zattrs(), metadata=list(),
         data <- list(DelayedArray::DelayedArray(data))
       }
     }
-    if(length(meta) < 1){
-      meta <- .make_label_meta(data, 
-                               version = 0.4, 
+    if(length(meta) < 1 && length(data) > 0){
+      meta <- .make_label_meta(data,
+                               version = 0.4,
                                axes = axes)
-    } 
+    }
     x <- .LabelArray(data=data, meta=meta, ...)
     metadata(x) <- metadata
     return(x)
diff --git a/R/PointFrame.R b/R/PointFrame.R
index 74a6f77c..88b015f7 100644
--- a/R/PointFrame.R
+++ b/R/PointFrame.R
@@ -32,9 +32,8 @@
 #'
 #' @examples
 #' library(SpatialData.data)
-#' dir.create(tf <- tempfile())
-#' base <- SpatialData.data:::.unzip_merfish_demo(tf)
-#' x <- file.path(base, "points", "single_molecule")
+#' zs <- get_demo_SDdata("merfish")
+#' x <- file.path(zs, "points", "single_molecule")
 #' (p <- readPoint(x))
 #' 
 #' head(as.data.frame(data(p)))
diff --git a/R/ShapeFrame.R b/R/ShapeFrame.R
index 2a9ad2b5..f6795436 100644
--- a/R/ShapeFrame.R
+++ b/R/ShapeFrame.R
@@ -1,5 +1,6 @@
 #' @name ShapeFrame
 #' @title The `ShapeFrame` class
+#' @aliases geom_type
 #'
 #' @param x \code{ShapeFrame}
 #' @param data \code{arrow}-derived table for on-disk,
@@ -9,20 +10,20 @@
 #'   content describing the overall object.
 #' @param name character string for extraction (see \code{?base::`$`}).
 #' @param i,j indices specifying elements to extract.
-#' @param drop ignored.
+#' @param drop,pattern ignored.
 #' @param ... optional arguments passed to and from other methods.
 #'
 #' @return \code{ShapeFrame}
 #'
 #' @examples
 #' library(SpatialData.data)
-#' dir.create(tf <- tempfile())
-#' base <- SpatialData.data:::.unzip_merfish_demo(tf)
-#' y <- file.path(base, "shapes", "cells")
+#' zs <- get_demo_SDdata("merfish")
+#' 
+#' y <- file.path(zs, "shapes", "cells")
 #' (s <- readShape(y))
 #' plot(sf::st_as_sf(data(s)), cex=0.2)
 #' 
-#' y <- file.path(base, "shapes", "anatomical")
+#' y <- file.path(zs, "shapes", "anatomical")
 #' (s <- readShape(y))
 #' plot(sf::st_as_sf(data(s)), cex=0.2)
 #'
@@ -56,16 +57,25 @@ setMethod("length", "ShapeFrame", \(x) nrow(data(x)))
 #' @export
 setMethod("names", "ShapeFrame", \(x) names(data(x)))
 
-#' @importFrom utils .DollarNames
 #' @export
-.DollarNames.ShapeFrame <- \(x, pattern="") {
+#' @rdname ShapeFrame
+#' @importFrom utils .DollarNames
+.DollarNames.ShapeFrame <- \(x, pattern="") 
     grep(pattern, names(x), value=TRUE)
-}
 
 #' @rdname ShapeFrame
 #' @exportMethod $
 setMethod("$", "ShapeFrame", \(x, name) data(x)[[name]])
 
+#' @export
+#' @rdname ShapeFrame
+#' @importFrom sf st_as_sf st_geometry_type
+setMethod("geom_type", "ShapeFrame", \(x) {
+    y <- st_as_sf(data(x[1, ]))
+    z <- st_geometry_type(y)
+    return(as.character(z))
+})
+
 # sub ----
 
 #' @rdname ShapeFrame
diff --git a/R/SpatialData.R b/R/SpatialData.R
index b27b9239..0db13141 100644
--- a/R/SpatialData.R
+++ b/R/SpatialData.R
@@ -8,6 +8,8 @@
 #' image images image<- images<- imageNames 
 #' shape shapes shape<- shapes<- shapeNames 
 #' table tables table<- tables<- tableNames 
+#' [[<-,SpatialData,character,ANY-method
+#' [[<-,SpatialData,numeric,ANY-method
 #' 
 #' @description ...
 #' 
@@ -31,7 +33,7 @@
 #' @examples
 #' x <- file.path("extdata", "blobs.zarr")
 #' x <- system.file(x, package="SpatialData")
-#' (x <- readSpatialData(x, anndataR=FALSE))
+#' (x <- readSpatialData(x, anndataR=TRUE))
 #' 
 #' # subsetting
 #' # layers are taken in order of appearance
diff --git a/R/Zattrs.R b/R/Zattrs.R
index 854443cf..eb969bec 100644
--- a/R/Zattrs.R
+++ b/R/Zattrs.R
@@ -1,6 +1,6 @@
 #' @name Zattrs
 #' @title The `Zattrs` class
-#'
+#' 
 #' @param x list extracted from a OME-NGFF compliant .zattrs file.
 #' @param name character string for extraction (see ?base::`$`).
 #' 
@@ -11,11 +11,13 @@
 #' x <- system.file(x, package="SpatialData")
 #' x <- readSpatialData(x, tables=FALSE)
 #' 
-#' z <- meta(label(x))
-#' axes(z) 
-#' CTdata(z)
+#' (z <- meta(label(x)))
+#' 
 #' CTname(z)
 #' CTtype(z)
+#' CTdata(z, "scale")
+#' 
+#' feature_key(point(x))
 #'
 #' @export
 Zattrs <- \(x=list()) {
@@ -33,3 +35,108 @@ Zattrs <- \(x=list()) {
 #' @rdname Zattrs
 #' @exportMethod $
 setMethod("$", "Zattrs", \(x, name) x[[name]])
+
+# internal use only!
+#' @noRd 
+setMethod("multiscales", "list", \(x) {
+    v <- x$spatialdata_attrs$version
+    if (!length(v)) stop("couldn't find 'version' in 'spatialdata_attrs'")
+    switch(v, "0.3"=x$ome$multiscales, x$multiscales)
+})
+
+.showZattrs <- function(object) {
+    cat("class: Zattrs\n")
+    ax <- axes(object)
+    cat(sprintf("axes(%d):\n", length(ax)))
+    if (is.character(ax[[1]])) {
+        cat("- name:", unlist(ax), "\n")
+    } else {
+        cat("- name:", vapply(ax, \(.) .$name, character(1)), "\n")
+        cat("- type:", vapply(ax, \(.) .$type, character(1)), "\n")
+    }
+    # TODO: more detailed 'sequence' display
+    cat(sprintf("coordTrans(%d):\n", n <- length(CTname(object))))
+    g <- \(.) {
+        . <- paste(unlist(.), collapse=",")
+        if (!grepl(",", .)) return(.)
+        sprintf("[%s]", .)
+    }
+    f <- \(.) {
+        if (is.null(.)) return("")
+        paste0(":", g(lapply(., g)))
+    }
+    for (i in seq_len(n))
+        cat(sprintf("- %s: (%s%s)\n",
+            CTname(object)[i],
+            CTtype(object)[i],
+            f(CTlist(object)[[i]][[CTtype(object)[i]]])))
+    ms <- object$multiscales[[1]]
+    if (!is.null(ms)) {
+        ds <- ms$datasets
+        ps <- vapply(ds, \(.) .$path, character(1))
+        coolcat("datasets(%d): %s\n", ps)
+        for (i in seq_along(ds)) {
+            ct <- ds[[i]]$coordinateTransformations[[1]]
+            cat(sprintf("- %s: (%s:%s)\n", 
+                ps[i], ct$type, g(ct[[ct$type]]))) 
+        }
+    }
+    cs <- unlist(channels(object))
+    if (!is.null(cs)) coolcat("channels(%d): %s\n", cs)
+}
+setMethod("show", "Zattrs", .showZattrs)
+
+#' @name SDattrs
+#' @title \code{SpatialData} attributes
+#' 
+#' @aliases
+#' region
+#' region_key
+#' feature_key
+#' instance_key
+#' 
+#' @param x depends on which attributes are available; 
+#'   specifically, \code{PointFrame} (\code{feature/instance_key}), or
+#'   \code{SingleCellExperiment} (\code{region}, \code{region/instance_key}),
+#' 
+#' @return character string
+#'
+#' @examples
+#' x <- file.path("extdata", "blobs.zarr")
+#' x <- system.file(x, package="SpatialData")
+#' x <- readSpatialData(x, anndataR=TRUE)
+#' 
+#' region(table(x))
+#' region_key(table(x))
+#' 
+#' instance_key(point(x))
+#' fk <- feature_key(point(x))
+#' base::table(point(x)[[fk]])
+NULL
+
+# TODO: only points can have this?
+#' @export
+#' @rdname SDattrs
+setMethod("feature_key", "list", \(x) x$spatialdata_attrs$feature_key)
+#' @export
+#' @rdname SDattrs
+setMethod("feature_key", "PointFrame", \(x) feature_key(meta(x)))
+
+# TODO: only tables can have this?
+#' @export
+#' @rdname SDattrs
+setMethod("region_key", "SingleCellExperiment", \(x) meta(x)$region_key)
+#' @export
+#' @rdname SDattrs
+setMethod("region", "SingleCellExperiment", \(x) meta(x)[[region_key(x)]])
+
+# TODO: only tables and points can have this?
+#' @export
+#' @rdname SDattrs
+setMethod("instance_key", "list", \(x) x$instance_key)
+#' @export
+#' @rdname SDattrs
+setMethod("instance_key", "PointFrame", \(x) instance_key(meta(x)$spatialdata_attrs))
+#' @export
+#' @rdname SDattrs
+setMethod("instance_key", "SingleCellExperiment", \(x) instance_key(meta(x)))
diff --git a/R/coord_utils.R b/R/coord_utils.R
deleted file mode 100644
index 04734da3..00000000
--- a/R/coord_utils.R
+++ /dev/null
@@ -1,443 +0,0 @@
-#' @name coord-utils
-#' @title Coordinate transformations
-#' @aliases axes CTname CTtype CTdata CTpath CTgraph addCT rmvCT
-#' 
-#' @param x \code{SpatialData}, an element, or \code{Zattrs}.
-#' @param i for \code{CTpath}, source node label; else, string or 
-#'   scalar integer giving the name or index of a coordinate space.
-#' @param j character string; name of target coordinate space.
-#' @param name character(1); name of coordinate space
-#' @param type character(1); type of transformation
-#' @param data transformation data; size and shape depend on transformation and
-#'   element type (e.g., numeric(1) for rotation, numeric(2) for scaling in 2D)
-#' @param ... option arguments passed to and from other methods.
-#' 
-#' @examples
-#' x <- file.path("extdata", "blobs.zarr")
-#' x <- system.file(x, package="SpatialData")
-#' x <- readSpatialData(x, tables=FALSE)
-#' 
-#' # element-wise
-#' g <- CTgraph(y <- image(x))
-#' graph::nodes(g)
-#' CTpath(y, "global")
-#' 
-#' # object-wide
-#' g <- CTgraph(x)
-#' plotCoordGraph(g)
-#' 
-#' # retrieve transformation from element to target space
-#' CTpath(x, "blobs_labels", "sequence")
-#' 
-#' # view available coordinate transformations
-#' CTdata(z <- meta(label(x)))
-#'
-#' # add
-#' addCT(z, "scale", "scale", c(12, 34)) # can't overwrite
-#' CTdata(addCT(z, "new", "translation", c(12, 34)))
-#' 
-#' # rmv
-#' CTdata(rmvCT(z, 2)) # by index
-#' CTdata(rmvCT(z, "scale")) # by name
-#' CTdata(rmvCT(z, 1)) # identity is protected
-NULL
-
-# TODO: currently applying transformations only on 'data.frame's for plotting,
-# not the actual data (e.g., image)... but this might be necessary for queries?
-
-# TODO: for all layers, implement all transformations 
-# (translate, scale, rotate, affine, and sequential)
-
-# axes() ----
-
-#' @rdname coord-utils
-#' @export
-setMethod("axes", "Zattrs", \(x, ...) {
-    if (!is.null(ms <- x$multiscales)) x <- ms
-    if (is.null(x <- x$axes)) stop("couldn't find 'axes'") 
-    if (is.character(x)) x else x[[1]]
-})
-
-#' @rdname coord-utils
-#' @export
-setMethod("axes", "SpatialDataElement", \(x, ...) axes(meta(x)))
-
-# CTdata/type/name() ----
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTdata", "Zattrs", \(x, ...) {
-    ms <- x$multiscales
-    if (!is.null(ms)) x <- ms
-    x <- x$coordinateTransformations
-    if (is.null(dim(x))) x[[1]] else x
-})
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTdata", "SpatialDataElement", \(x, ...) CTdata(meta(x)))
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTtype", "Zattrs", \(x, ...) CTdata(x)$type)
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTtype", "SpatialDataElement", \(x, ...) CTtype(meta(x)))
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTname", "Zattrs", \(x, ...) CTdata(x)$output$name)
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTname", "SpatialDataElement", \(x, ...) CTname(meta(x)))
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTname", "SpatialData", \(x, ...) {
-    g <- CTgraph(x)
-    t <- nodeData(g, nodes(g), "type")
-    names(t)[unlist(t) == "space"]
-})
-
-# CTgraph() ----
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTgraph", "SpatialData", \(x) {
-    names(ls) <- ls <- setdiff(.LAYERS, "tables")
-    md <- lapply(ls, \(l) {
-        names(es) <- es <- names(x[[l]])
-        lapply(es, \(e) meta(x[[l]][[e]]))
-    })
-    .make_g(md)
-})
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTgraph", "SpatialDataElement", \(x) 
-    .make_g(list("mock"=list("self"=meta(x)))))
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTgraph", "ANY", \(x) stop("'x' should be a", 
-    " 'SpatialData' object, or a non-'table' element"))
-
-#' @importFrom graph graphAM nodeDataDefaults<- edgeDataDefaults<-
-.init_g <- \() {
-    g <- graphAM(edgemode="directed")
-    edgeDataDefaults(g, "data") <- list()
-    edgeDataDefaults(g, "type") <- character()
-    nodeDataDefaults(g, "type") <- character()
-    return(g)
-}
-
-#' @importFrom graph nodes addNode addEdge nodeData<- edgeData<- 
-.make_g <- \(md) {
-    g <- .init_g()
-    for (l in names(md)) for (e in names(md[[l]])) {
-        .md <- md[[l]][[e]]
-        ms <- .md$multiscales
-        if (!is.null(ms)) .md <- ms
-        ct <- .md$coordinateTransformations
-        ct <- if (length(ct) == 1) ct[[1]] else ct
-        g <- addNode(e, g)
-        nodeData(g, e, "type") <- "element"
-        for (i in seq(nrow(ct))) {
-            n <- ct$output$name[i]
-            if (!n %in% nodes(g)) {
-                g <- addNode(n, g)
-                nodeData(g, n, "type") <- "space"
-            }
-            t <- ct$type[i]
-            if (t == "sequence") {
-                sq <- ct$transformations[i][[1]]
-                . <- e
-                for (j in seq(nrow(sq))) {
-                    if (j == nrow(sq)) {
-                        m <- n
-                    } else {
-                        m <- paste(e, n, j, sep="_")
-                        g <- addNode(m, g)
-                        nodeData(g, m, "type") <- "none"
-                    }
-                    t <- sq$type[j]
-                    d <- sq[[t]][j]
-                    g <- addEdge(., m, g)
-                    edgeData(g, ., m, "type") <- t
-                    edgeData(g, ., m, "data") <- d
-                    . <- m
-                }
-            } else {
-                g <- addEdge(e, n, g)
-                d <- ct[[ct$type[i]]][i]
-                edgeData(g, e, n, "type") <- t
-                edgeData(g, e, n, "data") <- d
-            }
-        }
-    }
-    return(g)
-}
-
-# CTpath() ----
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTpath", "SpatialData", \(x, i, j) {
-    g <- CTgraph(x)
-    .path_ij(g, i, j)
-})
-
-#' @rdname coord-utils
-#' @export
-setMethod("CTpath", "SpatialDataElement", \(x, j) {
-    g <- CTgraph(x)
-    .path_ij(g, "self", j)
-})
-
-#' @importFrom graph edgeData
-#' @importFrom RBGL sp.between
-.path_ij <- \(g, i, j) {
-    p <- sp.between(g, i, j)
-    p <- p[[1]]$path_detail
-    n <- length(p)-1
-    lapply(seq_len(n), \(.)
-        edgeData(g, p[.], p[.+1])[[1]])
-}
-
-# rmv ----
-
-#' @rdname coord-utils
-#' @export
-setMethod("rmvCT", "SpatialDataElement", 
-    \(x, i) { x@meta <- rmvCT(meta(x), i); x })
-
-#' @rdname coord-utils
-#' @export
-setMethod("rmvCT", "Zattrs", \(x, i) {
-    nms <- CTname(x)
-    if (is.numeric(i)) {
-        if (any(i > length(nms)))
-            stop("invalid 'i'")
-        i <- nms[i]
-    }
-    nan <- setdiff(i, nms)
-    if (length(nan)) stop(
-        "couln't find 'coordTrans' of name(s) ", 
-        paste(dQuote(nan), collapse=","))
-    i <- match(i, nms)
-    # # prevent against dropping identity
-    # i <- i[CTtype(x)[i] != "identity"]
-    ms <- "multiscales"
-    ct <- "coordinateTransformations"
-    if (length(i)) {
-        # utility to drop empty columns
-        j <- \(.) vapply(., \(.) !is.null(unlist(.)), logical(1))
-        if (!is.null(x[[ms]])) {
-            y <- x[[ms]][[ct]][[1]][-i, ]
-            x[[ms]][[ct]][[1]] <- y[, j(y)]
-        } else {
-            y <- x[[ct]][-i, ]
-            x[[ct]] <- y[, j(y)]
-        }
-    }
-    return(x)
-})
-
-# add ----
-
-#' @rdname coord-utils
-#' @export
-setMethod("addCT", "SpatialDataElement", \(x, name, type, data) {
-    x@meta <- addCT(meta(x), name, type, data); x })
-
-.check_ct <- \(x, type, data) {
-    d <- ifelse(is.character(a <- axes(x)), length(a), nrow(a))
-    f <- \(t) stop("invalid 'data' for transformation of 'type' ", dQuote(t))
-    t <- match.arg(type, c("identity", "scale", "rotate", "translation", "affine"))
-    . <- switch(t, 
-        identity=is.null(data),
-        translation=length(data) == d & is.numeric(data),
-        rotate=length(data) == 1 & is.numeric(data) & data > 0,
-        scale=length(data) == d & is.numeric(data) & all(data > 0),
-        TRUE)
-    if (!.) f(t)
-}
-
-# make ----
-
-.make_axes_meta <- function(x, unit = FALSE){
-  lapply(x, \(.){
-    meta <- list(names = ., 
-                 type = if(. == "c") "channel" else "space")
-    if(unit)
-      meta <- c(meta, list(unit = "unit"))
-    meta
-  })
-}
-
-.make_empty_ct <- function(x){
-  space <- .make_axes_meta(x, unit = TRUE)
-  input <- list(axes = space, 
-                name = paste(x, collapse = ""))
-  output <- list(axes = space, name = "global")
-  meta <- list(
-    list(input = input, 
-         output = output, 
-         type = "identity")
-  )
-  meta
-}
-
-.make_datasets <- function(x, axes){
-  paths <- paste0(seq_len(length(x)) - 1)
-  mapply(\(p) {
-    list(
-      coordinateTransformations = list(
-        list(
-          scale = vapply(axes, \(.){
-            if(. == "c") 1 else (2^as.numeric(p))
-          }, numeric(1)),
-          type = "scale" 
-        )
-      ), 
-      path = p
-    )
-  }, paths, USE.NAMES = FALSE, SIMPLIFY = FALSE)
-}
-
-#' @rdname coord-utils
-#' @export
-setMethod("addCT", "Zattrs", \(x, name, type="identity", data=NULL) {
-    stopifnot(
-        is.character(name), length(name) == 1,
-        is.character(type), length(type) == 1)
-    .check_ct(x, type, data)
-    ms <- "multiscales"
-    ts <- "transformations"
-    ct <- "coordinateTransformations"
-    # use existing as skeleton
-    fd <- (df <- CTdata(x))[1, ]
-    fd <- fd[, c("input", "output", "type")]
-    fd$type <- type
-    fd$output$name <- name
-    fd[[fd$type]] <- list(data)
-    # append to existing if 'name' already present 
-    idx <- match(name, CTname(x))
-    typ <- CTtype(x)[idx]
-    if (!is.na(typ) && typ == "identity") {
-        df <- df[0, ]
-        app <- FALSE
-    } else if (app <- !is.na(idx)) {
-        if (seq <- (typ == "sequence")) {
-            df <- df[idx, ][[ts]][[1]]
-            fd$output$name <- df$output$name[1]
-        } else {
-            df <- df[idx, ]
-            if (is.null(df[[ts]])) {
-                
-            } else {
-                df[[ts]][[1]] <- df
-            }
-            # fd$type <- type
-            # fd[[fd$type]] <- list(data)
-        }
-    } else {
-        # fd$type <- type
-        # fd[[fd$type]] <- list(data)
-    }
-    na <- setdiff(names(df), names(fd))
-    for (. in na) fd[[.]] <- list(NULL)
-    na <- setdiff(names(fd), names(df))
-    for (. in na) df[[.]] <- if (nrow(df) > 0) list(NULL) else list()
-    fd <- fd[, names(col) <- col <- names(df)]
-    # combine
-    if (app && !seq) {
-        # append to other
-        rownames(df) <- rownames(df$input) <- rownames(df$output) <- 1
-        rownames(fd) <- rownames(fd$input) <- rownames(fd$output) <- 2
-    } else {
-        # append to table or sequence
-        rownames(fd$input) <- rownames(fd$output) <- nrow(df)+1
-    }
-    new <- rbind(df, fd)
-    if (is_ms <- !is.null(x[[ms]])) {
-        .x <- x[[ms]][[ct]][[1]]
-    } else .x <- x[[ct]]
-    if (app) {
-        .x$type[idx] <- "sequence"
-        .x[idx, ]$transformations[[1]] <- new
-    } else .x <- new
-    if (is_ms) x[[ms]][[ct]][[1]] <- .x else x[[ct]] <- .x
-    return(x)
-})
-
-# Dec 8 VJC -- why is this in doc comment mode?  changing to plain comment
-# # @importFrom EBImage resize
-# setMethod("scale", "ImageArray", \(x, t, ...) {
-#     a <- as.array(data(x)) 
-#     # TODO: this should be done w/o realizing 
-#     # into memory, but EBImage needs an array?
-#     d <- length(dim(a))
-#     if (missing(t)) 
-#         t <- rep(1, d)
-#     b <- resize(aperm(a),
-#         w=dim(a)[d]*t[d],
-#         h=dim(a)[d-1]*t[d-1])
-#     x@data <- aperm(b)
-#     x
-# })
-# 
-# # @importFrom EBImage resize
-# setMethod("translation", "ImageArray", \(x, t, ...) {})
-# setMethod("transform", "ImageArray", \(x, t) get(t$type)(x, unlist(t[[t$type]])))
-
-# plotCoordGraph() ----
-
-#' @name plotCoordGraph
-#' @title CT graph viz.
-#' 
-#' @description
-#' given a \code{graphNEL} instance, nodes with \code{nchar>max} are
-#' split and hyphenated at character position \code{floor(nchar/fac)}.
-#' 
-#' @param g base R graph; extracted with \code{\link{CTgraph}}.
-#' @param cex scalar numeric; controls fontsize of node labels.
-#' 
-#' @examples
-#' x <- file.path("extdata", "blobs.zarr")
-#' x <- system.file(x, package="SpatialData")
-#' x <- readSpatialData(x, tables=FALSE)
-#' 
-#' g <- CTgraph(x)
-#' plotCoordGraph(g, cex=0.6)
-#' 
-#' @importFrom graph nodes nodes<- graph.par
-#' @export
-plotCoordGraph <- \(g, cex=0.6) {
-    if (!requireNamespace("Rgraphviz", quietly=TRUE))
-        stop("To use this function, install the 'Rgraphviz'.")
-    g2view <- g # leave 'g' alone
-    nodes(g2view) <- .nodefix(nodes(g2view))
-    graph.par(list(nodes=list(shape="plaintext", cex=cex)))
-    g2view <- Rgraphviz::layoutGraph(g2view)
-    Rgraphviz::renderGraph(g2view)
-}
-
-.nodefix <- \(x, fac=2, max=10) {
-    fix <- nchar(x) > max
-    if (!any(fix)) return(x)
-    x[fix] <- .fixup(x[fix], fac)
-    x
-}
-
-.fixup <- \(x, fac) {
-    xs <- strsplit(x, "")
-    nc <- floor(nchar(x)/fac)
-    vapply(seq_along(xs), \(i) {
-        j <- seq_len(nc[i])
-        y <- c(xs[[i]][j], "-\n", xs[[i]][-j])
-        paste(y, collapse="")
-    }, character(1))
-}
diff --git a/R/data.R b/R/data.R
index 9c6daa62..97aa5bf2 100644
--- a/R/data.R
+++ b/R/data.R
@@ -4,7 +4,7 @@
 #' 
 #' @description data were retrieved on Nov. 11th, 2024, from \href{https://github.com/scverse/spatialdata-notebooks/tree/main/notebooks/developers_resources/storage_format/multiple_elements.zarr}{here}.
 #'
-#' @return NULL
+#' @returns zarr store.
 #'
 #' @examples
 #' x <- file.path("extdata", "blobs.zarr")
diff --git a/R/mask.R b/R/mask.R
index 9f62a532..6b81b514 100644
--- a/R/mask.R
+++ b/R/mask.R
@@ -1,15 +1,21 @@
 #' @name mask
 #' @title Masking
 #'
-#' @description ...
+#' @description 
+#' Masking operations serve to aggregate data across layers, e.g., 
+#' counting points in shapes, averaging image channels by labels, etc.
+#' For added flexibility, these may be carried out directly between elements,
+#' or using an input \code{SpatialData} object and specifying element names.
 #' 
 #' @param x \code{\link{SpatialData}} object.
 #' @param i,j character string; names of elements to mask,
 #'   specifically, \code{i} will be masked by \code{j},
 #'   adding a \code{table} for \code{j} in \code{x}.
+#' @param how character string; statistic to use for masking.
+#' @param name function use to generate the new \code{table}'s name.
 #' @param ... optional arguments passed to and from other methods.
 #'
-#' @return \code{\link{SingleCellExperiment}}
+#' @return Input \code{SpatialData} object \code{x} with an additional table.
 #'
 #' @examples
 #' library(SingleCellExperiment)
@@ -17,88 +23,144 @@
 #' x <- system.file(x, package="SpatialData")
 #' x <- readSpatialData(x, tables=FALSE)
 #'
-#' # count points in circles
-#' x <- mask(x, "blobs_points", "blobs_circles")
-#' x <- mask(x, "blobs_image", "blobs_labels")
-#' tables(x)
+#' # count points in shapes
+#' y <- mask(x, "blobs_points", "blobs_circles")
+#' tail(tables(y), 1)
+#' 
+#' # average image channels by labels
+#' y <- mask(x, "blobs_image", "blobs_labels")
+#' tail(tables(y), 1)
 #'
+#' library(SpatialData.data)
+#' x <- get_demo_SDdata("merfish")
+#' x <- readSpatialData(x)
+#' 
+#' # sum table counts by shapes
+#' y <- mask(x, "cells", "anatomical")
+#' tail(tables(y), 1)
+#' 
 #' @export
 NULL
 
-# TODO: table from point + shape, image + label etc. etc. etc.
+.check_ij <- \(x, .) stopifnot(length(.) == 1, is.character(.), . %in% unlist(colnames(x)))
 
 #' @rdname mask
+#' @importFrom methods as
+#' @importFrom SummarizedExperiment assay assay<-
 #' @importFrom SingleCellExperiment int_colData int_colData<- int_metadata<-
 #' @export
-setMethod("mask", "SpatialData", \(x, i, j, ...) {
-    stopifnot(length(i) == 1, is.character(i), i %in% unlist(colnames(x)))
-    stopifnot(length(j) == 1, is.character(j), j %in% unlist(colnames(x)))
-    # get element types
-    ls <- vapply(
-        list(i, j), \(e) rownames(x)[vapply(colnames(x), 
-            \(es) e %in% es, logical(1))], character(1))
-    a <- element(x, ls[[1]], i)
-    b <- element(x, ls[[2]], j)
-    t <- .mask(a, b, ...)
-    md <- list(region=j, 
-        region_key="region", 
-        instance_key="instance")
-    int_metadata(t)$spatialdata_attrs <- md
-    cd <- data.frame(region=j, instance=colnames(t))
-    int_colData(t) <- cbind(int_colData(t), cd)
-    nm <- paste0(i, "_masked_by_", j)
-    `table<-`(x, nm, value=t)
+setMethod("mask", c("SpatialData", "ANY", "ANY"), \(x, i, j, 
+    how=NULL, name=\(i, j) sprintf("%s_by_%s", i, j), ...) {
+    .check_ij(x, i); .check_ij(x, j)
+    #if (!is.null(how)) how <- match.arg(how, c("sum", "mean"))
+    ok <- is.character(name) && length(name) == 1 && !name %in% tableNames(x)
+    nm <- if (is.function(name)) name(i, j) else if (ok) name else stop(
+        "Invalid 'name'; should be a function or a ",
+        "character string not yet in 'tableNames(x)'")
+    f <- \(i) names(which(rapply(colnames(x), \(.) i %in% ., "character")))
+    .i <- element(x, f(i), i)
+    .j <- element(x, f(j), j)
+    t <- tryCatch(error=\(.) NULL, getTable(x, i))
+    se <- .mask(.i, .j, how=how, table=t, ...)
+    md <- list(region=j, region_key="region", instance_key="instance")
+    int_metadata(se)$spatialdata_attrs <- md
+    assay(se) <- as(assay(se), "dgCMatrix")
+    cd <- int_colData(se)
+    cd$region <- j
+    cd$instance <- colnames(se)
+    int_colData(se) <- cd
+    `table<-`(x, nm, value=se)
 })
 
-setGeneric(".mask", \(a, b, ...) standardGeneric(".mask"))
+setGeneric(".mask", \(i, j, ...) standardGeneric(".mask"))
 
+#' @noRd
 #' @importFrom methods as
-#' @importFrom Matrix rowSums sparseVector t
+#' @importFrom Matrix sparseVector
+#' @importFrom SummarizedExperiment assayNames<-
 #' @importFrom SingleCellExperiment SingleCellExperiment
-#' @importFrom sf st_as_sf st_geometry_type st_sfc st_point st_distance
-setMethod(".mask", c("PointFrame", "ShapeFrame"), \(a, b) {
-    n <- nrow(b <- st_as_sf(data(b)))
-    fk <- meta(a)$spatialdata_attrs$feature_key
-    switch(paste(st_geometry_type(b)[1]),
-        POINT={
-            # realize one feature at a time
-            is <- split(seq_len(length(a)), a[[fk]])
-            ns <- lapply(is, \(.) {
-                # make points 'sf'-compliant
-                xy <- as.data.frame(a[., c("x", "y")])
-                ps <- st_sfc(lapply(asplit(xy, 1), st_point))
-                # for each circle, count points within radius
-                z <- rowSums(st_distance(b, ps) < b$radius)
-                # sparsify counts
-                sv <- sparseVector(z[i <- z > 0], which(i), n)
-                sm <- as(sv, "sparseMatrix")
-            })
-            # collect intro matrix w/ dim. features x circles
-            ns <- t(as(do.call(cbind, ns), "dgCMatrix"))
-            rownames(ns) <- names(is)
-            colnames(ns) <- seq(ncol(ns))
-        })
-    SingleCellExperiment(list(counts=ns))
+setMethod(".mask", c("ImageArray", "LabelArray"), \(i, j, how=NULL, ...) {
+    if (is.null(how)) { how <- "mean"; message("Missing 'how'; defaulting to 'mean'") }
+    stopifnot(dim(i)[-1] == dim(j))
+    .j <- as(data(j), "sparseVector")
+    .j <- as.vector(.j[ok <- .j > 0])
+    mx <- apply(data(i), 1, \(.i) {
+        .i <- as(.i, "sparseVector")
+        .i <- as.vector(.i[ok])
+        tapply(.i, .j, how)
+    })
+    colnames(mx) <- channels(i)
+    se <- SingleCellExperiment(list(t(mx)))
+    assayNames(se) <- how
+    return(se)
 })
 
+#' @noRd
 #' @importFrom methods as
-#' @importFrom DelayedArray realize
-#' @importFrom S4Arrays as.array.Array
+#' @importFrom Matrix t rowSums sparseVector sparseMatrix
 #' @importFrom SingleCellExperiment SingleCellExperiment
-setMethod(".mask", c("ImageArray", "LabelArray"), \(a, b, fun=mean) {
-    # TODO: somehow rewrite w/o realizing everything 
-    # at once (maybe w/ 'DelayedArray::blockApply'?)
-    .a2v <- \(.) as.vector(as.array.Array(.))
-    stopifnot(dim(a)[-1] == dim(b))
-    w <- .a2v(data(b)); w[w == 0] <- NA 
-    n <- length(i <- unique(w[!is.na(w)]))
-    ns <- vapply(seq_len(dim(a)[1]), \(.) {
-        v <- .a2v(data(a, 1)[., , ])
-        tapply(v, w, sum, na.rm=TRUE)
-    }, numeric(n))
-    ns <- t(as(ns, "dgCMatrix"))
-    dimnames(ns) <- list(seq(dim(a)[1]), i)
+#' @importFrom sf st_as_sf st_geometry_type st_distance
+setMethod(".mask", c("PointFrame", "ShapeFrame"), \(i, j, how=NULL, ...) {
+    if (!is.null(how)) warning("Can only count when masking points; ignoring 'how'")
+    fun <- switch(geom_type(j),
+        POINT=\(i, j) rowSums(st_distance(j, i) <= j$radius),
+        \(i, j) vapply(st_intersects(j, i), length, integer(1)))
+    # realize one feature at i time
+    n <- nrow(j <- st_as_sf(data(j)))
+    is <- split(seq_len(length(i)), i[[feature_key(i)]])
+    ns <- lapply(is, \(.) {
+        # make points 'sf'-compliant
+        i <- as.data.frame(i[., c("x", "y")])
+        i <- st_as_sf(i, coords=c("x", "y"))
+        # for each shape, count intersecting points
+        z <- fun(i, j)
+        # sparsify counts
+        sv <- sparseVector(z[i <- z > 0], which(i), n)
+        sm <- as(sv, "sparseMatrix")
+    })    
+    # collect into matrix w/ dim. features x shapes
+    ns <- t(do.call(cbind, ns))
+    rownames(ns) <- names(is)
+    colnames(ns) <- seq(ncol(ns))
     SingleCellExperiment(list(counts=ns))
 })
-setMethod(".mask", c("ANY", "ANY"), \(a, b) 
-    stop("'mask'ing between these element types not supported."))
+
+#' @noRd
+#' @importFrom methods as
+#' @importFrom Matrix sparseMatrix
+#' @importFrom SummarizedExperiment assay
+#' @importFrom SingleCellExperiment SingleCellExperiment
+setMethod(".mask", c("ShapeFrame", "ShapeFrame"), \(i, j, how=NULL, table=NULL, value=NULL, assay=1, ...) {
+    # validity
+    if (is.null(table)) stop("Missing 'table'; can't mask shapes without")
+    ok <- is.null(value) || (is.character(value) && all(value %in% rownames(table)))
+    if (!ok) stop("Invalid 'value'; should be in 'rownames(table(x, i))'")
+    if (is.null(how)) { how <- "sum"; message("Missing 'how'; defaulting to 'sum'") }
+    if (is.character(how)) how <- match.arg(how, c("sum", "mean", "detected", "prop.detected"))
+    # grouping
+    js <- st_intersects(st_as_sf(data(j)), st_as_sf(data(i)))
+    is <- factor(integer(nrow(i)), seq(0, nrow(j)))
+    is[unlist(js)] <- rep(seq_along(js), lengths(js))
+    ns <- tabulate(is, ni <- nlevels(is))
+    # aggregation
+    mx <- assay(table, assay)
+    if (grepl("detected$", how)) mx <- mx > 0
+    my <- sparseMatrix(
+        x=rep(1, length(is)), 
+        i=seq_along(is), j=is, 
+        dims=c(ncol(table), ni))
+    mx <- mx %*% my
+    if (grepl("mean|prop", how)) mx <- t(t(mx)/ns)
+    # wrangling
+    mx <- as(mx, "dgCMatrix")
+    colnames(mx) <- levels(is)
+    mx <- list(mx); names(mx) <- how
+    se <- SingleCellExperiment(mx)
+    nm <- paste0("n_", meta(table)$region)
+    se[[nm]] <- ns
+    return(se)
+})
+
+#' @noRd
+setMethod(".mask", c("ANY", "ANY"), \(i, j, ...) 
+    stop("'mask'ing between these element types not yet supported"))
diff --git a/R/metadata.R b/R/metadata.R
index 5e488057..b338c502 100644
--- a/R/metadata.R
+++ b/R/metadata.R
@@ -1,4 +1,58 @@
-.make_pointshape_meta <- function(x, 
+# helpers ----
+
+.make_axes_meta <- function(x, unit = FALSE){
+  lapply(x, \(.){
+    meta <- list(names = .,
+                 type = if(. == "c") "channel" else "space")
+    if(unit)
+      meta <- c(meta, list(unit = "unit"))
+    meta
+  })
+}
+
+.make_empty_ct <- function(x){
+  space <- .make_axes_meta(x, unit = TRUE)
+  input <- list(axes = space,
+                name = paste(x, collapse = ""))
+  output <- list(axes = space, name = "global")
+  meta <- list(
+    list(input = input,
+         output = output,
+         type = "identity")
+  )
+  meta
+}
+
+.make_datasets <- function(x, axes){
+  paths <- paste0(seq_len(length(x)) - 1)
+  mapply(\(p) {
+    list(
+      coordinateTransformations = list(
+        list(
+          scale = vapply(axes, \(.){
+            if(. == "c") 1 else (2^as.numeric(p))
+          }, numeric(1)),
+          type = "scale"
+        )
+      ),
+      path = p
+    )
+  }, paths, USE.NAMES = FALSE, SIMPLIFY = FALSE)
+}
+
+# metadata constructors ----
+#' @title Make point/shape metadata
+#' @description Make point/shape metadata
+#' @param x A points or shapes object
+#' @param axes A character vector of axes names
+#' @param encoding_type A string specifying the encoding type
+#' @param feature_key A string specifying the feature key
+#' @param instance_key A string specifying the instance key
+#' @param version A string specifying the version
+#' @return A list of metadata for the point/shape object
+#' @importFrom jsonlite fromJSON toJSON
+#' @noRd
+.make_pointshape_meta <- function(x,
                                   axes = NULL,
                                   encoding_type = "ngff:points",
                                   feature_key = NULL, 
@@ -7,7 +61,7 @@
   meta <- list()
   ax <- "axes"
   ct <- "coordinateTransformations"
-  sa <- "spatial_attrs"
+  sa <- "spatialdata_attrs"
   
   # axis
   # NOTE: rev dimensions since points and shapes want x, y
@@ -28,10 +82,20 @@
   meta[[ct]] <- .make_empty_ct(meta[[ax]])
   
   # update json list
-  meta <- fromJSON(toJSON(meta, auto_unbox = TRUE), simplifyVector = TRUE)
+  meta <- fromJSON(toJSON(meta, auto_unbox = TRUE), simplifyVector = FALSE)
   Zattrs(meta)
 }
+# TODO: make it the functions take a global option e.g. sd_zarr_version
+# as an argument for the default zarr version
 
+#' @title Make image metadata
+#' @description Make image metadata
+#' @param x An image object
+#' @param axes A character vector of axes names
+#' @param version A string specifying the version
+#' @return A list of metadata for the image object
+#' @importFrom jsonlite fromJSON toJSON
+#' @noRd
 .make_image_meta <- function(x, 
                              axes = NULL,
                              version = 0.4){
@@ -69,18 +133,26 @@
   meta[[v]] <-  list(version = version)
   
   # multiscales
-  meta <- list(multiscales = list(meta), 
+  meta <- list(multiscales = list(meta),
                omero = list(
-                 channels = lapply(seq_len(length(axes))-1, \(.) 
+                 channels = lapply(seq_len(length(axes))-1, \(.)
                                    list(label = .))
-               ), 
+               ),
                spatialdata_attrs = list(version = "0.1"))
-  
+
   # update json list
-  meta <- fromJSON(toJSON(meta, auto_unbox = TRUE), simplifyVector = TRUE)
+  meta <- fromJSON(toJSON(meta, auto_unbox = TRUE), simplifyVector = FALSE)
   Zattrs(meta)
 }
 
+#' @title Make label metadata
+#' @description Make label metadata
+#' @param x A label object
+#' @param axes A character vector of axes names
+#' @param version A string specifying the version
+#' @return A list of metadata for the label object
+#' @importFrom jsonlite fromJSON toJSON
+#' @noRd
 .make_label_meta <- function(x, 
                              axes = NULL,
                              version = 0.4){
@@ -120,13 +192,12 @@
                spatialdata_attrs = list(version = "0.1"))
   
   # update json list
-  meta <- fromJSON(toJSON(meta, auto_unbox = TRUE), simplifyVector = TRUE)
+  meta <- fromJSON(toJSON(meta, auto_unbox = TRUE), simplifyVector = FALSE)
   Zattrs(meta)
 }
 
-#' .get_valid_axes
-#' 
-#' Get validated axes
+#' @title Get valid axes
+#' @description Get validated axes
 #'
 #' @inheritParams write_image
 #' 
@@ -210,28 +281,5 @@
   return(c(nrow(x), n_col))
 }
 
-#' #' @importFrom sf st_as_sf st_geometry
-#' .get_geoarrow_dim <- function(x){
-#'   meta <- .get_geoarrow_metadata(x)
-#'   if(length(meta) > 1){
-#'     if("geometry" %in% colnames(meta)){
-#'       bbox <- meta$geo$columns$geometry$bbox
-#'       n_col <- if(length(bbox) == 4) 2 else 3
-#'     } else {
-#'       n_col <- ncol(x)
-#'     } 
-#'   } else {
-#'     if("geometry" %in% colnames(x)){
-#'       geo <- st_geometry(st_as_sf(df))
-#'     } else{
-#'       stop("No geometry object is detected!")
-#'     }
-#'   }
-#'   return(c(nrow(x), n_col))
-#' }
-#' 
-#' #' @importFrom jsonlite fromJSON
-#' .get_geoarrow_metadata <- function(x){
-#'   lapply(x$metadata, fromJSON)
-#' }
+
   
diff --git a/R/methods.R b/R/methods.R
index eaf7dc44..ed30acf8 100644
--- a/R/methods.R
+++ b/R/methods.R
@@ -43,7 +43,10 @@ setMethod("[[", c("SpatialData", "character"), \(x, i, ...) {
     for (. in names(j)) {
         .j <- j[[.]]
         n <- length(attr(x, .))
-        if (length(.j) == 1 && is.infinite(.j)) {
+        if (is.character(.j)) {
+            if (!all(.j %in% names(attr(x, .))))
+                stop("invalid 'j'")
+        } else if (length(.j) == 1 && is.infinite(.j)) {
             .j <- n
         } else if (any(.j > n)) {
             stop("invalid 'j'")
@@ -217,7 +220,7 @@ NULL
 
 f <- \(.) setReplaceMethod(., 
     c("SpatialData", "character", typ[[.]]), 
-    \(x, i, value) { 
+    \(x, i, value) {
         y <- attr(x, paste0(., "s"))
         y[[i]] <- value
         attr(x, paste0(., "s")) <- y
@@ -253,7 +256,7 @@ NULL
 
 f <- \(.) setReplaceMethod(., 
     c("SpatialData", "missing", typ[[.]]), 
-    \(x, i, value) {
+    \(x, i, value) { 
         f <- get(paste0(., "<-"))
         f(x=x, i=1, value=value)
 })
diff --git a/R/misc.R b/R/misc.R
index 3ca30006..713a5b82 100644
--- a/R/misc.R
+++ b/R/misc.R
@@ -1,16 +1,33 @@
 #' @name misc
-#' @title Miscellaneous `Miro` methods
-#' @description ...
-#'
-#' @param object \code{\link{SpatialData}} object or one of its 
-#'   elements, i.e., an Image/LabelArray or Point/ShapeFrame.
+#' @title Miscellaneous `SpatialData` methods
+#' @aliases show,SpatialData-method
+#' 
+#' @description 
+#' Miscellaneous methods (e.g., \code{show}) for the
+#' \code{\link{SpatialData}} class and its elements.
+#' 
+#' @param object 
+#'   \code{\link{SpatialData}} object or one of its elements,
+#'   i.e., an \code{Image/LabelArray} or \code{Point/ShapeFrame}.
 #'
 #' @return \code{NULL}
 #'
 #' @author Helena L. Crowell
 #'
 #' @examples
-#' # TODO
+#' zs <- file.path("extdata", "blobs.zarr")
+#' zs <- system.file(zs, package="SpatialData")
+#' (sd <- readSpatialData(zs, anndataR=TRUE))
+#' 
+#' # show element
+#' image(sd)
+#' label(sd)
+#' point(sd)
+#' shape(sd)
+#' 
+#' # show .zattrs
+#' meta(label(sd))
+#' meta(image(sd, 2))
 NULL
 
 #' @importFrom RBGL sp.between
@@ -55,11 +72,12 @@ NULL
     for (. in seq_along(t)) 
         cat(sprintf("  - %s (%s)\n", t[.], d[.]))
     # spaces
-    cat("coordinate systems:\n")
     e <- c(i, l, s, p)
     g <- CTgraph(object)
     t <- nodeData(g, nodes(g), "type")
-    for (c in nodes(g)[t == "space"]) {
+    n <- sum(i <- (t == "space"))
+    cat(sprintf("coordinate systems(%s):\n", n))
+    for (c in nodes(g)[i]) {
         pa <- suppressWarnings(sp.between(g, e, c))
         ss <- strsplit(names(pa), ":")
         ss <- ss[vapply(pa, \(.) !is.na(.$length), logical(1))]
diff --git a/R/query.R b/R/query.R
index d75183a6..01fa1524 100644
--- a/R/query.R
+++ b/R/query.R
@@ -1,125 +1,184 @@
 #' @name query
 #' @title spatial queries
 #'
+#' @description Spatial queries serve to subset \code{SpatialData} elements 
+#' according to a rectangular bounding box or arbitrary polygonal shapes. 
+#' Queries rely on lesser-/greater-equal and \code{sf::st_intersects} for 
+#' spatial operations (i.e., instances that intersect the query region 
+#' in any way are kept). For circle shapes, radii are currently ignored
+#' (i.e., a circle is kept if its centroid intersects the query region).
+#'
 #' @param x \code{SpatialData} element.
-#' @param j scalar character or integer; index or name of coordinate space.
+#' @param y query specification; 
+#' bounding box: length-4 numeric list with names 'xmin/xmax/ymin/ymax';
+#' polygon: numeric matrix with at least 3 rows and exactly 2 columns.
+#' @param i for \code{SpatialData}, index or name of table to query.
 #' @param ... optional arguments passed to and from other methods.
 #'
 #' @return same as input
 #'
 #' @examples
-#' x <- file.path("extdata", "blobs.zarr")
-#' x <- system.file(x, package="SpatialData")
-#' x <- readSpatialData(x, tables=FALSE)
+#' zs <- file.path("extdata", "blobs.zarr")
+#' zs <- system.file(zs, package="SpatialData")
+#' sd <- readSpatialData(zs, tables=FALSE)
+#' 
+#' # helper for visualizing point coordinates
+#' .xy <- \(.) data.frame(data(.)[c("x", "y")])
+#' 
+#' # bounding box
+#' y <- list(xmin=11, xmax=44, ymin=22, ymax=55)
+#' q <- query(p <- point(sd), y)
+#' 
+#' plot(.xy(p), asp=1)
+#' points(.xy(q), col="red")
+#' rect(y$xmin, y$ymin, y$xmax, y$ymax, border="blue")
 #' 
-#' image(x, "box") <- query(image(x), xmin=0, xmax=30, ymin=30, ymax=50)
+#' # polygon
+#' y <- rbind(c(20,10), c(50,30), c(20,50), c(30,30))
+#' q <- query(p <- point(sd), y)
 #' 
-#' image(x)
-#' image(x, "box")
+#' plot(.xy(p), asp=1)
+#' points(.xy(q), col="red")
+#' lines(rbind(y, y[1, ]), col="blue")
+#' 
+#' # shapes that intersect the query region are kept
+#' y <- rbind(c(30,45), c(40,45), c(35,50))
+#' t <- query(s <- shape(sd, 3), y)
+#' 
+#' require(sf, quietly=TRUE)
+#' df <- st_coordinates(st_as_sf(data(s)))
+#' fd <- st_coordinates(st_as_sf(data(t)))
+#' plot(
+#'   asp=1, xlim=c(15, 60), ylim=c(15, 60),
+#'   rbind(y, y[1, ]), type="l", col="blue") 
+#' foo <- by(df, df[, "L2"], \(x) points(x, type="b", col="black"))
+#' foo <- by(fd, fd[, "L2"], \(x) points(x, type="b", col="red"))
 NULL
 
-.check_bb <- \(args) {
-    m <- match(names(args), c("xmin", "xmax", "ymin", "ymax"))
-    if (any(is.na(m)) || !identical(sort(m), seq_len(4)))
-        stop("currently only supporting bounding box query;", 
-            " please provide 'xmin/xmax/ymin/ymax' as ...")
-}
-
 #' @rdname query
+#' @importFrom dplyr filter
 #' @export
-setMethod("query", "SpatialData", \(x, j=NULL, ...) {
-    # check validity of dots
-    args <- list(...)
-    .check_bb(args)
-    # guess coordinate space
-    stopifnot(length(j) == 1)
-    j <- if (is.null(j)) {
-        .guess_space(x)
-    } else {
-        if (is.character(j)) {
-            match.arg(j, CTname(x))
-        } else if (is.numeric(j)) {
-            stopifnot(j > 0, j == round(j))
-            CTname(x)[j]
-        }
+setMethod("query", "SpatialData", \(x, ..., i) {
+    # TODO: need more example data to properly implement this; 
+    # for now, just a proof of concept using 'spatialdata_attrs'
+    if (missing(i)) i <- 1
+    if (!length(tables(x))) 
+        stop("There aren't any tables")
+    if (is.numeric(i)) {
+        i <- tableNames(x)[i]
+    } else if (is.character(i)) {
+        i <- match.arg(i, tableNames(x))
     }
-    # execute query
-    for (l in rownames(x))
-        for (e in colnames(x)[[l]])
-            x[[l]][[e]] <- query(x[[l]][[e]], j, ...)
-    return(x)  
+    t <- x$tables[[i]]
+    ns <- vapply(nm <- colnames(x), length, integer(1))
+    nm <- data.frame(layer=rep.int(names(nm), ns), region=unlist(nm))
+    nm <- filter(nm, ...)
+    i <- match(nm$layer, .LAYERS)
+    j <- split(nm$region, nm$layer)
+    x <- x[i, j]
+    x$tables$table <- t
+    return(x)
 })
 
+.check_box <- \(bb) {
+    xy <- c("xmin", "xmax", "ymin", "ymax")
+    ok <- c(is.list(bb), 
+        length(bb) == 4, setequal(names(bb), xy),
+        bb$xmin <= bb$xmax, bb$ymin <= bb$ymax, 
+        is.numeric(bb <- unlist(bb)), !is.na(bb))
+    if (!all(ok)) stop(
+        "Invalid bounding box query; should be length-4 ",
+        "numeric list with names 'xmin/xmax/ymin/ymax'")
+}
+
+.check_pol <- \(mx) {
+    ok <- c(
+        is.matrix(mx), is.numeric(mx), 
+        nrow(mx) >= 3, ncol(mx) == 2,
+        !is.na(mx), is.finite(mx))
+    if (!all(ok)) stop(
+        "Invalid polygon query; should be numeric matrix with at ",
+        "least 3 rows and exactly 2 columns (= xy-coordinates)")
+    # ensure polygon is closed
+    top <- mx[1, ]
+    bot <- mx[nrow(mx), ]
+    if (!all(top == bot)) 
+        mx <- rbind(mx, top)
+    dup <- duplicated(as.data.frame(mx[-1, , drop=FALSE]))
+    if (any(dup)) stop("Invalid polygon query; found duplicated vertices")
+    return(mx)
+}
+
+.query_sdArray <- \(x, y) {
+    if (is.matrix(y)) stop(
+        "Polygon query not supported for ",
+        "element of type 'image/labelArray'")
+    .check_box(y)
+    # protect image channels (i.e., 
+    # only query spatial dimensions)
+    n <- length(d <- dim(x))
+    if (n == 3) d <- d[-1]
+    # assure query is within bounds
+    y$xmin <- max(y$xmin, 0)
+    y$ymin <- max(y$ymin, 0)
+    y$ymax <- min(y$ymax, d[1])
+    y$xmax <- min(y$xmax, d[2])
+    # subset spatial dimensions
+    i <- seq(y$ymin, y$ymax)
+    j <- seq(y$xmin, y$xmax)
+    if (n == 3) {
+        return(x[, i, j])
+    } else {
+        return(x[i, j])
+    }
+}
+
 #' @rdname query
 #' @export
-setMethod("query", "ImageArray", \(x, j, ...) {
-    qu <- list(...)
-    .check_bb(qu)
-    if (missing(j)) j <- 1
-    if (is.numeric(j)) j <- CTname(x)[j]
-    stopifnot(length(j) == 1)
-    . <- grep(j, CTname(x))
-    if (!length(.) || is.na(.)) stop("invalid 'j'")
-    # transform query into target space
-    ts <- CTpath(x, j)
-    xy <- list(c(qu$xmin, qu$xmax), c(qu$ymin, qu$ymax))
-    xy <- data.frame(xy); names(xy) <- c("x", "y")
-    xy <- .trans_xy(xy, ts, TRUE)
-    xy <- lapply(xy, \(.) as.list(round(.)))
-    x <- x[, # crop (i.e., subset) array dimensions 2-3
-        do.call(seq, xy[[2]]),
-        do.call(seq, xy[[1]])]
-    # transform array dimensions into target space
-    os <- data.frame(x=c(0, dim(x)[3]), y=c(0, dim(x)[2]))
-    os <- vapply(.trans_xy(os, ts), min, numeric(1))
-    # add transformation of type translation as to
-    # offset origin by difference between new & old
-    os <- unlist(qu[c("xmin", "ymin")]) - os
-    if (!all(os == 0)) x <- addCT(x, 
-        name=j, type="translation", 
-        data=c(0, os[2], os[1]))
-    return(x)
-})
+setMethod("query", "ImageArray", \(x, y) .query_sdArray(x, y))
 
 #' @rdname query
 #' @export
-setMethod("query", "LabelArray", \(x, ...) {
-    args <- list(...)
-    .check_bb(args)
-    d <- dim(x)
-    if (args$ymax > d[1]) args$ymax <- d[1]
-    if (args$xmax > d[2]) args$xmax <- d[2]
-    a <- data(x)[
-        seq(args$ymin, args$ymax),
-        seq(args$xmin, args$xmax)] 
-    x@data <- a
-    return(x)
-})
+setMethod("query", "LabelArray", \(x, y) .query_sdArray(x, y))
 
 #' @rdname query
+#' @importFrom sf st_as_sf st_intersects st_polygon st_bbox st_crop
 #' @export
-setMethod("query", "ShapeFrame", \(x, ...) {
-    args <- list(...)
-    .check_bb(args)
-    df <- st_as_sf(data(x))
-    xy <- st_coordinates(df)
-    i <- 
-        xy[, 1] >= args$xmin & 
-        xy[, 1] <= args$xmax & 
-        xy[, 2] >= args$ymin & 
-        xy[, 2] <= args$ymax 
-    x@data <- data(x)[which(i), ]
+setMethod("query", "ShapeFrame", \(x, y) {
+    # TODO: this will drop geometries where any coordinate 
+    # is out of bounds; keep but crop to boundary region?
+    if (is.matrix(y)) {
+        # TODO: currently ignoring 'radius' for circles (i.e.,
+        # query based on centroids only); what does Python do?
+        mx <- .check_pol(y)
+        sf <- st_as_sf(data(x))
+        ok <- st_intersects(sf, st_polygon(list(mx)), sparse=FALSE)
+        x@data <- x@data[which(ok), ]
+        return(x)
+    }
+    # note: non-spatial attributes (e.g., radius) give warnings?
+    .check_box(y)
+    sf <- st_as_sf(data(x))
+    bb <- st_bbox(unlist(y))
+    suppressWarnings(sf <- st_crop(sf, bb))
+    x@data <- sf[names(x)]
     return(x)  
 })
 
 #' @rdname query
+#' @importFrom sf st_as_sf st_polygon st_intersects
+#' @importFrom dplyr collect filter
 #' @export
-setMethod("query", "PointFrame", \(x, j, ...) {
-    args <- list(...)
-    .check_bb(args)
-    y <- filter(x, 
-        x >= args$xmin, x <= args$xmax, 
-        y >= args$ymin, y <= args$ymax)    
-    x@data <- y@data
-    return(x)
+setMethod("query", "PointFrame", \(x, y) {
+    if (is.matrix(y)) {
+        mx <- .check_pol(y)
+        xy <- st_as_sf(collect(data(x)[c("x", "y")]), coords=c("x", "y"))
+        ok <- st_intersects(xy, st_polygon(list(mx)), sparse=FALSE)
+        return(x[which(ok[, 1])])
+    } else {
+        .check_box(bb <- y)
+        filter(x, 
+            x >= bb$xmin, x <= bb$xmax, 
+            y >= bb$ymin, y <= bb$ymax)
+    }
 })
diff --git a/R/read.R b/R/read.R
index ca3b3f83..78217254 100644
--- a/R/read.R
+++ b/R/read.R
@@ -1,34 +1,41 @@
-#
-allp = c("session_info==1.0.0", "spatialdata==0.3.0", "spatialdata_io==0.1.7", 
-"pillow==11.1.0", "anndata==0.11.3", "annotated_types==0.7.0", "asciitree==0.3.3", 
-"attr==0.3.2", "certifi==2025.01.31", "charset_normalizer==3.4.1", 
-"click==8.1.8", "cloudpickle==3.1.1", "cycler==0.12.1", "dask==2024.4.1", 
-"dask_image==2024.5.3", "datashader==0.17.0", 
-"deprecated==1.2.18", "distributed==2024.4.1", 
-"flowio==1.3.0", "fsspec==2025.2.0", "geopandas==1.0.1", "h5py==3.12.1", 
-"idna==3.10", "imagecodecs==2024.12.30", "imageio==2.37.0", "jinja2==3.1.5", 
-"joblib==1.4.2", "kiwisolver==1.4.8", "lazy_loader==0.4", "legacy_api_wrap==1.4.1", 
-"llvmlite==0.44.0", "locket==1.0.0", "markupsafe==3.0.2", "matplotlib==3.10.0", 
-"more_itertools==10.3.0", "msgpack==1.1.0", "multipledispatch==0.6.0", 
-"multiscale_spatial_image==2.0.2", "natsort==8.4.0", "networkx==3.4.2", 
-"numba==0.61.0", "numcodecs==0.15.1", "numpy==2.1.3", "ome_types==0.5.3", 
-"ome_zarr==0.10.3", "packaging==24.2", "pandas==2.2.3", "param==2.2.0", 
-"pims==0.7", "platformdirs==4.3.6", "psutil==7.0.0", "pyarrow==19.0.0", 
-"pyct==0.5.0", "pydantic==2.10.6", "pydantic_compat==0.1.2", 
-"pydantic_core==2.27.2", "pygments==2.19.1", "pyparsing==3.2.1", 
-"pyproj==3.7.0", "pytz==2025.1", "readfcs==2.0.1", "requests==2.32.3", 
-"rich==13.9.4", "scanpy==1.11.0", "scipy==1.15.1", "setuptools==75.8.0", 
-"shapely==2.0.7", "six==1.17.0", "scikit-image==0.25.1", "scikit-learn==1.5.2", 
-"slicerator==1.1.0", "sortedcontainers==2.4.0", "spatial_image==1.1.0", 
-"tblib==3.0.0", "threadpoolctl==3.5.0", "tifffile==2025.1.10", 
-"toolz==1.0.0", "tornado==6.4.2", "tqdm==4.67.1", 
-"typing_extensions==4.12.2", "urllib3==2.3.0", "wrapt==1.17.2", 
-"xarray==2024.11.0", "xarray_dataclasses==1.9.1", "xarray_schema==0.0.3", 
-"zarr==2.18.4", "zict==3.0.0")
-# notes from VJC -- readSpatialData was modified below so
-# that if anndataR = FALSE, spatialdata.read_zarr is used
+# allp = c("session_info==1.0.0", "spatialdata==0.3.0", "spatialdata_io==0.1.7", 
+# "pillow==11.1.0", "anndata==0.11.3", "annotated_types==0.7.0", "asciitree==0.3.3", 
+# "attr==0.3.2", "certifi==2025.01.31", "charset_normalizer==3.4.1", 
+# "click==8.1.8", "cloudpickle==3.1.1", "cycler==0.12.1", "dask==2024.4.1", 
+# "dask_image==2024.5.3", "datashader==0.17.0", 
+# "deprecated==1.2.18", "distributed==2024.4.1", 
+# "flowio==1.3.0", "fsspec==2025.2.0", "geopandas==1.0.1", "h5py==3.12.1", 
+# "idna==3.10", "imagecodecs==2024.12.30", "imageio==2.37.0", "jinja2==3.1.5", 
+# "joblib==1.4.2", "kiwisolver==1.4.8", "lazy_loader==0.4", "legacy_api_wrap==1.4.1", 
+# "llvmlite==0.44.0", "locket==1.0.0", "markupsafe==3.0.2", "matplotlib==3.10.0", 
+# "more_itertools==10.3.0", "msgpack==1.1.0", "multipledispatch==0.6.0", 
+# "multiscale_spatial_image==2.0.2", "natsort==8.4.0", "networkx==3.4.2", 
+# "numba==0.61.0", "numcodecs==0.15.1", "numpy==2.1.3", "ome_types==0.5.3", 
+# "ome_zarr==0.10.3", "packaging==24.2", "pandas==2.2.3", "param==2.2.0", 
+# "pims==0.7", "platformdirs==4.3.6", "psutil==7.0.0", "pyarrow==19.0.0", 
+# "pyct==0.5.0", "pydantic==2.10.6", "pydantic_compat==0.1.2", 
+# "pydantic_core==2.27.2", "pygments==2.19.1", "pyparsing==3.2.1", 
+# "pyproj==3.7.0", "pytz==2025.1", "readfcs==2.0.1", "requests==2.32.3", 
+# "rich==13.9.4", "scanpy==1.11.0", "scipy==1.15.1", "setuptools==75.8.0", 
+# "shapely==2.0.7", "six==1.17.0", "scikit-image==0.25.1", "scikit-learn==1.5.2", 
+# "slicerator==1.1.0", "sortedcontainers==2.4.0", "spatial_image==1.1.0", 
+# "tblib==3.0.0", "threadpoolctl==3.5.0", "tifffile==2025.1.10", 
+# "toolz==1.0.0", "tornado==6.4.2", "tqdm==4.67.1", 
+# "typing_extensions==4.12.2", "urllib3==2.3.0", "wrapt==1.17.2", 
+# "xarray==2024.11.0", "xarray_dataclasses==1.9.1", "xarray_schema==0.0.3", 
+# "zarr==2.18.4", "zict==3.0.0")
+
+allp <- c(
+    "zarr==3.1.5", 
+    "spatialdata==0.7.0", 
+    "spatialdata_io==0.6.0", 
+    "spatialdata_plot==0.2.14", 
+    "setuptools==75.8.0")
+
+# notes from VJC/AM -- readSpatialData was modified below so
+# that if anndataR = FALSE, anndata.read_zarr is used
 # to get the whole zarr store, and then the tables are
-# transformed via zellkonverter.  this gives a 10x speedup
+# transformed via anndataR. This gives a 10x speedup
 # for ingesting the visium_hd_3.0.0 example but fails on
 # the blobs dataset in example("table-utils") because
 # of matters related to metadata/hasTable behavior
@@ -48,9 +55,9 @@ allp = c("session_info==1.0.0", "spatialdata==0.3.0", "spatialdata_io==0.1.7",
 #'   The default, NULL, reads all elements; alternatively, may be FALSE 
 #'   to skip a layer, or a integer vector specifying which elements to read.
 #' @param anndataR logical specifying whether 
-#'   to use \code{anndataR} to read tables; defaults to FALSE in `readSpatialData`,
-#'   and `readTable`,
-#'   so that pythonic \code{spatialdata} and \code{zellkonverter} are used.
+#'   to use \code{anndataR} to read tables; 
+#'   defaults to FALSE in `readSpatialData`, and `readTable`,
+#'   so that pythonic \code{anndata} are used.
 #' @param ... option arguments passed to and from other methods.
 #'
 #' @return 
@@ -61,100 +68,109 @@ allp = c("session_info==1.0.0", "spatialdata==0.3.0", "spatialdata_io==0.1.7",
 #'
 #' @examples
 #' library(SpatialData.data)
-#' dir.create(tf <- tempfile())
-#' base <- SpatialData.data:::.unzip_merfish_demo(tf)
-#' (x <- readSpatialData(base))
+#' zs <- get_demo_SDdata("merfish")
+#' 
+#' # read complete Zarr store
+#' (sd <- readSpatialData(zs, anndataR=TRUE))
+#' 
+#' # helper that gets path to first element in layer 'l' 
+#' fn <- \(l) list.files(file.path(zs, l), full.names=TRUE)[1]
+#'   
+#' # read individual element  
+#' readImage(fn("images"))
+#' readShape(fn("shapes"))
+#' readPoint(fn("points"))
 NULL
 
-readsdlayer <- function(x, ...) {
-  md <- read_zattrs(x)
-  ps <- .get_multiscales_dataset_paths(md)
-  list(array = lapply(ps, \(.) ZarrArray(file.path(x, as.character(.)))), 
-       md = md)
+#' @importFrom Rarr read_zarr_attributes
+#' @importFrom ZarrArray ZarrArray
+.readArray <- function(x, ...) {
+    md <- read_zarr_attributes(x)
+    ps <- .get_multiscales_dataset_paths(md)
+    ps <- file.path(x, as.character(ps))
+    as <- lapply(ps, ZarrArray)
+    list(array=as, md=md)
 }
 
 #' @rdname readSpatialData
-#' @importFrom Rarr ZarrArray
 #' @export
 readImage <- function(x, ...) {
-    lyrs <- readsdlayer(x, ...)
-    ImageArray(data=lyrs$array, meta=Zattrs(lyrs$md), ...)
+    l <- .readArray(x, ...)
+    ImageArray(data=l$array, meta=Zattrs(l$md), ...)
 }
 
 #' @rdname readSpatialData
-#' @importFrom Rarr ZarrArray
 #' @export
 readLabel <- function(x, ...) {
-  lyrs <- readsdlayer(x, ...)
-  LabelArray(data=lyrs$array, meta=Zattrs(lyrs$md), ...)
+    l <- .readArray(x, ...)
+    LabelArray(data=l$array, meta=Zattrs(l$md), ...)
 }
 
 #' @rdname readSpatialData
 #' @importFrom arrow open_dataset
+#' @importFrom Rarr read_zarr_attributes
 #' @export
 readPoint <- function(x, ...) {
-    md <- read_zattrs(x)
+    md <- read_zarr_attributes(x)
     pq <- list.files(x, "\\.parquet$", full.names=TRUE)
     PointFrame(data=open_dataset(pq), meta=Zattrs(md))
 }
 
 #' @rdname readSpatialData
 #' @importFrom arrow open_dataset
+#' @importFrom Rarr read_zarr_attributes
 #' @import geoarrow   
 #' @export
 readShape <- function(x, ...) {
-    requireNamespace("geoarrow", quietly=TRUE)
-    md <- read_zattrs(x)
     # TODO: previously had read_parquet(), 
     # but that doesn't work with geoparquet?
+    #requireNamespace("geoarrow", quietly=TRUE)
+    md <- read_zarr_attributes(x)
     pq <- list.files(x, "\\.parquet$", full.names=TRUE)
     ShapeFrame(data=open_dataset(pq), meta=Zattrs(md))
 }
 
 #' @importFrom basilisk BasiliskEnvironment
 .env <- BasiliskEnvironment(
-    pkgname="SpatialData",
-    envname="anndata_env",
-    packages=c("python==3.12.0", "zarr==2.18.4"),
+    pkgname="SpatialData", envname="anndata_env",
+    packages=c( "python==3.13.0"),
     pip=allp)
 
+#' @import anndataR
 #' @importFrom reticulate import
 #' @importFrom S4Vectors metadata
-#' @importFrom zellkonverter AnnData2SCE
 #' @importFrom SingleCellExperiment int_metadata
 #' @importFrom basilisk basiliskStart basiliskStop basiliskRun
 .readTables_basilisk <- function(x) {
     proc <- basiliskStart(.env)
     on.exit(basiliskStop(proc))
     basiliskRun(proc, x=x, \(x) {
-        # read in 'SpatialData' from .zarr store
-        sd <- import("spatialdata")
-        zs <- sd$read_zarr(x)
-        # return (named) list of SCEs
-        names(ts) <- ts <- names(zs$tables$data)
-        lapply(ts, \(z) {
-            se <- AnnData2SCE(zs$tables[z])
-            nm <- "spatialdata_attrs"
-            md <- metadata(se)[[nm]]
-            int_metadata(se)[[nm]] <- md
-            metadata(se)[[nm]] <- NULL
-            se
-        }) 
+      # read in 'AnnData' tables from .zarr store
+      sd <- import("anndata")
+      za <- import("zarr")
+      # return (named) list of SCEs
+      names(ts) <- ts <- list.dirs(file.path(x,"tables/"), 
+                                   recursive = FALSE, 
+                                   full.names = FALSE)
+      lapply(ts, \(z) {
+        zs <- sd$read_zarr(file.path(x, "tables", z))
+        se <- zs$as_SingleCellExperiment()
+        nm <- "spatialdata_attrs"
+        md <- metadata(se)[[nm]]
+        int_metadata(se)[[nm]] <- md
+        metadata(se)[[nm]] <- NULL
+        se
+      }) 
     })
 }
-
 .readTable_anndataR <- function(x) {
     if (!requireNamespace('anndataR', quietly=TRUE)) {
-        stop("To use this function, install the 'anndataR' package via\n",
-            "`BiocManager::install(\"keller-mark/anndataR\", ref=\"spatialdata\")`")
-    }
-    if (!requireNamespace('pizzarr', quietly=TRUE)) {
-        stop("To use this function, install the 'pizzarr' package via\n",
-            "`BiocManager::install(\"keller-mark/pizzarr\")`")
+        message("To make sure 'anndataR' package works as intended, ", 
+                "install the development version via\n",
+                "`BiocManager::install(\"keller-mark/anndataR\", ref=\"spatialdata\")`")
     }
     suppressWarnings({ # suppress warnings related to hidden files
-        adata <- anndataR::read_zarr(x)
-        anndataR::to_SingleCellExperiment(adata)
+        anndataR::read_zarr(x, as="SingleCellExperiment")
     })
 }
 
@@ -186,24 +202,26 @@ readTable <- function(x) {
 #' @export
 readSpatialData <- function(x, 
     images=TRUE, labels=TRUE, points=TRUE, 
-    shapes=TRUE, tables=TRUE, anndataR=FALSE) {
+    shapes=TRUE, tables=TRUE, anndataR=TRUE) {
     if (!anndataR) tables <- FALSE # will do manually below
     args <- as.list(environment())[.LAYERS]
     skip <- vapply(args, isFALSE, logical(1))
     sd <- lapply(.LAYERS[!skip], \(i) {
-        y <- file.path(x, i)
-        j <- list.files(y, full.names=TRUE)
+        j <- list.dirs(
+            file.path(x, i), 
+            recursive=FALSE, 
+            full.names=TRUE)
         names(j) <- basename(j)
         if (!isTRUE(opt <- args[[i]])) {
             if (is.numeric(opt) && opt > (. <- length(j))) 
                 stop("'", i, "=", opt, "', but only ", ., " elements found")
             if (is.character(opt) && length(. <- setdiff(opt, basename(j))))
-                stop("couln't find ", i, " of name", .)
+                stop("couldn't find ", i, " of name", .)
             j <- j[opt]
         }
         f <- get(paste0("read", toupper(substr(i, 1, 1)), substr(i, 2, nchar(i)-1)))
         lapply(j, \(.) do.call(f, list(.)))
     }) 
-    if (!anndataR) sd$tables <- .readTables_basilisk(x)
+    if (!anndataR && !isFALSE(tables)) sd$tables <- .readTables_basilisk(x)
     do.call(SpatialData, sd)
 }
diff --git a/R/sdArray.R b/R/sdArray.R
index 2eefc757..47d22cce 100644
--- a/R/sdArray.R
+++ b/R/sdArray.R
@@ -1,7 +1,8 @@
-#' @name Array-methods
+#' @name sdArray
 #' @title Methods for `ImageArray` and `LabelArray` class
 #' 
 #' @aliases 
+#' data_type
 #' data,ImageArray-method
 #' data,LabelArray-method
 #' dim,ImageArray-method
@@ -15,13 +16,20 @@
 #' @return \code{ImageArray}
 #'
 #' @examples
-#' # TODO
+#' library(SpatialData.data)
+#' zs <- get_demo_SDdata("merfish")
+#' 
+#' # helper that gets path to first element in layer 'l' 
+#' fn <- \(l) list.files(file.path(zs, l), full.names=TRUE)[1]
+#'   
+#' # read individual element  
+#' (ia <- readImage(fn("images")))
 #' 
 #' @importFrom S4Vectors metadata<-
 #' @importFrom methods new
 NULL
 
-#' @rdname Array-methods
+#' @rdname sdArray
 #' @export
 setMethod("data", "sdArray", \(x, k=1) {
   if (is.null(k)) return(x@data)
@@ -32,14 +40,30 @@ setMethod("data", "sdArray", \(x, k=1) {
   stop("'k=", k, "' but only ", n, " resolution(s) available")
 })
 
-#' @rdname Array-methods
+#' @rdname sdArray
 #' @export
 setMethod("dim", "sdArray", \(x) dim(data(x)))
 
-#' @rdname Array-methods
+#' @rdname sdArray
 #' @export
 setMethod("length", "sdArray", \(x) length(data(x, NULL)))
 
+#' @export
+#' @rdname sdArray
+#' @importFrom S4Vectors metadata
+setMethod("data_type", "sdArray", \(x) {
+    if (is(y <- data(x), "DelayedArray")) 
+        data_type(y) else metadata(x)$data_type
+})
+
+#' @export
+#' @rdname sdArray
+#' @importFrom DelayedArray DelayedArray
+#' @importFrom Rarr zarr_overview
+#' @importFrom ZarrArray path
+setMethod("data_type", "DelayedArray", \(x) zarr_overview(path(x), as_data_frame=TRUE)$data_type)
+
+
 #' .create_mip
 #' 
 #' Generate a downsampled pyramid of images.
@@ -87,5 +111,11 @@ setMethod("length", "sdArray", \(x) length(data(x, NULL)))
               perm = rev(seq_len(length(axes))))
     }
   }
+  if (method == "label") {
+    image_list <- lapply(image_list, function(x) {
+      storage.mode(x) <- "integer"
+      x
+    })
+  }
   image_list
 }
\ No newline at end of file
diff --git a/R/table_utils.R b/R/table_utils.R
index b875a0e2..7e2e6e59 100644
--- a/R/table_utils.R
+++ b/R/table_utils.R
@@ -18,11 +18,24 @@
 #' @param ... \code{data.frame} or list of data generation function(s) 
 #'   that accept an argument for the number of observations; see examples.
 #'   
+#' @returns 
+#' \itemize{
+#' \item \code{hasTable}: 
+#'   logical scalar (or character string, if \code{name=TRUE});
+#'   whether or not a \code{table} annotating \code{i} exists in \code{x}
+#' \item \code{getTable}: 
+#'   \code{SingleCellExperiment}; the \code{table} annotating 
+#'   \code{i} with optional filtering of matching observations
+#' \item \code{valTable}: 
+#'   vector of values (according to \code{j})
+#'   from the \code{table} annotating \code{i}
+#' }  
+#'   
 #' @examples
 #' library(SingleCellExperiment)
 #' x <- file.path("extdata", "blobs.zarr")
 #' x <- system.file(x, package="SpatialData")
-#' x <- readSpatialData(x, anndataR=FALSE)
+#' x <- readSpatialData(x, anndataR=TRUE)
 #' 
 #' # check if element has a 'table'
 #' hasTable(x, "blobs_points")
@@ -98,15 +111,12 @@ setMethod("hasTable", c("SpatialData", "character"), \(x, i, name=FALSE) {
     match.arg(i, unlist(nms[idx]))
     # count occurrences
     t <- lapply(tables(x), \(t) meta(t)$region)
-    n <- vapply(seq_along(t), \(.) i %in% t[[.]], numeric(1))
-    nan <- all(n == 0)
+    ok <- vapply(t, \(.) i %in% ., logical(1))
     # failure when no/many matches
-    if (name) {
-        dup <- length(unique(n)) != length(n)
-        if (nan) stop("no 'table' found for 'i'")
-        if (dup) stop("multiple 'table's found for 'i'")
-        return(names(t)[n == 1])
-    } else return(!nan)
+    if (!name) return(any(ok))
+    if (!any(ok)) stop("no 'table' found for 'i'")
+    if (sum(ok) > 1) stop("multiple 'table's found for 'i'")
+    return(names(t)[ok])
 })
 
 # get ----
@@ -121,15 +131,15 @@ setMethod("getTable", c("SpatialData", "ANY"), \(x, i, drop=TRUE) .invalid_i())
 setMethod("getTable", c("SpatialData", "character"), \(x, i, drop=TRUE) {
     stopifnot(isTRUE(drop) || isFALSE(drop))
     # get 'table' annotating 'i', if any
-    t <- table(x, hasTable(x, i, name=TRUE))
+    t <- SpatialData::table(x, hasTable(x, i, name=TRUE))
     # only keep observations belonging to 'i' (optional)
     if (drop) {
         rk <- meta(t)$region_key
         # TODO: check the replacement below, search colData as well?
         # t <- t[, int_colData(t)[[rk]] == i]
-        coldata <-
-          if(rk %in% names(cd <- int_colData(t))) cd[[rk]] else colData(t)[[rk]]
-        t <- t[, coldata == i]
+        int <- rk %in% names(cd <- int_colData(t))
+        cd <- if (int) cd[[rk]] else t[[rk]]
+        t <- t[, cd == i]
     }
     return(t)
 })
@@ -221,8 +231,7 @@ setMethod("setTable",
     int_colData(sce) <- cbind(int_colData(sce), icd)
     md <- list(region=i, region_key=rk, instance_key=ik)
     int_metadata(sce)[[sda]] <- md
-    table(x, name) <- sce
-    return(x)
+    SpatialData::`table<-`(x, i=name, value=sce)
 })
 
 # val ----
diff --git a/R/trans.R b/R/trans.R
index bef7a277..af9ec51f 100644
--- a/R/trans.R
+++ b/R/trans.R
@@ -1,14 +1,19 @@
 #' @name trans
 #' @rdname trans
 #' @title Transformations
-#' @aliases scale rotate translation
+#' @aliases scale rotate translation flip flop mirror
 #' 
-#' @param x \code{SpatialData} element
-#' @param j scalar character or numeric; 
-#'   name or index of coordinate space.
-#' @param t transformation data.
+#' @param x \code{SpatialData} element.
+#' @param t transformation data; exceptions: for \code{mirror}, controls
+#'   whether to perform \bold{v}ertical or \bold{h}orizontal reflection;
+#'   no data is needed for \code{flip} (\bold{v}) and \code{flop} (\bold{h}).
+#' @param k scalar index specifying which scale to use; 
+#'   \code{Inf} to use lowest available resolution;
+#'   only applies to \code{sdArray}s (images, labels).
 #' @param ... option arguments passed to and from other methods.
 #' 
+#' @returns \code{SpatialData} element with transformation(s) applied.
+#' 
 #' @examples
 #' x <- file.path("extdata", "blobs.zarr")
 #' x <- system.file(x, package="SpatialData")
@@ -16,14 +21,14 @@
 #' 
 #' # image
 #' y <- x
-#' image(y) <- scale(image(y), 1, c(1, 1, 1/3))
-#' CTpath(image(x), "global")
-#' CTpath(image(y), "global")
+#' image(y) <- scale(image(y), c(1, 1, 1/3))
+#' dim(image(x))
+#' dim(image(y))
 #'   
 #' # point
 #' y <- x
 #' point(y, "rot") <- rotate(point(y), 20)
-#' point(y, "wide") <- scale(point(y), c(1, 1.2))
+#' point(y, "wide") <- scale(point(y), c(1.2, 1))
 #' 
 #' xy0 <- as.data.frame(point(y))
 #' xy1 <- as.data.frame(point(y, "rot"))
@@ -36,34 +41,99 @@
 #' # shape
 #' y <- x
 #' shape(y, "rot") <- rotate(shape(y), 5)
-#' shape(y, "high") <- scale(shape(y), c(1.2, 1))
+#' shape(y, "wide") <- scale(shape(y), c(1.2, 1))
 #' shape(y, "left") <- translation(shape(y), c(-5, 0))
-#' 
-#' graph::plot(CTgraph(y))
+#' y["shapes", c("rot", "wide", "left")]
 NULL
 
-# image ----
+# rotation matrix to rotate points counter-clockwise through an angle 't'
+.R <- \(t) matrix(c(cos(t), sin(t), -sin(t), cos(t)), 2, 2)
+
+# array ----
 
+.mirror <- \(x, t, k=1) {
+    d <- length(dim(x)) == 3
+    i <- if (d) c(1, 3, 2) else c(2, 1)
+    x@data <- list(aperm(data(x, k), i))
+    rotate(x, t, k=1)
+}
+
+#' @export
 #' @rdname trans
+setMethod("mirror", "sdArray", \(x, t=c("v", "h"), k=1, ...) 
+    switch(match.arg(t), v=flip, h=flop)(x, k))
+
+#' @export
+#' @rdname trans
+setMethod("flip", "sdArray", \(x, k=1, ...) .mirror(x, -90, k))
+
+#' @export
+#' @rdname trans
+setMethod("flop", "sdArray", \(x, k=1, ...) .mirror(x, 90, k))
+
+#' @importFrom methods as
+#' @importFrom S4Vectors metadata<-
+.trans_a <- \(x, f, k=1) {
+    a <- f(aperm(as.array(data(x, k))))
+    metadata(x)$data_type <- data_type(x)
+    x@data <- list(as(aperm(a), "SparseArray"))
+    return(x)
+}
+
 #' @export
-setMethod("scale", c("ImageArray", "numeric"), \(x, j, t, ...) {
-    stopifnot(length(t) == 3, t > 0)
+#' @rdname trans
+#' @importFrom EBImage resize
+setMethod("scale", c("sdArray", "numeric"), \(x, t, k=1, ...) {
+    stopifnot(length(t) == length(dim(x)), is.finite(t), t > 0)
     if (all(t == 1)) return(x)
-    if (is.numeric(j)) j <- CTname(x)
-    j <- match.arg(j, CTname(x))
-    addCT(x, name=j, type="scale", data=t)
+    n <- length(d <- dim(data(x, k)))
+    f <- \(.) resize(.,
+        w=d[n]*t[n],
+        h=d[n-1]*t[n-1])
+    .trans_a(x, f, k)
 })
 
-# label ----
+#' @export
+#' @rdname trans
+#' @importFrom EBImage rotate
+setMethod("rotate", c("sdArray", "numeric"), \(x, t, k=1,...) {
+    # negate angle since 'EBImage' rotates clockwise
+    stopifnot(length(t) == 1, is.finite(t))
+    if (t %% 360 == 0) return(x)
+    f <- \(.) EBImage::rotate(., -t) 
+    if (length(d <- dim(data(x, k))) == 3) d <- d[-1]
+    metadata(x)$wh <- lapply(rev(d), \(.) c(c(0, .) %*% .R(-t*pi/180)))
+    .trans_a(x, f, k)
+})
 
-#TODO
+#' @export
+#' @rdname trans
+#' @importFrom EBImage translate
+setMethod("translation", c("sdArray", "numeric"), \(x, t, k=1, ...) {
+    stopifnot(length(t) == length(dim(x)), is.finite(t))
+    if (all(t == 0)) return(x)
+    d <- dim(data(x, k))
+    if (length(d) == 3) {
+        # protect non-spatial dim.
+        t <- t[-1]; d <- d[-1]
+    }
+    t <- rev(t); d <- rev(d)
+    metadata(x)$wh <- list(
+        c(t[1], t[1]+d[1]), 
+        c(t[2], t[2]+d[2]))
+    #f <- \(.) translate(., t, output.dim=d+t)
+    #.trans_a(x, f)
+    x
+})
 
 # point ----
 
+#' @export
 #' @rdname trans
 #' @importFrom dplyr mutate
-#' @export
 setMethod("scale", c("PointFrame", "numeric"), \(x, t, ...) {
+    stopifnot(is.numeric(t), length(t) == 2, t > 0, is.finite(t))
+    if (all(t == 1)) return(x)
     y <- NULL # R CMD check
     x@data <- x@data |>
         mutate(x=x*t[1]) |>
@@ -71,18 +141,19 @@ setMethod("scale", c("PointFrame", "numeric"), \(x, t, ...) {
     return(x)
 })
 
+#' @export
 #' @rdname trans
 #' @importFrom dplyr mutate select
-#' @export
 setMethod("rotate", c("PointFrame", "numeric"), \(x, t, ...) {
-    y <- .y <- .x <- NULL # R CMD check
+    stopifnot(is.numeric(t), length(t) == 1, is.finite(t))
+    if (t %% 360 == 0) return(x)
+    y <- a <- b <- c <- d <- NULL # R CMD check
     R <- .R(t*pi/180)
     x@data <- x@data |>
-        mutate(.x=x*R[1,1], .y=y*R[1,2]) |>
-        mutate(x=.x+.y) |>
-        mutate(.x=x*R[2,1], .y=y*R[2,2]) |>
-        mutate(y=.x+.y) |>
-        select(-.x, -.y)
+        mutate(a=x*R[1,1], b=y*R[1,2]) |>
+        mutate(c=x*R[2,1], d=y*R[2,2]) |>
+        mutate(x=a+b, y=c+d) |>
+        select(-c(a,b, c,d))
     return(x)
 })
 
@@ -90,6 +161,8 @@ setMethod("rotate", c("PointFrame", "numeric"), \(x, t, ...) {
 #' @importFrom dplyr mutate select
 #' @export
 setMethod("translation", c("PointFrame", "numeric"), \(x, t, ...) {
+    stopifnot(is.numeric(t), length(t) == 2, is.finite(t))
+    if (all(t == 0)) return(x)
     y <- NULL # R CMD check
     x@data <- x@data |>
         mutate(x=x+t[1]) |>
@@ -99,11 +172,23 @@ setMethod("translation", c("PointFrame", "numeric"), \(x, t, ...) {
 
 # shape ----
 
+# TODO: do this w/o realizing
+#' @importFrom sf st_as_sf st_geometry st_geometry<-
+.trans_s <- \(x, f) {
+    y <- st_as_sf(data(x))
+    xy <- st_coordinates(y)
+    xy <- data.frame(f(xy))
+    xy <- st_as_sf(xy, coords=names(xy))
+    st_geometry(y) <- st_geometry(xy)
+    x@data <- y
+    return(x)
+}
+
 #' @rdname trans
 #' @importFrom sf st_as_sf st_coordinates
 #' @export
 setMethod("scale", c("ShapeFrame", "numeric"), \(x, t, ...) {
-    stopifnot(is.numeric(t), length(t) == 2, t > 0, all(is.finite(t)))
+    stopifnot(is.numeric(t), length(t) == 2, t > 0, is.finite(t))
     .trans_s(x, \(xy) sweep(xy, 2, t, `*`))
 })
 
@@ -122,58 +207,3 @@ setMethod("translation", c("ShapeFrame", "numeric"), \(x, t, ...) {
     stopifnot(is.numeric(t), length(t) == 2, is.finite(t))
     .trans_s(x, \(xy) sweep(xy, 2, t, `+`))
 })
-
-# utils ----
-
-# rotation matrix to rotate points counter-clockwise through an angle 't'
-.R <- function(t) matrix(c(cos(t), -sin(t), sin(t), cos(t)), 2, 2)
-
-# count occurrences of each coordinate space;
-# return most frequent (in order of appearance)
-.guess_space <- \(x) {
-    nms <- lapply(rownames(x), \(l) 
-        lapply(colnames(x)[[l]], \(e) 
-            CTname(x[[l]][[e]])))
-    cnt <- table(nms <- unlist(nms))
-    cnt <- cnt[unique(nms)]
-    names(which.max(cnt))
-}
-
-.trans_xy <- \(xy, ts, rev=FALSE) {
-    if (rev) ts <- rev(ts)
-    for (. in seq_along(ts)) {
-        t <- ts[[.]]$type
-        d <- ts[[.]]$data
-        if (length(d) == 3)
-            d <- d[-1]
-        switch(t, 
-            identity={},
-            scale={
-                op <- ifelse(rev, `/`, `*`)
-                xy$x <- op(xy$x, d[2])
-                xy$y <- op(xy$y, d[1])
-            },
-            rotate={
-                xy <- xy %*% .R(d*pi/180)
-            },
-            translation={
-                op <- ifelse(rev, `-`, `+`)
-                xy$x <- op(xy$x, d[2])
-                xy$y <- op(xy$y, d[1])
-            })
-    }
-    return(xy)
-}
-
-# transform 'ShapeFrame' by realizing,
-# and updating 'sf' geometry coordinates
-#' @importFrom sf st_as_sf st_geometry st_geometry<-
-.trans_s <- \(x, f) {
-    y <- st_as_sf(data(x))
-    xy <- st_coordinates(y)
-    xy <- data.frame(f(xy))
-    xy <- st_as_sf(xy, coords=names(xy))
-    st_geometry(y) <- st_geometry(xy)
-    x@data <- y
-    return(x)
-}
\ No newline at end of file
diff --git a/R/tx_to_ext.R b/R/tx_to_ext.R
index 96128c7c..e4421a28 100644
--- a/R/tx_to_ext.R
+++ b/R/tx_to_ext.R
@@ -21,15 +21,20 @@
 #'   can include "maintain_positioning" (logical (1)) or numerics for
 #'   target_unit_to_pixels, target_width, target_height, target_depth.
 #'   
+#' @return \code{SpatialData} object. 
+#'   
 #' @examples
 #' src <- system.file("extdata", "blobs.zarr", package="SpatialData")
 #' td <- tempfile()
-#' do_tx_to_ext(
-#'   srcdir=src, dest=td, 
-#'   coordinate_system="global",
-#'   maintain_positioning=FALSE, 
-#'   target_width=400.)
-#' (sd <- readSpatialData(td))
+#' # TODO: for now this example converts to a zarr v3 so we comment out, 
+#' # check again later
+#' 
+#' # do_tx_to_ext(
+#' #  srcdir=src, dest=td, 
+#' #  coordinate_system="global",
+#' #  maintain_positioning=FALSE, 
+#' #  target_width=400.)
+#' # (sd <- readSpatialData(td))
 #' 
 #' @export
 do_tx_to_ext <- function(srcdir, dest, coordinate_system, ...) {
diff --git a/R/utils.R b/R/utils.R
new file mode 100644
index 00000000..8618e2ad
--- /dev/null
+++ b/R/utils.R
@@ -0,0 +1,128 @@
+#' @name utils
+#' @rdname utils
+#' @title Utilities
+#' @aliases centroids extent
+#' 
+#' @param x a \code{SpatialData} element (any but image).
+#' @param as character string; how results should be returned.
+#' @param ... optional arguments passed to and from other methods.
+#' 
+#' @returns
+#' For \code{centroids}, a table (\code{data.frame} or \code{matrix}) 
+#' of spatial coordinates (if \code{as="list"}, split by instance);
+#' for extend, a length-2 numeric list of x- and y-ranges.
+#' 
+#' @examples
+#' x <- file.path("extdata", "blobs.zarr")
+#' x <- system.file(x, package="SpatialData")
+#' x <- readSpatialData(x, tables=FALSE)
+#' 
+#' centroids(label(x))
+#' centroids(shape(x))
+#' centroids(shape(x, 3), "list")
+#' 
+#' head(centroids(point(x)))
+#' xy <- centroids(point(x), "list")
+#' plot(xy$gene_a, col=a <- "red")
+#' points(xy$gene_b, col=b <- "blue")
+#' legend("topright", legend=names(xy), col=c(a, b), pch=21)
+#' 
+#' # object-wide
+#' extent(x)
+#' 
+#' # element-wise
+#' extent(label(x))
+#' extent(point(x))
+#' extent(shape(x))
+NULL
+
+# centroids ----
+
+#' @export
+#' @rdname utils
+setMethod("centroids", "ANY", \(x, ...) stop("'centroids' ",
+    "only supported for label, shape, and point elements"))
+
+#' @export
+#' @rdname utils
+#' @importFrom Matrix summary
+setMethod("centroids", "LabelArray", \(x, 
+    as=c("data.frame", "matrix")) {
+    as <- match.arg(as)
+    y <- data(x)
+    y <- as(y, "dgCMatrix")
+    i <- summary(y)
+    # flip dimensions so that columns=x, rows=y
+    # TODO: should these be offset by 0.5?
+    i[, c(1, 2)] <- i[, c(2, 1)]-0.5
+    xy <- tapply(i[, -3], i[[3]], colMeans)
+    xy <- do.call(rbind, xy)
+    xy <- cbind(xy, as.integer(rownames(xy)))
+    dimnames(xy) <- list(NULL, c("x", "y", "i"))
+    if (as == "matrix") return(xy)
+    xy <- as.data.frame(xy)
+    xy$i <- factor(xy$i); xy
+})
+
+#' @export
+#' @rdname utils
+#' @importFrom sf st_as_sf st_geometry_type st_coordinates
+setMethod("centroids", "ShapeFrame", \(x, 
+    as=c("data.frame", "matrix", "list")) {
+    as <- match.arg(as)
+    y <- st_as_sf(data(x))
+    xy <- st_coordinates(y)
+    colnames(xy)[c(1, 2)] <- c("x", "y")
+    if (as == "matrix") return(xy)
+    xy <- as.data.frame(xy)
+    rownames(xy) <- NULL
+    if (ncol(xy) > 2) 
+        for (. in seq(3, ncol(xy))) 
+            xy[[.]] <- factor(xy[[.]], unique(xy[[.]]))
+    if (as == "data.frame") return(xy)
+    split(xy, xy[seq(3, ncol(xy))])
+})
+
+#' @export
+#' @rdname utils
+setMethod("centroids", "PointFrame", \(x, 
+    as=c("data.frame", "list")) {
+    as <- match.arg(as)
+    i <- feature_key(x)
+    xy <- data(x)[, c("x", "y", i)]
+    xy <- as.data.frame(xy)
+    if (as == "data.frame") return(xy)
+    lapply(split(xy, xy[[i]]), `[`, -3)
+})
+
+# extent ----
+
+# TODO: this needs more work to consider transformations
+
+#' @export
+#' @rdname utils
+setMethod("extent", "SpatialData", \(x) {
+    ls <- setdiff(.LAYERS, "tables")
+    ex <- lapply(ls, \(.) lapply(x[[.]], extent))
+    ex <- Reduce(c, ex)
+    names(xy) <- xy <- c("x", "y")
+    lapply(xy, \(z) {
+        d <- vapply(ex, \(.) .[[z]], numeric(2))
+        c(min(d[1, ]), max(d[2, ]))
+    })
+})
+
+#' @export
+#' @rdname utils
+setMethod("extent", "SpatialDataElement", \(x) {
+    if (is(x, "sdArray")) {
+        nm <- vapply(ax <- axes(x), \(.) .$name, character(1))
+        xy <- vapply(ax, \(.) .$type == "space", logical(1))
+        d <- dim(x); names(d) <- nm
+        lapply(d[xy], \(.) c(0, .))
+    } else {
+        ax <- unlist(axes(x))
+        xy <- centroids(x)[ax]
+        apply(xy, 2, range, simplify=FALSE)
+    }
+})
diff --git a/R/validity.R b/R/validity.R
index 5da54752..f30ed209 100644
--- a/R/validity.R
+++ b/R/validity.R
@@ -1,80 +1,122 @@
-# TODO: everything...
-
-.validateTable <- function(object) {
+# https://spatialdata.scverse.org/en/latest/design_doc.html#table-table-of-annotations-for-regions
+#' @importFrom SingleCellExperiment int_metadata int_colData
+.validateTables <- \(object) {
     msg <- c()
+    sce <- \(.) is(., "SingleCellExperiment")
     for (i in seq_along(tables(object))) {
-        t <- table(object, i)
-        if (!is(t, "SingleCellExperiment")) {
-            msg <- c(msg, paste0("Table ", i, " is not a 'SingleCellExperiment'"))
+        ok <- sce(se <- table(object, i))
+        if (!ok) msg <- c(msg, paste0(
+            i, "-th table is not a 'SingleCellExperiment'"))
+        if (!ok) next
+        md <- int_metadata(se)$spatialdata_attrs
+        nm <- c("region", "region_key", "instance_key")
+        .nm <- sprintf("'%s'", paste(nm, collapse="/"))
+        if (any(ok <- nm %in% names(md))) {
+            if (!all(ok)) msg <- c(msg, paste0(
+                i, "-th table missing ", .nm, "; must set all if any"))
+            ok <- all(vapply(md, is.character, logical(1)))
+            if (!ok) msg <- c(msg, paste0(
+                i, "-th table's ", .nm, " is not of type character"))
+            ok <- all(vapply(intersect(md, nm[-1]), length, integer(1)) == 1)
+            if (!ok) msg <- c(msg, paste0(
+                i, "-th table's 'region/instance_key' is not length 1"))
+            ok <- !is.null(int_colData(se)[[md$region_key]])
+            if (!ok) msg <- c(msg, paste0(
+                i, "-th table missing 'region_key' column in 'int_colData'"))
+            ok <- !is.null(int_colData(se)[[md$instance_key]])
+            if (!ok) msg <- c(msg, paste0(
+                i, "-th table missing 'instance_key' column in 'int_colData'"))
+
         }
-        # TODO: validate int_metadata$spatialdata_attrs
-        # md <- int_metadata(sce)[["spatialdata_attrs"]]
-        # if (!all(c("region_key", "instance_key") %in% names(md))) {
-        #     msg <- c(msg, paste0("region_key/instance_key not present in ",
-        #                          i, "-th sce int_metadata"))
-        # }
     }
+    na <- setdiff(
+        unlist(lapply(tables(object), \(.) if (sce(.)) region(.))),
+        unlist(colnames(object)[setdiff(.LAYERS, "tables")])) # don't flip!
+    if (length(na))
+        msg <- c(msg, paste(
+            "table region(s) not found in any layer:",
+            paste(sprintf("'%s'", na), collapse=", ")))
     return(msg)
 }
 
-.validatePointFrame <- function(object) {
-    msg <- NULL
-    # Checks if the points have the x,y coordinates, as they are hard-coded
-    # in the plot functions
-    if (length(points(object))) { # there are some cases where the points are empty
-        if (!is.null(data(point(object)))) {
-            np <- length(points(object))
-            for (i in seq_len(np)) {
-                dfi <- data(point(object, i))
-                if (!all(c("x", "y") %in% names(dfi))) {
-                    msg <- c(msg, paste0("'x' and 'y' missing in data point ", i))
-                }
-            }
-        }
+.validateImageArray <- \(object) {
+    msg <- c()
+    res <- length(object)
+    for (k in seq_len(res)) {
+        x <- data(object, k)
+        if (length(dim(x)) != 3) msg <- c(msg, paste(
+            "'ImageArray' resolution", k, "is not 3D"))
+        if (!type(x) %in% c("double", "integer")) msg <- c(msg, paste(
+            "'ImageArray' resolution", k, "is not of type double or integer"))
     }
     return(msg)
 }
+#' @importFrom S4Vectors setValidity2
+setValidity2("ImageArray", .validateImageArray)
 
-.validateImageArray <- function(object) {
+#' @importFrom ZarrArray type
+.validateLabelArray <- \(object) {
     msg <- c()
-    if (ni <- length(images(object))) {
-        for (i in seq_along(ni)) {
-            ai <- as.array(aperm(data(image(object,1))/255, perm=c(3,2,1)))
-            for (j in dim(ai)[3]) {
-                if (!all(vapply(ai[,,j], is.numeric, logical(1)))) {
-                    msg <- c(msg, paste0("Image ", i, " channel ", j, " not numeric"))
-                }
-            }
-        }
+    res <- length(object)
+    for (k in seq_len(res)) {
+        x <- data(object, k)
+        if (length(dim(x)) != 2) msg <- c(msg, paste(
+            "'LabelArray' resolution", k, "is not 2D"))
+        if (type(x) != "integer") msg <- c(msg, paste(
+            "'LabelArray' resolution", k, "is not of type integer"))
     }
     return(msg)
 }
+#' @importFrom S4Vectors setValidity2
+setValidity2("LabelArray", .validateLabelArray)
+
+.validatePointFrame <- \(object) {
+    msg <- c()
+    if (!length(object)) return(msg)
+    if (!"x" %in% names(object)) msg <- c(msg, "'PointFrame' missing 'x'.")
+    if (!"y" %in% names(object)) msg <- c(msg, "'PointFrame' missing 'y'.")
+    return(msg)
+}
+#' @importFrom S4Vectors setValidity2
+setValidity2("PointFrame", .validatePointFrame)
+
+.validateShapeFrame <- \(object) {
+    msg <- c()
+    if (!nrow(object)) return(msg)
+    if (!"geometry" %in% names(object)) msg <- c(msg, "'ShapeFrame' missing 'geometry'.")
+    return(msg)
+}
+#' @importFrom S4Vectors setValidity2
+setValidity2("ShapeFrame", .validateShapeFrame)
 
 #' @importFrom methods is
 .validateSpatialData <- \(x) {
+    msg <- c()
     typ <- c(
         images="ImageArray",
         labels="LabelArray",
         points="PointFrame",
         shapes="ShapeFrame",
         tables="SingleCellExperiment")
-    msg <- NULL
     for (. in names(typ)) if (length(x[[.]]))
         if (!all(vapply(x[[.]], \(y) is(y, typ[.]), logical(1))))
             msg <- c(msg, sprintf("'%s' should be a list of '%s'", ., typ[.]))
-    msg <- c(msg, .validatePointFrame(x))
-    msg <- c(msg, .validateTable(x))
-    for (y in labels(x)) .validateZattrsLabelArray(y)
-    if (length(msg))
-        return(msg)
-    return(TRUE)
+    # TODO: validate .zattrs across all layers
+    for (y in labels(x)) msg <- c(msg, .validateLabelArray(y))
+    for (y in images(x)) msg <- c(msg, .validateImageArray(y))
+    for (y in points(x)) msg <- c(msg, .validatePointFrame(y))
+    for (y in shapes(x)) msg <- c(msg, .validateShapeFrame(y))
+    msg <- c(msg, .validateTables(x))
+    return(msg)
 }
 
 #' @importFrom S4Vectors setValidity2
 setValidity2("SpatialData", .validateSpatialData)
 
+# TODO: version-specific .zattrs validation for all layers
+
 .validateZattrs_multiscales <- \(x, msg) {
-    if (is.null(ms <- x$multiscales))
+    if (is.null(ms <- x$multiscales[[1]]))
         msg <- c(msg, "missing 'multiscales'")
     # MUST contain
     for (. in c("axes", "datasets"))
@@ -96,18 +138,18 @@ setValidity2("SpatialData", .validateSpatialData)
 .validateZattrs_coordTrans <- \(x, msg) {
     if (!is.list(ct <- x$coordinateTransformations))
         msg <- c(msg, "missing or non-list 'coordTrans'")
-    ct <- ct[[1]]
-    for (. in c("input", "output", "type"))
-        if (is.null(ct[[.]]))
-            msg <- c(msg, sprintf("'coordTrans' missing '%s'", .))
+    for (i in seq_along(ct))
+        for (j in c("input", "output", "type"))
+            if (is.null(ct[[i]][[j]]))
+                msg <- c(msg, sprintf("'coordTrans' %s missing '%s'", i, j))
     return(msg)
 }
 .validateZattrsLabelArray <- \(x) {
     msg <- c()
     za <- meta(x)
     msg <- .validateZattrs_multiscales(za, msg)
-    ms <- za$multiscales
+    ms <- za$multiscales[[1]]
     msg <- .validateZattrs_axes(ms, msg)
     msg <- .validateZattrs_coordTrans(ms, msg)
-    if (length(msg)) return(msg) else return(TRUE)
+    return(msg)
 }
diff --git a/R/write.R b/R/write.R
index 8217abfe..ccd29f41 100644
--- a/R/write.R
+++ b/R/write.R
@@ -33,29 +33,45 @@ NULL
 
 #' @rdname writeSpatialData
 #' @export
-writeSpatialData <- function(x, name, path, replace = TRUE, version = "v2", 
+writeSpatialData <- function(x, name, path, replace = TRUE, version = "v2",
                              ...) {
   zarr.path <- .replace_zarr(name, path, replace, version)
-  
+
+  # write root-level spatialdata_attrs for v3 (Python uses this to pick the read path)
+  if (version == "v3")
+    Rarr::write_zarr_attributes(zarr.path,
+      new.zattrs = list(spatialdata_attrs = list(version = "0.2")))
+
   # write points
   . <- lapply(pointNames(x), \(.){
-    writePoint(point(x, .),., path = zarr.path, replace = replace)
+    writePoint(point(x, .),., path = zarr.path, replace = replace, version = version)
   })
-  
+
   # write shapes
   . <- lapply(shapeNames(x), \(.){
-    writeShape(shape(x, .),., path = zarr.path, replace = replace)
+    writeShape(shape(x, .),., path = zarr.path, replace = replace, version = version)
   })
-  
+
   # write images
   . <- lapply(imageNames(x), \(.){
-    writeImage(image(x, .),., path = zarr.path, replace = replace)
+    writeImage(image(x, .),., path = zarr.path, replace = replace, version = version)
   })
-  
+
   # write labels
   . <- lapply(labelNames(x), \(.){
-    writeLabel(label(x, .),., path = zarr.path, replace = replace)
+    writeLabel(label(x, .),., path = zarr.path, replace = replace, version = version)
   })
+
+  # write labels group metadata listing all label names (required by spatialdata spec)
+  # v2: {"labels": [...]}, v3: {"ome": {"labels": [...]}}
+  lnames <- labelNames(x)
+  if (length(lnames) > 0L) {
+    labels.dir <- file.path(zarr.path, "labels")
+    lnames_zattrs <- if (version == "v3")
+      list(ome = list(labels = as.list(lnames))) else
+      list(labels = as.list(lnames))
+    Rarr::write_zarr_attributes(labels.dir, new.zattrs = lnames_zattrs)
+  }
 }
 
 #' @rdname writeSpatialData
@@ -64,9 +80,12 @@ writePoint <- function(x, name, path, replace = TRUE, version = "v2") {
   # if no PointFrames were written before, update zarr store
   zarr.group <- .make_zarr_group(x, name, file.path(path, "points"), replace, version)
   # write meta
-  write_zattrs(path = zarr.group, meta(x))
+  zattrs <- as.list(meta(x))
+  if (version == "v3") zattrs$spatialdata_attrs$version <- "0.2"
+  Rarr::write_zarr_attributes(zarr.group, new.zattrs = zattrs)
   # write data
-  arrow::write_dataset(data(x), file.path(zarr.group, "points.parquet"))
+  arrow::write_dataset(data(x), file.path(zarr.group, "points.parquet"),
+                       basename_template = "part.{i}.parquet")
 }
 
 #' @rdname writeSpatialData
@@ -75,45 +94,74 @@ writeShape <- function(x, name, path, replace = TRUE, version = "v2") {
   # if no ShapeFrames were written before, update zarr store
   zarr.group <- .make_zarr_group(x, name, file.path(path, "shapes"), replace, version)
   # write meta
-  write_zattrs(path = zarr.group, meta(x))
-  # write data
-  arrow::write_dataset(data(x), file.path(zarr.group, "shapes.parquet"))
+  zattrs <- as.list(meta(x))
+  if (version == "v3") zattrs$spatialdata_attrs$version <- "0.3"
+  Rarr::write_zarr_attributes(zarr.group, new.zattrs = zattrs)
+  # write data as a single parquet file (matches Python spatialdata convention)
+  arrow::write_parquet(data(x), file.path(zarr.group, "shapes.parquet"))
 }
 
 #' @rdname writeSpatialData
+#' @importFrom Rarr write_zarr_array
+#' @importFrom DelayedArray realize
 #' @export
 writeImage <- function(x, name, path, replace = TRUE, version = "v2") {
   # if no ImageArray were written before, update zarr store
   zarr.group <- .make_zarr_group(x, name, file.path(path, "images"), replace, version)
-  # write meta
-  write_zattrs(path = zarr.group, meta(x))
+  zarr_version <- if (version == "v3") 3L else 2L
+  dimension_names <- .get_multiscale_axes(meta(x))
+  # write meta: for v3, OME-NGFF content goes under "ome" key in attributes
+  zattrs <- .wrap_ome_for_v3(meta(x), version)
+  if (version == "v3") zattrs$spatialdata_attrs$version <- "0.3"
+  Rarr::write_zarr_attributes(zarr.group, new.zattrs = zattrs)
   # write data
   lapply(
     .get_multiscales_dataset_paths(meta(x)),
     \(.){
-      da <- data(x, . + 1)
-      Rarr::write_zarr_array(realize(da), 
-                             zarr_array_path = file.path(zarr.group, .), 
-                             chunk_dim = dim(da))
+      arr <- realize(data(x, . + 1))
+      # Rarr reads names(dimnames(x)) to write dimension_names in v3 zarr.json
+      if (!is.null(dimension_names))
+        dimnames(arr) <- setNames(vector("list", length(dim(arr))), dimension_names)
+      Rarr::write_zarr_array(arr,
+                             zarr_array_path = file.path(zarr.group, .),
+                             chunk_dim = dim(arr),
+                             order = "C",
+                             dimension_separator = "/",
+                             zarr_version = zarr_version)
+      if (version == "v3")
+        .normalize_v3_array_metadata(file.path(zarr.group, .))
     }
   )
 }
 
 #' @rdname writeSpatialData
+#' @importFrom Rarr write_zarr_array
+#' @importFrom DelayedArray realize
 #' @export
 writeLabel <- function(x, name, path, replace = TRUE, version = "v2") {
   # if no LabelArray were written before, update zarr store
   zarr.group <- .make_zarr_group(x, name, file.path(path, "labels"), replace, version)
-  # write meta
-  write_zattrs(path = zarr.group, meta(x))
+  zarr_version <- if (version == "v3") 3L else 2L
+  dimension_names <- .get_multiscale_axes(meta(x))
+  # write meta: for v3, OME-NGFF content goes under "ome" key in attributes
+  zattrs <- .wrap_ome_for_v3(meta(x), version)
+  if (version == "v3") zattrs$spatialdata_attrs$version <- "0.3"
+  Rarr::write_zarr_attributes(zarr.group, new.zattrs = zattrs)
   # write data
   lapply(
     .get_multiscales_dataset_paths(meta(x)),
     \(.){
-      da <- data(x, . + 1)
-      Rarr::write_zarr_array(realize(da), 
-                             zarr_array_path = file.path(zarr.group, .), 
-                             chunk_dim = dim(da))
+      arr <- realize(data(x, . + 1))
+      if (!is.null(dimension_names))
+        dimnames(arr) <- setNames(vector("list", length(dim(arr))), dimension_names)
+      Rarr::write_zarr_array(arr,
+                             zarr_array_path = file.path(zarr.group, .),
+                             chunk_dim = dim(arr),
+                             order = "C",
+                             dimension_separator = "/",
+                             zarr_version = zarr_version)
+      if (version == "v3")
+        .normalize_v3_array_metadata(file.path(zarr.group, .))
     }
   )
-}
\ No newline at end of file
+}
diff --git a/R/zarr_utils.R b/R/zarr_utils.R
index 15f7e5b4..970dd3b1 100644
--- a/R/zarr_utils.R
+++ b/R/zarr_utils.R
@@ -9,23 +9,25 @@
 create_zarr_group <- function(store, name, version = "v2"){
   split.name <- strsplit(name, split = "\\/")[[1]]
   if(length(split.name) > 1){
-    split.name <- vapply(seq_len(length(split.name)), 
-                         function(x) paste(split.name[seq_len(x)], collapse = "/"), 
-                         FUN.VALUE = character(1)) 
+    split.name <- vapply(seq_len(length(split.name)),
+                         function(x) paste(split.name[seq_len(x)], collapse = "/"),
+                         FUN.VALUE = character(1))
     split.name <- rev(tail(split.name,2))
     if(!dir.exists(file.path(store,split.name[2])))
-      create_zarr_group(store = store, name = split.name[2])
+      create_zarr_group(store = store, name = split.name[2], version = version)
   }
   dir.create(file.path(store, split.name[1]), showWarnings = FALSE)
-  switch(version, 
+  switch(version,
          v2 = {
            write("{\"zarr_format\":2}", file = file.path(store, split.name[1], ".zgroup"))},
          v3 = {
-           stop("Currently only zarr v2 is supported!") 
+           write(
+             "{\"zarr_format\":3,\"node_type\":\"group\",\"attributes\":{}}",
+             file = file.path(store, split.name[1], "zarr.json"))
          },
-         stop("only zarr v2 is supported. Use version = 'v2'")
+         stop("version must be 'v2' or 'v3'")
   )
-  
+
 }
 
 #' create_zarr
@@ -47,70 +49,6 @@ create_zarr <- function(name, dir, version = "v2"){
   create_zarr_group(store = dir, name = name, version = version)
 }
 
-#' Read the .zattrs file associated with a Zarr array or group
-#' 
-#' @param path A character vector of length 1. This provides the
-#'   path to a Zarr array or group. This can either be on a local file
-#'   system or on S3 storage.
-#' @param s3_client A list representing an S3 client.  This should be produced
-#' by [paws.storage::s3()].
-#' 
-#' @returns A list containing the .zattrs elements
-#' 
-#' @importFrom jsonlite read_json fromJSON
-#' @importFrom stringr str_extract str_remove
-#'
-#' @export
-read_zattrs <- function(path, s3_client = NULL) {
-  path <- .normalize_array_path(path)
-  zattrs_path <- paste0(path, ".zattrs")
-  
-  if(!file.exists(zattrs_path))
-    stop("The group or array does not contain attributes (.zattrs)")
-  
-  if (!is.null(s3_client)) {
-    stop("no s3 support!")
-  } else {
-    zattrs <- read_json(zattrs_path, simplifyVector = TRUE)
-  }
-  return(zattrs)
-}
-
-#' Read the .zattrs file associated with a Zarr array or group
-#' 
-#' @param path A character vector of length 1. This provides the
-#'   path to a Zarr array or group. 
-#' @param new.zattrs a list inserted to .zattrs at the \code{path}.
-#' @param overwrite if TRUE, existing .zattrs elements will be overwritten by \code{new.zattrs}.
-#' 
-#' @importFrom jsonlite toJSON
-#'
-#' @export
-write_zattrs <- function(path, new.zattrs = list(), overwrite = TRUE){
-  path <- .normalize_array_path(path)
-  zattrs_path <- paste0(path, ".zattrs")
-  
-  if(is.null(names(new.zattrs)))
-    stop("list elements should be named")
-  
-  if("" %in% names(new.zattrs)){
-    message("Ignoring unnamed list elements")
-    new.zattrs <- new.zattrs[which(names(new.zattrs == ""))]
-  }
-  
-  if(file.exists(zattrs_path)){
-    old.zattrs <- read_json(zattrs_path)
-    if(overwrite){
-      old.zattrs <- old.zattrs[setdiff(names(old.zattrs), names(new.zattrs))]
-    } else {
-      new.zattrs <- new.zattrs[setdiff(names(new.zattrs), names(old.zattrs))] 
-    }
-    new.zattrs <- c(old.zattrs, new.zattrs)
-  }
-  
-  json <- .format_json(toJSON(new.zattrs, auto_unbox = TRUE, pretty = TRUE, null = "null"))
-  write(x = json, file = zattrs_path)
-}
 
 .replace_zarr <- function(name, path, replace, version = "v2")
 {
@@ -129,8 +67,14 @@ write_zattrs <- function(path, new.zattrs = list(), overwrite = TRUE){
 
 .make_zarr_group <- function(x, name, path, replace, version){
   # gd <- file.path(path, "points")
-  if(!dir.exists(path))
+  if(!dir.exists(path)) {
     dir.create(path)
+    switch(version,
+      v2 = write('{"zarr_format":2}', file = file.path(path, ".zgroup")),
+      v3 = write('{"zarr_format":3,"node_type":"group","attributes":{}}',
+                 file = file.path(path, "zarr.json"))
+    )
+  }
   ng <- file.path(path, name)
   if(replace){
     unlink(ng, recursive = TRUE)
@@ -145,46 +89,66 @@ write_zattrs <- function(path, new.zattrs = list(), overwrite = TRUE){
   return(ng)
 }
 
-#' Normalize a Zarr array path
-#'
-#' Taken from https://zarr.readthedocs.io/en/stable/spec/v2.html#logical-storage-paths
-#'
-#' @param path Character vector of length 1 giving the path to be normalised.
-#'
-#' @returns A character vector of length 1 containing the normalised path.
-#'
-#' @keywords Internal
-.normalize_array_path <- function(path) {
-  ## we strip the protocol because it gets messed up by the slash removal later
-  if (grepl(x = path, pattern = "^((https?://)|(s3://)).*$")) {
-    root <- gsub(x = path, pattern = "^((https?://)|(s3://)).*$", 
-                 replacement = "\\1")
-    path <- gsub(x = path, pattern = "^((https?://)|(s3://))(.*$)", 
-                 replacement = "\\4")
-  } else {
-    ## Replace all backward slash ("\\") with forward slash ("/")
-    path <- gsub(x = path, pattern = "\\", replacement = "/", fixed = TRUE)
-    path <- normalizePath(path, winslash = "/", mustWork = FALSE)
-    root <- gsub(x = path, "(^[[:alnum:]:.]*/)(.*)", replacement = "\\1")
-    path <- gsub(x = path, "(^[[:alnum:]:.]*/)(.*)", replacement = "\\2")
+
+# For zarr v3, OME-NGFF content (multiscales, omero, image-label) must be
+# nested under an "ome" key inside "attributes"; spatialdata_attrs stays at top.
+# If the metadata was read from a v3 store it already has "ome", so skip wrapping.
+.wrap_ome_for_v3 <- function(zattrs, version) {
+  if (version != "v3" || "ome" %in% names(zattrs)) return(as.list(zattrs))
+  ome_keys <- setdiff(names(zattrs), "spatialdata_attrs")
+  ome_content <- as.list(zattrs)[ome_keys]
+  # Strip v2-only fields from each multiscales entry
+  if (!is.null(ome_content$multiscales)) {
+    ome_content$multiscales <- lapply(ome_content$multiscales, function(ms) {
+      ms[setdiff(names(ms), c("version", "metadata"))]
+    })
   }
-  
-  ## Strip any leading "/" characters
-  path <- gsub(x = path, pattern = "^/", replacement = "", fixed = FALSE)
-  ## Strip any trailing "/" characters
-  path <- gsub(x = path, pattern = "/$", replacement = "", fixed = FALSE)
-  ## Collapse any sequence of more than one "/" character into a single "/" 
-  path <- gsub(x = path, pattern = "//*", replacement = "/", fixed = FALSE)
-  ## The key prefix is then obtained by appending a single "/" character to 
-  ## the normalized logical path.
-  path <- paste0(root, path, "/")
-  
-  return(path)
+  list(
+    ome = c(list(version = "0.5-dev-spatialdata"), ome_content),
+    spatialdata_attrs = zattrs[["spatialdata_attrs"]]
+  )
 }
 
-.format_json <- function(json) {
-  json <- gsub(x = json, pattern = "[", replacement = "[\n    ", fixed = TRUE)
-  json <- gsub(x = json, pattern = "],", replacement = "\n  ],", fixed = TRUE)
-  json <- gsub(x = json, pattern = ", ", replacement = ",\n    ", fixed = TRUE)
-  return(json)
-}
\ No newline at end of file
+.get_multiscale_axes <- function(zattrs) {
+  multiscales <- zattrs[["multiscales"]]
+  if (is.null(multiscales) && !is.null(zattrs[["ome"]]))
+    multiscales <- zattrs[["ome"]][["multiscales"]]
+  if (is.null(multiscales) || length(multiscales) == 0L) return(NULL)
+  axes <- multiscales[[1]][["axes"]]
+  if (is.null(axes) || length(axes) == 0L) return(NULL)
+  vapply(axes, `[[`, character(1), "name")
+}
+
+# Post-processes Rarr-written v3 array zarr.json:
+#   1. Sorts codecs to required order [array-array → array-bytes → bytes-bytes].
+#      Rarr currently serialises them as [transpose, zstd, bytes] which Python rejects.
+#   2. Adds "attributes": {} and "storage_transformers": [] which Python zarr expects
+#      but Rarr does not emit.
+# dimension_names are handled upstream by setting names(dimnames()) before write_zarr_array.
+.normalize_v3_array_metadata <- function(zarr_array_path) {
+  metadata_path <- file.path(zarr_array_path, "zarr.json")
+  if (!file.exists(metadata_path)) return(invisible(FALSE))
+
+  metadata <- jsonlite::read_json(metadata_path, simplifyVector = FALSE)
+  codecs <- metadata[["codecs"]]
+  if (!is.null(codecs) && length(codecs) > 1L) {
+    codec_names <- vapply(codecs, `[[`, character(1), "name")
+    codec_stage <- ifelse(
+      codec_names %in% "transpose", 1L,
+      ifelse(codec_names %in% c("bytes", "vlen-utf8", "vlen_utf8"), 2L, 3L)
+    )
+    metadata[["codecs"]] <- codecs[order(codec_stage)]
+  }
+
+  if (is.null(metadata[["attributes"]])) metadata[["attributes"]] <- list()
+  if (is.null(metadata[["storage_transformers"]])) metadata[["storage_transformers"]] <- list()
+
+  jsonlite::write_json(
+    metadata,
+    path = metadata_path,
+    auto_unbox = TRUE,
+    pretty = 4,
+    null = "null"
+  )
+  invisible(TRUE)
+}
diff --git a/README.md b/README.md
index 4ac6b05a..89f817af 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # `SpatialData`
 
+[![x](https://github.com/HelenaLC/SpatialData/actions/workflows/check-bioc.yml/badge.svg?branch=main&event=push)](https://github.com/HelenaLC/SpatialData/actions/workflows/check-bioc.yml)
+
 > for a demo of the class, see the [vignette](https://htmlpreview.github.io/?https://github.com/HelenaLC/SpatialData/blob/main/vignettes/SpatialData.html)
 
 > for visualization capabilites, see [`SpatialData.plot`](https://github.com/HelenaLC/SpatialData.plot)
diff --git a/inst/NEWS b/inst/NEWS
index d61edd0f..18c4e5df 100644
--- a/inst/NEWS
+++ b/inst/NEWS
@@ -1,3 +1,44 @@
+changes in version 0.99.29
+
+- revision of Zarr version-specific .zattrs handling
+- added Zarr v3 example dataset 'inst/extdata/blobs_v3'
+- reorganization of unit tests to facilitate v3-specific testing
+
+changes in version 0.99.28
+
+- validity checks for 'table' elements
+- fixed and reenable broken/skipped tests
+- spatialdata_attrs utilities (instance_key(), region_key(), region())
+
+changes in version 0.99.27
+
+- spatial queries (aka subsetting) by bounding box 
+  (all element types) or polygons (points and shapes),
+  including unit tests, documentation, visual examples
+- masking draft to aggregate information across layers
+  (image by label, point by shape, shape by shape;
+  the latter aggregates values in an associated table)
+
+changes in version 0.99.26
+
+- added unit tests for existing transformations
+- implemented minimal layer-wise validity checks
+  (Image/LabelArray and Shape/PointFrame elements)
+
+changes in version 0.99.25
+
+- improved Zattrs show method (cf., PR #117)
+- replace jsonlite::fromJSON() with Rarr::read_zarr_attributes()
+  for reading .zattrs & rewrite code-/test-base accordingly
+
+changes in version 0.99.24
+
+- ZarrArray imported by Bioconductor/ZarrArray
+- Rarr replaces pizzarr for importing tables via anndataR
+- anndataR replaces zellkonverter
+- update basilisk env to spatialdata==0.7.0
+- replace spatialdata.read with anndata.read_zarr to read tables
+
 changes in version 0.99.22
 
 - split off 'SpatialData.data'
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_image/0/c/0/0/0 b/inst/extdata/blobs_v3.zarr/images/blobs_image/0/c/0/0/0
new file mode 100644
index 00000000..30dae706
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/images/blobs_image/0/c/0/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_image/0/zarr.json b/inst/extdata/blobs_v3.zarr/images/blobs_image/0/zarr.json
new file mode 100644
index 00000000..ca44cb71
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/images/blobs_image/0/zarr.json
@@ -0,0 +1,49 @@
+{
+  "shape": [
+    3,
+    64,
+    64
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        3,
+        64,
+        64
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "c",
+    "y",
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_image/zarr.json b/inst/extdata/blobs_v3.zarr/images/blobs_image/zarr.json
new file mode 100644
index 00000000..daa726e2
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/images/blobs_image/zarr.json
@@ -0,0 +1,102 @@
+{
+  "attributes": {
+    "ome": {
+      "omero": {
+        "channels": [
+          {
+            "label": 0
+          },
+          {
+            "label": 1
+          },
+          {
+            "label": 2
+          }
+        ]
+      },
+      "version": "0.5-dev-spatialdata",
+      "multiscales": [
+        {
+          "datasets": [
+            {
+              "path": "0",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    1.0,
+                    1.0
+                  ]
+                }
+              ]
+            }
+          ],
+          "name": "/images/blobs_image",
+          "axes": [
+            {
+              "name": "c",
+              "type": "channel"
+            },
+            {
+              "name": "y",
+              "type": "space"
+            },
+            {
+              "name": "x",
+              "type": "space"
+            }
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "cyx",
+                "axes": [
+                  {
+                    "name": "c",
+                    "type": "channel"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "c",
+                    "type": "channel"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "spatialdata_attrs": {
+      "version": "0.3"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/0/c/0/0/0 b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/0/c/0/0/0
new file mode 100644
index 00000000..30dae706
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/0/c/0/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/0/zarr.json b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/0/zarr.json
new file mode 100644
index 00000000..724ab4cc
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/0/zarr.json
@@ -0,0 +1,44 @@
+{
+  "shape": [
+    3,
+    64,
+    64
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        3,
+        64,
+        64
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/1/c/0/0/0 b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/1/c/0/0/0
new file mode 100644
index 00000000..b685afc6
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/1/c/0/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/1/zarr.json b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/1/zarr.json
new file mode 100644
index 00000000..48c80911
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/1/zarr.json
@@ -0,0 +1,44 @@
+{
+  "shape": [
+    3,
+    32,
+    32
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        3,
+        32,
+        32
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/2/c/0/0/0 b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/2/c/0/0/0
new file mode 100644
index 00000000..48cbafdc
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/2/c/0/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/2/zarr.json b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/2/zarr.json
new file mode 100644
index 00000000..c33e2c1d
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/2/zarr.json
@@ -0,0 +1,44 @@
+{
+  "shape": [
+    3,
+    16,
+    16
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        3,
+        16,
+        16
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/zarr.json b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/zarr.json
new file mode 100644
index 00000000..8080f7d9
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/images/blobs_multiscale_image/zarr.json
@@ -0,0 +1,128 @@
+{
+  "attributes": {
+    "ome": {
+      "omero": {
+        "channels": [
+          {
+            "label": 0
+          },
+          {
+            "label": 1
+          },
+          {
+            "label": 2
+          }
+        ]
+      },
+      "version": "0.5-dev-spatialdata",
+      "multiscales": [
+        {
+          "datasets": [
+            {
+              "path": "0",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    1.0,
+                    1.0
+                  ]
+                }
+              ]
+            },
+            {
+              "path": "1",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    2.0,
+                    2.0
+                  ]
+                }
+              ]
+            },
+            {
+              "path": "2",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    4.0,
+                    4.0
+                  ]
+                }
+              ]
+            }
+          ],
+          "name": "/images/blobs_multiscale_image",
+          "axes": [
+            {
+              "name": "c",
+              "type": "channel"
+            },
+            {
+              "name": "y",
+              "type": "space"
+            },
+            {
+              "name": "x",
+              "type": "space"
+            }
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "cyx",
+                "axes": [
+                  {
+                    "name": "c",
+                    "type": "channel"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "c",
+                    "type": "channel"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "spatialdata_attrs": {
+      "version": "0.3"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/images/zarr.json b/inst/extdata/blobs_v3.zarr/images/zarr.json
new file mode 100644
index 00000000..d1f97dad
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/images/zarr.json
@@ -0,0 +1,5 @@
+{
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_labels/0/c/0/0 b/inst/extdata/blobs_v3.zarr/labels/blobs_labels/0/c/0/0
new file mode 100644
index 00000000..e6022913
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/labels/blobs_labels/0/c/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_labels/0/zarr.json b/inst/extdata/blobs_v3.zarr/labels/blobs_labels/0/zarr.json
new file mode 100644
index 00000000..dac77af5
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/labels/blobs_labels/0/zarr.json
@@ -0,0 +1,46 @@
+{
+  "shape": [
+    64,
+    64
+  ],
+  "data_type": "int16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        64,
+        64
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "dimension_names": [
+    "y",
+    "x"
+  ],
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_labels/zarr.json b/inst/extdata/blobs_v3.zarr/labels/blobs_labels/zarr.json
new file mode 100644
index 00000000..f68c3f89
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/labels/blobs_labels/zarr.json
@@ -0,0 +1,307 @@
+{
+  "attributes": {
+    "ome": {
+      "version": "0.5-dev-spatialdata",
+      "multiscales": [
+        {
+          "datasets": [
+            {
+              "path": "0",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    1.0
+                  ]
+                }
+              ]
+            }
+          ],
+          "name": "blobs_labels",
+          "axes": [
+            {
+              "name": "y",
+              "type": "space"
+            },
+            {
+              "name": "x",
+              "type": "space"
+            }
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "yx",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            },
+            {
+              "type": "scale",
+              "scale": [
+                3.0,
+                2.0
+              ],
+              "input": {
+                "name": "yx",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "scale",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            },
+            {
+              "type": "translation",
+              "translation": [
+                -50.0,
+                10.0
+              ],
+              "input": {
+                "name": "yx",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "translation",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            },
+            {
+              "type": "affine",
+              "affine": [
+                [
+                  20.0,
+                  10.0,
+                  30.0
+                ],
+                [
+                  50.0,
+                  40.0,
+                  60.0
+                ]
+              ],
+              "input": {
+                "name": "yx",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "affine",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            },
+            {
+              "type": "sequence",
+              "transformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    3.0,
+                    2.0
+                  ],
+                  "input": {
+                    "name": "yx",
+                    "axes": [
+                      {
+                        "name": "y",
+                        "type": "space",
+                        "unit": "unit"
+                      },
+                      {
+                        "name": "x",
+                        "type": "space",
+                        "unit": "unit"
+                      }
+                    ]
+                  },
+                  "output": {
+                    "name": "global",
+                    "axes": [
+                      {
+                        "name": "y",
+                        "type": "space",
+                        "unit": "unit"
+                      },
+                      {
+                        "name": "x",
+                        "type": "space",
+                        "unit": "unit"
+                      }
+                    ]
+                  }
+                },
+                {
+                  "type": "translation",
+                  "translation": [
+                    -50.0,
+                    10.0
+                  ],
+                  "input": {
+                    "name": "yx",
+                    "axes": [
+                      {
+                        "name": "y",
+                        "type": "space",
+                        "unit": "unit"
+                      },
+                      {
+                        "name": "x",
+                        "type": "space",
+                        "unit": "unit"
+                      }
+                    ]
+                  },
+                  "output": {
+                    "name": "global",
+                    "axes": [
+                      {
+                        "name": "y",
+                        "type": "space",
+                        "unit": "unit"
+                      },
+                      {
+                        "name": "x",
+                        "type": "space",
+                        "unit": "unit"
+                      }
+                    ]
+                  }
+                }
+              ],
+              "input": {
+                "name": "yx",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "sequence",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ],
+      "image-label": {
+        "version": "0.5"
+      }
+    },
+    "spatialdata_attrs": {
+      "version": "0.3"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/0/c/0/0 b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/0/c/0/0
new file mode 100644
index 00000000..e6022913
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/0/c/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/0/zarr.json b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/0/zarr.json
new file mode 100644
index 00000000..a573f4af
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/0/zarr.json
@@ -0,0 +1,42 @@
+{
+  "shape": [
+    64,
+    64
+  ],
+  "data_type": "int16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        64,
+        64
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/1/c/0/0 b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/1/c/0/0
new file mode 100644
index 00000000..826823f1
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/1/c/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/1/zarr.json b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/1/zarr.json
new file mode 100644
index 00000000..c5a39ce9
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/1/zarr.json
@@ -0,0 +1,42 @@
+{
+  "shape": [
+    32,
+    32
+  ],
+  "data_type": "int16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        32,
+        32
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/2/c/0/0 b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/2/c/0/0
new file mode 100644
index 00000000..3d9fa2dd
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/2/c/0/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/2/zarr.json b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/2/zarr.json
new file mode 100644
index 00000000..3dc5e399
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/2/zarr.json
@@ -0,0 +1,42 @@
+{
+  "shape": [
+    16,
+    16
+  ],
+  "data_type": "int16",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        16,
+        16
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/zarr.json b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/zarr.json
new file mode 100644
index 00000000..4a69969c
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/labels/blobs_multiscale_labels/zarr.json
@@ -0,0 +1,100 @@
+{
+  "attributes": {
+    "ome": {
+      "version": "0.5-dev-spatialdata",
+      "multiscales": [
+        {
+          "datasets": [
+            {
+              "path": "0",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    1.0,
+                    1.0
+                  ]
+                }
+              ]
+            },
+            {
+              "path": "1",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    2.0,
+                    2.0
+                  ]
+                }
+              ]
+            },
+            {
+              "path": "2",
+              "coordinateTransformations": [
+                {
+                  "type": "scale",
+                  "scale": [
+                    4.0,
+                    4.0
+                  ]
+                }
+              ]
+            }
+          ],
+          "name": "blobs_multiscale_labels",
+          "axes": [
+            {
+              "name": "y",
+              "type": "space"
+            },
+            {
+              "name": "x",
+              "type": "space"
+            }
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "yx",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "spatialdata_attrs": {
+      "version": "0.3"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/labels/zarr.json b/inst/extdata/blobs_v3.zarr/labels/zarr.json
new file mode 100644
index 00000000..51290556
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/labels/zarr.json
@@ -0,0 +1,12 @@
+{
+  "attributes": {
+    "ome": {
+      "labels": [
+        "blobs_labels",
+        "blobs_multiscale_labels"
+      ]
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/points/blobs_points/points.parquet/part.0.parquet b/inst/extdata/blobs_v3.zarr/points/blobs_points/points.parquet/part.0.parquet
new file mode 100644
index 00000000..5a95cc62
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/points/blobs_points/points.parquet/part.0.parquet differ
diff --git a/inst/extdata/blobs_v3.zarr/points/blobs_points/zarr.json b/inst/extdata/blobs_v3.zarr/points/blobs_points/zarr.json
new file mode 100644
index 00000000..889834a0
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/points/blobs_points/zarr.json
@@ -0,0 +1,51 @@
+{
+  "attributes": {
+    "encoding-type": "ngff:points",
+    "axes": [
+      "x",
+      "y"
+    ],
+    "coordinateTransformations": [
+      {
+        "type": "identity",
+        "input": {
+          "name": "xy",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        },
+        "output": {
+          "name": "global",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        }
+      }
+    ],
+    "spatialdata_attrs": {
+      "instance_key": "instance_id",
+      "feature_key": "genes",
+      "version": "0.2"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/points/zarr.json b/inst/extdata/blobs_v3.zarr/points/zarr.json
new file mode 100644
index 00000000..d1f97dad
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/points/zarr.json
@@ -0,0 +1,5 @@
+{
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/shapes/blobs_circles/shapes.parquet b/inst/extdata/blobs_v3.zarr/shapes/blobs_circles/shapes.parquet
new file mode 100644
index 00000000..0bfe0ec6
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/shapes/blobs_circles/shapes.parquet differ
diff --git a/inst/extdata/blobs_v3.zarr/shapes/blobs_circles/zarr.json b/inst/extdata/blobs_v3.zarr/shapes/blobs_circles/zarr.json
new file mode 100644
index 00000000..9a1f0a06
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/shapes/blobs_circles/zarr.json
@@ -0,0 +1,49 @@
+{
+  "attributes": {
+    "encoding-type": "ngff:shapes",
+    "axes": [
+      "x",
+      "y"
+    ],
+    "coordinateTransformations": [
+      {
+        "type": "identity",
+        "input": {
+          "name": "xy",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        },
+        "output": {
+          "name": "global",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        }
+      }
+    ],
+    "spatialdata_attrs": {
+      "version": "0.3"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/shapes/blobs_multipolygons/shapes.parquet b/inst/extdata/blobs_v3.zarr/shapes/blobs_multipolygons/shapes.parquet
new file mode 100644
index 00000000..86952e51
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/shapes/blobs_multipolygons/shapes.parquet differ
diff --git a/inst/extdata/blobs_v3.zarr/shapes/blobs_multipolygons/zarr.json b/inst/extdata/blobs_v3.zarr/shapes/blobs_multipolygons/zarr.json
new file mode 100644
index 00000000..9a1f0a06
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/shapes/blobs_multipolygons/zarr.json
@@ -0,0 +1,49 @@
+{
+  "attributes": {
+    "encoding-type": "ngff:shapes",
+    "axes": [
+      "x",
+      "y"
+    ],
+    "coordinateTransformations": [
+      {
+        "type": "identity",
+        "input": {
+          "name": "xy",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        },
+        "output": {
+          "name": "global",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        }
+      }
+    ],
+    "spatialdata_attrs": {
+      "version": "0.3"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/shapes/blobs_polygons/shapes.parquet b/inst/extdata/blobs_v3.zarr/shapes/blobs_polygons/shapes.parquet
new file mode 100644
index 00000000..0a1f1673
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/shapes/blobs_polygons/shapes.parquet differ
diff --git a/inst/extdata/blobs_v3.zarr/shapes/blobs_polygons/zarr.json b/inst/extdata/blobs_v3.zarr/shapes/blobs_polygons/zarr.json
new file mode 100644
index 00000000..9a1f0a06
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/shapes/blobs_polygons/zarr.json
@@ -0,0 +1,49 @@
+{
+  "attributes": {
+    "encoding-type": "ngff:shapes",
+    "axes": [
+      "x",
+      "y"
+    ],
+    "coordinateTransformations": [
+      {
+        "type": "identity",
+        "input": {
+          "name": "xy",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        },
+        "output": {
+          "name": "global",
+          "axes": [
+            {
+              "name": "x",
+              "type": "space",
+              "unit": "unit"
+            },
+            {
+              "name": "y",
+              "type": "space",
+              "unit": "unit"
+            }
+          ]
+        }
+      }
+    ],
+    "spatialdata_attrs": {
+      "version": "0.3"
+    }
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/shapes/zarr.json b/inst/extdata/blobs_v3.zarr/shapes/zarr.json
new file mode 100644
index 00000000..d1f97dad
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/shapes/zarr.json
@@ -0,0 +1,5 @@
+{
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/X/data/c/0 b/inst/extdata/blobs_v3.zarr/tables/table/X/data/c/0
new file mode 100644
index 00000000..1cafb41b
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/X/data/c/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/X/data/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/X/data/zarr.json
new file mode 100644
index 00000000..c9cc2cfc
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/X/data/zarr.json
@@ -0,0 +1,40 @@
+{
+  "shape": [
+    30
+  ],
+  "data_type": "float64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        30
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0.0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/X/indices/c/0 b/inst/extdata/blobs_v3.zarr/tables/table/X/indices/c/0
new file mode 100644
index 00000000..4ca94ff7
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/X/indices/c/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/X/indices/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/X/indices/zarr.json
new file mode 100644
index 00000000..18266fe6
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/X/indices/zarr.json
@@ -0,0 +1,40 @@
+{
+  "shape": [
+    30
+  ],
+  "data_type": "int32",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        30
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/X/indptr/c/0 b/inst/extdata/blobs_v3.zarr/tables/table/X/indptr/c/0
new file mode 100644
index 00000000..dce39b80
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/X/indptr/c/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/X/indptr/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/X/indptr/zarr.json
new file mode 100644
index 00000000..31decf2b
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/X/indptr/zarr.json
@@ -0,0 +1,40 @@
+{
+  "shape": [
+    11
+  ],
+  "data_type": "int32",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        11
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/X/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/X/zarr.json
new file mode 100644
index 00000000..f37c375c
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/X/zarr.json
@@ -0,0 +1,12 @@
+{
+  "attributes": {
+    "shape": [
+      10,
+      3
+    ],
+    "encoding-type": "csr_matrix",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/layers/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/layers/zarr.json
new file mode 100644
index 00000000..05cd3eb8
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/layers/zarr.json
@@ -0,0 +1,8 @@
+{
+  "attributes": {
+    "encoding-type": "dict",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/_index/c/0 b/inst/extdata/blobs_v3.zarr/tables/table/obs/_index/c/0
new file mode 100644
index 00000000..d3f50a2f
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/obs/_index/c/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/_index/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obs/_index/zarr.json
new file mode 100644
index 00000000..36548d79
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obs/_index/zarr.json
@@ -0,0 +1,41 @@
+{
+  "shape": [
+    10
+  ],
+  "data_type": "string",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        10
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": "",
+  "codecs": [
+    {
+      "name": "vlen-utf8",
+      "configuration": {}
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "string-array",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/instance_id/c/0 b/inst/extdata/blobs_v3.zarr/tables/table/obs/instance_id/c/0
new file mode 100644
index 00000000..8dbfad1d
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/obs/instance_id/c/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/instance_id/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obs/instance_id/zarr.json
new file mode 100644
index 00000000..1073667e
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obs/instance_id/zarr.json
@@ -0,0 +1,43 @@
+{
+  "shape": [
+    10
+  ],
+  "data_type": "int64",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        10
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes",
+      "configuration": {
+        "endian": "little"
+      }
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "array",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/region/categories/c/0 b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/categories/c/0
new file mode 100644
index 00000000..de92311e
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/categories/c/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/region/categories/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/categories/zarr.json
new file mode 100644
index 00000000..85fc95b1
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/categories/zarr.json
@@ -0,0 +1,41 @@
+{
+  "shape": [
+    1
+  ],
+  "data_type": "string",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        1
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": "",
+  "codecs": [
+    {
+      "name": "vlen-utf8",
+      "configuration": {}
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "string-array",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/region/codes/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/codes/zarr.json
new file mode 100644
index 00000000..85a8ca7d
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/codes/zarr.json
@@ -0,0 +1,40 @@
+{
+  "shape": [
+    10
+  ],
+  "data_type": "int8",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        10
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": 0,
+  "codecs": [
+    {
+      "name": "bytes"
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "array",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/region/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/zarr.json
new file mode 100644
index 00000000..0ac12c3a
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obs/region/zarr.json
@@ -0,0 +1,9 @@
+{
+  "attributes": {
+    "ordered": false,
+    "encoding-type": "categorical",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obs/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obs/zarr.json
new file mode 100644
index 00000000..b7c5909c
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obs/zarr.json
@@ -0,0 +1,13 @@
+{
+  "attributes": {
+    "column-order": [
+      "instance_id",
+      "region"
+    ],
+    "_index": "_index",
+    "encoding-type": "dataframe",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obsm/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obsm/zarr.json
new file mode 100644
index 00000000..05cd3eb8
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obsm/zarr.json
@@ -0,0 +1,8 @@
+{
+  "attributes": {
+    "encoding-type": "dict",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/obsp/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/obsp/zarr.json
new file mode 100644
index 00000000..05cd3eb8
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/obsp/zarr.json
@@ -0,0 +1,8 @@
+{
+  "attributes": {
+    "encoding-type": "dict",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/raw/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/raw/zarr.json
new file mode 100644
index 00000000..de573f69
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/raw/zarr.json
@@ -0,0 +1,36 @@
+{
+  "shape": [],
+  "data_type": "bool",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": []
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": false,
+  "codecs": [
+    {
+      "name": "bytes"
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "null",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/instance_key/c b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/instance_key/c
new file mode 100644
index 00000000..6bd76d81
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/instance_key/c differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/instance_key/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/instance_key/zarr.json
new file mode 100644
index 00000000..0a9eb931
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/instance_key/zarr.json
@@ -0,0 +1,37 @@
+{
+  "shape": [],
+  "data_type": "string",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": []
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": "",
+  "codecs": [
+    {
+      "name": "vlen-utf8",
+      "configuration": {}
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "string",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region/c b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region/c
new file mode 100644
index 00000000..de92311e
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region/c differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region/zarr.json
new file mode 100644
index 00000000..0a9eb931
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region/zarr.json
@@ -0,0 +1,37 @@
+{
+  "shape": [],
+  "data_type": "string",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": []
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": "",
+  "codecs": [
+    {
+      "name": "vlen-utf8",
+      "configuration": {}
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "string",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region_key/c b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region_key/c
new file mode 100644
index 00000000..99c3ca14
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region_key/c differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region_key/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region_key/zarr.json
new file mode 100644
index 00000000..0a9eb931
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/region_key/zarr.json
@@ -0,0 +1,37 @@
+{
+  "shape": [],
+  "data_type": "string",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": []
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": "",
+  "codecs": [
+    {
+      "name": "vlen-utf8",
+      "configuration": {}
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "string",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/zarr.json
new file mode 100644
index 00000000..05cd3eb8
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/uns/spatialdata_attrs/zarr.json
@@ -0,0 +1,8 @@
+{
+  "attributes": {
+    "encoding-type": "dict",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/uns/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/uns/zarr.json
new file mode 100644
index 00000000..05cd3eb8
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/uns/zarr.json
@@ -0,0 +1,8 @@
+{
+  "attributes": {
+    "encoding-type": "dict",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/var/_index/c/0 b/inst/extdata/blobs_v3.zarr/tables/table/var/_index/c/0
new file mode 100644
index 00000000..0d0349cc
Binary files /dev/null and b/inst/extdata/blobs_v3.zarr/tables/table/var/_index/c/0 differ
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/var/_index/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/var/_index/zarr.json
new file mode 100644
index 00000000..21ca57b6
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/var/_index/zarr.json
@@ -0,0 +1,41 @@
+{
+  "shape": [
+    3
+  ],
+  "data_type": "string",
+  "chunk_grid": {
+    "name": "regular",
+    "configuration": {
+      "chunk_shape": [
+        3
+      ]
+    }
+  },
+  "chunk_key_encoding": {
+    "name": "default",
+    "configuration": {
+      "separator": "/"
+    }
+  },
+  "fill_value": "",
+  "codecs": [
+    {
+      "name": "vlen-utf8",
+      "configuration": {}
+    },
+    {
+      "name": "zstd",
+      "configuration": {
+        "level": 0,
+        "checksum": false
+      }
+    }
+  ],
+  "attributes": {
+    "encoding-type": "string-array",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "array",
+  "storage_transformers": []
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/var/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/var/zarr.json
new file mode 100644
index 00000000..390d1856
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/var/zarr.json
@@ -0,0 +1,10 @@
+{
+  "attributes": {
+    "column-order": [],
+    "_index": "_index",
+    "encoding-type": "dataframe",
+    "encoding-version": "0.2.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/varm/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/varm/zarr.json
new file mode 100644
index 00000000..05cd3eb8
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/varm/zarr.json
@@ -0,0 +1,8 @@
+{
+  "attributes": {
+    "encoding-type": "dict",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/varp/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/varp/zarr.json
new file mode 100644
index 00000000..05cd3eb8
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/varp/zarr.json
@@ -0,0 +1,8 @@
+{
+  "attributes": {
+    "encoding-type": "dict",
+    "encoding-version": "0.1.0"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/table/zarr.json b/inst/extdata/blobs_v3.zarr/tables/table/zarr.json
new file mode 100644
index 00000000..02404661
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/table/zarr.json
@@ -0,0 +1,13 @@
+{
+  "attributes": {
+    "encoding-type": "anndata",
+    "encoding-version": "0.1.0",
+    "spatialdata-encoding-type": "ngff:regions_table",
+    "region": "blobs_labels",
+    "region_key": "region",
+    "instance_key": "instance_id",
+    "version": "0.2"
+  },
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/tables/zarr.json b/inst/extdata/blobs_v3.zarr/tables/zarr.json
new file mode 100644
index 00000000..d1f97dad
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/tables/zarr.json
@@ -0,0 +1,5 @@
+{
+  "attributes": {},
+  "zarr_format": 3,
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/inst/extdata/blobs_v3.zarr/zarr.json b/inst/extdata/blobs_v3.zarr/zarr.json
new file mode 100644
index 00000000..ccb8916d
--- /dev/null
+++ b/inst/extdata/blobs_v3.zarr/zarr.json
@@ -0,0 +1,1947 @@
+{
+  "attributes": {
+    "spatialdata_attrs": {
+      "version": "0.2",
+      "spatialdata_software_version": "0.7.2"
+    }
+  },
+  "zarr_format": 3,
+  "consolidated_metadata": {
+    "kind": "inline",
+    "must_understand": false,
+    "metadata": {
+      "images": {
+        "attributes": {},
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "labels": {
+        "attributes": {
+          "ome": {
+            "labels": [
+              "blobs_labels",
+              "blobs_multiscale_labels"
+            ]
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "points": {
+        "attributes": {},
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "shapes": {
+        "attributes": {},
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables": {
+        "attributes": {},
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "images/blobs_image": {
+        "attributes": {
+          "ome": {
+            "omero": {
+              "channels": [
+                {
+                  "label": 0
+                },
+                {
+                  "label": 1
+                },
+                {
+                  "label": 2
+                }
+              ]
+            },
+            "version": "0.5-dev-spatialdata",
+            "multiscales": [
+              {
+                "datasets": [
+                  {
+                    "path": "0",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          1.0,
+                          1.0,
+                          1.0
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                "name": "/images/blobs_image",
+                "axes": [
+                  {
+                    "name": "c",
+                    "type": "channel"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space"
+                  }
+                ],
+                "coordinateTransformations": [
+                  {
+                    "type": "identity",
+                    "input": {
+                      "name": "cyx",
+                      "axes": [
+                        {
+                          "name": "c",
+                          "type": "channel"
+                        },
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "global",
+                      "axes": [
+                        {
+                          "name": "c",
+                          "type": "channel"
+                        },
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            ]
+          },
+          "spatialdata_attrs": {
+            "version": "0.3"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "images/blobs_multiscale_image": {
+        "attributes": {
+          "ome": {
+            "omero": {
+              "channels": [
+                {
+                  "label": 0
+                },
+                {
+                  "label": 1
+                },
+                {
+                  "label": 2
+                }
+              ]
+            },
+            "version": "0.5-dev-spatialdata",
+            "multiscales": [
+              {
+                "datasets": [
+                  {
+                    "path": "0",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          1.0,
+                          1.0,
+                          1.0
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "path": "1",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          1.0,
+                          2.0,
+                          2.0
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "path": "2",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          1.0,
+                          4.0,
+                          4.0
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                "name": "/images/blobs_multiscale_image",
+                "axes": [
+                  {
+                    "name": "c",
+                    "type": "channel"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space"
+                  }
+                ],
+                "coordinateTransformations": [
+                  {
+                    "type": "identity",
+                    "input": {
+                      "name": "cyx",
+                      "axes": [
+                        {
+                          "name": "c",
+                          "type": "channel"
+                        },
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "global",
+                      "axes": [
+                        {
+                          "name": "c",
+                          "type": "channel"
+                        },
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            ]
+          },
+          "spatialdata_attrs": {
+            "version": "0.3"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "labels/blobs_labels": {
+        "attributes": {
+          "ome": {
+            "version": "0.5-dev-spatialdata",
+            "multiscales": [
+              {
+                "datasets": [
+                  {
+                    "path": "0",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          1.0,
+                          1.0
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                "name": "blobs_labels",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space"
+                  }
+                ],
+                "coordinateTransformations": [
+                  {
+                    "type": "identity",
+                    "input": {
+                      "name": "yx",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "global",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "type": "scale",
+                    "scale": [
+                      3.0,
+                      2.0
+                    ],
+                    "input": {
+                      "name": "yx",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "scale",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "type": "translation",
+                    "translation": [
+                      -50.0,
+                      10.0
+                    ],
+                    "input": {
+                      "name": "yx",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "translation",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "type": "affine",
+                    "affine": [
+                      [
+                        20.0,
+                        10.0,
+                        30.0
+                      ],
+                      [
+                        50.0,
+                        40.0,
+                        60.0
+                      ]
+                    ],
+                    "input": {
+                      "name": "yx",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "affine",
+                      "axes": [
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    "type": "sequence",
+                    "transformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          3.0,
+                          2.0
+                        ],
+                        "input": {
+                          "name": "yx",
+                          "axes": [
+                            {
+                              "name": "y",
+                              "type": "space",
+                              "unit": "unit"
+                            },
+                            {
+                              "name": "x",
+                              "type": "space",
+                              "unit": "unit"
+                            }
+                          ]
+                        },
+                        "output": {
+                          "name": "global",
+                          "axes": [
+                            {
+                              "name": "y",
+                              "type": "space",
+                              "unit": "unit"
+                            },
+                            {
+                              "name": "x",
+                              "type": "space",
+                              "unit": "unit"
+                            }
+                          ]
+                        }
+                      },
+                      {
+                        "type": "translation",
+                        "translation": [
+                          -50.0,
+                          10.0
+                        ],
+                        "input": {
+                          "name": "yx",
+                          "axes": [
+                            {
+                              "name": "y",
+                              "type": "space",
+                              "unit": "unit"
+                            },
+                            {
+                              "name": "x",
+                              "type": "space",
+                              "unit": "unit"
+                            }
+                          ]
+                        },
+                        "output": {
+                          "name": "global",
+                          "axes": [
+                            {
+                              "name": "y",
+                              "type": "space",
+                              "unit": "unit"
+                            },
+                            {
+                              "name": "x",
+                              "type": "space",
+                              "unit": "unit"
+                            }
+                          ]
+                        }
+                      }
+                    ],
+                    "input": {
+                      "name": "yx",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "sequence",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            ],
+            "image-label": {
+              "version": "0.5"
+            }
+          },
+          "spatialdata_attrs": {
+            "version": "0.3"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "labels/blobs_multiscale_labels": {
+        "attributes": {
+          "ome": {
+            "version": "0.5-dev-spatialdata",
+            "multiscales": [
+              {
+                "datasets": [
+                  {
+                    "path": "0",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          1.0,
+                          1.0
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "path": "1",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          2.0,
+                          2.0
+                        ]
+                      }
+                    ]
+                  },
+                  {
+                    "path": "2",
+                    "coordinateTransformations": [
+                      {
+                        "type": "scale",
+                        "scale": [
+                          4.0,
+                          4.0
+                        ]
+                      }
+                    ]
+                  }
+                ],
+                "name": "blobs_multiscale_labels",
+                "axes": [
+                  {
+                    "name": "y",
+                    "type": "space"
+                  },
+                  {
+                    "name": "x",
+                    "type": "space"
+                  }
+                ],
+                "coordinateTransformations": [
+                  {
+                    "type": "identity",
+                    "input": {
+                      "name": "yx",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    },
+                    "output": {
+                      "name": "global",
+                      "axes": [
+                        {
+                          "name": "y",
+                          "type": "space",
+                          "unit": "unit"
+                        },
+                        {
+                          "name": "x",
+                          "type": "space",
+                          "unit": "unit"
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            ]
+          },
+          "spatialdata_attrs": {
+            "version": "0.3"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "points/blobs_points": {
+        "attributes": {
+          "encoding-type": "ngff:points",
+          "axes": [
+            "x",
+            "y"
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "xy",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ],
+          "spatialdata_attrs": {
+            "instance_key": "instance_id",
+            "feature_key": "genes",
+            "version": "0.2"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "shapes/blobs_circles": {
+        "attributes": {
+          "encoding-type": "ngff:shapes",
+          "axes": [
+            "x",
+            "y"
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "xy",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ],
+          "spatialdata_attrs": {
+            "version": "0.3"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "shapes/blobs_multipolygons": {
+        "attributes": {
+          "encoding-type": "ngff:shapes",
+          "axes": [
+            "x",
+            "y"
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "xy",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ],
+          "spatialdata_attrs": {
+            "version": "0.3"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "shapes/blobs_polygons": {
+        "attributes": {
+          "encoding-type": "ngff:shapes",
+          "axes": [
+            "x",
+            "y"
+          ],
+          "coordinateTransformations": [
+            {
+              "type": "identity",
+              "input": {
+                "name": "xy",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              },
+              "output": {
+                "name": "global",
+                "axes": [
+                  {
+                    "name": "x",
+                    "type": "space",
+                    "unit": "unit"
+                  },
+                  {
+                    "name": "y",
+                    "type": "space",
+                    "unit": "unit"
+                  }
+                ]
+              }
+            }
+          ],
+          "spatialdata_attrs": {
+            "version": "0.3"
+          }
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table": {
+        "attributes": {
+          "encoding-type": "anndata",
+          "encoding-version": "0.1.0",
+          "spatialdata-encoding-type": "ngff:regions_table",
+          "region": "blobs_labels",
+          "region_key": "region",
+          "instance_key": "instance_id",
+          "version": "0.2"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "images/blobs_image/0": {
+        "shape": [
+          3,
+          64,
+          64
+        ],
+        "data_type": "float64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              3,
+              64,
+              64
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0.0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "c",
+          "y",
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "images/blobs_multiscale_image/0": {
+        "shape": [
+          3,
+          64,
+          64
+        ],
+        "data_type": "float64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              3,
+              64,
+              64
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0.0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "images/blobs_multiscale_image/1": {
+        "shape": [
+          3,
+          32,
+          32
+        ],
+        "data_type": "float64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              3,
+              32,
+              32
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0.0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "images/blobs_multiscale_image/2": {
+        "shape": [
+          3,
+          16,
+          16
+        ],
+        "data_type": "float64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              3,
+              16,
+              16
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0.0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "labels/blobs_labels/0": {
+        "shape": [
+          64,
+          64
+        ],
+        "data_type": "int16",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              64,
+              64
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "dimension_names": [
+          "y",
+          "x"
+        ],
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "labels/blobs_multiscale_labels/0": {
+        "shape": [
+          64,
+          64
+        ],
+        "data_type": "int16",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              64,
+              64
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "labels/blobs_multiscale_labels/1": {
+        "shape": [
+          32,
+          32
+        ],
+        "data_type": "int16",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              32,
+              32
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "labels/blobs_multiscale_labels/2": {
+        "shape": [
+          16,
+          16
+        ],
+        "data_type": "int16",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              16,
+              16
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/layers": {
+        "attributes": {
+          "encoding-type": "dict",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/obs": {
+        "attributes": {
+          "column-order": [
+            "instance_id",
+            "region"
+          ],
+          "_index": "_index",
+          "encoding-type": "dataframe",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/obsm": {
+        "attributes": {
+          "encoding-type": "dict",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/obsp": {
+        "attributes": {
+          "encoding-type": "dict",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/raw": {
+        "shape": [],
+        "data_type": "bool",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": []
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": false,
+        "codecs": [
+          {
+            "name": "bytes"
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "null",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/uns": {
+        "attributes": {
+          "encoding-type": "dict",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/var": {
+        "attributes": {
+          "column-order": [],
+          "_index": "_index",
+          "encoding-type": "dataframe",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/varm": {
+        "attributes": {
+          "encoding-type": "dict",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/varp": {
+        "attributes": {
+          "encoding-type": "dict",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/X": {
+        "attributes": {
+          "shape": [
+            10,
+            3
+          ],
+          "encoding-type": "csr_matrix",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/obs/_index": {
+        "shape": [
+          10
+        ],
+        "data_type": "string",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              10
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": "",
+        "codecs": [
+          {
+            "name": "vlen-utf8",
+            "configuration": {}
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "string-array",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/obs/instance_id": {
+        "shape": [
+          10
+        ],
+        "data_type": "int64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              10
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "array",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/obs/region": {
+        "attributes": {
+          "ordered": false,
+          "encoding-type": "categorical",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/uns/spatialdata_attrs": {
+        "attributes": {
+          "encoding-type": "dict",
+          "encoding-version": "0.1.0"
+        },
+        "zarr_format": 3,
+        "consolidated_metadata": {
+          "kind": "inline",
+          "must_understand": false,
+          "metadata": {}
+        },
+        "node_type": "group"
+      },
+      "tables/table/var/_index": {
+        "shape": [
+          3
+        ],
+        "data_type": "string",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              3
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": "",
+        "codecs": [
+          {
+            "name": "vlen-utf8",
+            "configuration": {}
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "string-array",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/X/data": {
+        "shape": [
+          30
+        ],
+        "data_type": "float64",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              30
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0.0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/X/indices": {
+        "shape": [
+          30
+        ],
+        "data_type": "int32",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              30
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/X/indptr": {
+        "shape": [
+          11
+        ],
+        "data_type": "int32",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              11
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes",
+            "configuration": {
+              "endian": "little"
+            }
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {},
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/obs/region/categories": {
+        "shape": [
+          1
+        ],
+        "data_type": "string",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              1
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": "",
+        "codecs": [
+          {
+            "name": "vlen-utf8",
+            "configuration": {}
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "string-array",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/obs/region/codes": {
+        "shape": [
+          10
+        ],
+        "data_type": "int8",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": [
+              10
+            ]
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": 0,
+        "codecs": [
+          {
+            "name": "bytes"
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "array",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/uns/spatialdata_attrs/instance_key": {
+        "shape": [],
+        "data_type": "string",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": []
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": "",
+        "codecs": [
+          {
+            "name": "vlen-utf8",
+            "configuration": {}
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "string",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/uns/spatialdata_attrs/region": {
+        "shape": [],
+        "data_type": "string",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": []
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": "",
+        "codecs": [
+          {
+            "name": "vlen-utf8",
+            "configuration": {}
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "string",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      },
+      "tables/table/uns/spatialdata_attrs/region_key": {
+        "shape": [],
+        "data_type": "string",
+        "chunk_grid": {
+          "name": "regular",
+          "configuration": {
+            "chunk_shape": []
+          }
+        },
+        "chunk_key_encoding": {
+          "name": "default",
+          "configuration": {
+            "separator": "/"
+          }
+        },
+        "fill_value": "",
+        "codecs": [
+          {
+            "name": "vlen-utf8",
+            "configuration": {}
+          },
+          {
+            "name": "zstd",
+            "configuration": {
+              "level": 0,
+              "checksum": false
+            }
+          }
+        ],
+        "attributes": {
+          "encoding-type": "string",
+          "encoding-version": "0.2.0"
+        },
+        "zarr_format": 3,
+        "node_type": "array",
+        "storage_transformers": []
+      }
+    }
+  },
+  "node_type": "group"
+}
\ No newline at end of file
diff --git a/man/CTgraph.Rd b/man/CTgraph.Rd
new file mode 100644
index 00000000..5892ad88
--- /dev/null
+++ b/man/CTgraph.Rd
@@ -0,0 +1,76 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/CTgraph.R
+\name{CTgraph}
+\alias{CTgraph}
+\alias{CTpath}
+\alias{CTplot}
+\alias{CTgraph,SpatialData-method}
+\alias{CTgraph,SpatialDataElement-method}
+\alias{CTgraph,ANY-method}
+\alias{CTpath,SpatialData-method}
+\alias{CTpath,SpatialDataElement-method}
+\alias{CTpath,ANY-method}
+\title{Coord. trans. graph}
+\usage{
+\S4method{CTgraph}{SpatialData}(x)
+
+\S4method{CTgraph}{SpatialDataElement}(x)
+
+\S4method{CTgraph}{ANY}(x)
+
+\S4method{CTpath}{SpatialData}(x, i, j)
+
+\S4method{CTpath}{SpatialDataElement}(x, j)
+
+\S4method{CTpath}{ANY}(x)
+
+CTplot(g, cex = 0.5, fac = 2, max = 10)
+}
+\arguments{
+\item{x}{\code{SpatialData}, an element, or \code{Zattrs}.}
+
+\item{i}{character string; name of source node.}
+
+\item{j}{character string; name of target coordinate space.}
+
+\item{g}{base R graph; extracted with \code{CTgraph}.}
+
+\item{cex}{scalar numeric; controls fontsize of node labels.}
+
+\item{fac, max}{scalar numeric; node labels with \code{nchar>max}
+are split and hyphenated at position \code{floor(nchar/fac)}}
+}
+\value{
+\itemize{
+\item \code{CTgraph}: 
+  \code{graph::graphAM} object with nodes for each element and
+  coordinate space, and edges for each transformation (if specified)
+\item \code{CTpath}: 
+  list of transformations from \code{i} to \code{j};
+  length > 1 if \code{type} is \code{"sequential"}, length-1 otherwise;
+  each element specifies \code{type} and \code{data} of the transformation
+\item \code{CTplot}: 
+  visualizes the element-coordinate space graph with \code{Rgraphviz}
+}
+}
+\description{
+Coord. trans. graph
+}
+\examples{
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- readSpatialData(x, tables=FALSE)
+
+# object-wide
+g <- CTgraph(x)
+CTplot(g)   
+
+# one element
+y <- label(x)
+g <- CTgraph(y)
+CTplot(g) 
+
+# retrieve transformation(s) 
+# from element to target space
+CTpath(x, "blobs_labels", "sequence")
+}
diff --git a/man/coord-utils.Rd b/man/CTutils.Rd
similarity index 57%
rename from man/coord-utils.Rd
rename to man/CTutils.Rd
index a321588a..a04efc4b 100644
--- a/man/coord-utils.Rd
+++ b/man/CTutils.Rd
@@ -1,62 +1,52 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/coord_utils.R
-\name{coord-utils}
-\alias{coord-utils}
+% Please edit documentation in R/CTutils.R
+\name{CTutils}
+\alias{CTutils}
 \alias{axes}
+\alias{CTlist}
 \alias{CTname}
 \alias{CTtype}
 \alias{CTdata}
-\alias{CTpath}
-\alias{CTgraph}
 \alias{addCT}
 \alias{rmvCT}
 \alias{axes,Zattrs-method}
 \alias{axes,SpatialDataElement-method}
+\alias{CTlist,Zattrs-method}
 \alias{CTdata,Zattrs-method}
-\alias{CTdata,SpatialDataElement-method}
 \alias{CTtype,Zattrs-method}
-\alias{CTtype,SpatialDataElement-method}
 \alias{CTname,Zattrs-method}
+\alias{CTlist,SpatialDataElement-method}
+\alias{CTdata,SpatialDataElement-method}
+\alias{CTtype,SpatialDataElement-method}
 \alias{CTname,SpatialDataElement-method}
 \alias{CTname,SpatialData-method}
-\alias{CTgraph,SpatialData-method}
-\alias{CTgraph,SpatialDataElement-method}
-\alias{CTgraph,ANY-method}
-\alias{CTpath,SpatialData-method}
-\alias{CTpath,SpatialDataElement-method}
 \alias{rmvCT,SpatialDataElement-method}
 \alias{rmvCT,Zattrs-method}
 \alias{addCT,SpatialDataElement-method}
 \alias{addCT,Zattrs-method}
-\title{Coordinate transformations}
+\title{Coord. trans. utilities}
 \usage{
 \S4method{axes}{Zattrs}(x, ...)
 
 \S4method{axes}{SpatialDataElement}(x, ...)
 
-\S4method{CTdata}{Zattrs}(x, ...)
+\S4method{CTlist}{Zattrs}(x, ...)
 
-\S4method{CTdata}{SpatialDataElement}(x, ...)
+\S4method{CTdata}{Zattrs}(x, i = 1, ...)
 
 \S4method{CTtype}{Zattrs}(x, ...)
 
-\S4method{CTtype}{SpatialDataElement}(x, ...)
-
 \S4method{CTname}{Zattrs}(x, ...)
 
-\S4method{CTname}{SpatialDataElement}(x, ...)
-
-\S4method{CTname}{SpatialData}(x, ...)
-
-\S4method{CTgraph}{SpatialData}(x)
+\S4method{CTlist}{SpatialDataElement}(x, ...)
 
-\S4method{CTgraph}{SpatialDataElement}(x)
+\S4method{CTdata}{SpatialDataElement}(x, i = 1, ...)
 
-\S4method{CTgraph}{ANY}(x)
+\S4method{CTtype}{SpatialDataElement}(x, ...)
 
-\S4method{CTpath}{SpatialData}(x, i, j)
+\S4method{CTname}{SpatialDataElement}(x, ...)
 
-\S4method{CTpath}{SpatialDataElement}(x, j)
+\S4method{CTname}{SpatialData}(x, ...)
 
 \S4method{rmvCT}{SpatialDataElement}(x, i)
 
@@ -74,8 +64,6 @@
 \item{i}{for \code{CTpath}, source node label; else, string or 
 scalar integer giving the name or index of a coordinate space.}
 
-\item{j}{character string; name of target coordinate space.}
-
 \item{name}{character(1); name of coordinate space}
 
 \item{type}{character(1); type of transformation}
@@ -83,35 +71,41 @@ scalar integer giving the name or index of a coordinate space.}
 \item{data}{transformation data; size and shape depend on transformation and
 element type (e.g., numeric(1) for rotation, numeric(2) for scaling in 2D)}
 }
+\value{
+\itemize{
+\item \code{CTname}: character string; 
+  transformation name (e.g., "global")
+\item \code{CTtype}: character string; 
+  transformation type (e.g., "affine")
+\item \code{CTdata}: list;
+  transformation data (e.g., scalar numeric for rotation)
+\item \code{CTlist}: list;
+  list of transformation specifications per OME-NGFF spec
+\item \code{add/rmvCT}: 
+  \code{SpatialDataElement} or \code{Zattrs} 
+  with transformation(s) added/removed
+\item \code{axes}: list; 
+  each element is a character string (name), or list 
+  with axis name and type (e.g., "space" or "channel")
+}
+}
 \description{
-Coordinate transformations
+Coord. trans. utilities
 }
 \examples{
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
 x <- readSpatialData(x, tables=FALSE)
 
-# element-wise
-g <- CTgraph(y <- image(x))
-graph::nodes(g)
-CTpath(y, "global")
-
-# object-wide
-g <- CTgraph(x)
-plotCoordGraph(g)
-
-# retrieve transformation from element to target space
-CTpath(x, "blobs_labels", "sequence")
-
-# view available coordinate transformations
-CTdata(z <- meta(label(x)))
+# view available target coordinate systems
+CTname(z <- meta(label(x)))
 
 # add
-addCT(z, "scale", "scale", c(12, 34)) # can't overwrite
-CTdata(addCT(z, "new", "translation", c(12, 34)))
+addCT(z, "scale", "scale", c(12, 34)) # overwrite
+CTname(addCT(z, "new", "translation", c(12, 34)))
 
 # rmv
-CTdata(rmvCT(z, 2)) # by index
-CTdata(rmvCT(z, "scale")) # by name
-CTdata(rmvCT(z, 1)) # identity is protected
+CTname(rmvCT(z, 2))        # by index
+CTname(rmvCT(z, "scale"))  # by name
+CTname(rmvCT(z, "global")) # identity is protected
 }
diff --git a/man/ImageArray.Rd b/man/ImageArray.Rd
index cfdf1669..1ed003ed 100644
--- a/man/ImageArray.Rd
+++ b/man/ImageArray.Rd
@@ -2,8 +2,9 @@
 % Please edit documentation in R/ImageArray.R
 \name{ImageArray}
 \alias{ImageArray}
-\alias{channels,ImageArray-method}
+\alias{channels,Zattrs-method}
 \alias{channels}
+\alias{channels,ImageArray-method}
 \alias{channels,ANY-method}
 \alias{[,ImageArray,ANY,ANY,ANY-method}
 \title{The `ImageArray` class}
@@ -17,6 +18,8 @@ ImageArray(
   ...
 )
 
+\S4method{channels}{Zattrs}(x, ...)
+
 \S4method{channels}{ImageArray}(x, ...)
 
 \S4method{channels}{ANY}(x, ...)
@@ -24,7 +27,7 @@ ImageArray(
 \S4method{[}{ImageArray,ANY,ANY,ANY}(x, i, j, k, ..., drop = FALSE)
 }
 \arguments{
-\item{data}{list of \code{\link[Rarr]{ZarrArray}}s}
+\item{data}{list of \code{\link[ZarrArray]{ZarrArray}}s}
 
 \item{meta}{\code{\link{Zattrs}}}
 
@@ -54,9 +57,8 @@ The `ImageArray` class
 }
 \examples{
 library(SpatialData.data)
-dir.create(td <- tempfile())
-pa <- SpatialData.data:::.unzip_merfish_demo(td)
-pa <- file.path(pa, "images", "rasterized")
+zs <- get_demo_SDdata("merfish")
+pa <- file.path(zs, "images", "rasterized")
 (ia <- readImage(pa))
 
 }
diff --git a/man/LabelArray.Rd b/man/LabelArray.Rd
index 1ff66b5e..6a480e2b 100644
--- a/man/LabelArray.Rd
+++ b/man/LabelArray.Rd
@@ -6,7 +6,7 @@
 \title{The \code{LabelArray} class}
 \usage{
 LabelArray(
-  data = array(),
+  data = list(),
   meta = Zattrs(),
   metadata = list(),
   multiscale = FALSE,
@@ -17,7 +17,7 @@ LabelArray(
 \S4method{[}{LabelArray,ANY,ANY,ANY}(x, i, j, ..., drop = FALSE)
 }
 \arguments{
-\item{data}{list of \code{\link[Rarr]{ZarrArray}}s}
+\item{data}{list of \code{\link[ZarrArray]{ZarrArray}}s}
 
 \item{meta}{\code{\link{Zattrs}}}
 
@@ -53,6 +53,12 @@ Currently defined methods (here, \code{x} is a \code{LabelArray}):
 }
 }
 \examples{
-# TODO
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- file.path(x, "labels", "blobs_labels")
+
+(y <- readLabel(x))
+y[1:10, 1:10]
+meta(y)
 
 }
diff --git a/man/PointFrame.Rd b/man/PointFrame.Rd
index b2a140b0..1830a9b2 100644
--- a/man/PointFrame.Rd
+++ b/man/PointFrame.Rd
@@ -79,9 +79,8 @@ Currently defined methods (here, \code{x} is a \code{PointFrame}):
 }
 \examples{
 library(SpatialData.data)
-dir.create(tf <- tempfile())
-base <- SpatialData.data:::.unzip_merfish_demo(tf)
-x <- file.path(base, "points", "single_molecule")
+zs <- get_demo_SDdata("merfish")
+x <- file.path(zs, "points", "single_molecule")
 (p <- readPoint(x))
 
 head(as.data.frame(data(p)))
diff --git a/man/SDattrs.Rd b/man/SDattrs.Rd
new file mode 100644
index 00000000..c5cb65ae
--- /dev/null
+++ b/man/SDattrs.Rd
@@ -0,0 +1,54 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/Zattrs.R
+\name{SDattrs}
+\alias{SDattrs}
+\alias{region}
+\alias{region_key}
+\alias{feature_key}
+\alias{instance_key}
+\alias{feature_key,list-method}
+\alias{feature_key,PointFrame-method}
+\alias{region_key,SingleCellExperiment-method}
+\alias{region,SingleCellExperiment-method}
+\alias{instance_key,list-method}
+\alias{instance_key,PointFrame-method}
+\alias{instance_key,SingleCellExperiment-method}
+\title{\code{SpatialData} attributes}
+\usage{
+\S4method{feature_key}{list}(x)
+
+\S4method{feature_key}{PointFrame}(x)
+
+\S4method{region_key}{SingleCellExperiment}(x)
+
+\S4method{region}{SingleCellExperiment}(x)
+
+\S4method{instance_key}{list}(x)
+
+\S4method{instance_key}{PointFrame}(x)
+
+\S4method{instance_key}{SingleCellExperiment}(x)
+}
+\arguments{
+\item{x}{depends on which attributes are available; 
+specifically, \code{PointFrame} (\code{feature/instance_key}), or
+\code{SingleCellExperiment} (\code{region}, \code{region/instance_key}),}
+}
+\value{
+character string
+}
+\description{
+\code{SpatialData} attributes
+}
+\examples{
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- readSpatialData(x, anndataR=TRUE)
+
+region(table(x))
+region_key(table(x))
+
+instance_key(point(x))
+fk <- feature_key(point(x))
+base::table(point(x)[[fk]])
+}
diff --git a/man/ShapeFrame.Rd b/man/ShapeFrame.Rd
index bb940c2d..e69d3efc 100644
--- a/man/ShapeFrame.Rd
+++ b/man/ShapeFrame.Rd
@@ -2,10 +2,13 @@
 % Please edit documentation in R/ShapeFrame.R
 \name{ShapeFrame}
 \alias{ShapeFrame}
+\alias{geom_type}
 \alias{dim,ShapeFrame-method}
 \alias{length,ShapeFrame-method}
 \alias{names,ShapeFrame-method}
+\alias{.DollarNames.ShapeFrame}
 \alias{$,ShapeFrame-method}
+\alias{geom_type,ShapeFrame-method}
 \alias{[,ShapeFrame,missing,ANY,ANY-method}
 \alias{[,ShapeFrame,ANY,missing,ANY-method}
 \alias{[,ShapeFrame,missing,missing,ANY-method}
@@ -20,8 +23,12 @@ ShapeFrame(data = data.frame(), meta = Zattrs(), metadata = list(), ...)
 
 \S4method{names}{ShapeFrame}(x)
 
+\method{.DollarNames}{ShapeFrame}(x, pattern = "")
+
 \S4method{$}{ShapeFrame}(x, name)
 
+\S4method{geom_type}{ShapeFrame}(x)
+
 \S4method{[}{ShapeFrame,missing,ANY,ANY}(x, i, j, ..., drop = TRUE)
 
 \S4method{[}{ShapeFrame,ANY,missing,ANY}(x, i, j, ..., drop = TRUE)
@@ -47,7 +54,7 @@ content describing the overall object.}
 
 \item{i, j}{indices specifying elements to extract.}
 
-\item{drop}{ignored.}
+\item{drop, pattern}{ignored.}
 }
 \value{
 \code{ShapeFrame}
@@ -57,13 +64,13 @@ The `ShapeFrame` class
 }
 \examples{
 library(SpatialData.data)
-dir.create(tf <- tempfile())
-base <- SpatialData.data:::.unzip_merfish_demo(tf)
-y <- file.path(base, "shapes", "cells")
+zs <- get_demo_SDdata("merfish")
+
+y <- file.path(zs, "shapes", "cells")
 (s <- readShape(y))
 plot(sf::st_as_sf(data(s)), cex=0.2)
 
-y <- file.path(base, "shapes", "anatomical")
+y <- file.path(zs, "shapes", "anatomical")
 (s <- readShape(y))
 plot(sf::st_as_sf(data(s)), cex=0.2)
 
diff --git a/man/SpatialData.Rd b/man/SpatialData.Rd
index e760cfd6..671a894f 100644
--- a/man/SpatialData.Rd
+++ b/man/SpatialData.Rd
@@ -34,6 +34,8 @@
 \alias{table<-}
 \alias{tables<-}
 \alias{tableNames}
+\alias{[[<-,SpatialData,character,ANY-method}
+\alias{[[<-,SpatialData,numeric,ANY-method}
 \alias{$,SpatialData-method}
 \alias{[[,SpatialData,numeric,ANY-method}
 \alias{[[,SpatialData,character,ANY-method}
@@ -50,8 +52,6 @@
 \alias{element,SpatialData,ANY,numeric-method}
 \alias{element,SpatialData,ANY,missing-method}
 \alias{element,SpatialData,ANY,ANY-method}
-\alias{[[<-,SpatialData,numeric,ANY-method}
-\alias{[[<-,SpatialData,character,ANY-method}
 \title{The `SpatialData` class}
 \usage{
 SpatialData(images, labels, points, shapes, tables)
@@ -126,7 +126,7 @@ or NULL/\code{list()} to remove an element/layer completely.}
 \examples{
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
-(x <- readSpatialData(x, anndataR=FALSE))
+(x <- readSpatialData(x, anndataR=TRUE))
 
 # subsetting
 # layers are taken in order of appearance
diff --git a/man/Zattrs.Rd b/man/Zattrs.Rd
index b736e2e7..49a06fae 100644
--- a/man/Zattrs.Rd
+++ b/man/Zattrs.Rd
@@ -25,10 +25,12 @@ x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
 x <- readSpatialData(x, tables=FALSE)
 
-z <- meta(label(x))
-axes(z) 
-CTdata(z)
+(z <- meta(label(x)))
+
 CTname(z)
 CTtype(z)
+CTdata(z, "scale")
+
+feature_key(point(x))
 
 }
diff --git a/man/blobs.Rd b/man/blobs.Rd
index 1aad2796..9cd4b024 100644
--- a/man/blobs.Rd
+++ b/man/blobs.Rd
@@ -3,6 +3,9 @@
 \name{blobs}
 \alias{blobs}
 \title{`SpatialData` .zarr toy datasets}
+\value{
+zarr store.
+}
 \description{
 data were retrieved on Nov. 11th, 2024, from \href{https://github.com/scverse/spatialdata-notebooks/tree/main/notebooks/developers_resources/storage_format/multiple_elements.zarr}{here}.
 }
diff --git a/man/do_tx_to_ext.Rd b/man/do_tx_to_ext.Rd
index 198d6149..47c8656c 100644
--- a/man/do_tx_to_ext.Rd
+++ b/man/do_tx_to_ext.Rd
@@ -17,17 +17,23 @@ do_tx_to_ext(srcdir, dest, coordinate_system, ...)
 can include "maintain_positioning" (logical (1)) or numerics for
 target_unit_to_pixels, target_width, target_height, target_depth.}
 }
+\value{
+\code{SpatialData} object.
+}
 \description{
 Use Python's 'spatialdata' 'transform_to_data_extent' on a spatialdata zarr store
 }
 \examples{
 src <- system.file("extdata", "blobs.zarr", package="SpatialData")
 td <- tempfile()
-do_tx_to_ext(
-  srcdir=src, dest=td, 
-  coordinate_system="global",
-  maintain_positioning=FALSE, 
-  target_width=400.)
-(sd <- readSpatialData(td))
+# TODO: for now this example converts to a zarr v3 so we comment out, 
+# check again later
+
+# do_tx_to_ext(
+#  srcdir=src, dest=td, 
+#  coordinate_system="global",
+#  maintain_positioning=FALSE, 
+#  target_width=400.)
+# (sd <- readSpatialData(td))
 
 }
diff --git a/man/dot-normalize_array_path.Rd b/man/dot-normalize_array_path.Rd
deleted file mode 100644
index 8a491cab..00000000
--- a/man/dot-normalize_array_path.Rd
+++ /dev/null
@@ -1,18 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/zarr_utils.R
-\name{.normalize_array_path}
-\alias{.normalize_array_path}
-\title{Normalize a Zarr array path}
-\usage{
-.normalize_array_path(path)
-}
-\arguments{
-\item{path}{Character vector of length 1 giving the path to be normalised.}
-}
-\value{
-A character vector of length 1 containing the normalised path.
-}
-\description{
-Taken from https://zarr.readthedocs.io/en/stable/spec/v2.html#logical-storage-paths
-}
-\keyword{Internal}
diff --git a/man/mask.Rd b/man/mask.Rd
index 2caa01cf..9c248c12 100644
--- a/man/mask.Rd
+++ b/man/mask.Rd
@@ -5,7 +5,14 @@
 \alias{mask,SpatialData-method}
 \title{Masking}
 \usage{
-\S4method{mask}{SpatialData}(x, i, j, ...)
+\S4method{mask}{SpatialData}(
+  x,
+  i,
+  j,
+  how = NULL,
+  name = function(i, j) sprintf("\%s_by_\%s", i, j),
+  ...
+)
 }
 \arguments{
 \item{x}{\code{\link{SpatialData}} object.}
@@ -14,13 +21,20 @@
 specifically, \code{i} will be masked by \code{j},
 adding a \code{table} for \code{j} in \code{x}.}
 
+\item{how}{character string; statistic to use for masking.}
+
+\item{name}{function use to generate the new \code{table}'s name.}
+
 \item{...}{optional arguments passed to and from other methods.}
 }
 \value{
-\code{\link{SingleCellExperiment}}
+Input \code{SpatialData} object \code{x} with an additional table.
 }
 \description{
-...
+Masking operations serve to aggregate data across layers, e.g., 
+counting points in shapes, averaging image channels by labels, etc.
+For added flexibility, these may be carried out directly between elements,
+or using an input \code{SpatialData} object and specifying element names.
 }
 \examples{
 library(SingleCellExperiment)
@@ -28,9 +42,20 @@ x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
 x <- readSpatialData(x, tables=FALSE)
 
-# count points in circles
-x <- mask(x, "blobs_points", "blobs_circles")
-x <- mask(x, "blobs_image", "blobs_labels")
-tables(x)
+# count points in shapes
+y <- mask(x, "blobs_points", "blobs_circles")
+tail(tables(y), 1)
+
+# average image channels by labels
+y <- mask(x, "blobs_image", "blobs_labels")
+tail(tables(y), 1)
+
+library(SpatialData.data)
+x <- get_demo_SDdata("merfish")
+x <- readSpatialData(x)
+
+# sum table counts by shapes
+y <- mask(x, "cells", "anatomical")
+tail(tables(y), 1)
 
 }
diff --git a/man/misc.Rd b/man/misc.Rd
index 32e489b2..4c5cade5 100644
--- a/man/misc.Rd
+++ b/man/misc.Rd
@@ -6,7 +6,7 @@
 \alias{show,sdArray-method}
 \alias{show,PointFrame-method}
 \alias{show,ShapeFrame-method}
-\title{Miscellaneous `Miro` methods}
+\title{Miscellaneous `SpatialData` methods}
 \usage{
 \S4method{show}{SpatialData}(object)
 
@@ -17,17 +17,30 @@
 \S4method{show}{ShapeFrame}(object)
 }
 \arguments{
-\item{object}{\code{\link{SpatialData}} object or one of its 
-elements, i.e., an Image/LabelArray or Point/ShapeFrame.}
+\item{object}{\code{\link{SpatialData}} object or one of its elements,
+i.e., an \code{Image/LabelArray} or \code{Point/ShapeFrame}.}
 }
 \value{
 \code{NULL}
 }
 \description{
-...
+Miscellaneous methods (e.g., \code{show}) for the
+\code{\link{SpatialData}} class and its elements.
 }
 \examples{
-# TODO
+zs <- file.path("extdata", "blobs.zarr")
+zs <- system.file(zs, package="SpatialData")
+(sd <- readSpatialData(zs, anndataR=TRUE))
+
+# show element
+image(sd)
+label(sd)
+point(sd)
+shape(sd)
+
+# show .zattrs
+meta(label(sd))
+meta(image(sd, 2))
 }
 \author{
 Helena L. Crowell
diff --git a/man/plotCoordGraph.Rd b/man/plotCoordGraph.Rd
deleted file mode 100644
index a4acca58..00000000
--- a/man/plotCoordGraph.Rd
+++ /dev/null
@@ -1,26 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/coord_utils.R
-\name{plotCoordGraph}
-\alias{plotCoordGraph}
-\title{CT graph viz.}
-\usage{
-plotCoordGraph(g, cex = 0.6)
-}
-\arguments{
-\item{g}{base R graph; extracted with \code{\link{CTgraph}}.}
-
-\item{cex}{scalar numeric; controls fontsize of node labels.}
-}
-\description{
-given a \code{graphNEL} instance, nodes with \code{nchar>max} are
-split and hyphenated at character position \code{floor(nchar/fac)}.
-}
-\examples{
-x <- file.path("extdata", "blobs.zarr")
-x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, tables=FALSE)
-
-g <- CTgraph(x)
-plotCoordGraph(g, cex=0.6)
-
-}
diff --git a/man/query.Rd b/man/query.Rd
index 66b8b488..4b566bcc 100644
--- a/man/query.Rd
+++ b/man/query.Rd
@@ -9,36 +9,72 @@
 \alias{query,PointFrame-method}
 \title{spatial queries}
 \usage{
-\S4method{query}{SpatialData}(x, j = NULL, ...)
+\S4method{query}{SpatialData}(x, ..., i)
 
-\S4method{query}{ImageArray}(x, j, ...)
+\S4method{query}{ImageArray}(x, y)
 
-\S4method{query}{LabelArray}(x, ...)
+\S4method{query}{LabelArray}(x, y)
 
-\S4method{query}{ShapeFrame}(x, ...)
+\S4method{query}{ShapeFrame}(x, y)
 
-\S4method{query}{PointFrame}(x, j, ...)
+\S4method{query}{PointFrame}(x, y)
 }
 \arguments{
 \item{x}{\code{SpatialData} element.}
 
-\item{j}{scalar character or integer; index or name of coordinate space.}
-
 \item{...}{optional arguments passed to and from other methods.}
+
+\item{i}{for \code{SpatialData}, index or name of table to query.}
+
+\item{y}{query specification; 
+bounding box: length-4 numeric list with names 'xmin/xmax/ymin/ymax';
+polygon: numeric matrix with at least 3 rows and exactly 2 columns.}
 }
 \value{
 same as input
 }
 \description{
-spatial queries
+Spatial queries serve to subset \code{SpatialData} elements 
+according to a rectangular bounding box or arbitrary polygonal shapes. 
+Queries rely on lesser-/greater-equal and \code{sf::st_intersects} for 
+spatial operations (i.e., instances that intersect the query region 
+in any way are kept). For circle shapes, radii are currently ignored
+(i.e., a circle is kept if its centroid intersects the query region).
 }
 \examples{
-x <- file.path("extdata", "blobs.zarr")
-x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, tables=FALSE)
+zs <- file.path("extdata", "blobs.zarr")
+zs <- system.file(zs, package="SpatialData")
+sd <- readSpatialData(zs, tables=FALSE)
+
+# helper for visualizing point coordinates
+.xy <- \(.) data.frame(data(.)[c("x", "y")])
+
+# bounding box
+y <- list(xmin=11, xmax=44, ymin=22, ymax=55)
+q <- query(p <- point(sd), y)
+
+plot(.xy(p), asp=1)
+points(.xy(q), col="red")
+rect(y$xmin, y$ymin, y$xmax, y$ymax, border="blue")
+
+# polygon
+y <- rbind(c(20,10), c(50,30), c(20,50), c(30,30))
+q <- query(p <- point(sd), y)
+
+plot(.xy(p), asp=1)
+points(.xy(q), col="red")
+lines(rbind(y, y[1, ]), col="blue")
 
-image(x, "box") <- query(image(x), xmin=0, xmax=30, ymin=30, ymax=50)
+# shapes that intersect the query region are kept
+y <- rbind(c(30,45), c(40,45), c(35,50))
+t <- query(s <- shape(sd, 3), y)
 
-image(x)
-image(x, "box")
+require(sf, quietly=TRUE)
+df <- st_coordinates(st_as_sf(data(s)))
+fd <- st_coordinates(st_as_sf(data(t)))
+plot(
+  asp=1, xlim=c(15, 60), ylim=c(15, 60),
+  rbind(y, y[1, ]), type="l", col="blue") 
+foo <- by(df, df[, "L2"], \(x) points(x, type="b", col="black"))
+foo <- by(fd, fd[, "L2"], \(x) points(x, type="b", col="red"))
 }
diff --git a/man/readSpatialData.Rd b/man/readSpatialData.Rd
index 000ed434..812a51dc 100644
--- a/man/readSpatialData.Rd
+++ b/man/readSpatialData.Rd
@@ -26,7 +26,7 @@ readSpatialData(
   points = TRUE,
   shapes = TRUE,
   tables = TRUE,
-  anndataR = FALSE
+  anndataR = TRUE
 )
 }
 \arguments{
@@ -42,9 +42,9 @@ The default, NULL, reads all elements; alternatively, may be FALSE
 to skip a layer, or a integer vector specifying which elements to read.}
 
 \item{anndataR}{logical specifying whether 
-to use \code{anndataR} to read tables; defaults to FALSE in `readSpatialData`,
-and `readTable`,
-so that pythonic \code{spatialdata} and \code{zellkonverter} are used.}
+to use \code{anndataR} to read tables; 
+defaults to FALSE in `readSpatialData`, and `readTable`,
+so that pythonic \code{anndata} are used.}
 }
 \value{
 \itemize{
@@ -57,7 +57,16 @@ Reading `SpatialData`
 }
 \examples{
 library(SpatialData.data)
-dir.create(tf <- tempfile())
-base <- SpatialData.data:::.unzip_merfish_demo(tf)
-(x <- readSpatialData(base))
+zs <- get_demo_SDdata("merfish")
+
+# read complete Zarr store
+(sd <- readSpatialData(zs, anndataR=TRUE))
+
+# helper that gets path to first element in layer 'l' 
+fn <- \(l) list.files(file.path(zs, l), full.names=TRUE)[1]
+  
+# read individual element  
+readImage(fn("images"))
+readShape(fn("shapes"))
+readPoint(fn("points"))
 }
diff --git a/man/read_zattrs.Rd b/man/read_zattrs.Rd
deleted file mode 100644
index ccd83f36..00000000
--- a/man/read_zattrs.Rd
+++ /dev/null
@@ -1,22 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/zarr_utils.R
-\name{read_zattrs}
-\alias{read_zattrs}
-\title{Read the .zattrs file associated with a Zarr array or group}
-\usage{
-read_zattrs(path, s3_client = NULL)
-}
-\arguments{
-\item{path}{A character vector of length 1. This provides the
-path to a Zarr array or group. This can either be on a local file
-system or on S3 storage.}
-
-\item{s3_client}{A list representing an S3 client.  This should be produced
-by [paws.storage::s3()].}
-}
-\value{
-A list containing the .zattrs elements
-}
-\description{
-Read the .zattrs file associated with a Zarr array or group
-}
diff --git a/man/Array-methods.Rd b/man/sdArray.Rd
similarity index 63%
rename from man/Array-methods.Rd
rename to man/sdArray.Rd
index 083e08df..cb1ca718 100644
--- a/man/Array-methods.Rd
+++ b/man/sdArray.Rd
@@ -1,7 +1,8 @@
 % Generated by roxygen2: do not edit by hand
 % Please edit documentation in R/sdArray.R
-\name{Array-methods}
-\alias{Array-methods}
+\name{sdArray}
+\alias{sdArray}
+\alias{data_type}
 \alias{data,ImageArray-method}
 \alias{data,LabelArray-method}
 \alias{dim,ImageArray-method}
@@ -11,6 +12,8 @@
 \alias{data,sdArray-method}
 \alias{dim,sdArray-method}
 \alias{length,sdArray-method}
+\alias{data_type,sdArray-method}
+\alias{data_type,DelayedArray-method}
 \title{Methods for `ImageArray` and `LabelArray` class}
 \usage{
 \S4method{data}{sdArray}(x, k = 1)
@@ -18,6 +21,10 @@
 \S4method{dim}{sdArray}(x)
 
 \S4method{length}{sdArray}(x)
+
+\S4method{data_type}{sdArray}(x)
+
+\S4method{data_type}{DelayedArray}(x)
 }
 \arguments{
 \item{x}{\code{ImageArray} or  \code{LabelArray}}
@@ -31,6 +38,13 @@
 Methods for `ImageArray` and `LabelArray` class
 }
 \examples{
-# TODO
+library(SpatialData.data)
+zs <- get_demo_SDdata("merfish")
+
+# helper that gets path to first element in layer 'l' 
+fn <- \(l) list.files(file.path(zs, l), full.names=TRUE)[1]
+  
+# read individual element  
+(ia <- readImage(fn("images")))
 
 }
diff --git a/man/table-utils.Rd b/man/table-utils.Rd
index 709cd7c4..c9f700ee 100644
--- a/man/table-utils.Rd
+++ b/man/table-utils.Rd
@@ -56,6 +56,19 @@ or row name to retrieve \code{assay} data.}
 \item{assay}{character string or scalar integer; 
 specifies which \code{assay} to use when \code{j} is a row name.}
 }
+\value{
+\itemize{
+\item \code{hasTable}: 
+  logical scalar (or character string, if \code{name=TRUE});
+  whether or not a \code{table} annotating \code{i} exists in \code{x}
+\item \code{getTable}: 
+  \code{SingleCellExperiment}; the \code{table} annotating 
+  \code{i} with optional filtering of matching observations
+\item \code{valTable}: 
+  vector of values (according to \code{j})
+  from the \code{table} annotating \code{i}
+}
+}
 \description{
 \code{SpatialData} annotations
 }
@@ -63,7 +76,7 @@ specifies which \code{assay} to use when \code{j} is a row name.}
 library(SingleCellExperiment)
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, anndataR=FALSE)
+x <- readSpatialData(x, anndataR=TRUE)
 
 # check if element has a 'table'
 hasTable(x, "blobs_points")
diff --git a/man/trans.Rd b/man/trans.Rd
index 8602b2e5..b4f9c87d 100644
--- a/man/trans.Rd
+++ b/man/trans.Rd
@@ -5,7 +5,15 @@
 \alias{scale}
 \alias{rotate}
 \alias{translation}
-\alias{scale,ImageArray,numeric-method}
+\alias{flip}
+\alias{flop}
+\alias{mirror}
+\alias{mirror,sdArray-method}
+\alias{flip,sdArray-method}
+\alias{flop,sdArray-method}
+\alias{scale,sdArray,numeric-method}
+\alias{rotate,sdArray,numeric-method}
+\alias{translation,sdArray,numeric-method}
 \alias{scale,PointFrame,numeric-method}
 \alias{rotate,PointFrame,numeric-method}
 \alias{translation,PointFrame,numeric-method}
@@ -14,7 +22,17 @@
 \alias{translation,ShapeFrame,numeric-method}
 \title{Transformations}
 \usage{
-\S4method{scale}{ImageArray,numeric}(x, j, t, ...)
+\S4method{mirror}{sdArray}(x, t = c("v", "h"), k = 1, ...)
+
+\S4method{flip}{sdArray}(x, k = 1, ...)
+
+\S4method{flop}{sdArray}(x, k = 1, ...)
+
+\S4method{scale}{sdArray,numeric}(x, t, k = 1, ...)
+
+\S4method{rotate}{sdArray,numeric}(x, t, k = 1, ...)
+
+\S4method{translation}{sdArray,numeric}(x, t, k = 1, ...)
 
 \S4method{scale}{PointFrame,numeric}(x, t, ...)
 
@@ -29,15 +47,21 @@
 \S4method{translation}{ShapeFrame,numeric}(x, t, ...)
 }
 \arguments{
-\item{x}{\code{SpatialData} element}
+\item{x}{\code{SpatialData} element.}
 
-\item{j}{scalar character or numeric; 
-name or index of coordinate space.}
+\item{t}{transformation data; exceptions: for \code{mirror}, controls
+whether to perform \bold{v}ertical or \bold{h}orizontal reflection;
+no data is needed for \code{flip} (\bold{v}) and \code{flop} (\bold{h}).}
 
-\item{t}{transformation data.}
+\item{k}{scalar index specifying which scale to use; 
+\code{Inf} to use lowest available resolution;
+only applies to \code{sdArray}s (images, labels).}
 
 \item{...}{option arguments passed to and from other methods.}
 }
+\value{
+\code{SpatialData} element with transformation(s) applied.
+}
 \description{
 Transformations
 }
@@ -48,14 +72,14 @@ x <- readSpatialData(x, tables=FALSE)
 
 # image
 y <- x
-image(y) <- scale(image(y), 1, c(1, 1, 1/3))
-CTpath(image(x), "global")
-CTpath(image(y), "global")
+image(y) <- scale(image(y), c(1, 1, 1/3))
+dim(image(x))
+dim(image(y))
   
 # point
 y <- x
 point(y, "rot") <- rotate(point(y), 20)
-point(y, "wide") <- scale(point(y), c(1, 1.2))
+point(y, "wide") <- scale(point(y), c(1.2, 1))
 
 xy0 <- as.data.frame(point(y))
 xy1 <- as.data.frame(point(y, "rot"))
@@ -68,8 +92,7 @@ points(xy2[, c(1, 2)], col=4)
 # shape
 y <- x
 shape(y, "rot") <- rotate(shape(y), 5)
-shape(y, "high") <- scale(shape(y), c(1.2, 1))
+shape(y, "wide") <- scale(shape(y), c(1.2, 1))
 shape(y, "left") <- translation(shape(y), c(-5, 0))
-
-graph::plot(CTgraph(y))
+y["shapes", c("rot", "wide", "left")]
 }
diff --git a/man/utils.Rd b/man/utils.Rd
new file mode 100644
index 00000000..245bc2c4
--- /dev/null
+++ b/man/utils.Rd
@@ -0,0 +1,64 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/utils.R
+\name{utils}
+\alias{utils}
+\alias{centroids}
+\alias{extent}
+\alias{centroids,ANY-method}
+\alias{centroids,LabelArray-method}
+\alias{centroids,ShapeFrame-method}
+\alias{centroids,PointFrame-method}
+\alias{extent,SpatialData-method}
+\alias{extent,SpatialDataElement-method}
+\title{Utilities}
+\usage{
+\S4method{centroids}{ANY}(x, ...)
+
+\S4method{centroids}{LabelArray}(x, as = c("data.frame", "matrix"))
+
+\S4method{centroids}{ShapeFrame}(x, as = c("data.frame", "matrix", "list"))
+
+\S4method{centroids}{PointFrame}(x, as = c("data.frame", "list"))
+
+\S4method{extent}{SpatialData}(x)
+
+\S4method{extent}{SpatialDataElement}(x)
+}
+\arguments{
+\item{x}{a \code{SpatialData} element (any but image).}
+
+\item{...}{optional arguments passed to and from other methods.}
+
+\item{as}{character string; how results should be returned.}
+}
+\value{
+For \code{centroids}, a table (\code{data.frame} or \code{matrix}) 
+of spatial coordinates (if \code{as="list"}, split by instance);
+for extend, a length-2 numeric list of x- and y-ranges.
+}
+\description{
+Utilities
+}
+\examples{
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- readSpatialData(x, tables=FALSE)
+
+centroids(label(x))
+centroids(shape(x))
+centroids(shape(x, 3), "list")
+
+head(centroids(point(x)))
+xy <- centroids(point(x), "list")
+plot(xy$gene_a, col=a <- "red")
+points(xy$gene_b, col=b <- "blue")
+legend("topright", legend=names(xy), col=c(a, b), pch=21)
+
+# object-wide
+extent(x)
+
+# element-wise
+extent(label(x))
+extent(point(x))
+extent(shape(x))
+}
diff --git a/man/write_zattrs.Rd b/man/write_zattrs.Rd
deleted file mode 100644
index 944db4ea..00000000
--- a/man/write_zattrs.Rd
+++ /dev/null
@@ -1,19 +0,0 @@
-% Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/zarr_utils.R
-\name{write_zattrs}
-\alias{write_zattrs}
-\title{Read the .zattrs file associated with a Zarr array or group}
-\usage{
-write_zattrs(path, new.zattrs = list(), overwrite = TRUE)
-}
-\arguments{
-\item{path}{A character vector of length 1. This provides the
-path to a Zarr array or group.}
-
-\item{new.zattrs}{a list inserted to .zattrs at the \code{path}.}
-
-\item{overwrite}{if TRUE, existing .zattrs elements will be overwritten by \code{new.zattrs}.}
-}
-\description{
-Read the .zattrs file associated with a Zarr array or group
-}
diff --git a/tests/testthat/test-PointFrame.R b/tests/testthat/test-PointFrame.R
index def83fc4..1fa4470d 100644
--- a/tests/testthat/test-PointFrame.R
+++ b/tests/testthat/test-PointFrame.R
@@ -37,7 +37,8 @@ test_that("filter", {
     n <- length(p <- point(x))
     expect_length(filter(p), n)
     expect_length(filter(p, x > Inf), 0)
-    expect_error(filter(p, z == 1))
+    f <- \() filter(p, z == 1)
+    expect_error(show(f()))
 })
 
 test_that("select", {
@@ -45,7 +46,8 @@ test_that("select", {
     replicate(3, {
         n <- sample(ncol(p), 1)
         i <- sample(names(p), n)
-        y <- select(p, i); z <- data(p)[, i]
+        y <- select(p, all_of(i))
+        z <- data(p)[, i]
         expect_equal(collect(data(y)), collect(z))
     })
 })
diff --git a/tests/testthat/test-ctgraph.R b/tests/testthat/test-ctgraph.R
new file mode 100644
index 00000000..b230d71a
--- /dev/null
+++ b/tests/testthat/test-ctgraph.R
@@ -0,0 +1,55 @@
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- readSpatialData(x, anndataR=TRUE)
+
+test_that("CTgraph", {
+    # invalid
+    expect_error(CTgraph(list()))
+    expect_error(CTgraph(SpatialData::table(x)))
+    # object-wide
+    g <- CTgraph(x)
+    expect_is(g, "graph")
+    # graph should contain node for
+    # every element & transformation
+    ns <- lapply(setdiff(SpatialData:::.LAYERS, "tables"), 
+        \(l) lapply(names(x[[l]]), 
+            \(e) c(e, CTname(x[[l]][[e]]))))
+    ns <- sort(unique(unlist(ns)))
+    expect_true(all(ns %in% sort(graph::nodes(g))))
+    # element-wise
+    for (l in setdiff(SpatialData:::.LAYERS, "tables")) 
+        for (e in names(x[[l]])) {
+            y <- x[[l]][[e]]
+            g <- CTgraph(y)
+            expect_is(g, "graph")
+            expect_true("self" %in% graph::nodes(g))
+        }
+})
+
+test_that("CTpath", {
+    i <- "blobs_image"
+    y <- element(x, "images", i)
+    z <- CTpath(y, j <- CTname(y))
+    expect_identical(CTpath(x, i, j), z)
+    expect_is(z, "list")
+    expect_length(z <- z[[1]], 2)
+    expect_setequal(names(z), c("type", "data"))
+    expect_is(z$type, "character")
+    expect_length(z$type, 1)
+})
+
+test_that("CTplot", {
+    f <- function(.) {
+        tf <- tempfile(fileext=".pdf")
+        on.exit(unlink(tf))
+        pdf(tf); .; dev.off()
+        file.size(tf)
+    }
+    g <- CTgraph(x)
+    p <- f(CTplot(g))
+    expect_is(p, "numeric")
+    expect_true(p > f(plot(1)))
+    p <- f(CTplot(g, 0.1))
+    q <- f(CTplot(g, 0.9))
+    expect_true(p < q)
+})
diff --git a/tests/testthat/test-ctutils.R b/tests/testthat/test-ctutils.R
new file mode 100644
index 00000000..4f61b212
--- /dev/null
+++ b/tests/testthat/test-ctutils.R
@@ -0,0 +1,128 @@
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- readSpatialData(x, anndataR=TRUE)
+
+.CTtype <- c(
+    "identity", "scale", "rotate", 
+    "translation", "affine", "sequence")
+
+test_that("CTlist", {
+    y <- CTlist(label(x))
+    expect_is(y, "list")
+    expect_length(y, 5)
+    z <- Reduce(intersect, lapply(y, names))
+    expect_setequal(z, c("input", "output", "type"))
+    z <- vapply(y, \(.) .$type, character(1))
+    expect_true(all(z %in% .CTtype))
+})
+test_that("CTdata", {
+    # invalid
+    expect_error(CTdata(label(x), ""))
+    expect_error(CTdata(label(x), 99))
+    expect_error(CTdata(label(x), Inf))
+    expect_error(CTdata(label(x), TRUE))
+    # identity
+    y <- CTdata(label(x), "global")
+    expect_null(y)
+    # scale
+    y <- CTdata(label(x), "scale")
+    expect_is(y, "list")
+    expect_length(y, 2)
+    expect_is(unlist(y), "numeric")
+    expect_true(all(unlist(y) > 0))
+    # translation
+    y <- CTdata(label(x), "translation")
+    expect_is(y, "list")
+    expect_length(y, 2)
+    expect_is(unlist(y), "numeric")
+    # affine
+    y <- CTdata(label(x), "affine")
+    expect_is(y, "list")
+    expect_length(y, 2)
+    expect_is(unlist(y), "numeric")
+    expect_true(all(unlist(y) > 0))
+    z <- vapply(y, length, integer(1))
+    expect_true(all(z == 3))
+    # sequence
+    y <- CTdata(label(x), "sequence")
+    expect_is(y, "list")
+    expect_length(y, 2)
+    expect_true(all(names(y) %in% .CTtype))
+    z <- vapply(y, length, integer(1))
+    expect_true(all(z == 2))
+})
+test_that("CTtype", {
+    y <- CTtype(label(x))
+    expect_is(y, "character")
+    expect_length(y, 5)
+    expect_true(all(y %in% .CTtype))
+})
+test_that("CTname,element", {
+    y <- CTname(label(x))
+    expect_is(y, "character")
+    expect_length(y, 5)
+    expect_true(all(nchar(y) > 0))
+    expect_true(!any(duplicated(y)))
+})
+test_that("CTname,object", {
+    y <- CTname(x)
+    expect_is(y, "character")
+    expect_true(!any(duplicated(y)))
+    y <- CTname(image(x))
+    z <- CTname(meta(image(x)))
+    expect_is(y, "character")
+    expect_length(y, 1)
+    expect_identical(y, z)
+})
+
+test_that("rmvCT", {
+    y <- label(x)
+    # invalid index/name
+    expect_error(rmvCT(y, 100))
+    expect_error(rmvCT(y, "."))
+    expect_error(rmvCT(y, c(".", CTname(y)[1])))
+    # identity is kept with a warning
+    expect_warning(z <- rmvCT(y, "global"))
+    expect_identical(CTname(z), CTname(y))
+    # by name
+    i <- sample(setdiff(CTname(y), "global"), 2) 
+    expect_identical(CTname(rmvCT(y, i)), setdiff(CTname(y), i))
+    # by index
+    i <- sample(which(CTtype(y) != "identity"), 2) 
+    expect_identical(CTname(rmvCT(y, i)), CTname(y)[-i])
+})
+
+test_that("addCT", {
+    # get 1st element from each layer
+    ls <- setdiff(SpatialData:::.LAYERS, "tables")
+    es <- lapply(ls, \(.) x[.,1][[.]][[1]])
+    .check_data <- \(z, x) {
+        expect_true("." %in% CTname(z))
+        ct <- CTlist(z)[[which(CTname(z) == ".")]]
+        expect_identical(ct[[t]][[1]], x)
+    }
+    for (y in es) {
+        t <- "identity"
+        expect_error(addCT(y, ".", t, 12345))
+        expect_silent(z <- addCT(y, ".", t, v <- NULL))
+        .check_data(z, v)
+        t <- "rotate"
+        expect_error(addCT(y, ".", t, -12345)) # negative
+        expect_error(addCT(y, ".", t, c(1,1))) # too many
+        expect_error(addCT(y, ".", t, ".")) # not a number
+        expect_silent(z <- addCT(y, ".", t, v <- 1)) 
+        .check_data(z, v)
+        t <- "scale"
+        d <- ifelse(is(y, "ImageArray"), 3, 2)
+        expect_error(addCT(y, ".", t, numeric(d))) # zeroes
+        expect_error(addCT(y, ".", t, 1+numeric(d+1))) # too many
+        expect_error(addCT(y, ".", t, character(d))) # not a number
+        expect_silent(z <- addCT(y, ".", t, v <- 1+numeric(d)))
+        .check_data(z, v)
+        t <- "translation"
+        expect_error(addCT(y, ".", t, numeric(d+1))) # too many
+        expect_error(addCT(y, ".", t, character(d))) # not a number
+        expect_silent(z <- addCT(y, ".", t, v <- numeric(d)))
+        .check_data(z, v)
+    }
+})
diff --git a/tests/testthat/test-imagearray.R b/tests/testthat/test-imagearray.R
index 182c94a5..3acb046f 100644
--- a/tests/testthat/test-imagearray.R
+++ b/tests/testthat/test-imagearray.R
@@ -37,16 +37,6 @@ test_that("data(),ImageArray", {
     expect_error(data(img, ""))
     expect_error(data(img, c(1,2)))
 })
-
-x <- file.path("extdata", "blobs.zarr")
-x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, tables=FALSE)
-
-test_that("[,ImageArray", {
-  y <- image(x, i <- "blobs_image")
-  y <- y[,seq_len(32)] # subset to make things harder
-})
-
 test_that("create", {
   
   # create image
@@ -159,4 +149,29 @@ test_that("write multiscale", {
   expect_identical(realize(data(imgarray, 3)), 
                    realize(data(imgarray2, 3)))
   expect_identical(meta(imgarray),meta(imgarray2))
-})
\ No newline at end of file
+})
+
+test_that("write v3 uses Python-readable codec ordering", {
+  td <- tempdir()
+  zarr.path <- file.path(td, "test_v3.zarr")
+  unlink(zarr.path, recursive = TRUE)
+
+  set.seed(1)
+  img <- array(sample(1:255, size = 20 * 20 * 3, replace = TRUE),
+               dim = c(3, 20, 20))
+  imgarray <- ImageArray(img, axes = c("c", "y", "x"))
+  sd <- SpatialData(images = list(test_image = imgarray))
+
+  writeSpatialData(sd, "test_v3.zarr", path = td, version = "v3")
+
+  metadata <- jsonlite::read_json(
+    file.path(zarr.path, "images", "test_image", "0", "zarr.json"),
+    simplifyVector = FALSE
+  )
+  codec_names <- vapply(metadata$codecs, `[[`, character(1), "name")
+
+  expect_identical(codec_names, c("transpose", "bytes", "zstd"))
+  expect_equal(unname(unlist(metadata$dimension_names)), c("c", "y", "x"))
+  expect_equal(metadata$attributes, list())
+  expect_equal(metadata$storage_transformers, list())
+})
diff --git a/tests/testthat/test-labelarray.R b/tests/testthat/test-labelarray.R
index 5a5b59d8..4e420e89 100644
--- a/tests/testthat/test-labelarray.R
+++ b/tests/testthat/test-labelarray.R
@@ -1,7 +1,5 @@
-arr <- seq_len(12)
-
 test_that("LabelArray()", {
-  val <- sample(arr, 20*20, replace=TRUE)
+  val <- sample(seq_len(12), 20*20, replace=TRUE)
   mat <- array(val, dim=c(20, 20))
   expect_silent(LabelArray(mat))
   expect_silent(LabelArray(mat, list()))
@@ -12,14 +10,15 @@ test_that("LabelArray()", {
   expect_silent(LabelArray(list(mat)))
   expect_silent(LabelArray(list(mat), Zattrs()))
   # multiscale
-  dim <- lapply(c(20, 10, 5), \(.) c(3, rep(., 2)))
-  lys <- lapply(dim, \(.) array(sample(arr, prod(.), replace=TRUE), dim=.))
+  dim <- lapply(c(20, 10, 5), \(.) rep(., 2))
+  lys <- lapply(dim, \(.) array(sample(seq_len(12), prod(.), replace=TRUE), dim=.))
   expect_silent(LabelArray(lys))
 })
 
+
 test_that("data(),LabelArray", {
-  dim <- lapply(c(8, 4, 2), \(.) c(3, rep(., 2)))
-  lys <- lapply(dim, \(.) array(0, dim=.))
+  dim <- lapply(c(8, 4, 2), \(.) rep(., 2))
+  lys <- lapply(dim, \(.) array(0L, dim=.))
   lab <- LabelArray(lys)
   for (. in seq_along(lys))
     expect_identical(data(lab, .), lys[[.]])
@@ -31,16 +30,6 @@ test_that("data(),LabelArray", {
   expect_error(data(lab, c(1,2)))
 })
 
-x <- file.path("extdata", "blobs.zarr")
-x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, tables=FALSE)
-
-test_that("[,LabelArray", {
-  y <- label(x, i <- "blobs_labels")
-  y <- y[,seq_len(32)] # subset to make things harder
-  y <- label(x, i <- "blobs_multiscale_labels")
-  y <- y[,seq_len(32)] # subset to make things harder
-})
 
 test_that("create", {
   
diff --git a/tests/testthat/test-mask.R b/tests/testthat/test-mask.R
index ad3545b9..1eebe0d0 100644
--- a/tests/testthat/test-mask.R
+++ b/tests/testthat/test-mask.R
@@ -1,26 +1,68 @@
 library(SingleCellExperiment)
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, anndataR=FALSE)
+x <- readSpatialData(x, anndataR=TRUE)
 
-test_that("mask(),ImageArray,LabelArray", {
+test_that("mask,unsupported", {
+    nm <- list(
+        c(imageNames(x)[1], imageNames(x)[2]), # image,image
+        c(labelNames(x)[1], labelNames(x)[2]), # label,label
+        c(labelNames(x)[1], imageNames(x)[1]), # label,image
+        c(shapeNames(x)[1], pointNames(x)[1])) # shape,point
+    for (ij in nm) expect_error(mask(x, ij[1], ij[2]))
+})
+
+test_that("mask,ImageArray,LabelArray", {
     i <- "blobs_image"
     j <- "blobs_labels"
-    x <- SpatialData::mask(x, i, j, fun=sum)
+    # reproduce example data
+    y <- mask(x, i, j, how="sum")
     expect_equivalent(
-        assay(SpatialData::table(x, 1)),
-        assay(SpatialData::table(x, 2)))
+        assay(tables(y)[[2]]), 
+        assay(tables(x)[[1]]))
+    # default to 'mean' with a message
+    expect_message(y <- mask(x, i, j))
+    expect_silent(z <- mask(x, i, j, how="mean"))
+    expect_identical(y, z)
 })
 
-test_that("mask(),PointFrame,ShapeFrame", {
+test_that("mask,PointFrame,ShapeFrame", {
     i <- "blobs_points"
     j <- "blobs_circles"
-    x <- SpatialData::mask(x, i, j)
-    t <- getTable(x, j)
-    md <- meta(point(x, i))
-    md <- md$spatialdata_attrs
-    fk <- md$feature_key
-    nr <- length(unique(point(x, i)[[fk]]))
+    y <- mask(x, i, j)
+    t <- getTable(y, j)
+    fk <- feature_key(p <- point(x, i))
+    np <- length(unique(p[[fk]]))
     nc <- nrow(shape(x, j))
-    expect_equal(dim(t), c(nr, nc))
+    expect_equal(dim(t), c(np, nc))
+    # ignore 'how' with a warning
+    expect_warning(mask(x, i, j, how="sum"))
+})
+
+require(SpatialData.data, quietly=TRUE)
+x <- get_demo_SDdata("merfish")
+x <- readSpatialData(x)
+
+test_that("mask,ShapeFrame,ShapeFrame", {
+    i <- "cells"
+    j <- "anatomical"
+    # error without 'table'
+    y <- x; tables(y) <- list()
+    expect_error(mask(y, i, j))
+    # default to 'sum' with a message
+    expect_message(y <- mask(x, i, j))
+    expect_silent(z <- mask(x, i, j, how="sum"))
+    expect_identical(y, z)
+    old <- getTable(y, i)
+    new <- getTable(y, j)
+    expect_equal(dim(new), c(nrow(old), nrow(shape(x, j))+1))
+    expect_equal(sum(assay(new)), sum(assay(old)))
+    expect_identical(rownames(new), rownames(old))
+    expect_identical(meta(new)$region, j)
+    # 'value' should be a character 
+    # vector of rownames in 'table(x, i)'
+    v <- sample(rownames(old), 5)
+    new <- getTable(mask(x, i, j, value=v), j)
+    expect_equal(sum(assay(new[v, ])), sum(assay(old[v, ])))
+    expect_error(mask(x, i, j, value=`[<-`(v, i=1, "x")))
 })
diff --git a/tests/testthat/test-methods.R b/tests/testthat/test-methods.R
index 7ee02f2c..66e5c677 100644
--- a/tests/testthat/test-methods.R
+++ b/tests/testthat/test-methods.R
@@ -1,14 +1,14 @@
-if (FALSE) {
 library(SingleCellExperiment)
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
 x <- readSpatialData(x)
 
-sdtable = SpatialData::table   # skirt ambiguity and limitations of get()
-"sdtable<-" = "SpatialData::table<-"   # skirt ambiguity and limitations of get()
-sdtables = SpatialData::tables
+# # skirt base::table ambiguity
+# sdtable <- SpatialData::table    
+# `sdtable<-` <- `SpatialData::table<-`   
+# sdtables <- SpatialData::tables
 
-fun <- c("image", "label", "shape", "point", "sdtable")
+fun <- c("image", "label", "shape", "point", "table")
 nms <- c("blobs_image", "blobs_labels", "blobs_circles", "blobs_points", "table")
 typ <- c("ImageArray", "LabelArray", "ShapeFrame", "PointFrame", "SingleCellExperiment")
 
@@ -53,19 +53,19 @@ test_that("get one", {
     # i=numeric
     mapply(f=fun, t=typ, \(f, t) 
         expect_is(get(f)(x, i=1), t))
-    # i=character -- VJC Dec 8 2024 -- ambiguity of table()?
-#    mapply(f=fun, t=typ, n=nms, \(f, t, n) 
-#        expect_is(get(f)(x, i=n), t))
+    # i=character
+    mapply(f=fun, t=typ, n=nms, \(f, t, n)
+        expect_is(get(f)(x, i=n), t))
     # i=invalid
-#    for (f in fun) {
-#        expect_error(get(f)(x, 0))
-#        expect_error(get(f)(x, "."))
-#        expect_error(get(f)(x, c(1,1)))
-#        expect_silent(y <- get(f)(x, Inf))
-#        set <- get(paste0(f, "s<-"))
-#        y <- set(x, list())
-#        expect_error(get(f)(y, 1))
-#    }
+    for (f in fun) {
+        expect_error(get(f)(x, 0))
+        expect_error(get(f)(x, "."))
+        expect_error(get(f)(x, c(1,1)))
+        expect_silent(y <- get(f)(x, Inf))
+        set <- get(paste0(f, "s<-"))
+        y <- set(x, list())
+        expect_error(get(f)(y, 1))
+    }
 })
 
 # set ----
@@ -169,12 +169,12 @@ test_that("[,LabelArray", {
     expect_equal(dim(y[FALSE,FALSE]), c(0,0)) 
     expect_equal(dim(y[FALSE,TRUE]), c(0,ncol(y))) 
     expect_equal(dim(y[TRUE,FALSE]), c(nrow(y),0)) 
-    i <- logical(nrow(y)); j <- logical(ncol(y))
-    n <- replicate(2, sample(seq(2, 10), 1))
-    i[sample(nrow(y), n[1])] <- TRUE
-    j[sample(ncol(y), n[2])] <- TRUE
-    expect_equal(nrow(y[i,]), n[1])
-    expect_equal(ncol(y[,j]), n[2])
+    # i <- logical(nrow(y)); j <- logical(ncol(y))
+    # n <- replicate(2, sample(seq(2, 10), 1))
+    # i[sample(nrow(y), n[1])] <- TRUE
+    # j[sample(ncol(y), n[2])] <- TRUE
+    # expect_equal(nrow(y[i,]), n[1])
+    # expect_equal(ncol(y[,j]), n[2])
     # numeric
     expect_identical(y[,], y) # none
     expect_equal(nrow(y[1,]), 1) # no j
@@ -257,4 +257,3 @@ test_that("[,SpatialData", {
         element(y, 1, 1), 
         element(x, 1, .n(x)[1]))
 })
-}
diff --git a/tests/testthat/test-query.R b/tests/testthat/test-query.R
index 1c742f6c..0490f584 100644
--- a/tests/testthat/test-query.R
+++ b/tests/testthat/test-query.R
@@ -1,45 +1,96 @@
-library(sf)
+require(sf, quietly=TRUE)
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, tables=FALSE)
+x <- readSpatialData(x, anndataR=TRUE)
 
-test_that("query,...", {
-    # extract 1st element from every layer
-    lys <- lapply(seq_len(4), \(.) x[.,1][[.]][[1]])
-    for (y in lys) {
-        # missing bounding box coordinates
-        expect_error(query(y, xmin=0, xmax=1, ymin=0))
-        # # invalid coordinate space
-        # expect_error(query(y, ".", xmin=0, xmax=1, ymin=0, ymax=1))
-        # expect_error(query(y, 100, xmin=0, xmax=1, ymin=0, ymax=1))
-    }
+test_that("query,.check_box", {
+    # valid
+    q <- list(
+        list(xmin=0, xmax=1, ymin=0, ymax=1),
+        list(xmin=-1, xmax=0, ymin=-1, ymax=0),
+        list(xmin=-Inf, xmax=Inf, ymin=-Inf, ymax=Inf))
+    for (. in q) expect_silent(.check_box(.))
+    # invalid
+    q <- list(
+        list(xmin=0, xmax=1, ymin=0), 
+        list(xmin=1, xmax=0, ymin=1, ymax=0),
+        list(xmin=0, xmax=-1, ymin=0, ymax=-1),
+        list(xmin=0, xmax=1, ymin=10, ymax=NA),
+        list(xmin=Inf, xmax=-Inf, ymin=Inf, ymax=-Inf))
+    for (. in q) expect_error(.check_box(.))
+})
+
+test_that("query,.check_pol", {
+    # valid
+    q <- list(
+        m <- matrix(seq_len(8), 4, 2), 
+        rbind(c(1,1), c(2,2), c(3,3)), # open
+        rbind(c(1,1), c(2,2), c(3,3), c(1,1))) 
+    for (. in q) expect_silent(.check_pol(.))
+    # invalid
+    q <- list(
+        matrix(seq_len(6), 2, 3), # wrong dim.
+        matrix(numeric(6), 3, 2), # duplicates
+        `[<-`(m, i=1, j=1, value=Inf), # not finite
+        `[<-`(m, i=1, j=1, value=NA))  # missing value
+    for (. in q) expect_error(.check_pol(.))
 })
 
 test_that("query,ImageArray", {
     d <- dim(i <- image(x))
-    # neither crop nor shift
-    expect_identical(query(i, xmin=0, xmax=d[3], ymin=0, ymax=d[2]), i)
+    # unsupported query
+    y <- matrix(seq_len(8), 4, 2)
+    expect_error(query(i, y))
+    # query equals dimensions
+    y <- list(xmin=0, xmax=d[3], ymin=0, ymax=d[2])
+    expect_identical(query(i, y), i)
+    # order is irrelevant
+    y <- list(ymax=d[2], xmax=d[3], xmin=0, ymin=0)
+    expect_identical(query(i, y), i)
+    # crop but don't shift
+    y <- list(xmin=0, xmax=w <- d[3]/2, ymin=0, ymax=h <- d[2]/4)
+    expect_equal(dim(j <- query(i, y)), c(3, h, w)) 
+    expect_identical(CTlist(i), CTlist(j))
+    # crop and shift
+    y <- list(
+        xmin=dx <- 3, xmax=w <- d[3]/2, 
+        ymin=dy <- 5, ymax=h <- d[2]/4)
+    expect_equal(dim(query(i, y)), c(3, 1+h-dy, 1+w-dx))
+    # non-finite boundaries
+    y <- list(xmin=-Inf, xmax=Inf, ymin=-Inf, ymax=Inf)
+    expect_silent(query(i, y))
+})
+
+test_that("query,LabelArray", {
+    d <- dim(l <- label(x))
+    # query equals dimensions
+    y <- list(xmin=0, xmax=d[2], ymin=0, ymax=d[1])
+    expect_identical(query(l, y), l)
     # order is irrelevant
-    expect_identical(query(i, ymax=d[2], xmax=d[3], xmin=0, ymin=0), i)
+    y <- list(ymax=d[1], xmax=d[2], xmin=0, ymin=0)
+    expect_identical(query(l, y), l)
     # crop but don't shift
-    j <- query(i, xmin=0, xmax=w <- d[3]/2, ymin=0, ymax=h <- d[2]/4)
-    expect_equal(dim(j), c(3, h, w)) 
-    expect_identical(CTdata(i), CTdata(j))
+    y <- list(xmin=0, xmax=w <- d[2]/2, ymin=0, ymax=h <- d[1]/4)
+    expect_equal(dim(m <- query(l, y)), c(h, w)) 
+    expect_identical(CTlist(l), CTlist(m))
     # crop and shift
-    j <- query(i, xmin=1, xmax=w <- d[3]/2, ymin=2, ymax=h <- d[2]/4)
-    expect_equal(dim(j), c(3, 1+h-2, 1+w-1))
-    expect_equal(CTtype(j), t <- "translation")
-    expect_equivalent(CTdata(j)[[t]][[1]], c(0, 2, 1))
+    y <- list(
+        xmin=dx <- 3, xmax=w <- d[2]/2, 
+        ymin=dy <- 5, ymax=h <- d[1]/4)
+    expect_equal(dim(query(l, y)), c(1+h-dy, 1+w-dx))
+    # non-finite boundaries
+    y <- list(xmin=-Inf, xmax=Inf, ymin=-Inf, ymax=Inf)
+    expect_silent(query(l, y))
 })
 
-test_that("query,PointFrame", {
+test_that("query-box,PointFrame", {
     n <- length(p <- point(x))
     # this shouldn't do anything
-    q <- query(p, xmin=-Inf, xmax=Inf, ymin=-Inf, ymax=Inf)
+    q <- query(p, list(xmin=-Inf, xmax=Inf, ymin=-Inf, ymax=Inf))
     expect_is(data(q), "arrow_dplyr_query")
     expect_identical(collect(data(p)), collect(data(q)))
     # this should drop everything
-    q <- query(p, xmin=Inf, xmax=-Inf, ymin=Inf, ymax=-Inf)
+    q <- query(p, list(xmin=0, xmax=1e-3, ymin=0, ymax=1e-3))
     expect_equal(nrow(collect(data(q))), 0)
     # proper query
     bb <- lapply(c("x", "y"), \(.) {
@@ -47,22 +98,44 @@ test_that("query,PointFrame", {
         d <- c((d <- diff(range(v)))/4, d/2)
         names(d) <- paste0(., c("min", "max"))
         as.list(d) }) |> Reduce(f=c)
-    q <- do.call(query, c(list(x=p), bb))
+    q <- do.call(query, c(list(x=p), list(bb)))
     df <- collect(data(p))
     fd <- collect(data(q))
-    i <- df$x >= bb$xmin & df$x <= bb$xmax & 
+    i <- 
+        df$x >= bb$xmin & df$x <= bb$xmax & 
         df$y >= bb$ymin & df$y <= bb$ymax
     expect_identical(df[i, ], fd)
 })
 
-test_that("query,ShapeFrame", {
+test_that("query-pol,PointFrame", {
+    n <- length(p <- point(x))
+    f <- \(.) collect(data(.))
+    # mock all-inclusive query
+    xy <- rbind(c(0,0), c(0,1e6), c(1e6,0))
+    expect_identical(f(query(p, xy)), f(p))
+    # sample random points &
+    # query tiny polygon around them
+    replicate(5, {
+        i <- sample(n, 1)
+        xy <- c(p[i]$x, p[i]$y)
+        i <- p$x == xy[1] & p$y == xy[2]
+        xy <- rbind(
+            xy+c(0, d <- 1e-6),
+            xy+c(-d,-d), xy+c(+d,-d))
+        q <- query(p, xy)
+        expect_length(q, sum(i))
+        expect_identical(f(q), f(p[which(i)]))
+    })
+})
+
+test_that("query-box,ShapeFrame", {
     n <- length(s <- shape(x))
     # mock query without any effect
-    t <- query(s, xmin=-Inf, xmax=Inf, ymin=-Inf, ymax=Inf)
-    expect_equal(collect(data(s)), collect(data(t)))
+    t <- query(s, list(xmin=-Inf, xmax=Inf, ymin=-Inf, ymax=Inf))
+    expect_equal(nrow(data(t)), nrow(data(s)))
     # this should drop everything
-    t <- query(s, xmin=Inf, xmax=-Inf, ymin=Inf, ymax=-Inf)
-    expect_equal(nrow(collect(data(t))), 0)
+    t <- query(s, list(xmin=0, xmax=1e-3, ymin=0, ymax=1e-3))
+    expect_equal(nrow(t), 0)
     # proper query
     xy <- st_coordinates(st_as_sf(data(s)))
     xy <- data.frame(xy); names(xy) <- c("x", "y")
@@ -70,6 +143,26 @@ test_that("query,ShapeFrame", {
     bb <- lapply(xy, \(.) c(.-1e-9, .+1e-9))
     bb <- data.frame(t(unlist(bb)))
     names(bb) <- c("xmin", "xmax", "ymin", "ymax")
-    t <- do.call(query, c(list(x=s), bb))
+    t <- do.call(query, c(list(x=s), list(bb)))
     expect_equal(s[i], t)
 })
+
+test_that("query-pol,ShapeFrame", {
+    n <- length(s <- shape(x))
+    # mock all-inclusive query
+    xy <- rbind(c(0,0), c(0,1e6), c(1e6,0))
+    expect_equal(query(s, xy), s)
+    # sample random shapes &
+    # query tiny polygon around them
+    xy <- st_coordinates(st_as_sf(data(s)))
+    replicate(5, {
+        i <- sample(n, 1)
+        xy <- xy[i, ]
+        xy <- rbind(
+            xy+c(0, d <- 1e-6),
+            xy+c(-d,-d), xy+c(+d,-d))
+        t <- query(s, xy)
+        expect_length(t, 1)
+        expect_equal(t, s[i])
+    })
+})
diff --git a/tests/testthat/test-reading.R b/tests/testthat/test-read.R
similarity index 86%
rename from tests/testthat/test-reading.R
rename to tests/testthat/test-read.R
index 807d261e..57b7a4fe 100644
--- a/tests/testthat/test-reading.R
+++ b/tests/testthat/test-read.R
@@ -11,17 +11,13 @@ test_that("readElement()", {
     for (l in names(typ)) {
         f <- paste0(toupper(substr(l, 1, 1)), substr(l, 2, nchar(l)-1))
         y <- list.files(file.path(x, l), full.names=TRUE)[1]
-        if (l != "tables") {
-            expect_is(get(paste0("read", f))(y), typ[l])
-        } else {
-            expect_is(.readTables_basilisk(x)[[1]], typ[l])
-        }
+        expect_is(get(paste0("read", f))(y), typ[l])
     }
 })
 
 test_that("readSpatialData()", {
     expect_is(y <- readSpatialData(x), "SpatialData")
-    a <- list(images=TRUE, labels=TRUE, shapes=TRUE, points=TRUE)#, tables=TRUE)
+    a <- list(images=TRUE, labels=TRUE, shapes=TRUE, points=TRUE, tables=FALSE)
     for (. in names(a)) {
         # setting any layer to FALSE skips it
         b <- c(list(x=x), a); b[[.]] <- FALSE
diff --git a/tests/testthat/test-sdarray.R b/tests/testthat/test-sdarray.R
new file mode 100644
index 00000000..de123f94
--- /dev/null
+++ b/tests/testthat/test-sdarray.R
@@ -0,0 +1,22 @@
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- readSpatialData(x, anndataR=TRUE)
+
+test_that("data_type()", {
+    # image
+    za <- data(image(x))
+    dt <- data_type(za)
+    expect_length(dt, 1)
+    expect_is(dt, "character")
+    expect_identical(dt, "float64")
+    expect_identical(dt, data_type(za[1,,]))
+    expect_identical(dt, data_type(image(x)))
+    # label
+    za <- data(label(x))
+    dt <- data_type(za)
+    expect_length(dt, 1)
+    expect_is(dt, "character")
+    expect_identical(dt, "int16")
+    expect_identical(dt, data_type(head(za)))
+    expect_identical(dt, data_type(label(x)))
+})
diff --git a/tests/testthat/test-tables.R b/tests/testthat/test-tables.R
index 74e5f6b6..57147ca2 100644
--- a/tests/testthat/test-tables.R
+++ b/tests/testthat/test-tables.R
@@ -1,20 +1,19 @@
-oo = options()$arrow.pull_as_vector
-
-options(arrow.pull_as_vector=TRUE)
 require(SingleCellExperiment, quietly=TRUE)
+oo <- options()$arrow.pull_as_vector
+options(arrow.pull_as_vector=TRUE)
+
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, table=1, anndataR=FALSE)
+x <- readSpatialData(x, anndataR=TRUE)
 
-md <- int_metadata(SpatialData::table(x))
+se <- SpatialData::table(x)
+md <- int_metadata(se)
 md <- md$spatialdata_attrs
 i <- md[[rk <- md$region_key]]
-#int_colData(SpatialData::table(x))[[rk]] <- 
-#    paste(int_colData(SpatialData::table(x))[[rk]])
 
 test_that("hasTable()", {
     # TRUE
-    i <- md$region
+    i <- region(table(x))
     expect_true(hasTable(x, i))
     # FALSE
     j <- setdiff(unlist(colnames(x)), c(i, tableNames(x)))
@@ -32,7 +31,6 @@ test_that("hasTable()", {
     expect_error(hasTable(setTable(x, i), i, name=TRUE)) # many
 })
 
-if (FALSE) {
 test_that("getTable()", {
     # invalid
     expect_error(getTable(x, 123))
@@ -46,21 +44,16 @@ test_that("getTable()", {
     expect_error(getTable(x, i, "."))
     expect_error(getTable(x, i, c(TRUE, FALSE)))
     # alter 'region' of a couple random observations
-    s <- t
-    . <- sample(ncol(s), 2)
-    # TODO: check the replacement of this test below
-    # int_colData(s)[[rk]][.] <- "."
-    tmp <- as.character(colData(s)[[rk]])
-    tmp[.] <- "."
-    colData(s)[[rk]] <- tmp
-    SpatialData::table(x) <- s
+    s <- t; y <- x
+    int_colData(s)[[rk]] <- paste(int_colData(s)[[rk]])
+    int_colData(s)[[rk]][. <- sample(ncol(s), 2)] <- "."
+    SpatialData::table(y) <- s
     # these should be gone when 'drop=TRUE'
-    t1 <- getTable(x, i, drop=FALSE)
-    t2 <- getTable(x, i, drop=TRUE)
+    t1 <- getTable(y, i, drop=FALSE)
+    t2 <- getTable(y, i, drop=TRUE)
     expect_identical(t1, s)
     expect_identical(t2, s[, -.])
 })
-}
 
 test_that("setTable(),labels", {
     # invalid 'i'
@@ -91,8 +84,7 @@ test_that("setTable(),points/shapes", {
         n <- switch(.,
             shape=length(y),
             point={
-                md <- meta(y)$spatialdata_attrs
-                ik <- md$instance_key
+                ik <- instance_key(y)
                 n <- length(unique(pull(data(y), ik)))
             })
         df <- data.frame(foo=runif(n))
@@ -101,8 +93,7 @@ test_that("setTable(),points/shapes", {
         expect_true(hasTable(y, i))
         t <- getTable(y, i)
         expect_identical(t$foo, df$foo)
-        md <- int_metadata(t)$spatialdata_attrs
-        expect_identical(md$region, i)
+        #expect_identical(region(t), i)
         # dots = list of functions
         f <- list(
             numbers=\(n) runif(n),
@@ -112,8 +103,7 @@ test_that("setTable(),points/shapes", {
         expect_true(hasTable(y, i))
         t <- getTable(y, i)
         expect_true(all(names(f) %in% names(colData(t))))
-        md <- int_metadata(t)$spatialdata_attrs
-        expect_identical(md$region, i)
+        #expect_identical(region(t), i)
     }
 })
 
@@ -125,9 +115,9 @@ test_that("valTable()", {
     expect_error(valTable(x, i, sample(rownames(t), 2)))
     expect_error(valTable(x, i, sample(names(colData(t)), 2)))
     # 'colData'
-    df <- DataFrame(a=sample(letters, n), b=runif(n),
-                    region = valTable(x, i, j <- "region"))
-    s <- t; colData(s) <- df; y <- x; SpatialData::table(y) <- s
+    cd <- DataFrame(a=sample(letters, n), b=runif(n))
+    s <- t; colData(s) <- cd
+    y <- x; SpatialData::table(y) <- s
     expect_identical(valTable(y, i, j <- "a"), s[[j]])
     expect_identical(valTable(y, i, j <- "b"), s[[j]])
     expect_error(valTable(y, i, "c"))
diff --git a/tests/testthat/test-trans.R b/tests/testthat/test-trans.R
new file mode 100644
index 00000000..71bb6579
--- /dev/null
+++ b/tests/testthat/test-trans.R
@@ -0,0 +1,160 @@
+zs <- file.path("extdata", "blobs.zarr")
+zs <- system.file(zs, package="SpatialData")
+sd <- readSpatialData(zs, tables=FALSE)
+
+test_that("mirror,sdArray", {
+    x <- label(sd, 1)[-1,-c(1,2)]
+    expect_error(mirror(x, "x"))
+    expect_identical(mirror(x, "v"), flip(x))
+    expect_identical(mirror(x, "h"), flop(x))
+    # vertical reflection
+    y <- flip(x)
+    expect_identical(dim(y), dim(x))
+    expect_equal(data(y)[1, ], rev(data(x)[1, ]))
+    expect_equal(data(y)[, 1], data(x)[, ncol(x)])
+    # horizontal reflection
+    y <- flop(x)
+    expect_identical(dim(y), dim(x))
+    expect_equal(data(y)[, 1], rev(data(x)[, 1]))
+    expect_equal(data(y)[1, ], data(x)[nrow(x), ])
+})
+
+test_that("translation,imageArray", {
+    x <- image(sd, 1)
+    # identity
+    y <- translation(x, c(0,0,0))
+    expect_identical(x, y)
+    expect_null(metadata(y)$wh)
+    # invalid
+    expect_error(translation(x, numeric(2)))
+    expect_error(translation(x, numeric(4)))
+    expect_error(translation(x, character(3)))
+    # row
+    t <- c(0,n <- sample(77, 1),0)
+    z <- translation(y <- x[,-1,-c(1,2)], t)
+    expect_equal(dim(z), dim(y))
+    expect_is(data(z), "DelayedArray")
+    md <- metadata(z)$wh
+    expect_is(md, "list")
+    expect_is(unlist(md), "numeric")
+    expect_equal(md[[1]], c(0, dim(y)[3]))
+    expect_equal(md[[2]], c(n, dim(y)[2]+n))
+    # col
+    t <- c(0,0,n <- sample(77, 1))
+    z <- translation(y <- x[,-1,-c(1,2)], t)
+    expect_equal(dim(z), dim(y))
+    expect_is(data(z), "DelayedArray")
+    md <- metadata(z)$wh
+    expect_is(md, "list")
+    expect_is(unlist(md), "numeric")
+    expect_equal(md[[1]], c(n, dim(y)[3]+n))
+    expect_equal(md[[2]], c(0, dim(y)[2]))
+})
+
+test_that("translation,labelArray", {
+    x <- label(sd, 1)
+    # identity
+    y <- translation(x, c(0,0))
+    expect_identical(x, y)
+    expect_null(metadata(y)$wh)
+    # invalid
+    expect_error(translation(x, numeric(1)))
+    expect_error(translation(x, numeric(3)))
+    expect_error(translation(x, character(2)))
+    # row
+    t <- c(n <- sample(77, 1), 0)
+    z <- translation(y <- x[-1,-c(1,2)], t)
+    expect_equal(dim(z), dim(y))
+    expect_is(data(z), "DelayedArray")
+    md <- metadata(z)$wh
+    expect_is(md, "list")
+    expect_is(unlist(md), "numeric")
+    expect_equal(md[[1]], c(0, dim(y)[2]))
+    expect_equal(md[[2]], c(n, dim(y)[1]+n))
+    # col
+    t <- c(0, n <- sample(77, 1))
+    z <- translation(y <- x[-1,-c(1,2)], t)
+    expect_equal(dim(z), dim(y))
+    expect_is(data(z), "DelayedArray")
+    md <- metadata(z)$wh
+    expect_is(md, "list")
+    expect_is(unlist(md), "numeric")
+    expect_equal(md[[1]], c(n, dim(y)[2]+n))
+    expect_equal(md[[2]], c(0, dim(y)[1]))
+    # TODO: multiscale
+    # x <- label(sd, 2)
+    # t <- c(n <- nrow(x), 0)
+    # y <- translation(x, t)
+    # dx <- vapply(data(x, NULL), dim, integer(2))
+    # dy <- vapply(data(y, NULL), dim, integer(2))
+    # expect_equal(dx[1,], dy[1,]/2)
+    # expect_identical(dx[2,], dy[2,])
+})
+
+test_that("translation,PointFrame", {
+    x <- point(sd, 1)
+    y <- translation(x, c(0,0))
+    expect_identical(x, y)
+    # invalid
+    expect_error(translation(x, numeric(1)))
+    expect_error(translation(x, numeric(3)))
+    expect_error(translation(x, logical(2)))
+    expect_error(translation(x, c(Inf, Inf)))
+    expect_error(translation(x, character(2)))
+    expect_error(translation(x, NA*numeric(2)))
+    # valid
+    i <- setdiff(names(x), c("x", "y"))
+    f <- \() sample(33, 1)*sample(c(-1, 1), 1)
+    replicate(5, {
+        n <- f(); m <- f()
+        y <- translation(x, c(n,m))
+        expect_equal(x$x+n, y$x)
+        expect_equal(x$y+m, y$y)
+        for (. in i) expect_identical(x[[.]], y[[.]])
+    })
+})
+
+test_that("scale,PointFrame", {
+    x <- point(sd, 1)
+    y <- scale(x, c(1, 1))
+    expect_identical(x, y)
+    # invalid
+    expect_error(scale(x, -c(1, 1)))
+    expect_error(scale(x, c(1, -1)))
+    expect_error(scale(x, numeric(1)))
+    expect_error(scale(x, numeric(3)))
+    expect_error(scale(x, logical(2)))
+    expect_error(scale(x, character(2)))
+    expect_error(scale(x, NA*numeric(2)))
+    expect_error(scale(x, c(Inf, Inf)))
+    # valid
+    i <- setdiff(names(x), c("x", "y"))
+    f <- \() replicate(2, runif(1, 0.1, 2))
+    g <- \(.) cbind(.$x, .$y)
+    replicate(5, {
+        y <- scale(x, t <- f())
+        expect_equal(sweep(g(x), 2, t, `*`), g(y))
+    })
+})
+
+test_that("rotate,PointFrame", {
+    x <- point(sd, 1)
+    y <- rotate(x, 0)
+    expect_identical(x, y)
+    # invalid
+    expect_error(rotate(x, Inf))
+    expect_error(rotate(x, numeric(2)))
+    expect_error(rotate(x, logical(1)))
+    expect_error(rotate(x, character(1)))
+    expect_error(rotate(x, NA*numeric(1)))
+    # valid
+    i <- setdiff(names(x), c("x", "y"))
+    f <- \() sample(777, 1)*sample(c(-1, 1), 1)
+    g <- \(.) cbind(.$x, .$y)
+    replicate(5, {
+        y <- rotate(x, t <- f())
+        R <- .R(t*base::pi/180)
+        expect_equal(t(R %*% t(g(x))), g(y))
+        for (. in i) expect_identical(x[[.]], y[[.]])
+    })
+})
diff --git a/tests/testthat/test-utils.R b/tests/testthat/test-utils.R
new file mode 100644
index 00000000..74343ff3
--- /dev/null
+++ b/tests/testthat/test-utils.R
@@ -0,0 +1,98 @@
+xy <- c("x", "y")
+require(sf, quietly=TRUE)
+x <- file.path("extdata", "blobs.zarr")
+x <- system.file(x, package="SpatialData")
+x <- readSpatialData(x, tables=FALSE)
+
+test_that("centroids,LabelArray", {
+    y <- label(x)
+    z <- centroids(y, "data.frame")
+    expect_is(z, "data.frame")
+    expect_identical(names(z), c(xy, "i"))
+    expect_is(z$i, "factor")
+    expect_is(unlist(z[xy]), "numeric")
+    .z <- centroids(y, "matrix")
+    expect_is(.z, "matrix")
+    z$i <- as.integer(as.character(z$i))
+    expect_identical(.z, as.matrix(z))
+})
+test_that("centroids,PointFrame", {
+    i <- feature_key(y <- point(x))
+    z <- centroids(y, "data.frame")
+    expect_is(z, "data.frame")
+    expect_identical(names(z), c(xy, i))
+    expect_is(z[[i]], "factor")
+    expect_is(unlist(z[xy]), "integer")
+    .z <- centroids(y, "list")
+    expect_is(.z, "list")
+    expect_all_true(names(.z) %in% z[[i]])
+    expect_length(.z, length(unique(z[[i]])))
+    for (. in names(.z)) expect_identical(
+        .z[[.]][xy], z[z[[i]] == ., xy])
+})
+test_that("centroids,ShapeFrame", {
+    # circle
+    y <- shape(x)
+    z <- centroids(y, "data.frame")
+    expect_is(z, "data.frame")
+    expect_identical(names(z), xy)
+    expect_is(unlist(z[xy]), "numeric")
+    .z <- centroids(y, "matrix")
+    expect_identical(.z, as.matrix(z))
+    # polygon
+    y <- shape(x, 3)
+    z <- centroids(y, "data.frame")
+    expect_is(z, "data.frame")
+    expect_all_true(xy %in% names(z))
+    expect_is(z[[ncol(z)]], "factor")
+    expect_is(unlist(z[xy]), "numeric")
+    .z <- centroids(y, "matrix")
+    expect_is(.z, "matrix")
+    expect_identical(.z[, xy], as.matrix(z[xy]))
+    # multipolygon
+    y <- shape(x, 2)
+    z <- centroids(y, "data.frame")
+    expect_is(z, "data.frame")
+    expect_all_true(xy %in% names(z))
+    expect_is(z[[ncol(z)]], "factor")
+    expect_is(unlist(z[xy]), "numeric")
+    .z <- centroids(y, "matrix")
+    expect_is(.z, "matrix")
+    for (. in seq(3, ncol(z)))
+        z[[.]] <- as.integer(as.character(z[[.]]))
+    expect_identical(.z, as.matrix(z))
+})
+
+test_that("extent,ImageArray", {
+    z <- extent(y <- image(x)[,-1,-c(1,2)])
+    expect_is(z, "list")
+    expect_is(unlist(z), "numeric")
+    expect_identical(names(z), rev(xy))
+    expect_identical(z$y, c(0, dim(y)[2]))
+    expect_identical(z$x, c(0, dim(y)[3]))
+})
+test_that("extent,LabelArray", {
+    z <- extent(y <- label(x)[,-1,-c(1,2)])
+    expect_is(z, "list")
+    expect_is(unlist(z), "numeric")
+    expect_identical(names(z), rev(xy))
+    expect_identical(z$y, c(0, dim(y)[1]))
+    expect_identical(z$x, c(0, dim(y)[2]))
+})
+test_that("extent,PointFrame", {
+    z <- extent(y <- point(x))
+    expect_is(z, "list")
+    expect_identical(names(z), xy)
+    expect_is(unlist(z), "integer")
+    expect_identical(z$x, range(y$x))
+    expect_identical(z$y, range(y$y))
+})
+test_that("extent,ShapeFrame", {
+    z <- extent(y <- shape(x))
+    expect_is(z, "list")
+    expect_identical(names(z), xy)
+    expect_is(unlist(z), "numeric")
+    mx <- st_coordinates(st_as_sf(data(y)))
+    expect_identical(z$x, range(mx[, 1]))
+    expect_identical(z$y, range(mx[, 2]))
+})
diff --git a/tests/testthat/test-validity.R b/tests/testthat/test-validity.R
new file mode 100644
index 00000000..e08c8393
--- /dev/null
+++ b/tests/testthat/test-validity.R
@@ -0,0 +1,48 @@
+require(dplyr, quietly=TRUE)
+zs <- file.path("extdata", "blobs.zarr")
+zs <- system.file(zs, package="SpatialData")
+sd <- readSpatialData(zs, tables=FALSE)
+
+test_that("validity,ImageArray", {
+    # all resolutions should be numbers
+    # (note: logical gets coerced to binary)
+    expect_error(ImageArray(list(v <- character(1))))
+    x <- image(sd,1); x@data[[1]][1,1,1] <- v; expect_error(validObject(x))
+    x <- image(sd,2); x@data[[2]][1,1,1] <- v; expect_error(validObject(x))
+    # there should be three dimensions (channels + spatial)
+    expect_error(ImageArray(list(a <- array(numeric(1), c(1,1)))))
+    x <- image(sd,1); x@data[[1]] <- a; expect_error(validObject(x))
+    x <- image(sd,2); x@data[[2]] <- a; expect_error(validObject(x))
+})
+
+test_that("validity,LabelArray", {
+    # all resolutions should be of type integer
+    for (v in list(logical(1), character(1), numeric(1))) {
+        expect_error(LabelArray(list(v)))
+        x <- label(sd,1); x@data[[1]][1,1] <- v; expect_error(validObject(x))
+        x <- label(sd,2); x@data[[2]][1,1] <- v; expect_error(validObject(x))
+    }
+    # there should be two dimensions
+    expect_error(LabelArray(list(a <- array(integer(1), c(1,1,1)))))
+    x <- label(sd,1); x@data[[1]] <- a; expect_error(validObject(x))
+    x <- label(sd,2); x@data[[2]] <- a; expect_error(validObject(x))
+})
+
+test_that("validity,PointFrame", {
+    x <- point(sd,1)
+    expect_error(validObject(select(x, -x)))
+    expect_error(validObject(select(x, -y)))
+    expect_silent(validObject(select(x, -c(x, y))[0,]))
+})
+
+test_that("validity,ShapeFrame", {
+    x <- shape(sd,1)
+    x@data <- select(data(x), -radius)
+    expect_silent(validObject(x))
+    x <- shape(sd,1)
+    x@data <- filter(data(x), radius == Inf)
+    expect_silent(validObject(x))
+    x <- shape(sd,1)
+    x@data <- select(data(x), -geometry)
+    expect_error(validObject(x))
+})
diff --git a/tests/testthat/test-zarrutils.R b/tests/testthat/test-zarrutils.R
index 1d086572..6b0708dd 100644
--- a/tests/testthat/test-zarrutils.R
+++ b/tests/testthat/test-zarrutils.R
@@ -32,52 +32,116 @@ test_that("create zarr/group", {
   expect_true(dir.exists(file.path(output_zarr, "group3/subgroup1/subsubgroup1")))
   expect_true(file.exists(file.path(output_zarr, "group3/subgroup1/subsubgroup1", ".zgroup")))
   
-  # version 3 and other entries
+  # invalid version string
   dir.create(td <- tempfile())
   name <- "test"
-  output_zarr <- file.path(td, paste0(name, ".zarr"))
-  expect_error(create_zarr(dir = td, name = name, version = "v4"), pattern = "only zarr v2 is supported")
+  expect_error(create_zarr(dir = td, name = name, version = "v4"), pattern = "version must be 'v2' or 'v3'")
 })
 
+test_that("create zarr/group v3", {
 
-# create zarr array
+  dir.create(td <- tempfile())
+  name <- "test.zarr"
+  output_zarr <- file.path(td, name)
+
+  # open v3 zarr store
+  create_zarr(name = name, dir = td, version = "v3")
+  expect_true(dir.exists(output_zarr))
+  expect_true(file.exists(file.path(output_zarr, "zarr.json")))
+  expect_false(file.exists(file.path(output_zarr, ".zgroup")))
+
+  # check zarr.json exists and attributes are empty
+  expect_true(file.exists(file.path(output_zarr, "zarr.json")))
+  expect_equal(Rarr::read_zarr_attributes(output_zarr), list())
+
+  # create a sub-group
+  create_zarr_group(store = output_zarr, name = "images", version = "v3")
+  expect_true(file.exists(file.path(output_zarr, "images", "zarr.json")))
+  expect_false(file.exists(file.path(output_zarr, "images", ".zgroup")))
+
+  # create nested groups — parent group should also be v3
+  create_zarr_group(store = output_zarr, name = "points/blobs_points", version = "v3")
+  expect_true(file.exists(file.path(output_zarr, "points", "zarr.json")))
+  expect_true(file.exists(file.path(output_zarr, "points/blobs_points", "zarr.json")))
+})
+
+
+# create a v2 zarr array for the v2 zattrs tests
 dir.create(td <- tempfile())
 path <- file.path(td, "test.zarr")
 x <- array(runif(n = 10), dim = c(2, 5))
 Rarr::write_zarr_array(
   x = x, zarr_array_path = path,
-  chunk_dim = c(2, 5)
+  chunk_dim = c(2, 5), zarr_version = 2L
 )
 
 test_that("read/write zattrs", {
   
   # add .zattrs to /
   zattrs <- list(foo = "foo", bar = "bar")
-  write_zattrs(path = path, new.zattrs = zattrs)
+  Rarr::write_zarr_attributes(path, new.zattrs = zattrs)
   expect_true(file.exists(file.path(path, ".zattrs")))
-  
+
   # check .zattrs
-  read.zattrs <- read_zattrs(path)
+  read.zattrs <- Rarr::read_zarr_attributes(path)
   expect_equal(read.zattrs, zattrs)
-  
+
   # add new elements to .zattrs
   zattrs.new.elem <- list(foo2 = "foo")
-  write_zattrs(path = path, new.zattrs = zattrs.new.elem)
-  read.zattrs <- read_zattrs(path)
+  Rarr::write_zarr_attributes(path, new.zattrs = zattrs.new.elem)
+  read.zattrs <- Rarr::read_zarr_attributes(path)
   expect_equal(read.zattrs, c(zattrs,zattrs.new.elem))
-  
+
   # overwrite
   zattrs.new.elem <- list(foo2 = "foo2")
-  write_zattrs(path = path, new.zattrs = zattrs.new.elem)
-  read.zattrs <- read_zattrs(path)
+  Rarr::write_zarr_attributes(path, new.zattrs = zattrs.new.elem)
+  read.zattrs <- Rarr::read_zarr_attributes(path)
   zattrs[names(zattrs.new.elem)] <- zattrs.new.elem
   expect_equal(read.zattrs, c(zattrs))
-  
+
   # overwrite = FALSE
   zattrs.new.elem <- list(foo2 = "foo")
-  write_zattrs(path = path, new.zattrs = zattrs.new.elem, overwrite = FALSE)
-  read.zattrs <- read_zattrs(path)
+  Rarr::write_zarr_attributes(path, new.zattrs = zattrs.new.elem, overwrite = FALSE)
+  read.zattrs <- Rarr::read_zarr_attributes(path)
   zattrs[names(zattrs.new.elem)] <- "foo2"
   expect_equal(read.zattrs, c(zattrs))
-  
+
+})
+
+test_that("read/write zattrs v3", {
+
+  # create a v3 zarr group to use as the target path
+  dir.create(td <- tempfile())
+  grp <- file.path(td, "elem")
+  create_zarr_group(store = td, name = "elem", version = "v3")
+
+  # write attributes into zarr.json
+  zattrs <- list(foo = "foo", bar = "bar")
+  Rarr::write_zarr_attributes(grp, new.zattrs = zattrs)
+  expect_true(file.exists(file.path(grp, "zarr.json")))
+  expect_false(file.exists(file.path(grp, ".zattrs")))
+
+  # read back attributes from zarr.json
+  read.zattrs <- Rarr::read_zarr_attributes(grp)
+  expect_equal(read.zattrs, zattrs)
+
+  # zarr.json must still exist (zarr_format / node_type preserved by Rarr internally)
+  expect_true(file.exists(file.path(grp, "zarr.json")))
+
+  # add new element
+  Rarr::write_zarr_attributes(grp, new.zattrs = list(baz = "baz"))
+  read.zattrs <- Rarr::read_zarr_attributes(grp)
+  expect_equal(read.zattrs, c(zattrs, list(baz = "baz")))
+
+  # overwrite existing key
+  Rarr::write_zarr_attributes(grp, new.zattrs = list(foo = "FOO"))
+  read.zattrs <- Rarr::read_zarr_attributes(grp)
+  expect_equal(read.zattrs$foo, "FOO")
+  expect_equal(read.zattrs$bar, "bar")   # untouched key preserved
+
+  # overwrite = FALSE should not overwrite existing key
+  Rarr::write_zarr_attributes(grp, new.zattrs = list(foo = "original"), overwrite = FALSE)
+  read.zattrs <- Rarr::read_zarr_attributes(grp)
+  expect_equal(read.zattrs$foo, "FOO")   # unchanged
+
 })
\ No newline at end of file
diff --git a/tests/testthat/test-zattrs.R b/tests/testthat/test-zattrs.R
index c618854e..ccfc0edb 100644
--- a/tests/testthat/test-zattrs.R
+++ b/tests/testthat/test-zattrs.R
@@ -1,134 +1,51 @@
-x <- file.path("extdata", "blobs.zarr")
-x <- system.file(x, package="SpatialData")
-x <- readSpatialData(x, anndataR=FALSE)
+z <- list(v1="blobs.zarr", v3="blobs_v3.zarr")
 
-test_that("axes", {
-    # image
-    y <- axes(image(x))
-    expect_is(y, "data.frame")
-    expect_equal(dim(y), c(3, 2))
-    # label
-    y <- axes(label(x))
-    expect_is(y, "data.frame")
-    expect_equal(dim(y), c(2, 2))
-    # shape
-    y <- axes(shape(x))
-    expect_is(y, "character")
-    expect_length(y, 2)
-    # point
-    y <- axes(point(x))
-    expect_is(y, "character")
-    expect_length(y, 2)
-})
+for (v in names(z)) {
+    
+    x <- file.path("extdata", z[[v]])
+    x <- system.file(x, package="SpatialData")
+    x <- readSpatialData(x, anndataR=TRUE)
+        
+    test_that(paste0(v, "-multiscales"), {
+        y <- meta(image(x))
+        z <- multiscales(y)
+        expect_is(z, "list")
+        expect_length(z, 1)
+        y$spatialdata_attrs <- NULL
+        expect_error(multiscales(y))
+    })
+    
+    test_that(paste0(v, "-axes"), {
+        # image
+        y <- axes(image(x))
+        expect_is(y, "list")
+        expect_length(y, 3)
+        # label
+        y <- axes(label(x))
+        expect_is(y, "list")
+        expect_length(y, 2)
+        # shape
+        y <- axes(shape(x))
+        expect_is(y, "list")
+        expect_length(y, 2)
+        expect_equal(unlist(y), c("x", "y"))
+        # point
+        y <- axes(point(x))
+        expect_is(y, "list")
+        expect_length(y, 2)
+        expect_equal(unlist(y), c("x", "y"))
+        # missing
+        y <- image(x)
+        switch(v,
+            "v3"=y@meta$ome$multiscales[[1]]$axes <- NULL,
+            y@meta$multiscales[[1]]$axes <- NULL)
+        expect_error(axes(y))
+    })
+    
+    test_that(paste0(v, "-channels"), {
+        expect_error(channels(label(x)))
+        expect_silent(z <- channels(y <- image(x)))
+        expect_length(z, dim(y)[1])
+    })
 
-test_that("rmvCT", {
-    y <- label(x)
-    # invalid index/name
-    expect_error(rmvCT(y, 100))
-    expect_error(rmvCT(y, "."))
-    expect_error(rmvCT(y, c(".", CTname(y)[1])))
-    # by name
-    i <- sample(CTname(y), 2) 
-    expect_identical(CTname(rmvCT(y, i)), setdiff(CTname(y), i))
-    # by index
-    i <- sample(seq_along(CTname(y)), 2) 
-    expect_identical(CTname(rmvCT(y, i)), CTname(y)[-i])
-})
-
-test_that("addCT", {
-    # get 1st element from each layer
-    ls <- setdiff(SpatialData:::.LAYERS, "tables")
-    es <- lapply(ls, \(.) x[.,1][[.]][[1]])
-    .check_data <- \(z, x) {
-        expect_true("." %in% CTname(z))
-        ct <- CTdata(z)[CTname(z) == ".", ]
-        expect_identical(ct[[t]][[1]], x)
-    }
-    for (y in es) {
-        t <- "identity"
-        expect_error(addCT(y, ".", t, 12345))
-        expect_silent(z <- addCT(y, ".", t, v <- NULL))
-        .check_data(z, v)
-        t <- "rotate"
-        expect_error(addCT(y, ".", t, -12345)) # negative
-        expect_error(addCT(y, ".", t, c(1,1))) # too many
-        expect_error(addCT(y, ".", t, ".")) # not a number
-        expect_silent(z <- addCT(y, ".", t, v <- 1)) 
-        .check_data(z, v)
-        t <- "scale"
-        d <- ifelse(is(y, "ImageArray"), 3, 2)
-        expect_error(addCT(y, ".", t, numeric(d))) # zeroes
-        expect_error(addCT(y, ".", t, 1+numeric(d+1))) # too many
-        expect_error(addCT(y, ".", t, character(d))) # not a number
-        expect_silent(z <- addCT(y, ".", t, v <- 1+numeric(d)))
-        .check_data(z, v)
-        t <- "translation"
-        expect_error(addCT(y, ".", t, numeric(d+1))) # too many
-        expect_error(addCT(y, ".", t, character(d))) # not a number
-        expect_silent(z <- addCT(y, ".", t, v <- numeric(d)))
-        .check_data(z, v)
-    }
-})
-
-test_that("CTname", {
-    y <- CTname(x)
-    expect_is(y, "character")
-    expect_true(!any(duplicated(y)))
-    y <- CTname(image(x))
-    z <- CTname(meta(image(x)))
-    expect_is(y, "character")
-    expect_length(y, 1)
-    expect_identical(y, z)
-})
-
-test_that("CTgraph", {
-    # invalid
-    expect_error(CTgraph(list()))
-    expect_error(CTgraph(SpatialData::table(x)))
-    # object-wide
-    g <- CTgraph(x)
-    expect_is(g, "graph")
-    # graph should contain node for
-    # every element & transformation
-    ns <- lapply(setdiff(SpatialData:::.LAYERS, "tables"), 
-        \(l) lapply(names(x[[l]]), 
-        \(e) c(e, CTname(x[[l]][[e]]))))
-    ns <- sort(unique(unlist(ns)))
-    expect_true(all(ns %in% sort(graph::nodes(g))))
-    # element-wise
-    for (l in setdiff(SpatialData:::.LAYERS, "tables")) 
-        for (e in names(x[[l]])) {
-            y <- x[[l]][[e]]
-            g <- CTgraph(y)
-            expect_is(g, "graph")
-            expect_true("self" %in% graph::nodes(g))
-        }
-})
-
-test_that("CTpath", {
-    i <- "blobs_image"
-    y <- element(x, "images", i)
-    z <- CTpath(y, j <- CTname(y))
-    expect_identical(CTpath(x, i, j), z)
-    expect_is(z, "list")
-    expect_length(z <- z[[1]], 2)
-    expect_setequal(names(z), c("type", "data"))
-    expect_is(z$type, "character")
-    expect_length(z$type, 1)
-})
-
-test_that("plotCoordGraph", {
-    f <- function(.) {
-        tf <- tempfile(fileext=".pdf")
-        on.exit(unlink(tf))
-        pdf(tf); .; dev.off()
-        file.size(tf)
-    }
-    g <- CTgraph(x)
-    p <- f(plotCoordGraph(g))
-    expect_is(p, "numeric")
-    expect_true(p > f(plot(1)))
-    p <- f(plotCoordGraph(g, 0.1))
-    q <- f(plotCoordGraph(g, 0.9))
-    expect_true(p < q)
-})
+}
\ No newline at end of file
diff --git a/vignettes/SpatialData.Rmd b/vignettes/SpatialData.Rmd
index 956096ff..8c6e879d 100644
--- a/vignettes/SpatialData.Rmd
+++ b/vignettes/SpatialData.Rmd
@@ -49,7 +49,7 @@ For demonstration, we read in a toy dataset that is available through the packag
 ```{r blobs-read}
 x <- file.path("extdata", "blobs.zarr")
 x <- system.file(x, package="SpatialData")
-(x <- readSpatialData(x, anndataR=FALSE))  # VJC Dec 8, test effect of absence of anndataR
+(x <- readSpatialData(x, anndataR=TRUE))
 ```
 
 `SpatialData` object behave like a list, thereby supporting flexible accession, 
@@ -119,9 +119,7 @@ To facilitate .zattrs handling, we provide a set of functions to access and modi
 - `rmv/addCT` to remove, add, or append coordinate transformations
 
 ```{r cs-methods}
-z <- meta(label(x))
-axes(z)
-CTdata(z)
+(z <- meta(label(x)))
 CTname(rmvCT(z, "scale"))
 CTname(addCT(z, 
     name="D'Artagnan", 
@@ -134,7 +132,7 @@ We can represent these are a graph as follows:
 
 ```{r cs-graph}
 (g <- CTgraph(x))
-plotCoordGraph(g)
+CTplot(g)
 ```
 
 The above representation greatly facilitates queries of the transformation(s) 
diff --git a/vignettes/SpatialData.html b/vignettes/SpatialData.html
index cf711c6f..0f8bfcff 100644
--- a/vignettes/SpatialData.html
+++ b/vignettes/SpatialData.html
@@ -10,7 +10,7 @@
 
 
 
-<meta name="date" content="2024-11-24" />
+<meta name="date" content="2026-04-02" />
 
 <title>SpatialData</title>
 
@@ -702,9 +702,9 @@
 
 <h1 class="title toc-ignore"><code>SpatialData</code></h1>
 <p class="author-name">Helena Lucia Crowell, Louise Deconinck, Artür Manukyan, Dario Righelli, Estella Dong and Vince Carey</p>
-<h4 class="date">November 24, 2024</h4>
+<h4 class="date">April 02, 2026</h4>
 <h4 class="package">Package</h4>
-<p>SpatialData 0.99.19</p>
+<p>SpatialData 0.99.25</p>
 
 </div>
 
@@ -717,14 +717,11 @@ <h1>Contents</h1>
 <li><a href="#annotations" id="toc-annotations"><span class="toc-section-number">1.2</span> Annotations</a></li>
 <li><a href="#transformations" id="toc-transformations"><span class="toc-section-number">1.3</span> Transformations</a></li>
 </ul></li>
-<li><a href="#datasets" id="toc-datasets"><span class="toc-section-number">2</span> Datasets</a></li>
-<li><a href="#session-info" id="toc-session-info"><span class="toc-section-number">3</span> Session info</a></li>
+<li><a href="#session-info" id="toc-session-info"><span class="toc-section-number">2</span> Session info</a></li>
 </ul>
 </div>
 
-<pre class="r"><code>library(ggplot2)
-library(ggnewscale)
-library(SpatialData)
+<pre class="r"><code>library(SpatialData)
 library(SingleCellExperiment)</code></pre>
 <div id="introduction" class="section level1" number="1">
 <h1><span class="header-section-number">1</span> Introduction</h1>
@@ -733,11 +730,11 @@ <h1><span class="header-section-number">1</span> Introduction</h1>
 <code>.zarr</code> files that follow <a href="https://ngff.openmicroscopy.org/latest/#image-layout">OME-NGFF specs</a>.</p>
 <p>Each <code>SpatialData</code> object is composed of five layers: images, labels, shapes,
 points, and tables. Each layer may contain an arbitrary number of elements.</p>
-<p>Images and labels are represented as <code>ZarrArray</code>s (<em><a href="https://bioconductor.org/packages/3.20/Rarr">Rarr</a></em>).
+<p>Images and labels are represented as <code>ZarrArray</code>s (<em><a href="https://bioconductor.org/packages/3.23/Rarr">Rarr</a></em>).
 Points and shapes are represented as <em><a href="https://CRAN.R-project.org/package=arrow">arrow</a></em> objects linked
 to an on-disk <em>.parquet</em> file. As such, all data are represented out of memory.</p>
 <p>Element annotation as well as cross-layer summarizations (e.g., count matrices)
-are represented as <em><a href="https://bioconductor.org/packages/3.20/SingleCellExperiment">SingleCellExperiment</a></em> as tables.</p>
+are represented as <em><a href="https://bioconductor.org/packages/3.23/SingleCellExperiment">SingleCellExperiment</a></em> as tables.</p>
 <div id="handling" class="section level2" number="1.1">
 <h2><span class="header-section-number">1.1</span> Handling</h2>
 <p>For demonstration, we read in a toy dataset that is available through the package:</p>
@@ -792,20 +789,11 @@ <h2><span class="header-section-number">1.1</span> Handling</h2>
 ## 
 ## See $metadata for additional Schema metadata</code></pre>
 <pre class="r"><code>meta(shape(x)) </code></pre>
-<pre><code>## An object of class &quot;Zattrs&quot;
-## [[1]]
-## [1] &quot;x&quot; &quot;y&quot;
-## 
-## [[2]]
-##     input.axes input.name  output.axes output.name     type
-## 1 c(&quot;x&quot;, &quot;....         xy c(&quot;x&quot;, &quot;....      global identity
-## 
-## [[3]]
-## [1] &quot;ngff:shapes&quot;
-## 
-## [[4]]
-## [[4]]$version
-## [1] &quot;0.2&quot;</code></pre>
+<pre><code>## class: Zattrs
+## axes(2):
+## - name: x y 
+## coordTrans(1):
+## - global: (identity)</code></pre>
 </div>
 <div id="annotations" class="section level2" number="1.2">
 <h2><span class="header-section-number">1.2</span> Annotations</h2>
@@ -853,14 +841,14 @@ <h2><span class="header-section-number">1.2</span> Annotations</h2>
 y &lt;- setTable(x, i, df)
 head(colData(getTable(y, i)))</code></pre>
 <pre><code>## DataFrame with 6 rows and 1 column
-##           n
-##   &lt;numeric&gt;
-## 1 0.0741157
-## 2 0.2648403
-## 3 0.5950422
-## 4 0.6883271
-## 5 0.0452319
-## 6 0.1401131</code></pre>
+##            n
+##    &lt;numeric&gt;
+## 1 0.00353685
+## 2 0.94029116
+## 3 0.78284891
+## 4 0.97153644
+## 5 0.81024104
+## 6 0.72704077</code></pre>
 <pre class="r"><code># ...using a list of data generating functions
 f &lt;- list(
     numbers=\(n) runif(n),
@@ -871,12 +859,12 @@ <h2><span class="header-section-number">1.2</span> Annotations</h2>
 <pre><code>## DataFrame with 6 rows and 2 columns
 ##     numbers     letters
 ##   &lt;numeric&gt; &lt;character&gt;
-## 1  0.156174           m
-## 2  0.998399           m
-## 3  0.418688           d
-## 4  0.302950           k
-## 5  0.319555           x
-## 6  0.443932           l</code></pre>
+## 1 0.9760238           f
+## 2 0.8935270           p
+## 3 0.0271508           l
+## 4 0.6642598           a
+## 5 0.3210180           o
+## 6 0.4329136           d</code></pre>
 </div>
 <div id="transformations" class="section level2" number="1.3">
 <h2><span class="header-section-number">1.3</span> Transformations</h2>
@@ -886,32 +874,26 @@ <h2><span class="header-section-number">1.3</span> Transformations</h2>
 <li><code>CTdata/name/type</code> to access coordinate transformation components</li>
 <li><code>rmv/addCT</code> to remove, add, or append coordinate transformations</li>
 </ul>
-<pre class="r"><code>z &lt;- meta(label(x))
-axes(z)</code></pre>
-<pre><code>##   name  type
-## 1    y space
-## 2    x space</code></pre>
-<pre class="r"><code>CTdata(z)</code></pre>
-<pre><code>##     input.axes input.name  output.axes output.name        type scale
-## 1 c(&quot;y&quot;, &quot;....         yx c(&quot;y&quot;, &quot;....      global    identity      
-## 2 c(&quot;y&quot;, &quot;....         yx c(&quot;y&quot;, &quot;....       scale       scale  3, 2
-## 3 c(&quot;y&quot;, &quot;....         yx c(&quot;y&quot;, &quot;.... translation translation      
-## 4 c(&quot;y&quot;, &quot;....         yx c(&quot;x&quot;, &quot;....      affine      affine      
-## 5 c(&quot;y&quot;, &quot;....         yx c(&quot;y&quot;, &quot;....    sequence    sequence      
-##   translation       affine transformations
-## 1                                         
-## 2                                         
-## 3     -50, 10                             
-## 4             20, 50, ....                
-## 5                             list(axe....</code></pre>
+<pre class="r"><code>(z &lt;- meta(label(x)))</code></pre>
+<pre><code>## class: Zattrs
+## axes(2):
+## - name: y x 
+## - type: space space 
+## coordTrans(5):
+## - global: (identity)
+## - scale: (scale)
+## - translation: (translation)
+## - affine: (affine)
+## - sequence: (sequence)
+## datasets(1): 0
+## - 0: (scale:[1,1])</code></pre>
 <pre class="r"><code>CTname(rmvCT(z, &quot;scale&quot;))</code></pre>
 <pre><code>## [1] &quot;global&quot;      &quot;translation&quot; &quot;affine&quot;      &quot;sequence&quot;</code></pre>
 <pre class="r"><code>CTname(addCT(z, 
     name=&quot;D&#39;Artagnan&quot;, 
     type=&quot;scale&quot;, 
     data=c(19, 94)))</code></pre>
-<pre><code>## [1] &quot;global&quot;      &quot;scale&quot;       &quot;translation&quot; &quot;affine&quot;      &quot;sequence&quot;   
-## [6] &quot;D&#39;Artagnan&quot;</code></pre>
+<pre><code>## [1] &quot;D&#39;Artagnan&quot;</code></pre>
 <p><code>Zattrs</code> specify an explicit relationship between elements and coordinate systems.
 We can represent these are a graph as follows:</p>
 <pre class="r"><code>(g &lt;- CTgraph(x))</code></pre>
@@ -919,7 +901,7 @@ <h2><span class="header-section-number">1.3</span> Transformations</h2>
 ## Number of Nodes = 14 
 ## Number of Edges = 13</code></pre>
 <pre class="r"><code>plotCoordGraph(g)</code></pre>
-<p><img role="img" src="data:image/png;base64,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" width="100%" /></p>
+<p><img role="img" aria-label src="data:image/png;base64,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" alt width="100%" /></p>
 <p>The above representation greatly facilitates queries of the transformation(s)
 required to spatially align elements. <code>blobs_labels</code>, for example, requires a
 sequential transformation (scaling and translation) for the <code>sequence</code> space:</p>
@@ -931,7 +913,12 @@ <h2><span class="header-section-number">1.3</span> Transformations</h2>
 invisible(CTpath(y, j))</code></pre>
 <pre><code>## [[1]]
 ## [[1]]$data
-## [1] 3 2
+## [[1]]$data[[1]]
+## [1] 3
+## 
+## [[1]]$data[[2]]
+## [1] 2
+## 
 ## 
 ## [[1]]$type
 ## [1] &quot;scale&quot;
@@ -939,55 +926,26 @@ <h2><span class="header-section-number">1.3</span> Transformations</h2>
 ## 
 ## [[2]]
 ## [[2]]$data
-## [1] -50  10
+## [[2]]$data[[1]]
+## [1] -50
+## 
+## [[2]]$data[[2]]
+## [1] 10
+## 
 ## 
 ## [[2]]$type
 ## [1] &quot;translation&quot;</code></pre>
 </div>
 </div>
-<div id="datasets" class="section level1" number="2">
-<h1><span class="header-section-number">2</span> Datasets</h1>
-<p>Data from a variety of technologies has been made available as <code>SpatialData</code> .zarr stores
-<a href="https://spatialdata.scverse.org/en/latest/tutorials/notebooks/datasets/README.html">here</a>.
-These, in turn, have been deposited in Bioconductor’s NSF Open Storage Network bucket,
-and can be retrieved with caching support using <em><a href="https://bioconductor.org/packages/3.20/BiocFileCache">BiocFileCache</a></em>.</p>
-<p>We can interrogate the bucket for available (zipped) .zarr archives:</p>
-<pre class="r"><code>available_spd_zarr_zips()</code></pre>
-<pre><code>## [1] &quot;mcmicro_io.zip&quot;                         
-## [2] &quot;merfish.zarr.zip&quot;                       
-## [3] &quot;mibitof.zip&quot;                            
-## [4] &quot;steinbock_io.zip&quot;                       
-## [5] &quot;visium_associated_xenium_io_aligned.zip&quot;
-## [6] &quot;visium_hd_3.0.0_io.zip&quot;</code></pre>
-<p>Any of the above can be retrieved (once) into some location, and read into R; for example:</p>
-<pre class="r"><code>dir.create(td &lt;- tempfile())
-pa &lt;- unzip_spd_demo(
-    zipname=&quot;merfish.zarr.zip&quot;, 
-    dest=td, source=&quot;biocOSN&quot;)
-(x &lt;- readSpatialData(pa))</code></pre>
-<pre><code>## class: SpatialData
-## - images(1):
-##   - rasterized (1,522,575)
-## - labels(0):
-## - points(1):
-##   - single_molecule (3714642)
-## - shapes(2):
-##   - anatomical (6,polygon)
-##   - cells (2389,circle)
-## - tables(1):
-##   - table (268,2389)
-## coordinate systems:
-## - global(4): rasterized anatomical cells single_molecule</code></pre>
-</div>
-<div id="session-info" class="section level1" number="3">
-<h1><span class="header-section-number">3</span> Session info</h1>
-<pre><code>## R version 4.4.1 Patched (2024-07-08 r86893)
-## Platform: aarch64-apple-darwin20
-## Running under: macOS Sonoma 14.2.1
+<div id="session-info" class="section level1" number="2">
+<h1><span class="header-section-number">2</span> Session info</h1>
+<pre><code>## R version 4.6.0 alpha (2026-03-26 r89725)
+## Platform: aarch64-apple-darwin23
+## Running under: macOS Sequoia 15.6.1
 ## 
 ## Matrix products: default
-## BLAS:   /Library/Frameworks/R.framework/Versions/4.4-arm64/Resources/lib/libRblas.0.dylib 
-## LAPACK: /Library/Frameworks/R.framework/Versions/4.4-arm64/Resources/lib/libRlapack.dylib;  LAPACK version 3.12.0
+## BLAS:   /Library/Frameworks/R.framework/Versions/4.6/Resources/lib/libRblas.0.dylib 
+## LAPACK: /Library/Frameworks/R.framework/Versions/4.6/Resources/lib/libRlapack.dylib;  LAPACK version 3.12.1
 ## 
 ## locale:
 ## [1] en_US.UTF-8/en_US.UTF-8/en_US.UTF-8/C/en_US.UTF-8/en_US.UTF-8
@@ -1000,49 +958,42 @@ <h1><span class="header-section-number">3</span> Session info</h1>
 ## [8] base     
 ## 
 ## other attached packages:
-##  [1] Rarr_1.6.0                  DelayedArray_0.32.0        
-##  [3] SparseArray_1.6.0           S4Arrays_1.6.0             
-##  [5] abind_1.4-8                 Matrix_1.7-1               
-##  [7] SingleCellExperiment_1.28.0 SummarizedExperiment_1.36.0
-##  [9] Biobase_2.66.0              GenomicRanges_1.58.0       
-## [11] GenomeInfoDb_1.42.0         IRanges_2.40.0             
-## [13] S4Vectors_0.44.0            BiocGenerics_0.52.0        
-## [15] MatrixGenerics_1.18.0       matrixStats_1.4.1          
-## [17] SpatialData_0.99.19         ggnewscale_0.5.0           
-## [19] ggplot2_3.5.1               BiocStyle_2.34.0           
+##  [1] SingleCellExperiment_1.33.2 SummarizedExperiment_1.41.1
+##  [3] Biobase_2.71.0              GenomicRanges_1.63.1       
+##  [5] Seqinfo_1.1.0               IRanges_2.45.0             
+##  [7] S4Vectors_0.49.0            BiocGenerics_0.57.0        
+##  [9] generics_0.1.4              MatrixGenerics_1.23.0      
+## [11] matrixStats_1.5.0           SpatialData_0.99.25        
+## [13] BiocStyle_2.39.0           
 ## 
 ## loaded via a namespace (and not attached):
-##  [1] DBI_1.2.3               RBGL_1.82.0             anndataR_0.99.0        
-##  [4] rlang_1.1.4             magrittr_2.0.3          e1071_1.7-16           
-##  [7] compiler_4.4.1          RSQLite_2.3.8           dir.expiry_1.14.0      
-## [10] paws.storage_0.7.0      png_0.1-8               vctrs_0.6.5            
-## [13] stringr_1.5.1           wk_0.9.4                pkgconfig_2.0.3        
-## [16] crayon_1.5.3            fastmap_1.2.0           magick_2.8.5           
-## [19] dbplyr_2.5.0            XVector_0.46.0          paws.common_0.7.7      
-## [22] utf8_1.2.4              rmarkdown_2.29          graph_1.84.0           
-## [25] UCSC.utils_1.2.0        tinytex_0.54            purrr_1.0.2            
-## [28] bit_4.5.0               xfun_0.49               zlibbioc_1.52.0        
-## [31] cachem_1.1.0            jsonlite_1.8.9          blob_1.2.4             
-## [34] parallel_4.4.1          R6_2.5.1                bslib_0.8.0            
-## [37] stringi_1.8.4           reticulate_1.40.0       jquerylib_0.1.4        
-## [40] Rcpp_1.0.13-1           bookdown_0.41           assertthat_0.2.1       
-## [43] knitr_1.49              R.utils_2.12.3          tidyselect_1.2.1       
-## [46] rstudioapi_0.17.1       yaml_2.3.10             zellkonverter_1.16.0   
-## [49] curl_6.0.1              lattice_0.22-6          tibble_3.2.1           
-## [52] basilisk.utils_1.18.0   withr_3.0.2             evaluate_1.0.1         
-## [55] sf_1.0-19               units_0.8-5             proxy_0.4-27           
-## [58] BiocFileCache_2.14.0    xml2_1.3.6              pillar_1.9.0           
-## [61] BiocManager_1.30.25     filelock_1.0.3          KernSmooth_2.23-24     
-## [64] pizzarr_0.1.0           generics_0.1.3          nanoarrow_0.6.0        
-## [67] munsell_0.5.1           scales_1.3.0            class_7.3-22           
-## [70] glue_1.8.0              tools_4.4.1             grid_4.4.1             
-## [73] colorspace_2.1-1        paws_0.7.0              GenomeInfoDbData_1.2.13
-## [76] basilisk_1.18.0         cli_3.6.3               fansi_1.0.6            
-## [79] arrow_17.0.0.1          dplyr_1.1.4             geoarrow_0.2.1         
-## [82] Rgraphviz_2.50.0        gtable_0.3.6            R.methodsS3_1.8.2      
-## [85] sass_0.4.9              digest_0.6.37           classInt_0.4-10        
-## [88] memoise_2.0.1           htmltools_0.5.8.1       R.oo_1.27.0            
-## [91] lifecycle_1.0.4         httr_1.4.7              bit64_4.5.2</code></pre>
+##  [1] tidyselect_1.2.1    dplyr_1.2.0         filelock_1.0.3     
+##  [4] arrow_23.0.1.2      R.utils_2.13.0      fastmap_1.2.0      
+##  [7] digest_0.6.39       lifecycle_1.0.5     sf_1.1-0           
+## [10] paws.storage_0.9.0  magrittr_2.0.4      compiler_4.6.0     
+## [13] rlang_1.1.7         sass_0.4.10         tools_4.6.0        
+## [16] yaml_2.3.12         knitr_1.51          S4Arrays_1.11.1    
+## [19] bit_4.6.0           classInt_0.4-11     curl_7.0.0         
+## [22] reticulate_1.45.0   DelayedArray_0.37.0 KernSmooth_2.23-26 
+## [25] abind_1.4-8         withr_3.0.2         purrr_1.2.1        
+## [28] R.oo_1.27.1         grid_4.6.0          e1071_1.7-17       
+## [31] tinytex_0.59        cli_3.6.5           rmarkdown_2.31     
+## [34] crayon_1.5.3        otel_0.2.0          rstudioapi_0.18.0  
+## [37] DBI_1.3.0           cachem_1.1.0        proxy_0.4-29       
+## [40] assertthat_0.2.1    parallel_4.6.0      BiocManager_1.30.27
+## [43] XVector_0.51.0      geoarrow_0.4.2      basilisk_1.23.0    
+## [46] vctrs_0.7.2         Matrix_1.7-5        jsonlite_2.0.0     
+## [49] dir.expiry_1.19.0   bookdown_0.46       bit64_4.6.0-1      
+## [52] RBGL_1.87.0         Rgraphviz_2.55.0    magick_2.9.1       
+## [55] jquerylib_0.1.4     units_1.0-1         glue_1.8.0         
+## [58] ZarrArray_0.99.1    Rarr_1.11.32        tibble_3.3.1       
+## [61] pillar_1.11.1       rappdirs_0.3.4      nanoarrow_0.8.0    
+## [64] htmltools_0.5.9     graph_1.89.1        R6_2.6.1           
+## [67] httr2_1.2.2         wk_0.9.5            evaluate_1.0.5     
+## [70] lattice_0.22-9      R.methodsS3_1.8.2   png_0.1-9          
+## [73] paws.common_0.8.9   bslib_0.10.0        class_7.3-23       
+## [76] Rcpp_1.1.1          SparseArray_1.11.11 anndataR_1.1.2     
+## [79] xfun_0.57           pkgconfig_2.0.3</code></pre>
 </div>