@vitessce/config 4.0.3 → 4.0.5

package/dist/index.js

@@ -42,10 +42,10 @@ var hasRequiredPluralize;
 function requirePluralize() {
   if (hasRequiredPluralize) return pluralize$1.exports;
   hasRequiredPluralize = 1;
-  (function(module2, exports) {
+  (function(module, exports) {
     (function(root, pluralize2) {
       if (typeof commonjsRequire === "function" && true && true) {
-        module2.exports = pluralize2();
+        module.exports = pluralize2();
       } else {
         root.pluralize = pluralize2();
       }
@@ -444,10 +444,10 @@ var hasRequiredLoglevel;
 function requireLoglevel() {
   if (hasRequiredLoglevel) return loglevel$1.exports;
   hasRequiredLoglevel = 1;
-  (function(module2) {
+  (function(module) {
     (function(root, definition) {
-      if (module2.exports) {
-        module2.exports = definition();
+      if (module.exports) {
+        module.exports = definition();
       } else {
         root.log = definition();
       }
@@ -1433,10 +1433,10 @@ class VitessceConfig {
    * @returns {VitessceConfig} A new config instance, with values set to match
    * the config parameter.
    */
-  static fromJSON(config2) {
-    const { name, description, version: schemaVersion } = config2;
+  static fromJSON(config) {
+    const { name, description, version: schemaVersion } = config;
     const vc = new VitessceConfig({ schemaVersion, name, description });
-    config2.datasets.forEach((d) => {
+    config.datasets.forEach((d) => {
       const newDataset = vc.addDataset(d.name, d.description, { uid: d.uid });
       d.files.forEach((f) => {
         newDataset.addFile({
@@ -1447,9 +1447,9 @@ class VitessceConfig {
         });
       });
     });
-    Object.keys(config2.coordinationSpace).forEach((cType) => {
+    Object.keys(config.coordinationSpace).forEach((cType) => {
       if (cType !== CoordinationType.DATASET) {
-        const cObj = config2.coordinationSpace[cType];
+        const cObj = config.coordinationSpace[cType];
         vc.config.coordinationSpace[cType] = {};
         Object.entries(cObj).forEach(([cScopeName, cScopeValue]) => {
           const scope = new VitessceConfigCoordinationScope(cType, cScopeName);
@@ -1458,7 +1458,7 @@ class VitessceConfig {
         });
       }
     });
-    config2.layout.forEach((c) => {
+    config.layout.forEach((c) => {
       const newView = new VitessceConfigView(
         c.component,
         c.coordinationScopes,
@@ -2095,10 +2095,10 @@ async function generateConfig$1(fileUrls, hintTitle = null) {
     return vc.toJSON();
   });
 }
-function strip_prefix(path) {
+function stripPrefix(path) {
   return path.slice(1);
 }
-function fetch_range(url, offset, length, opts = {}) {
+function fetchRange(url, offset, length, opts = {}) {
   if (offset !== void 0 && length !== void 0) {
     opts = {
       ...opts,
@@ -2110,7 +2110,7 @@ function fetch_range(url, offset, length, opts = {}) {
   }
   return fetch(url, opts);
 }
-function merge_init(storeOverrides, requestOverrides) {
+function mergeInit(storeOverrides, requestOverrides) {
   return {
     ...storeOverrides,
     ...requestOverrides,
@@ -2133,7 +2133,7 @@ function resolve(root, path) {
   resolved.search = base.search;
   return resolved;
 }
-async function handle_response(response) {
+async function handleResponse(response) {
   if (response.status === 404) {
     return void 0;
   }
@@ -2142,55 +2142,156 @@ async function handle_response(response) {
   }
   throw new Error(`Unexpected response status ${response.status} ${response.statusText}`);
 }
-async function fetch_suffix(url, suffix_length, init, use_suffix_request) {
-  if (use_suffix_request) {
-    return fetch(url, {
-      ...init,
-      headers: { ...init.headers, Range: `bytes=-${suffix_length}` }
-    });
-  }
-  let response = await fetch(url, { ...init, method: "HEAD" });
-  if (!response.ok) {
-    return response;
-  }
-  let content_length = response.headers.get("Content-Length");
-  let length = Number(content_length);
-  return fetch_range(url, length - suffix_length, length, init);
-}
 class FetchStore {
+  #fetch;
   #overrides;
-  #use_suffix_request;
+  #useSuffixRequest;
   constructor(url, options = {}) {
     this.url = url;
+    this.#fetch = options.fetch ?? ((request) => fetch(request));
     this.#overrides = options.overrides ?? {};
-    this.#use_suffix_request = options.useSuffixRequest ?? false;
+    this.#useSuffixRequest = options.useSuffixRequest ?? false;
   }
-  #merge_init(overrides) {
-    return merge_init(this.#overrides, overrides);
+  #buildRequest(url, init) {
+    return new Request(url, mergeInit(this.#overrides, init));
   }
   async get(key, options = {}) {
     let href = resolve(this.url, key).href;
-    let response = await fetch(href, this.#merge_init(options));
-    return handle_response(response);
+    let request = this.#buildRequest(href, options);
+    let response = await this.#fetch(request);
+    return handleResponse(response);
   }
   async getRange(key, range, options = {}) {
     let url = resolve(this.url, key);
-    let init = this.#merge_init(options);
     let response;
     if ("suffixLength" in range) {
-      response = await fetch_suffix(url, range.suffixLength, init, this.#use_suffix_request);
+      response = await this.#fetchSuffix(url, range.suffixLength, options);
     } else {
-      response = await fetch_range(url, range.offset, range.length, init);
+      let rangeInit = {
+        ...options,
+        headers: {
+          ...options.headers,
+          Range: `bytes=${range.offset}-${range.offset + range.length - 1}`
+        }
+      };
+      let request = this.#buildRequest(url, rangeInit);
+      response = await this.#fetch(request);
     }
-    return handle_response(response);
+    return handleResponse(response);
   }
+  async #fetchSuffix(url, suffixLength, options) {
+    if (this.#useSuffixRequest) {
+      let init = {
+        ...options,
+        headers: { ...options.headers, Range: `bytes=-${suffixLength}` }
+      };
+      return this.#fetch(this.#buildRequest(url, init));
+    }
+    let headRequest = this.#buildRequest(url, {
+      ...options,
+      method: "HEAD"
+    });
+    let response = await this.#fetch(headRequest);
+    if (!response.ok) {
+      return response;
+    }
+    let contentLength = response.headers.get("Content-Length");
+    let length = Number(contentLength);
+    let offset = length - suffixLength;
+    let rangeInit = {
+      ...options,
+      headers: {
+        ...options.headers,
+        Range: `bytes=${offset}-${length - 1}`
+      }
+    };
+    return this.#fetch(this.#buildRequest(url, rangeInit));
+  }
+}
+class ZarritaError extends Error {
+}
+class NotFoundError extends ZarritaError {
+  constructor(context, options = {}) {
+    super(`Not found: ${context}`, { cause: options.cause });
+    this._tag = "NotFoundError";
+    this.name = "NotFoundError";
+    this.path = options.path;
+    this.found = options.found;
+  }
+}
+class InvalidMetadataError extends ZarritaError {
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this._tag = "InvalidMetadataError";
+    this.name = "InvalidMetadataError";
+    this.path = options.path;
+  }
+}
+class UnknownCodecError extends ZarritaError {
+  constructor(codec) {
+    super(`Unknown codec: ${codec}`);
+    this._tag = "UnknownCodecError";
+    this.name = "UnknownCodecError";
+    this.codec = codec;
+  }
+}
+class CodecPipelineError extends ZarritaError {
+  constructor(options) {
+    const parts = [
+      `Failed to ${options.direction} chunk`,
+      options.codec && `via codec "${options.codec}"`,
+      options.chunkPath && `at ${options.chunkPath}`
+    ].filter(Boolean);
+    super(parts.join(" "), { cause: options.cause });
+    this._tag = "CodecPipelineError";
+    this.name = "CodecPipelineError";
+    this.direction = options.direction;
+    this.codec = options.codec;
+    this.chunkPath = options.chunkPath;
+  }
+}
+class UnsupportedError extends ZarritaError {
+  constructor(feature) {
+    super(`Unsupported: ${feature}`);
+    this._tag = "UnsupportedError";
+    this.name = "UnsupportedError";
+    this.feature = feature;
+  }
+}
+function unimplementedEncode(codecName) {
+  return () => {
+    throw new UnsupportedError(`${codecName} encode`);
+  };
+}
+class BitroundCodec {
+  constructor(configuration, _meta) {
+    this.kind = "array_to_array";
+    this.encode = unimplementedEncode("bitround");
+    if (configuration.keepbits < 0) {
+      throw new InvalidMetadataError("keepbits must be zero or positive");
+    }
+  }
+  static fromConfig(configuration, meta) {
+    return new BitroundCodec(configuration, meta);
+  }
+  /**
+   * Decode a chunk of data (no-op).
+   * @param arr - The chunk to decode
+   * @returns The decoded chunk
+   */
+  decode(arr) {
+    return arr;
+  }
+}
+function isArrayBufferLike(x) {
+  return x instanceof ArrayBuffer || x instanceof SharedArrayBuffer;
 }
 class BoolArray {
   #bytes;
   constructor(x, byteOffset, length) {
     if (typeof x === "number") {
       this.#bytes = new Uint8Array(x);
-    } else if (x instanceof ArrayBuffer) {
+    } else if (isArrayBufferLike(x)) {
       this.#bytes = new Uint8Array(x, byteOffset, length);
     } else {
       this.#bytes = new Uint8Array(Array.from(x, (v) => v ? 1 : 0));
@@ -2234,7 +2335,7 @@ class ByteStringArray {
     this.#encoder = new TextEncoder();
     if (typeof x === "number") {
       this._data = new Uint8Array(x * chars);
-    } else if (x instanceof ArrayBuffer) {
+    } else if (isArrayBufferLike(x)) {
       if (length)
         length = length * chars;
       this._data = new Uint8Array(x, byteOffset, length);
@@ -2288,7 +2389,7 @@ class UnicodeStringArray {
     this.chars = chars;
     if (typeof x === "number") {
       this.#data = new Int32Array(x * chars);
-    } else if (x instanceof ArrayBuffer) {
+    } else if (isArrayBufferLike(x)) {
       if (length)
         length *= chars;
       this.#data = new Int32Array(x, byteOffset, length);
@@ -2347,19 +2448,43 @@ class UnicodeStringArray {
     }
   }
 }
-function json_encode_object(o) {
-  const str = JSON.stringify(o, null, 2);
+function jsonEncodeObject(o) {
+  const str = JSON.stringify(o, (_key, value) => {
+    if (typeof value === "number") {
+      if (Number.isNaN(value))
+        return "NaN";
+      if (value === Infinity)
+        return "Infinity";
+      if (value === -Infinity)
+        return "-Infinity";
+    }
+    return value;
+  }, 2);
   return new TextEncoder().encode(str);
 }
-function json_decode_object(bytes) {
+function assertSharedArrayBufferAvailable() {
+  if (typeof SharedArrayBuffer === "undefined") {
+    throw new Error("SharedArrayBuffer is not available. In browsers, this requires Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers to be set.");
+  }
+}
+function createBuffer(byteLength, useShared) {
+  {
+    return new SharedArrayBuffer(byteLength);
+  }
+}
+function jsonDecodeObject(bytes) {
   const str = new TextDecoder().decode(bytes);
-  return JSON.parse(str);
+  try {
+    return JSON.parse(str);
+  } catch (cause) {
+    throw new InvalidMetadataError("Failed to decode JSON", { cause });
+  }
 }
-function byteswap_inplace(view, bytes_per_element2) {
-  const numFlips = bytes_per_element2 / 2;
-  const endByteIndex = bytes_per_element2 - 1;
+function byteswapInplace(view, bytesPerElement2) {
+  const numFlips = bytesPerElement2 / 2;
+  const endByteIndex = bytesPerElement2 - 1;
   let t = 0;
-  for (let i = 0; i < view.length; i += bytes_per_element2) {
+  for (let i = 0; i < view.length; i += bytesPerElement2) {
     for (let j = 0; j < numFlips; j += 1) {
       t = view[i + j];
       view[i + j] = view[i + endByteIndex - j];
@@ -2367,16 +2492,16 @@ function byteswap_inplace(view, bytes_per_element2) {
     }
   }
 }
-function get_ctr(data_type) {
-  if (data_type === "v2:object") {
+function getCtr(dataType) {
+  if (dataType === "v2:object") {
     return globalThis.Array;
   }
-  let match = data_type.match(/v2:([US])(\d+)/);
+  let match = dataType.match(/v2:([US])(\d+)/);
   if (match) {
     let [, kind, chars] = match;
     return (kind === "U" ? UnicodeStringArray : ByteStringArray).bind(null, Number(chars));
   }
-  if (data_type === "string") {
+  if (dataType === "string") {
     return globalThis.Array;
   }
   let ctr = {
@@ -2392,11 +2517,13 @@ function get_ctr(data_type) {
     float32: Float32Array,
     float64: Float64Array,
     bool: BoolArray
-  }[data_type];
-  assert(ctr, `Unknown or unsupported data_type: ${data_type}`);
+  }[dataType];
+  if (!ctr) {
+    throw new InvalidMetadataError(`Unknown or unsupported dataType: ${dataType}`);
+  }
   return ctr;
 }
-function get_strides(shape, order) {
+function getStrides(shape, order) {
   const rank = shape.length;
   if (typeof order === "string") {
     order = order === "C" ? Array.from({ length: rank }, (_, i) => i) : Array.from({ length: rank }, (_, i) => rank - 1 - i);
@@ -2410,25 +2537,27 @@ function get_strides(shape, order) {
   }
   return stride;
 }
-function create_chunk_key_encoder({ name, configuration }) {
+function createChunkKeyEncoder({ name, configuration }) {
   if (name === "default") {
     const separator = configuration?.separator ?? "/";
-    return (chunk_coords) => ["c", ...chunk_coords].join(separator);
+    return (chunkCoords) => ["c", ...chunkCoords].join(separator);
   }
   if (name === "v2") {
     const separator = configuration?.separator ?? ".";
-    return (chunk_coords) => chunk_coords.join(separator) || "0";
+    return (chunkCoords) => chunkCoords.join(separator) || "0";
   }
-  throw new Error(`Unknown chunk key encoding: ${name}`);
+  throw new InvalidMetadataError(`Unknown chunk key encoding: ${name}`);
 }
-function coerce_dtype(dtype) {
+function coerceDtype(dtype) {
   if (dtype === "|O") {
-    return { data_type: "v2:object" };
+    return { dataType: "v2:object" };
   }
   let match = dtype.match(/^([<|>])(.*)$/);
-  assert(match, `Invalid dtype: ${dtype}`);
+  if (!match) {
+    throw new InvalidMetadataError(`Invalid dtype: ${dtype}`);
+  }
   let [, endian, rest] = match;
-  let data_type = {
+  let dataType = {
     b1: "bool",
     i1: "int8",
     u1: "uint8",
@@ -2442,33 +2571,73 @@ function coerce_dtype(dtype) {
     f4: "float32",
     f8: "float64"
   }[rest] ?? (rest.startsWith("S") || rest.startsWith("U") ? `v2:${rest}` : void 0);
-  assert(data_type, `Unsupported or unknown dtype: ${dtype}`);
+  if (!dataType) {
+    throw new InvalidMetadataError(`Unsupported or unknown dtype: ${dtype}`);
+  }
   if (endian === "|") {
-    return { data_type };
+    return { dataType };
   }
-  return { data_type, endian: endian === "<" ? "little" : "big" };
+  return { dataType, endian: endian === "<" ? "little" : "big" };
 }
-function v2_to_v3_array_metadata(meta, attributes = {}) {
+function isFixedScaleOffsetConfig(filter) {
+  return (filter.id === "fixedscaleoffset" || filter.id === "numcodecs.fixedscaleoffset") && typeof filter.scale === "number" && typeof filter.offset === "number" && (filter.astype === void 0 || typeof filter.astype === "string") && (filter.dtype === void 0 || typeof filter.dtype === "string");
+}
+function v2ToV3ArrayMetadata(meta, attributes = {}) {
   let codecs = [];
-  let dtype = coerce_dtype(meta.dtype);
+  let dtype = coerceDtype(meta.dtype);
   if (meta.order === "F") {
     codecs.push({ name: "transpose", configuration: { order: "F" } });
   }
+  for (let filter of meta.filters ?? []) {
+    if (filter.id === "fixedscaleoffset" || filter.id === "numcodecs.fixedscaleoffset") {
+      if (!isFixedScaleOffsetConfig(filter)) {
+        throw new InvalidMetadataError(`Invalid fixedscaleoffset filter: ${JSON.stringify(filter)}`);
+      }
+      codecs.push({
+        name: "scale_offset",
+        configuration: {
+          scale: filter.scale,
+          offset: filter.offset
+        }
+      });
+      let astype = filter.astype ?? filter.dtype;
+      if (astype !== void 0 && astype !== meta.dtype) {
+        let castTarget = coerceDtype(astype).dataType;
+        if (!isDataType(castTarget, "number") && !isDataType(castTarget, "bigint")) {
+          throw new InvalidMetadataError(`fixedscaleoffset astype must be a numeric data type, got ${astype}`);
+        }
+        codecs.push({
+          name: "cast_value",
+          configuration: {
+            data_type: castTarget,
+            // `np.around` uses banker's rounding (round-half-to-even).
+            rounding: "nearest-even",
+            // Matches de-facto numpy integer-overflow behavior.
+            out_of_range: "wrap"
+          }
+        });
+      }
+      continue;
+    }
+    let { id, ...configuration } = filter;
+    codecs.push({ name: `numcodecs.${id}`, configuration });
+  }
   if ("endian" in dtype && dtype.endian === "big") {
     codecs.push({ name: "bytes", configuration: { endian: "big" } });
   }
-  for (let { id, ...configuration } of meta.filters ?? []) {
-    codecs.push({ name: id, configuration });
-  }
   if (meta.compressor) {
     let { id, ...configuration } = meta.compressor;
-    codecs.push({ name: id, configuration });
+    codecs.push({ name: `numcodecs.${id}`, configuration });
+  }
+  let dimensionNames;
+  if (globalThis.Array.isArray(attributes._ARRAY_DIMENSIONS)) {
+    dimensionNames = attributes._ARRAY_DIMENSIONS;
   }
   return {
     zarr_format: 3,
     node_type: "array",
     shape: meta.shape,
-    data_type: dtype.data_type,
+    data_type: dtype.dataType,
     chunk_grid: {
       name: "regular",
       configuration: {
@@ -2483,44 +2652,56 @@ function v2_to_v3_array_metadata(meta, attributes = {}) {
     },
     codecs,
     fill_value: meta.fill_value,
+    dimension_names: dimensionNames,
     attributes
   };
 }
-function v2_to_v3_group_metadata(_meta, attributes = {}) {
+function v2ToV3GroupMetadata(_meta, attributes = {}) {
   return {
     zarr_format: 3,
     node_type: "group",
     attributes
   };
 }
-function is_dtype(dtype, query) {
+function isDataType(dtype, query) {
   if (query !== "number" && query !== "bigint" && query !== "boolean" && query !== "object" && query !== "string") {
     return dtype === query;
   }
-  let is_boolean = dtype === "bool";
+  let isBoolean = dtype === "bool";
   if (query === "boolean")
-    return is_boolean;
-  let is_string = dtype.startsWith("v2:U") || dtype.startsWith("v2:S") || dtype === "string";
+    return isBoolean;
+  let isString = dtype.startsWith("v2:U") || dtype.startsWith("v2:S") || dtype === "string";
   if (query === "string")
-    return is_string;
-  let is_bigint = dtype === "int64" || dtype === "uint64";
+    return isString;
+  let isBigint = dtype === "int64" || dtype === "uint64";
   if (query === "bigint")
-    return is_bigint;
-  let is_object = dtype === "v2:object";
+    return isBigint;
+  let isObject = dtype === "v2:object";
   if (query === "object")
-    return is_object;
-  return !is_string && !is_bigint && !is_boolean && !is_object;
+    return isObject;
+  return !isString && !isBigint && !isBoolean && !isObject;
 }
-function is_sharding_codec(codec) {
+function isShardingCodec(codec) {
   return codec?.name === "sharding_indexed";
 }
-function ensure_correct_scalar(metadata) {
+function ensureCorrectScalar(metadata) {
   if ((metadata.data_type === "uint64" || metadata.data_type === "int64") && metadata.fill_value != null) {
     return BigInt(metadata.fill_value);
   }
+  let isFloat = metadata.data_type === "float16" || metadata.data_type === "float32" || metadata.data_type === "float64";
+  if (typeof metadata.fill_value === "string" && isFloat) {
+    let mapping = {
+      NaN: NaN,
+      Infinity: Infinity,
+      "-Infinity": -Infinity
+    };
+    if (metadata.fill_value in mapping) {
+      return mapping[metadata.fill_value];
+    }
+  }
   return metadata.fill_value;
 }
-function rethrow_unless(error, ...errors) {
+function rethrowUnless(error, ...errors) {
   if (!errors.some((ErrorClass) => error instanceof ErrorClass)) {
     throw error;
   }
@@ -2531,7 +2712,13 @@ function assert(expression, msg = "") {
   }
 }
 async function decompress(data, { format, signal }) {
-  const response = data instanceof Response ? data : new Response(data);
+  let response;
+  if (data instanceof ArrayBuffer) {
+    response = new Response(data);
+  } else {
+    let bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    response = new Response(bytes.slice().buffer);
+  }
   assert(response.body, "Response does not contain body.");
   try {
     const decompressedResponse = new Response(response.body.pipeThrough(new DecompressionStream(format), { signal }));
@@ -2542,37 +2729,13 @@ async function decompress(data, { format, signal }) {
     throw new Error(`Failed to decode ${format}`);
   }
 }
-class BitroundCodec {
-  constructor(configuration, _meta) {
-    this.kind = "array_to_array";
-    assert(configuration.keepbits >= 0, "keepbits must be zero or positive");
-  }
-  static fromConfig(configuration, meta) {
-    return new BitroundCodec(configuration, meta);
-  }
-  /**
-   * Encode a chunk of data with bit-rounding.
-   * @param _arr - The chunk to encode
-   */
-  encode(_arr) {
-    throw new Error("`BitroundCodec.encode` is not implemented. Please open an issue at https://github.com/manzt/zarrita.js/issues.");
-  }
-  /**
-   * Decode a chunk of data (no-op).
-   * @param arr - The chunk to decode
-   * @returns The decoded chunk
-   */
-  decode(arr) {
-    return arr;
-  }
-}
-const LITTLE_ENDIAN_OS = system_is_little_endian();
-function system_is_little_endian() {
+const LITTLE_ENDIAN_OS = systemIsLittleEndian();
+function systemIsLittleEndian() {
   const a = new Uint32Array([305419896]);
   const b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
   return !(b[0] === 18);
 }
-function bytes_per_element(TypedArray) {
+function bytesPerElement(TypedArray) {
   if ("BYTES_PER_ELEMENT" in TypedArray) {
     return TypedArray.BYTES_PER_ELEMENT;
   }
@@ -2582,9 +2745,9 @@ class BytesCodec {
   constructor(configuration, meta) {
     this.kind = "array_to_bytes";
     this.#endian = configuration?.endian;
-    this.#TypedArray = get_ctr(meta.data_type);
+    this.#TypedArray = getCtr(meta.dataType);
     this.#shape = meta.shape;
-    this.#stride = get_strides(meta.shape, "C");
+    this.#stride = getStrides(meta.shape, "C");
     const sample = new this.#TypedArray(0);
     this.#BYTES_PER_ELEMENT = sample.BYTES_PER_ELEMENT;
   }
@@ -2599,13 +2762,21 @@ class BytesCodec {
   encode(arr) {
     let bytes = new Uint8Array(arr.data.buffer);
     if (LITTLE_ENDIAN_OS && this.#endian === "big") {
-      byteswap_inplace(bytes, bytes_per_element(this.#TypedArray));
+      bytes = bytes.slice();
+      byteswapInplace(bytes, bytesPerElement(this.#TypedArray));
     }
     return bytes;
   }
+  computeEncodedSize(decodedSize) {
+    return decodedSize;
+  }
   decode(bytes) {
     if (LITTLE_ENDIAN_OS && this.#endian === "big") {
-      byteswap_inplace(bytes, bytes_per_element(this.#TypedArray));
+      bytes = bytes.slice();
+      byteswapInplace(bytes, bytesPerElement(this.#TypedArray));
+    }
+    if (bytes.byteOffset % this.#BYTES_PER_ELEMENT !== 0) {
+      bytes = bytes.slice();
     }
     return {
       data: new this.#TypedArray(bytes.buffer, bytes.byteOffset, bytes.byteLength / this.#BYTES_PER_ELEMENT),
@@ -2614,42 +2785,359 @@ class BytesCodec {
     };
   }
 }
+const SPECIAL_FLOATS = {
+  NaN: NaN,
+  Infinity: Infinity,
+  "-Infinity": -Infinity
+};
+const FLOAT_BYTES = {
+  float16: 2,
+  float32: 4,
+  float64: 8
+};
+function isFloatType(dataType) {
+  return dataType in FLOAT_BYTES;
+}
+function isBigintType(dataType) {
+  return dataType === "int64" || dataType === "uint64";
+}
+function hexToFloat(hex, byteWidth) {
+  const int = BigInt(hex);
+  const buf = new ArrayBuffer(byteWidth);
+  const view = new DataView(buf);
+  if (byteWidth === 2) {
+    if (typeof view.getFloat16 !== "function") {
+      throw new UnsupportedError("float16 hex-encoded scalar decoding (requires DataView.prototype.getFloat16)");
+    }
+    view.setUint16(0, Number(int));
+    return view.getFloat16(0);
+  }
+  if (byteWidth === 4) {
+    view.setUint32(0, Number(int));
+    return view.getFloat32(0);
+  }
+  view.setBigUint64(0, int);
+  return view.getFloat64(0);
+}
+function parseJsonScalar(dataType, value) {
+  if (isBigintType(dataType)) {
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+      throw new InvalidMetadataError(`Expected an integer value for data type "${dataType}", got ${JSON.stringify(value)}`);
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "number") {
+    if (!isFloatType(dataType) && !Number.isInteger(value)) {
+      throw new InvalidMetadataError(`Expected an integer value for data type "${dataType}", got ${value}`);
+    }
+    return value;
+  }
+  if (!isFloatType(dataType)) {
+    throw new InvalidMetadataError(`String-encoded scalar "${value}" is not valid for non-float data type "${dataType}"`);
+  }
+  if (value in SPECIAL_FLOATS) {
+    return SPECIAL_FLOATS[value];
+  }
+  return hexToFloat(value, FLOAT_BYTES[dataType]);
+}
+const SUPPORTED$2 = /* @__PURE__ */ new Set([
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "float16",
+  "float32",
+  "float64"
+]);
+const INT_BOUNDS = {
+  int8: [-128, 2 ** 7 - 1],
+  uint8: [0, 2 ** 8 - 1],
+  int16: [-32768, 2 ** 15 - 1],
+  uint16: [0, 2 ** 16 - 1],
+  int32: [-2147483648, 2 ** 31 - 1],
+  uint32: [0, 2 ** 32 - 1]
+};
+const BIGINT_BOUNDS = {
+  int64: [-(2n ** 63n), 2n ** 63n - 1n],
+  uint64: [0n, 2n ** 64n - 1n]
+};
+function parseScalarMapEntries(entries, srcType, tgtType) {
+  return entries.map(([src, tgt]) => ({
+    src: parseJsonScalar(srcType, src),
+    tgt: parseJsonScalar(tgtType, tgt)
+  }));
+}
+function scalarMapLookup(value, entries) {
+  for (const entry of entries) {
+    if (typeof entry.src === "number" && Number.isNaN(entry.src)) {
+      if (typeof value === "number" && Number.isNaN(value)) {
+        return entry.tgt;
+      }
+    } else if (value === entry.src) {
+      return entry.tgt;
+    }
+  }
+  return void 0;
+}
+function roundNearestEven(value) {
+  if (!Number.isFinite(value))
+    return value;
+  if (Math.abs(value - Math.trunc(value)) === 0.5) {
+    const floor = Math.floor(value);
+    const ceil = Math.ceil(value);
+    return floor % 2 === 0 ? floor : ceil;
+  }
+  return Math.round(value);
+}
+function nearestAway(value) {
+  return Math.sign(value) * Math.floor(Math.abs(value) + 0.5);
+}
+function getRoundingFn(mode) {
+  switch (mode) {
+    case "nearest-even":
+      return roundNearestEven;
+    case "towards-zero":
+      return Math.trunc;
+    case "towards-positive":
+      return Math.ceil;
+    case "towards-negative":
+      return Math.floor;
+    case "nearest-away":
+      return nearestAway;
+  }
+}
+function makeIntRangeCheck(lo, hi, outOfRange) {
+  const range = hi - lo + 1;
+  switch (outOfRange) {
+    case "clamp":
+      return (v) => v < lo ? lo : v > hi ? hi : v;
+    case "wrap":
+      return (v) => v >= lo && v <= hi ? v : ((v - lo) % range + range) % range + lo;
+    default:
+      return (v) => {
+        if (v >= lo && v <= hi)
+          return v;
+        throw new Error(`Value ${v} out of range [${lo}, ${hi}]. Set out_of_range='clamp' or out_of_range='wrap' to handle this.`);
+      };
+  }
+}
+function makeBigintRangeCheck(lo, hi, outOfRange) {
+  const range = hi - lo + 1n;
+  switch (outOfRange) {
+    case "clamp":
+      return (v) => v < lo ? lo : v > hi ? hi : v;
+    case "wrap":
+      return (v) => v >= lo && v <= hi ? v : ((v - lo) % range + range) % range + lo;
+    default:
+      return (v) => {
+        if (v >= lo && v <= hi)
+          return v;
+        throw new Error(`Value ${v} out of range [${lo}, ${hi}]. Set out_of_range='clamp' or out_of_range='wrap' to handle this.`);
+      };
+  }
+}
+class CastValueCodec {
+  constructor(arrayType, encodedType, rounding, outOfRange, decodeMapEntries, encodeMapEntries) {
+    this.kind = "array_to_array";
+    this.encode = unimplementedEncode("cast_value");
+    this.#encodedType = encodedType;
+    this.#arrayTypeCtr = getCtr(arrayType);
+    this.#decodeValue = buildConverter(encodedType, arrayType, rounding, outOfRange, decodeMapEntries);
+    this.#encodeFillValue = buildConverter(arrayType, encodedType, rounding, outOfRange, encodeMapEntries);
+  }
+  #encodedType;
+  #arrayTypeCtr;
+  #decodeValue;
+  #encodeFillValue;
+  /** Return updated metadata reflecting the type and fill value after encoding. */
+  getEncodedMeta(meta) {
+    let fillValue = meta.fillValue;
+    if (fillValue != null) {
+      fillValue = this.#encodeFillValue(fillValue);
+    }
+    return { ...meta, dataType: this.#encodedType, fillValue };
+  }
+  static fromConfig(config, meta) {
+    const arrayType = meta.dataType;
+    const encodedType = config.data_type;
+    if (!SUPPORTED$2.has(arrayType)) {
+      throw new InvalidMetadataError(`cast_value codec does not support array data type: ${arrayType}`);
+    }
+    if (!SUPPORTED$2.has(encodedType)) {
+      throw new InvalidMetadataError(`cast_value codec does not support encoded data type: ${encodedType}`);
+    }
+    const rounding = config.rounding ?? "nearest-even";
+    const decodeMapEntries = config.scalar_map?.decode ? parseScalarMapEntries(config.scalar_map.decode, encodedType, arrayType) : [];
+    const encodeMapEntries = config.scalar_map?.encode ? parseScalarMapEntries(config.scalar_map.encode, arrayType, encodedType) : [];
+    return new CastValueCodec(arrayType, encodedType, rounding, config.out_of_range, decodeMapEntries, encodeMapEntries);
+  }
+  decode(chunk) {
+    const input = chunk.data;
+    const out = new this.#arrayTypeCtr(input.length);
+    for (let i = 0; i < input.length; i++) {
+      out[i] = this.#decodeValue(input[i]);
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
+}
+function buildConverter(sourceType, targetType, rounding, outOfRange, mapEntries) {
+  const srcIsFloat = isFloatType(sourceType);
+  const srcIsBigint = isBigintType(sourceType);
+  const dstIsFloat = isFloatType(targetType);
+  const dstIsBigint = isBigintType(targetType);
+  let baseFn;
+  if (srcIsFloat && dstIsFloat) {
+    if (rounding !== "nearest-even") {
+      throw new InvalidMetadataError(`cast_value float -> float only supports "nearest-even" rounding, got "${rounding}"`);
+    }
+    baseFn = (v) => v;
+  } else if (srcIsFloat && !dstIsFloat && !dstIsBigint) {
+    const round = getRoundingFn(rounding);
+    const check = makeIntRangeCheck(...INT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => {
+      if (!Number.isFinite(v)) {
+        throw new Error(`Cannot cast ${v} to integer type without scalar_map`);
+      }
+      return check(round(v));
+    };
+  } else if (srcIsFloat && dstIsBigint) {
+    const round = getRoundingFn(rounding);
+    const check = makeBigintRangeCheck(...BIGINT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => {
+      if (!Number.isFinite(v)) {
+        throw new Error(`Cannot cast ${v} to integer type without scalar_map`);
+      }
+      return check(BigInt(round(v)));
+    };
+  } else if (!srcIsFloat && !srcIsBigint && dstIsFloat) {
+    baseFn = (v) => v;
+  } else if (srcIsBigint && dstIsFloat) {
+    baseFn = (v) => Number(v);
+  } else if (!srcIsFloat && !srcIsBigint && !dstIsFloat && !dstIsBigint) {
+    baseFn = makeIntRangeCheck(...INT_BOUNDS[targetType], outOfRange);
+  } else if (!srcIsFloat && !srcIsBigint && dstIsBigint) {
+    const check = makeBigintRangeCheck(...BIGINT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => check(BigInt(v));
+  } else if (srcIsBigint && !dstIsFloat && !dstIsBigint) {
+    const check = makeIntRangeCheck(...INT_BOUNDS[targetType], outOfRange);
+    baseFn = (v) => check(Number(v));
+  } else if (srcIsBigint && dstIsBigint) {
+    baseFn = makeBigintRangeCheck(...BIGINT_BOUNDS[targetType], outOfRange);
+  } else {
+    throw new Error(`Unhandled type combination: ${sourceType} -> ${targetType}`);
+  }
+  if (mapEntries.length === 0) {
+    return baseFn;
+  }
+  const fn = (v) => {
+    const mapped = scalarMapLookup(v, mapEntries);
+    if (mapped !== void 0)
+      return mapped;
+    return baseFn(v);
+  };
+  return fn;
+}
 class Crc32cCodec {
   constructor() {
     this.kind = "bytes_to_bytes";
+    this.encode = unimplementedEncode("crc32c");
   }
   static fromConfig() {
     return new Crc32cCodec();
   }
-  encode(_) {
-    throw new Error("Not implemented");
-  }
   decode(arr) {
     return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength - 4);
   }
+  computeEncodedSize(decodedSize) {
+    return decodedSize + 4;
+  }
+}
+const SUPPORTED$1 = /* @__PURE__ */ new Set([
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "float16",
+  "float32",
+  "float64"
+]);
+function assertCOrFContiguous(shape, stride) {
+  const n = shape.length;
+  let c = n === 0 || stride[n - 1] === 1;
+  for (let i = n - 2; i >= 0 && c; i--) {
+    c = stride[i] === stride[i + 1] * shape[i + 1];
+  }
+  if (c)
+    return;
+  let f = n === 0 || stride[0] === 1;
+  for (let i = 1; i < n && f; i++) {
+    f = stride[i] === stride[i - 1] * shape[i - 1];
+  }
+  if (f)
+    return;
+  throw new Error(`DeltaCodec requires C- or Fortran-contiguous strides, got shape=${JSON.stringify(shape)} stride=${JSON.stringify(stride)}`);
+}
+class DeltaCodec {
+  constructor(ctr) {
+    this.kind = "array_to_array";
+    this.#ctr = ctr;
+  }
+  #ctr;
+  static fromConfig(_config, meta) {
+    if (!SUPPORTED$1.has(meta.dataType)) {
+      throw new InvalidMetadataError(`Delta codec does not support data type: ${meta.dataType}`);
+    }
+    return new DeltaCodec(getCtr(meta.dataType));
+  }
+  encode(chunk) {
+    assertCOrFContiguous(chunk.shape, chunk.stride);
+    const src = chunk.data;
+    const out = new this.#ctr(src.length);
+    out[0] = src[0];
+    for (let i = 1; i < src.length; i++) {
+      out[i] = src[i] - src[i - 1];
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
+  decode(chunk) {
+    assertCOrFContiguous(chunk.shape, chunk.stride);
+    const src = chunk.data;
+    const out = new this.#ctr(src.length);
+    out[0] = src[0];
+    for (let i = 1; i < src.length; i++) {
+      out[i] = out[i - 1] + src[i];
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
 }
 class GzipCodec {
   constructor() {
     this.kind = "bytes_to_bytes";
+    this.encode = unimplementedEncode("gzip");
   }
   static fromConfig(_) {
     return new GzipCodec();
   }
-  encode(_bytes) {
-    throw new Error("Gzip encoding is not enabled by default. Please register a custom codec with `numcodecs/gzip`.");
-  }
   async decode(bytes) {
     const buffer = await decompress(bytes, { format: "gzip" });
     return new Uint8Array(buffer);
   }
 }
-function throw_on_nan_replacer(_key, value) {
+function throwOnNanReplacer(_key, value) {
   assert(!Number.isNaN(value), "JsonCodec allow_nan is false but NaN was encountered during encoding.");
   assert(value !== Number.POSITIVE_INFINITY, "JsonCodec allow_nan is false but Infinity was encountered during encoding.");
   assert(value !== Number.NEGATIVE_INFINITY, "JsonCodec allow_nan is false but -Infinity was encountered during encoding.");
   return value;
 }
-function sort_keys_replacer(_key, value) {
+function sortKeysReplacer(_key, value) {
   return value instanceof Object && !Array.isArray(value) ? Object.keys(value).sort().reduce((sorted, key) => {
     sorted[key] = value[key];
     return sorted;
@@ -2668,7 +3156,7 @@ class JsonCodec {
         separators = [", ", ": "];
       }
     }
-    this.#encoder_config = {
+    this.#encoderConfig = {
       encoding,
       skipkeys,
       ensure_ascii,
@@ -2678,59 +3166,142 @@ class JsonCodec {
       separators,
       sort_keys
     };
-    this.#decoder_config = { strict };
+    this.#decoderConfig = { strict };
   }
-  #encoder_config;
-  #decoder_config;
+  #encoderConfig;
+  #decoderConfig;
   static fromConfig(configuration) {
     return new JsonCodec(configuration);
   }
   encode(buf) {
-    const { indent, encoding, ensure_ascii, check_circular, allow_nan, sort_keys } = this.#encoder_config;
+    const { indent, encoding, ensure_ascii, check_circular, allow_nan, sort_keys } = this.#encoderConfig;
     assert(encoding === "utf-8", "JsonCodec does not yet support non-utf-8 encoding.");
-    const replacer_functions = [];
+    const replacerFunctions = [];
     assert(check_circular, "JsonCodec does not yet support skipping the check for circular references during encoding.");
     if (!allow_nan) {
-      replacer_functions.push(throw_on_nan_replacer);
+      replacerFunctions.push(throwOnNanReplacer);
     }
     if (sort_keys) {
-      replacer_functions.push(sort_keys_replacer);
+      replacerFunctions.push(sortKeysReplacer);
     }
     const items = Array.from(buf.data);
     items.push("|O");
     items.push(buf.shape);
     let replacer;
-    if (replacer_functions.length) {
+    if (replacerFunctions.length) {
       replacer = (key, value) => {
-        let new_value = value;
-        for (let sub_replacer of replacer_functions) {
-          new_value = sub_replacer(key, new_value);
+        let newValue = value;
+        for (let subReplacer of replacerFunctions) {
+          newValue = subReplacer(key, newValue);
         }
-        return new_value;
+        return newValue;
       };
     }
-    let json_str = JSON.stringify(items, replacer, indent);
+    let jsonStr = JSON.stringify(items, replacer, indent);
     if (ensure_ascii) {
-      json_str = json_str.replace(/[\u007F-\uFFFF]/g, (chr) => {
-        const full_str = `0000${chr.charCodeAt(0).toString(16)}`;
-        const sub_str = full_str.substring(full_str.length - 4);
-        return `\\u${sub_str}`;
+      jsonStr = jsonStr.replace(/[\u007F-\uFFFF]/g, (chr) => {
+        const fullStr = `0000${chr.charCodeAt(0).toString(16)}`;
+        const subStr = fullStr.substring(fullStr.length - 4);
+        return `\\u${subStr}`;
       });
     }
-    return new TextEncoder().encode(json_str);
+    return new TextEncoder().encode(jsonStr);
   }
   decode(bytes) {
-    const { strict } = this.#decoder_config;
+    const { strict } = this.#decoderConfig;
     assert(strict, "JsonCodec does not yet support non-strict decoding.");
-    const items = json_decode_object(bytes);
+    const items = jsonDecodeObject(bytes);
     const shape = items.pop();
     items.pop();
     assert(shape, "0D not implemented for JsonCodec.");
-    const stride = get_strides(shape, "C");
+    const stride = getStrides(shape, "C");
     const data = items;
     return { data, shape, stride };
   }
 }
+const SUPPORTED = /* @__PURE__ */ new Set([
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "int64",
+  "uint64",
+  "float16",
+  "float32",
+  "float64"
+]);
+class ScaleOffsetCodec {
+  constructor(scale, offset, ctr) {
+    this.kind = "array_to_array";
+    this.encode = unimplementedEncode("scale_offset");
+    this.#scale = scale;
+    this.#offset = offset;
+    this.#ctr = ctr;
+  }
+  #ctr;
+  #scale;
+  #offset;
+  static fromConfig(config, meta) {
+    if (!SUPPORTED.has(meta.dataType)) {
+      throw new InvalidMetadataError(`scale_offset codec does not support data type: ${meta.dataType}`);
+    }
+    return new ScaleOffsetCodec(parseJsonScalar(meta.dataType, config.scale ?? 1), parseJsonScalar(meta.dataType, config.offset ?? 0), getCtr(meta.dataType));
+  }
+  decode(chunk) {
+    const src = chunk.data;
+    const out = new this.#ctr(src.length);
+    for (let i = 0; i < src.length; i++) {
+      out[i] = src[i] / this.#scale + this.#offset;
+    }
+    return { data: out, shape: chunk.shape, stride: chunk.stride };
+  }
+}
+class ShuffleCodec {
+  constructor(configuration, meta) {
+    this.kind = "bytes_to_bytes";
+    if (meta) {
+      let sample = new (getCtr(meta.dataType))(0);
+      assert("BYTES_PER_ELEMENT" in sample, `Shuffle codec requires a fixed-size dtype, got "${meta.dataType}"`);
+      this.#BYTES_PER_ELEMENT = sample.BYTES_PER_ELEMENT;
+    } else {
+      this.#BYTES_PER_ELEMENT = configuration.elementsize ?? 4;
+    }
+  }
+  #BYTES_PER_ELEMENT;
+  static fromConfig(configuration, meta) {
+    return new ShuffleCodec(configuration, meta);
+  }
+  encode(data) {
+    return shuffle(data, this.#BYTES_PER_ELEMENT);
+  }
+  decode(data) {
+    return unshuffle(data, this.#BYTES_PER_ELEMENT);
+  }
+}
+function shuffle(data, elementSize) {
+  let length = data.length;
+  let nElements = Math.floor(length / elementSize);
+  let result = new Uint8Array(length);
+  for (let byte = 0; byte < elementSize; byte++) {
+    for (let i = 0; i < nElements; i++) {
+      result[byte * nElements + i] = data[i * elementSize + byte];
+    }
+  }
+  return result;
+}
+function unshuffle(data, elementSize) {
+  let length = data.length;
+  let nElements = Math.floor(length / elementSize);
+  let result = new Uint8Array(length);
+  for (let byte = 0; byte < elementSize; byte++) {
+    for (let i = 0; i < nElements; i++) {
+      result[i * elementSize + byte] = data[byte * nElements + i];
+    }
+  }
+  return result;
+}
 function proxy(arr) {
   if (arr instanceof BoolArray || arr instanceof ByteStringArray || arr instanceof UnicodeStringArray) {
     const arrp = new Proxy(arr, {
@@ -2746,40 +3317,42 @@ function proxy(arr) {
   }
   return arr;
 }
-function empty_like(chunk, order) {
+function emptyLike(chunk, order) {
   let data;
   if (chunk.data instanceof ByteStringArray || chunk.data instanceof UnicodeStringArray) {
-    data = new chunk.constructor(
-      // @ts-expect-error
-      chunk.data.length,
-      chunk.data.chars
+    data = new chunk.data.constructor(
+      // @ts-expect-error - the two argument form is not on the shared type
+      chunk.data.chars,
+      chunk.data.length
     );
   } else {
-    data = new chunk.constructor(chunk.data.length);
+    data = new chunk.data.constructor(chunk.data.length);
   }
   return {
     data,
     shape: chunk.shape,
-    stride: get_strides(chunk.shape, order)
+    stride: getStrides(chunk.shape, order)
   };
 }
-function convert_array_order(src, target) {
-  let out = empty_like(src, target);
-  let n_dims = src.shape.length;
-  let size = src.data.length;
-  let index = Array(n_dims).fill(0);
-  let src_data = proxy(src.data);
-  let out_data = proxy(out.data);
-  for (let src_idx = 0; src_idx < size; src_idx++) {
-    let out_idx = 0;
-    for (let dim = 0; dim < n_dims; dim++) {
-      out_idx += index[dim] * out.stride[dim];
-    }
-    out_data[out_idx] = src_data[src_idx];
+function convertArrayOrder(src, target) {
+  let out = emptyLike(src, target);
+  let nDims = src.shape.length;
+  let size = src.shape.reduce((a, b) => a * b, 1);
+  let index = Array(nDims).fill(0);
+  let srcData = proxy(src.data);
+  let outData = proxy(out.data);
+  for (let n = 0; n < size; n++) {
+    let srcIdx = 0;
+    let outIdx = 0;
+    for (let dim = 0; dim < nDims; dim++) {
+      srcIdx += index[dim] * src.stride[dim];
+      outIdx += index[dim] * out.stride[dim];
+    }
+    outData[outIdx] = srcData[srcIdx];
     index[0] += 1;
-    for (let dim = 0; dim < n_dims; dim++) {
+    for (let dim = 0; dim < nDims; dim++) {
       if (index[dim] === src.shape[dim]) {
-        if (dim + 1 === n_dims) {
+        if (dim + 1 === nDims) {
           break;
         }
         index[dim] = 0;
@@ -2789,13 +3362,13 @@ function convert_array_order(src, target) {
   }
   return out;
 }
-function get_order(chunk) {
+function getOrder(chunk) {
   let rank = chunk.shape.length;
   assert(rank === chunk.stride.length, "Shape and stride must have the same length.");
   return chunk.stride.map((s, i) => ({ stride: s, index: i })).sort((a, b) => b.stride - a.stride).map((entry) => entry.index);
 }
-function matches_order(chunk, target) {
-  let source = get_order(chunk);
+function matchesOrder(chunk, target) {
+  let source = getOrder(chunk);
   assert(source.length === target.length, "Orders must match");
   return source.every((dim, i) => dim === target[i]);
 }
@@ -2805,70 +3378,64 @@ class TransposeCodec {
     let value = configuration.order ?? "C";
     let rank = meta.shape.length;
     let order = new Array(rank);
-    let inverseOrder = new Array(rank);
     if (value === "C") {
       for (let i = 0; i < rank; ++i) {
         order[i] = i;
-        inverseOrder[i] = i;
       }
     } else if (value === "F") {
       for (let i = 0; i < rank; ++i) {
         order[i] = rank - i - 1;
-        inverseOrder[i] = rank - i - 1;
       }
     } else {
       order = value;
-      order.forEach((x, i) => {
-        assert(inverseOrder[x] === void 0, `Invalid permutation: ${JSON.stringify(value)}`);
-        inverseOrder[x] = i;
+      let seen = new Array(rank);
+      order.forEach((x) => {
+        assert(!seen[x], `Invalid permutation: ${JSON.stringify(value)}`);
+        seen[x] = true;
       });
     }
     this.#order = order;
-    this.#inverseOrder = inverseOrder;
   }
   #order;
-  #inverseOrder;
   static fromConfig(configuration, meta) {
     return new TransposeCodec(configuration, meta);
   }
   encode(arr) {
-    if (matches_order(arr, this.#inverseOrder)) {
+    if (matchesOrder(arr, this.#order)) {
       return arr;
     }
-    return convert_array_order(arr, this.#inverseOrder);
+    return convertArrayOrder(arr, this.#order);
   }
   decode(arr) {
     return {
       data: arr.data,
       shape: arr.shape,
-      stride: get_strides(arr.shape, this.#order)
+      stride: getStrides(arr.shape, this.#order)
     };
   }
 }
 class VLenUTF8 {
   constructor(shape) {
     this.kind = "array_to_bytes";
+    this.encode = unimplementedEncode("vlen-utf8");
     this.#shape = shape;
-    this.#strides = get_strides(shape, "C");
+    this.#strides = getStrides(shape, "C");
   }
   #shape;
   #strides;
   static fromConfig(_, meta) {
     return new VLenUTF8(meta.shape);
   }
-  encode(_chunk) {
-    throw new Error("Method not implemented.");
-  }
   decode(bytes) {
     let decoder = new TextDecoder();
     let view = new DataView(bytes.buffer);
     let data = Array(view.getUint32(0, true));
     let pos = 4;
     for (let i = 0; i < data.length; i++) {
-      let item_length = view.getUint32(pos, true);
+      let itemLength = view.getUint32(pos, true);
       pos += 4;
-      data[i] = decoder.decode(bytes.buffer.slice(pos, pos + item_length));
-      pos += item_length;
+      data[i] = decoder.decode(bytes.buffer.slice(pos, pos + itemLength));
+      pos += itemLength;
     }
     return { data, shape: this.#shape, stride: this.#strides };
   }
@@ -2876,195 +3443,181 @@ class VLenUTF8 {
 class ZlibCodec {
   constructor() {
     this.kind = "bytes_to_bytes";
+    this.encode = unimplementedEncode("zlib");
   }
   static fromConfig(_) {
     return new ZlibCodec();
   }
-  encode(_bytes) {
-    throw new Error("Zlib encoding is not enabled by default. Please register a codec with `numcodecs/zlib`.");
-  }
   async decode(bytes) {
     const buffer = await decompress(bytes, { format: "deflate" });
     return new Uint8Array(buffer);
   }
 }
-function create_default_registry() {
-  return (/* @__PURE__ */ new Map()).set("blosc", () => import("./blosc-DvQQ1ST0.js").then((m) => m.default)).set("lz4", () => import("./lz4-BIbM36RN.js").then((m) => m.default)).set("zstd", () => import("./zstd-CO575QiM.js").then((m) => m.default)).set("gzip", () => GzipCodec).set("zlib", () => ZlibCodec).set("transpose", () => TransposeCodec).set("bytes", () => BytesCodec).set("crc32c", () => Crc32cCodec).set("vlen-utf8", () => VLenUTF8).set("json2", () => JsonCodec).set("bitround", () => BitroundCodec);
+function createDefaultRegistry() {
+  let blosc = () => import("./blosc-DvQQ1ST0.js").then((m) => m.default);
+  let lz4 = () => import("./lz4-BIbM36RN.js").then((m) => m.default);
+  let zstd = () => import("./zstd-CO575QiM.js").then((m) => m.default);
+  let gzip = () => GzipCodec;
+  let zlib = () => ZlibCodec;
+  return (/* @__PURE__ */ new Map()).set("blosc", blosc).set("lz4", lz4).set("zstd", zstd).set("gzip", gzip).set("zlib", zlib).set("transpose", () => TransposeCodec).set("bytes", () => BytesCodec).set("crc32c", () => Crc32cCodec).set("vlen-utf8", () => VLenUTF8).set("json2", () => JsonCodec).set("bitround", () => BitroundCodec).set("cast_value", () => CastValueCodec).set("scale_offset", () => ScaleOffsetCodec).set("numcodecs.blosc", blosc).set("numcodecs.lz4", lz4).set("numcodecs.zstd", zstd).set("numcodecs.gzip", gzip).set("numcodecs.zlib", zlib).set("numcodecs.vlen-utf8", () => VLenUTF8).set("numcodecs.shuffle", () => ShuffleCodec).set("numcodecs.delta", () => DeltaCodec).set("numcodecs.bitround", () => BitroundCodec).set("numcodecs.json2", () => JsonCodec);
 }
-const registry = create_default_registry();
-function create_codec_pipeline(chunk_metadata) {
-  let codecs;
+const registry = createDefaultRegistry();
+function createCodecPipeline(chunkMetadata) {
+  let codecsPromise;
+  function getCodecs() {
+    if (!codecsPromise)
+      codecsPromise = loadCodecs(chunkMetadata);
+    return codecsPromise;
+  }
+  async function runStep(direction, codec, fn) {
+    try {
+      return await fn();
+    } catch (cause) {
+      throw new CodecPipelineError({ direction, codec, cause });
+    }
+  }
   return {
     async encode(chunk) {
-      if (!codecs)
-        codecs = await load_codecs(chunk_metadata);
-      for (const codec of codecs.array_to_array) {
-        chunk = await codec.encode(chunk);
+      let codecs = await getCodecs();
+      for (const { name, codec } of codecs.arrayToArray) {
+        chunk = await runStep("encode", name, () => codec.encode(chunk));
       }
-      let bytes = await codecs.array_to_bytes.encode(chunk);
-      for (const codec of codecs.bytes_to_bytes) {
-        bytes = await codec.encode(bytes);
+      let bytes = await runStep("encode", codecs.arrayToBytes.name, () => codecs.arrayToBytes.codec.encode(chunk));
+      for (const { name, codec } of codecs.bytesToBytes) {
+        bytes = await runStep("encode", name, () => codec.encode(bytes));
       }
       return bytes;
     },
     async decode(bytes) {
-      if (!codecs)
-        codecs = await load_codecs(chunk_metadata);
-      for (let i = codecs.bytes_to_bytes.length - 1; i >= 0; i--) {
-        bytes = await codecs.bytes_to_bytes[i].decode(bytes);
+      let codecs = await getCodecs();
+      for (let i = codecs.bytesToBytes.length - 1; i >= 0; i--) {
+        const { name, codec } = codecs.bytesToBytes[i];
+        bytes = await runStep("decode", name, () => codec.decode(bytes));
       }
-      let chunk = await codecs.array_to_bytes.decode(bytes);
-      for (let i = codecs.array_to_array.length - 1; i >= 0; i--) {
-        chunk = await codecs.array_to_array[i].decode(chunk);
+      let chunk = await runStep("decode", codecs.arrayToBytes.name, () => codecs.arrayToBytes.codec.decode(bytes));
+      for (let i = codecs.arrayToArray.length - 1; i >= 0; i--) {
+        const { name, codec } = codecs.arrayToArray[i];
+        chunk = await runStep("decode", name, () => codec.decode(chunk));
       }
       return chunk;
+    },
+    async computeEncodedSize(decodedSize) {
+      let codecs = await getCodecs();
+      let size = applyEncodedSize(codecs.arrayToBytes.name, codecs.arrayToBytes.codec, decodedSize);
+      for (const { name, codec } of codecs.bytesToBytes) {
+        size = applyEncodedSize(name, codec, size);
+      }
+      return size;
     }
   };
 }
-async function load_codecs(chunk_meta) {
-  let promises = chunk_meta.codecs.map(async (meta) => {
+function applyEncodedSize(name, codec, size) {
+  if (!codec.computeEncodedSize) {
+    throw new InvalidMetadataError(`Codec "${name}" cannot compute its encoded size; it is not a fixed-size codec and cannot be used in a sharding index pipeline`);
+  }
+  return codec.computeEncodedSize(size);
+}
+async function loadCodecs(chunkMeta) {
+  let promises = chunkMeta.codecs.map(async (meta) => {
     let Codec = await registry.get(meta.name)?.();
-    assert(Codec, `Unknown codec: ${meta.name}`);
+    if (!Codec) {
+      throw new UnknownCodecError(meta.name);
+    }
     return { Codec, meta };
   });
-  let array_to_array = [];
-  let array_to_bytes;
-  let bytes_to_bytes = [];
+  let arrayToArray = [];
+  let arrayToBytes;
+  let bytesToBytes = [];
+  let currentMeta = { ...chunkMeta };
   for await (let { Codec, meta } of promises) {
-    let codec = Codec.fromConfig(meta.configuration, chunk_meta);
+    let codec = Codec.fromConfig(meta.configuration, currentMeta);
     switch (codec.kind) {
       case "array_to_array":
-        array_to_array.push(codec);
+        arrayToArray.push({
+          name: meta.name,
+          codec
+        });
+        if (codec.getEncodedMeta) {
+          currentMeta = codec.getEncodedMeta(currentMeta);
+        }
         break;
       case "array_to_bytes":
-        array_to_bytes = codec;
+        arrayToBytes = {
+          name: meta.name,
+          codec
+        };
         break;
       default:
-        bytes_to_bytes.push(codec);
+        bytesToBytes.push({
+          name: meta.name,
+          codec
+        });
     }
   }
-  if (!array_to_bytes) {
-    assert(is_typed_array_like_meta(chunk_meta), `Cannot encode ${chunk_meta.data_type} to bytes without a codec`);
-    array_to_bytes = BytesCodec.fromConfig({ endian: "little" }, chunk_meta);
-  }
-  return { array_to_array, array_to_bytes, bytes_to_bytes };
-}
-function is_typed_array_like_meta(meta) {
-  return meta.data_type !== "v2:object" && meta.data_type !== "string";
-}
-class NodeNotFoundError extends Error {
-  constructor(context, options = {}) {
-    super(`Node not found: ${context}`, options);
-    this.name = "NodeNotFoundError";
-  }
-}
-class KeyError extends Error {
-  constructor(path) {
-    super(`Missing key: ${path}`);
-    this.name = "KeyError";
-  }
-}
-async function get_consolidated_metadata(store, metadataKeyOption) {
-  const metadataKey = metadataKeyOption ?? ".zmetadata";
-  let bytes = await store.get(`/${metadataKey}`);
-  if (!bytes) {
-    throw new NodeNotFoundError("v2 consolidated metadata", {
-      cause: new KeyError(`/${metadataKey}`)
-    });
-  }
-  let meta = json_decode_object(bytes);
-  assert(meta.zarr_consolidated_format === 1, "Unsupported consolidated format.");
-  return meta;
-}
-function is_meta_key(key) {
-  return key.endsWith(".zarray") || key.endsWith(".zgroup") || key.endsWith(".zattrs") || key.endsWith("zarr.json");
-}
-function is_v3(meta) {
-  return "zarr_format" in meta && meta.zarr_format === 3;
-}
-async function withConsolidated(store, opts = {}) {
-  let v2_meta = await get_consolidated_metadata(store, opts.metadataKey);
-  let known_meta = {};
-  for (let [key, value] of Object.entries(v2_meta.metadata)) {
-    known_meta[`/${key}`] = value;
+  if (!arrayToBytes) {
+    if (!isTypedArrayLikeMeta(currentMeta)) {
+      throw new InvalidMetadataError(`Cannot encode ${currentMeta.dataType} to bytes without a codec`);
+    }
+    arrayToBytes = {
+      name: "bytes",
+      codec: BytesCodec.fromConfig({ endian: "little" }, currentMeta)
+    };
   }
   return {
-    async get(...args) {
-      let [key, opts2] = args;
-      if (known_meta[key]) {
-        return json_encode_object(known_meta[key]);
-      }
-      let maybe_bytes = await store.get(key, opts2);
-      if (is_meta_key(key) && maybe_bytes) {
-        let meta = json_decode_object(maybe_bytes);
-        known_meta[key] = meta;
-      }
-      return maybe_bytes;
-    },
-    // Delegate range requests to the underlying store.
-    // Note: Supporting range requests for consolidated metadata is possible
-    // but unlikely to be useful enough to justify the effort.
-    getRange: store.getRange?.bind(store),
-    contents() {
-      let contents = [];
-      for (let [key, value] of Object.entries(known_meta)) {
-        let parts = key.split("/");
-        let filename = parts.pop();
-        let path = parts.join("/") || "/";
-        if (filename === ".zarray")
-          contents.push({ path, kind: "array" });
-        if (filename === ".zgroup")
-          contents.push({ path, kind: "group" });
-        if (is_v3(value)) {
-          contents.push({ path, kind: value.node_type });
-        }
-      }
-      return contents;
-    }
+    arrayToArray,
+    arrayToBytes,
+    bytesToBytes
   };
 }
+function isTypedArrayLikeMeta(meta) {
+  return meta.dataType !== "v2:object" && meta.dataType !== "string";
+}
 const MAX_BIG_UINT = 18446744073709551615n;
-function create_sharded_chunk_getter(location, shard_shape, encode_shard_key, sharding_config) {
-  assert(location.store.getRange, "Store does not support range requests");
-  let get_range = location.store.getRange.bind(location.store);
-  let index_shape = shard_shape.map((d, i) => d / sharding_config.chunk_shape[i]);
-  let index_codec = create_codec_pipeline({
-    data_type: "uint64",
-    shape: [...index_shape, 2],
-    codecs: sharding_config.index_codecs
+function createShardedChunkGetter(location, shardShape, encodeShardKey, shardingConfig) {
+  if (!location.store.getRange) {
+    throw new UnsupportedError("sharding requires a store with getRange");
+  }
+  let getRange = location.store.getRange.bind(location.store);
+  let indexShape = shardShape.map((d, i) => d / shardingConfig.chunk_shape[i]);
+  let indexCodec = createCodecPipeline({
+    dataType: "uint64",
+    shape: [...indexShape, 2],
+    codecs: shardingConfig.index_codecs,
+    fillValue: null
   });
+  let rawIndexSize = 16 * indexShape.reduce((a, b) => a * b, 1);
   let cache = {};
-  return async (chunk_coord, options) => {
-    let shard_coord = chunk_coord.map((d, i) => Math.floor(d / index_shape[i]));
-    let shard_path = location.resolve(encode_shard_key(shard_coord)).path;
-    let index;
-    if (shard_path in cache) {
-      index = cache[shard_path];
-    } else {
-      let checksum_size = 4;
-      let index_size = 16 * index_shape.reduce((a, b) => a * b, 1);
-      let bytes = await get_range(shard_path, {
-        suffixLength: index_size + checksum_size
-      }, options);
-      index = cache[shard_path] = bytes ? await index_codec.decode(bytes) : null;
+  return async (chunkCoord, options) => {
+    let shardCoord = chunkCoord.map((d, i) => Math.floor(d / indexShape[i]));
+    let shardPath = location.resolve(encodeShardKey(shardCoord)).path;
+    if (!(shardPath in cache)) {
+      cache[shardPath] = (async () => {
+        let suffixLength = await indexCodec.computeEncodedSize(rawIndexSize);
+        let bytes = await getRange(shardPath, { suffixLength }, options);
+        return bytes ? await indexCodec.decode(bytes) : null;
+      })().catch((err) => {
+        delete cache[shardPath];
+        throw err;
+      });
     }
+    let index = await cache[shardPath];
     if (index === null) {
       return void 0;
     }
     let { data, shape, stride } = index;
-    let linear_offset = chunk_coord.map((d, i) => d % shape[i]).reduce((acc, sel, idx) => acc + sel * stride[idx], 0);
-    let offset = data[linear_offset];
-    let length = data[linear_offset + 1];
+    let linearOffset = chunkCoord.map((d, i) => d % shape[i]).reduce((acc, sel, idx) => acc + sel * stride[idx], 0);
+    let offset = data[linearOffset];
+    let length = data[linearOffset + 1];
     if (offset === MAX_BIG_UINT && length === MAX_BIG_UINT) {
       return void 0;
     }
-    return get_range(shard_path, {
+    return getRange(shardPath, {
       offset: Number(offset),
       length: Number(length)
     }, options);
   };
 }
-var _a;
+var _a$1;
 class Location {
   constructor(store, path = "/") {
     this.store = store;
@@ -3086,92 +3639,121 @@ class Group extends Location {
     return this.#metadata.attributes;
   }
 }
-function get_array_order(codecs) {
-  const maybe_transpose_codec = codecs.find((c) => c.name === "transpose");
-  return maybe_transpose_codec?.configuration?.order ?? "C";
+function getArrayOrder(codecs) {
+  const maybeTransposeCodec = codecs.find((c) => c.name === "transpose");
+  return maybeTransposeCodec?.configuration?.order ?? "C";
+}
+function projectOrder(order, axes) {
+  let rank = new Map(axes.map((axis, i) => [axis, i]));
+  return order.filter((axis) => rank.has(axis)).map((axis) => rank.get(axis));
+}
+function makeStrideGetter(nativeOrder) {
+  return (shape, axes) => {
+    let order = globalThis.Array.isArray(nativeOrder) && axes ? projectOrder(nativeOrder, axes) : nativeOrder;
+    return getStrides(shape, order);
+  };
 }
 const CONTEXT_MARKER = Symbol("zarrita.context");
-function create_context(location, metadata) {
-  let { configuration } = metadata.codecs.find(is_sharding_codec) ?? {};
-  let shared_context = {
-    encode_chunk_key: create_chunk_key_encoder(metadata.chunk_key_encoding),
-    TypedArray: get_ctr(metadata.data_type),
-    fill_value: metadata.fill_value
+function createContext(location, metadata) {
+  let { configuration } = metadata.codecs.find(isShardingCodec) ?? {};
+  let sharedContext = {
+    encodeChunkKey: createChunkKeyEncoder(metadata.chunk_key_encoding),
+    TypedArray: getCtr(metadata.data_type),
+    fillValue: metadata.fill_value
   };
   if (configuration) {
-    let native_order2 = get_array_order(configuration.codecs);
+    let nativeOrder2 = getArrayOrder(configuration.codecs);
     return {
-      ...shared_context,
+      ...sharedContext,
       kind: "sharded",
-      chunk_shape: configuration.chunk_shape,
-      codec: create_codec_pipeline({
-        data_type: metadata.data_type,
+      chunkShape: configuration.chunk_shape,
+      codec: createCodecPipeline({
+        dataType: metadata.data_type,
         shape: configuration.chunk_shape,
-        codecs: configuration.codecs
+        codecs: configuration.codecs,
+        fillValue: metadata.fill_value
       }),
-      get_strides(shape) {
-        return get_strides(shape, native_order2);
-      },
-      get_chunk_bytes: create_sharded_chunk_getter(location, metadata.chunk_grid.configuration.chunk_shape, shared_context.encode_chunk_key, configuration)
+      getStrides: makeStrideGetter(nativeOrder2),
+      getChunkBytes: createShardedChunkGetter(location, metadata.chunk_grid.configuration.chunk_shape, sharedContext.encodeChunkKey, configuration)
     };
   }
-  let native_order = get_array_order(metadata.codecs);
+  let nativeOrder = getArrayOrder(metadata.codecs);
   return {
-    ...shared_context,
+    ...sharedContext,
     kind: "regular",
-    chunk_shape: metadata.chunk_grid.configuration.chunk_shape,
-    codec: create_codec_pipeline({
-      data_type: metadata.data_type,
+    chunkShape: metadata.chunk_grid.configuration.chunk_shape,
+    codec: createCodecPipeline({
+      dataType: metadata.data_type,
       shape: metadata.chunk_grid.configuration.chunk_shape,
-      codecs: metadata.codecs
+      codecs: metadata.codecs,
+      fillValue: metadata.fill_value
     }),
-    get_strides(shape) {
-      return get_strides(shape, native_order);
-    },
-    async get_chunk_bytes(chunk_coords, options) {
-      let chunk_key = shared_context.encode_chunk_key(chunk_coords);
-      let chunk_path = location.resolve(chunk_key).path;
-      return location.store.get(chunk_path, options);
+    getStrides: makeStrideGetter(nativeOrder),
+    async getChunkBytes(chunkCoords, options) {
+      let chunkKey = sharedContext.encodeChunkKey(chunkCoords);
+      let chunkPath = location.resolve(chunkKey).path;
+      return location.store.get(chunkPath, options);
     }
   };
 }
-let Array$1 = class Array2 extends (_a = Location, _a) {
+let Array$1 = class Array2 extends (_a$1 = Location, _a$1) {
   constructor(store, path, metadata) {
     super(store, path);
     this.kind = "array";
     this.#metadata = {
       ...metadata,
-      fill_value: ensure_correct_scalar(metadata)
+      fill_value: ensureCorrectScalar(metadata)
     };
-    this[CONTEXT_MARKER] = create_context(this, metadata);
+    this[CONTEXT_MARKER] = createContext(this, this.#metadata);
   }
   #metadata;
   get attrs() {
     return this.#metadata.attributes;
   }
+  get dimensionNames() {
+    return this.#metadata.dimension_names;
+  }
+  get fillValue() {
+    return this.#metadata.fill_value;
+  }
   get shape() {
     return this.#metadata.shape;
   }
   get chunks() {
-    return this[CONTEXT_MARKER].chunk_shape;
+    return this[CONTEXT_MARKER].chunkShape;
   }
   get dtype() {
     return this.#metadata.data_type;
   }
-  async getChunk(chunk_coords, options) {
+  async getChunk(chunkCoords, options, opts) {
+    if (opts?.useSharedArrayBuffer) {
+      assertSharedArrayBufferAvailable();
+    }
     let context = this[CONTEXT_MARKER];
-    let maybe_bytes = await context.get_chunk_bytes(chunk_coords, options);
-    if (!maybe_bytes) {
-      let size = context.chunk_shape.reduce((a, b) => a * b, 1);
-      let data = new context.TypedArray(size);
-      data.fill(context.fill_value);
+    let maybeBytes = await context.getChunkBytes(chunkCoords, options);
+    if (!maybeBytes) {
+      let size = context.chunkShape.reduce((a, b) => a * b, 1);
+      let data;
+      if (opts?.useSharedArrayBuffer) {
+        let sample = new context.TypedArray(0);
+        if (!("BYTES_PER_ELEMENT" in sample)) {
+          console.warn("zarrita: useSharedArrayBuffer is not supported for non-buffer-backed data types.");
+          data = new context.TypedArray(size);
+        } else {
+          let buffer = createBuffer(size * sample.BYTES_PER_ELEMENT);
+          data = new context.TypedArray(buffer, 0, size);
+        }
+      } else {
+        data = new context.TypedArray(size);
+      }
+      data.fill(context.fillValue);
       return {
         data,
-        shape: context.chunk_shape,
-        stride: context.get_strides(context.chunk_shape)
+        shape: context.chunkShape,
+        stride: context.getStrides(context.chunkShape)
       };
     }
-    return context.codec.decode(maybe_bytes);
+    return context.codec.decode(maybeBytes);
   }
   /**
    * A helper method to narrow `zarr.Array` Dtype.
@@ -3191,86 +3773,168 @@ let Array$1 = class Array2 extends (_a = Location, _a) {
    * ```
    */
   is(query) {
-    return is_dtype(this.dtype, query);
+    return isDataType(this.dtype, query);
   }
 };
-let VERSION_COUNTER = create_version_counter();
-function create_version_counter() {
-  let version_counts = /* @__PURE__ */ new WeakMap();
-  function get_counts(store) {
-    let counts = version_counts.get(store) ?? { v2: 0, v3: 0 };
-    version_counts.set(store, counts);
+function createProxy(target, overrides) {
+  let boundCache = /* @__PURE__ */ new Map();
+  return new Proxy(target, {
+    get(t, prop) {
+      if (prop in overrides)
+        return overrides[prop];
+      let cached = boundCache.get(prop);
+      if (cached !== void 0)
+        return cached;
+      let value = Reflect.get(t, prop, t);
+      if (typeof value === "function") {
+        let bound = value.bind(t);
+        boundCache.set(prop, bound);
+        return bound;
+      }
+      return value;
+    },
+    has(t, prop) {
+      return prop in overrides || Reflect.has(t, prop);
+    },
+    ownKeys(t) {
+      let keys = /* @__PURE__ */ new Set([...Reflect.ownKeys(t), ...Object.keys(overrides)]);
+      return [...keys];
+    },
+    getOwnPropertyDescriptor(t, prop) {
+      if (prop in overrides) {
+        return {
+          configurable: true,
+          enumerable: true,
+          value: overrides[prop]
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(t, prop);
+    }
+  });
+}
+function assertFactoryResult(value) {
+  if (value == null || typeof value !== "object") {
+    throw new Error("Extension factory must return an object of overrides");
+  }
+}
+function mergeArrayExtensions(inner, overrides) {
+  let innerExts = inner.arrayExtensions;
+  let freshExts = overrides.arrayExtensions;
+  if (!innerExts?.length)
+    return overrides;
+  if (!freshExts?.length)
+    return { ...overrides, arrayExtensions: innerExts };
+  return { ...overrides, arrayExtensions: [...innerExts, ...freshExts] };
+}
+function defineStoreExtension(factory) {
+  return (store, opts) => {
+    let result = factory(store, opts);
+    if (result instanceof Promise) {
+      return result.then((overrides) => {
+        assertFactoryResult(overrides);
+        return createProxy(store, mergeArrayExtensions(store, overrides));
+      });
+    }
+    assertFactoryResult(result);
+    return createProxy(store, mergeArrayExtensions(store, result));
+  };
+}
+function applyExtensions(value, extensions) {
+  let result = value;
+  for (let ext of extensions) {
+    if (result instanceof Promise) {
+      result = result.then((v) => ext(v));
+    } else {
+      result = ext(result);
+    }
+  }
+  return result;
+}
+function extendArray(array, ...extensions) {
+  return applyExtensions(array, extensions);
+}
+async function maybeExtend(array) {
+  let exts = array.store.arrayExtensions;
+  if (!exts?.length)
+    return array;
+  let variadic = extendArray;
+  return await variadic(array, ...exts);
+}
+let VERSION_COUNTER = createVersionCounter();
+function createVersionCounter() {
+  let versionCounts = /* @__PURE__ */ new WeakMap();
+  function getCounts(store) {
+    let counts = versionCounts.get(store) ?? { v2: 0, v3: 0 };
+    versionCounts.set(store, counts);
     return counts;
   }
   return {
     increment(store, version) {
-      get_counts(store)[version] += 1;
+      getCounts(store)[version] += 1;
     },
-    version_max(store) {
-      let counts = get_counts(store);
+    versionMax(store) {
+      let counts = getCounts(store);
       return counts.v3 > counts.v2 ? "v3" : "v2";
     }
   };
 }
-async function load_attrs(location) {
-  let meta_bytes = await location.store.get(location.resolve(".zattrs").path);
-  if (!meta_bytes)
+async function loadAttrs(location, signal) {
+  let metaBytes = await location.store.get(location.resolve(".zattrs").path, {
+    signal
+  });
+  if (!metaBytes)
     return {};
-  return json_decode_object(meta_bytes);
+  return jsonDecodeObject(metaBytes);
 }
-async function open_v2(location, options = {}) {
+async function openV2(location, options = {}) {
   let loc = "store" in location ? location : new Location(location);
+  let { signal } = options;
   let attrs = {};
   if (options.attrs ?? true)
-    attrs = await load_attrs(loc);
+    attrs = await loadAttrs(loc, signal);
+  signal?.throwIfAborted();
   if (options.kind === "array")
-    return open_array_v2(loc, attrs);
+    return openArrayV2(loc, attrs, signal);
   if (options.kind === "group")
-    return open_group_v2(loc, attrs);
-  return open_array_v2(loc, attrs).catch((err) => {
-    rethrow_unless(err, NodeNotFoundError);
-    return open_group_v2(loc, attrs);
+    return openGroupV2(loc, attrs, signal);
+  return openArrayV2(loc, attrs, signal).catch((err) => {
+    rethrowUnless(err, NotFoundError, InvalidMetadataError);
+    return openGroupV2(loc, attrs, signal);
   });
 }
-async function open_array_v2(location, attrs) {
+async function openArrayV2(location, attrs, signal) {
   let { path } = location.resolve(".zarray");
-  let meta = await location.store.get(path);
+  let meta = await location.store.get(path, { signal });
   if (!meta) {
-    throw new NodeNotFoundError("v2 array", {
-      cause: new KeyError(path)
-    });
+    throw new NotFoundError("v2 array", { path });
   }
   VERSION_COUNTER.increment(location.store, "v2");
-  return new Array$1(location.store, location.path, v2_to_v3_array_metadata(json_decode_object(meta), attrs));
+  return maybeExtend(new Array$1(location.store, location.path, v2ToV3ArrayMetadata(jsonDecodeObject(meta), attrs)));
 }
-async function open_group_v2(location, attrs) {
+async function openGroupV2(location, attrs, signal) {
   let { path } = location.resolve(".zgroup");
-  let meta = await location.store.get(path);
+  let meta = await location.store.get(path, { signal });
   if (!meta) {
-    throw new NodeNotFoundError("v2 group", {
-      cause: new KeyError(path)
-    });
+    throw new NotFoundError("v2 group", { path });
   }
   VERSION_COUNTER.increment(location.store, "v2");
-  return new Group(location.store, location.path, v2_to_v3_group_metadata(json_decode_object(meta), attrs));
+  return new Group(location.store, location.path, v2ToV3GroupMetadata(jsonDecodeObject(meta), attrs));
 }
-async function _open_v3(location) {
+async function _openV3(location, signal) {
   let { store, path } = location.resolve("zarr.json");
-  let meta = await location.store.get(path);
+  let meta = await location.store.get(path, { signal });
   if (!meta) {
-    throw new NodeNotFoundError("v3 array or group", {
-      cause: new KeyError(path)
-    });
+    throw new NotFoundError("v3 array or group", { path });
   }
-  let meta_doc = json_decode_object(meta);
-  if (meta_doc.node_type === "array") {
-    meta_doc.fill_value = ensure_correct_scalar(meta_doc);
+  let metaDoc = jsonDecodeObject(meta);
+  if (metaDoc.node_type === "array") {
+    metaDoc.fill_value = ensureCorrectScalar(metaDoc);
   }
-  return meta_doc.node_type === "array" ? new Array$1(store, location.path, meta_doc) : new Group(store, location.path, meta_doc);
+  return metaDoc.node_type === "array" ? maybeExtend(new Array$1(store, location.path, metaDoc)) : new Group(store, location.path, metaDoc);
 }
-async function open_v3(location, options = {}) {
+async function openV3(location, options = {}) {
   let loc = "store" in location ? location : new Location(location);
-  let node = await _open_v3(loc);
+  let node = await _openV3(loc, options.signal);
   VERSION_COUNTER.increment(loc.store, "v3");
   if (options.kind === void 0)
     return node;
@@ -3279,20 +3943,129 @@ async function open_v3(location, options = {}) {
   if (options.kind === "group" && node instanceof Group)
     return node;
   let kind = node instanceof Array$1 ? "array" : "group";
-  throw new Error(`Expected node of kind ${options.kind}, found ${kind}.`);
+  throw new NotFoundError(`${options.kind} at ${loc.path}`, {
+    path: loc.path,
+    found: kind
+  });
 }
 async function open(location, options = {}) {
   let store = "store" in location ? location.store : location;
-  let version_max = VERSION_COUNTER.version_max(store);
-  let open_primary = version_max === "v2" ? open.v2 : open.v3;
-  let open_secondary = version_max === "v2" ? open.v3 : open.v2;
-  return open_primary(location, options).catch((err) => {
-    rethrow_unless(err, NodeNotFoundError);
-    return open_secondary(location, options);
+  let versionMax = VERSION_COUNTER.versionMax(store);
+  let openPrimary = versionMax === "v2" ? open.v2 : open.v3;
+  let openSecondary = versionMax === "v2" ? open.v3 : open.v2;
+  return openPrimary(location, options).catch((err) => {
+    rethrowUnless(err, NotFoundError, InvalidMetadataError);
+    return openSecondary(location, options);
   });
 }
-open.v2 = open_v2;
-open.v3 = open_v3;
+open.v2 = openV2;
+open.v3 = openV3;
+function isConsolidatedV2(meta) {
+  return typeof meta === "object" && meta !== null && "zarr_consolidated_format" in meta && meta.zarr_consolidated_format === 1 && "metadata" in meta && typeof meta.metadata === "object" && meta.metadata !== null;
+}
+function isConsolidatedV3(meta) {
+  return typeof meta === "object" && meta !== null && "zarr_format" in meta && meta.zarr_format === 3 && "node_type" in meta && meta.node_type === "group" && "consolidated_metadata" in meta && typeof meta.consolidated_metadata === "object" && meta.consolidated_metadata !== null && "metadata" in meta.consolidated_metadata && typeof meta.consolidated_metadata.metadata === "object" && meta.consolidated_metadata.metadata !== null;
+}
+function isMetaKey(key) {
+  return key.endsWith(".zarray") || key.endsWith(".zgroup") || key.endsWith(".zattrs") || key.endsWith("zarr.json");
+}
+function isV3(meta) {
+  return "zarr_format" in meta && meta.zarr_format === 3;
+}
+async function loadConsolidatedV2(store, metadataKey) {
+  let key = metadataKey ?? ".zmetadata";
+  let bytes = await store.get(`/${key}`);
+  if (!bytes) {
+    throw new NotFoundError("v2 consolidated metadata", {
+      path: `/${key}`
+    });
+  }
+  let meta = jsonDecodeObject(bytes);
+  if (!isConsolidatedV2(meta)) {
+    throw new InvalidMetadataError("Invalid or unsupported v2 consolidated format", { path: `/${key}` });
+  }
+  let knownMeta = {};
+  for (let [k, value] of Object.entries(meta.metadata)) {
+    knownMeta[`/${k}`] = value;
+  }
+  return knownMeta;
+}
+async function loadConsolidatedV3(store) {
+  let bytes = await store.get("/zarr.json");
+  if (!bytes) {
+    throw new NotFoundError("v3 consolidated metadata", {
+      path: "/zarr.json"
+    });
+  }
+  let rootMeta = jsonDecodeObject(bytes);
+  if (!isConsolidatedV3(rootMeta)) {
+    throw new InvalidMetadataError("Root zarr.json does not contain consolidated_metadata", { path: "/zarr.json" });
+  }
+  let knownMeta = {};
+  knownMeta["/zarr.json"] = {
+    zarr_format: 3,
+    node_type: "group",
+    attributes: rootMeta.attributes ?? {}
+  };
+  for (let [path, meta] of Object.entries(rootMeta.consolidated_metadata.metadata)) {
+    let normalized = path.startsWith("/") ? path : `/${path}`;
+    let key = `${normalized}/zarr.json`;
+    knownMeta[key] = meta;
+  }
+  return knownMeta;
+}
+function resolveFormats(store, format) {
+  if (format !== void 0) {
+    return globalThis.Array.isArray(format) ? format : [format];
+  }
+  let versionMax = VERSION_COUNTER.versionMax(store);
+  return versionMax === "v3" ? ["v3", "v2"] : ["v2", "v3"];
+}
+const withConsolidatedMetadata = defineStoreExtension(async (store, opts = {}) => {
+  let formats = resolveFormats(store, opts.format);
+  let lastError;
+  for (let format of formats) {
+    try {
+      let knownMeta = format === "v2" ? await loadConsolidatedV2(store, opts.metadataKey) : await loadConsolidatedV3(store);
+      return {
+        async get(key, options) {
+          if (knownMeta[key]) {
+            return jsonEncodeObject(knownMeta[key]);
+          }
+          let maybeBytes = await store.get(key, options);
+          if (isMetaKey(key) && maybeBytes) {
+            knownMeta[key] = jsonDecodeObject(maybeBytes);
+          }
+          return maybeBytes;
+        },
+        contents() {
+          let contents = [];
+          for (let [key, value] of Object.entries(knownMeta)) {
+            let parts = key.split("/");
+            let filename = parts.pop();
+            let path = parts.join("/") || "/";
+            if (filename === ".zarray")
+              contents.push({ path, kind: "array" });
+            if (filename === ".zgroup")
+              contents.push({ path, kind: "group" });
+            if (isV3(value)) {
+              contents.push({ path, kind: value.node_type });
+            }
+          }
+          return contents;
+        }
+      };
+    } catch (err) {
+      rethrowUnless(err, NotFoundError, InvalidMetadataError);
+      lastError = err;
+    }
+  }
+  throw lastError;
+});
+function extendStore(store, ...extensions) {
+  return applyExtensions(store, extensions);
+}
+var _a, _b;
 function readBlobAsArrayBuffer(blob) {
   if (blob.arrayBuffer) {
     return blob.arrayBuffer();
@@ -3316,7 +4089,7 @@ function isBlob(v) {
 function isSharedArrayBuffer(b) {
   return typeof SharedArrayBuffer !== "undefined" && b instanceof SharedArrayBuffer;
 }
-const isNode = typeof process !== "undefined" && process.versions && typeof process.versions.node !== "undefined" && typeof process.versions.electron === "undefined";
+typeof process !== "undefined" && !!(process === null || process === void 0 ? void 0 : process.versions) && typeof ((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== "undefined" && typeof ((_b = process === null || process === void 0 ? void 0 : process.versions) === null || _b === void 0 ? void 0 : _b.electron) === "undefined";
 function isTypedArraySameAsArrayBuffer(typedArray) {
   return typedArray.byteOffset === 0 && typedArray.byteLength === typedArray.buffer.byteLength;
 }
@@ -3347,389 +4120,47 @@ let BlobReader$1 = class BlobReader {
     return this.blob.slice(offset, offset + length, type);
   }
 };
-function inflate(data, buf) {
-  var u8 = Uint8Array;
-  if (data[0] == 3 && data[1] == 0) return buf ? buf : new u8(0);
-  var bitsF = _bitsF, bitsE = _bitsE, decodeTiny = _decodeTiny, get17 = _get17;
-  var noBuf = buf == null;
-  if (noBuf) buf = new u8(data.length >>> 2 << 3);
-  var BFINAL = 0, BTYPE = 0, HLIT = 0, HDIST = 0, HCLEN = 0, ML = 0, MD = 0;
-  var off = 0, pos = 0;
-  var lmap, dmap;
-  while (BFINAL == 0) {
-    BFINAL = bitsF(data, pos, 1);
-    BTYPE = bitsF(data, pos + 1, 2);
-    pos += 3;
-    if (BTYPE == 0) {
-      if ((pos & 7) != 0) pos += 8 - (pos & 7);
-      var p8 = (pos >>> 3) + 4, len = data[p8 - 4] | data[p8 - 3] << 8;
-      if (noBuf) buf = _check(buf, off + len);
-      buf.set(new u8(data.buffer, data.byteOffset + p8, len), off);
-      pos = p8 + len << 3;
-      off += len;
-      continue;
-    }
-    if (noBuf) buf = _check(buf, off + (1 << 17));
-    if (BTYPE == 1) {
-      lmap = U.flmap;
-      dmap = U.fdmap;
-      ML = (1 << 9) - 1;
-      MD = (1 << 5) - 1;
-    }
-    if (BTYPE == 2) {
-      HLIT = bitsE(data, pos, 5) + 257;
-      HDIST = bitsE(data, pos + 5, 5) + 1;
-      HCLEN = bitsE(data, pos + 10, 4) + 4;
-      pos += 14;
-      for (var i = 0; i < 38; i += 2) {
-        U.itree[i] = 0;
-        U.itree[i + 1] = 0;
-      }
-      var tl = 1;
-      for (var i = 0; i < HCLEN; i++) {
-        var l = bitsE(data, pos + i * 3, 3);
-        U.itree[(U.ordr[i] << 1) + 1] = l;
-        if (l > tl) tl = l;
-      }
-      pos += 3 * HCLEN;
-      makeCodes(U.itree, tl);
-      codes2map(U.itree, tl, U.imap);
-      lmap = U.lmap;
-      dmap = U.dmap;
-      pos = decodeTiny(U.imap, (1 << tl) - 1, HLIT + HDIST, data, pos, U.ttree);
-      var mx0 = _copyOut(U.ttree, 0, HLIT, U.ltree);
-      ML = (1 << mx0) - 1;
-      var mx1 = _copyOut(U.ttree, HLIT, HDIST, U.dtree);
-      MD = (1 << mx1) - 1;
-      makeCodes(U.ltree, mx0);
-      codes2map(U.ltree, mx0, lmap);
-      makeCodes(U.dtree, mx1);
-      codes2map(U.dtree, mx1, dmap);
-    }
-    while (true) {
-      var code = lmap[get17(data, pos) & ML];
-      pos += code & 15;
-      var lit = code >>> 4;
-      if (lit >>> 8 == 0) {
-        buf[off++] = lit;
-      } else if (lit == 256) {
-        break;
-      } else {
-        var end = off + lit - 254;
-        if (lit > 264) {
-          var ebs = U.ldef[lit - 257];
-          end = off + (ebs >>> 3) + bitsE(data, pos, ebs & 7);
-          pos += ebs & 7;
-        }
-        var dcode = dmap[get17(data, pos) & MD];
-        pos += dcode & 15;
-        var dlit = dcode >>> 4;
-        var dbs = U.ddef[dlit], dst = (dbs >>> 4) + bitsF(data, pos, dbs & 15);
-        pos += dbs & 15;
-        if (noBuf) buf = _check(buf, off + (1 << 17));
-        while (off < end) {
-          buf[off] = buf[off++ - dst];
-          buf[off] = buf[off++ - dst];
-          buf[off] = buf[off++ - dst];
-          buf[off] = buf[off++ - dst];
-        }
-        off = end;
-      }
-    }
-  }
-  return buf.length == off ? buf : buf.slice(0, off);
-}
-function _check(buf, len) {
-  var bl = buf.length;
-  if (len <= bl) return buf;
-  var nbuf = new Uint8Array(Math.max(bl << 1, len));
-  nbuf.set(buf, 0);
-  return nbuf;
-}
-function _decodeTiny(lmap, LL, len, data, pos, tree) {
-  var bitsE = _bitsE, get17 = _get17;
-  var i = 0;
-  while (i < len) {
-    var code = lmap[get17(data, pos) & LL];
-    pos += code & 15;
-    var lit = code >>> 4;
-    if (lit <= 15) {
-      tree[i] = lit;
-      i++;
-    } else {
-      var ll = 0, n = 0;
-      if (lit == 16) {
-        n = 3 + bitsE(data, pos, 2);
-        pos += 2;
-        ll = tree[i - 1];
-      } else if (lit == 17) {
-        n = 3 + bitsE(data, pos, 3);
-        pos += 3;
-      } else if (lit == 18) {
-        n = 11 + bitsE(data, pos, 7);
-        pos += 7;
-      }
-      var ni = i + n;
-      while (i < ni) {
-        tree[i] = ll;
-        i++;
-      }
-    }
-  }
-  return pos;
-}
-function _copyOut(src, off, len, tree) {
-  var mx = 0, i = 0, tl = tree.length >>> 1;
-  while (i < len) {
-    var v = src[i + off];
-    tree[i << 1] = 0;
-    tree[(i << 1) + 1] = v;
-    if (v > mx) mx = v;
-    i++;
-  }
-  while (i < tl) {
-    tree[i << 1] = 0;
-    tree[(i << 1) + 1] = 0;
-    i++;
-  }
-  return mx;
-}
-function makeCodes(tree, MAX_BITS) {
-  var max_code = tree.length;
-  var code, bits, n, i, len;
-  var bl_count = U.bl_count;
-  for (var i = 0; i <= MAX_BITS; i++) bl_count[i] = 0;
-  for (i = 1; i < max_code; i += 2) bl_count[tree[i]]++;
-  var next_code = U.next_code;
-  code = 0;
-  bl_count[0] = 0;
-  for (bits = 1; bits <= MAX_BITS; bits++) {
-    code = code + bl_count[bits - 1] << 1;
-    next_code[bits] = code;
-  }
-  for (n = 0; n < max_code; n += 2) {
-    len = tree[n + 1];
-    if (len != 0) {
-      tree[n] = next_code[len];
-      next_code[len]++;
-    }
-  }
-}
-function codes2map(tree, MAX_BITS, map) {
-  var max_code = tree.length;
-  var r15 = U.rev15;
-  for (var i = 0; i < max_code; i += 2) if (tree[i + 1] != 0) {
-    var lit = i >> 1;
-    var cl = tree[i + 1], val = lit << 4 | cl;
-    var rest = MAX_BITS - cl, i0 = tree[i] << rest, i1 = i0 + (1 << rest);
-    while (i0 != i1) {
-      var p0 = r15[i0] >>> 15 - MAX_BITS;
-      map[p0] = val;
-      i0++;
-    }
-  }
-}
-function revCodes(tree, MAX_BITS) {
-  var r15 = U.rev15, imb = 15 - MAX_BITS;
-  for (var i = 0; i < tree.length; i += 2) {
-    var i0 = tree[i] << MAX_BITS - tree[i + 1];
-    tree[i] = r15[i0] >>> imb;
-  }
-}
-function _bitsE(dt, pos, length) {
-  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8) >>> (pos & 7) & (1 << length) - 1;
-}
-function _bitsF(dt, pos, length) {
-  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8 | dt[(pos >>> 3) + 2] << 16) >>> (pos & 7) & (1 << length) - 1;
-}
-function _get17(dt, pos) {
-  return (dt[pos >>> 3] | dt[(pos >>> 3) + 1] << 8 | dt[(pos >>> 3) + 2] << 16) >>> (pos & 7);
-}
-const U = function() {
-  var u16 = Uint16Array, u32 = Uint32Array;
-  return {
-    next_code: new u16(16),
-    bl_count: new u16(16),
-    ordr: [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
-    of0: [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 999, 999, 999],
-    exb: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0, 0],
-    ldef: new u16(32),
-    df0: [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 65535, 65535],
-    dxb: [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 0, 0],
-    ddef: new u32(32),
-    flmap: new u16(512),
-    fltree: [],
-    fdmap: new u16(32),
-    fdtree: [],
-    lmap: new u16(32768),
-    ltree: [],
-    ttree: [],
-    dmap: new u16(32768),
-    dtree: [],
-    imap: new u16(512),
-    itree: [],
-    //rev9 : new u16(  512)
-    rev15: new u16(1 << 15),
-    lhst: new u32(286),
-    dhst: new u32(30),
-    ihst: new u32(19),
-    lits: new u32(15e3),
-    strt: new u16(1 << 16),
-    prev: new u16(1 << 15)
-  };
-}();
-(function() {
-  var len = 1 << 15;
-  for (var i = 0; i < len; i++) {
-    var x = i;
-    x = (x & 2863311530) >>> 1 | (x & 1431655765) << 1;
-    x = (x & 3435973836) >>> 2 | (x & 858993459) << 2;
-    x = (x & 4042322160) >>> 4 | (x & 252645135) << 4;
-    x = (x & 4278255360) >>> 8 | (x & 16711935) << 8;
-    U.rev15[i] = (x >>> 16 | x << 16) >>> 17;
-  }
-  function pushV(tgt, n, sv) {
-    while (n-- != 0) tgt.push(0, sv);
-  }
-  for (var i = 0; i < 32; i++) {
-    U.ldef[i] = U.of0[i] << 3 | U.exb[i];
-    U.ddef[i] = U.df0[i] << 4 | U.dxb[i];
-  }
-  pushV(U.fltree, 144, 8);
-  pushV(U.fltree, 255 - 143, 9);
-  pushV(U.fltree, 279 - 255, 7);
-  pushV(U.fltree, 287 - 279, 8);
-  makeCodes(U.fltree, 9);
-  codes2map(U.fltree, 9, U.flmap);
-  revCodes(U.fltree, 9);
-  pushV(U.fdtree, 32, 5);
-  makeCodes(U.fdtree, 5);
-  codes2map(U.fdtree, 5, U.fdmap);
-  revCodes(U.fdtree, 5);
-  pushV(U.itree, 19, 0);
-  pushV(U.ltree, 286, 0);
-  pushV(U.dtree, 30, 0);
-  pushV(U.ttree, 320, 0);
-})();
-({
-  table: function() {
-    var tab = new Uint32Array(256);
-    for (var n = 0; n < 256; n++) {
-      var c = n;
-      for (var k = 0; k < 8; k++) {
-        if (c & 1) c = 3988292384 ^ c >>> 1;
-        else c = c >>> 1;
-      }
-      tab[n] = c;
-    }
-    return tab;
-  }()
-});
-function inflateRaw(file, buf) {
-  return inflate(file, buf);
-}
-const config = {
-  numWorkers: 1,
-  workerURL: "",
-  useWorkers: false
-};
 let nextId = 0;
 const waitingForWorkerQueue = [];
-function startWorker(url) {
-  return new Promise((resolve2, reject) => {
-    const worker = new Worker(url);
-    worker.onmessage = (e) => {
-      if (e.data === "start") {
-        worker.onerror = void 0;
-        worker.onmessage = void 0;
-        resolve2(worker);
-      } else {
-        reject(new Error(`unexpected message: ${e.data}`));
-      }
-    };
-    worker.onerror = reject;
+async function decompressRaw(src) {
+  const ds = new DecompressionStream("deflate-raw");
+  const writer = ds.writable.getWriter();
+  writer.write(src).then(() => writer.close()).catch(() => {
   });
+  const chunks = [];
+  const reader = ds.readable.getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    chunks.push(value);
+  }
+  const size = chunks.reduce((s, c) => s + c.byteLength, 0);
+  const result = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
 }
-function dynamicRequire(mod, request) {
-  return mod.require ? mod.require(request) : {};
-}
-(function() {
-  if (isNode) {
-    const { Worker: Worker2 } = dynamicRequire(module, "worker_threads");
-    return {
-      async createWorker(url) {
-        return new Worker2(url);
-      },
-      addEventListener(worker, fn) {
-        worker.on("message", (data) => {
-          fn({ target: worker, data });
-        });
-      },
-      async terminate(worker) {
-        await worker.terminate();
-      }
-    };
-  } else {
-    return {
-      async createWorker(url) {
-        try {
-          const worker = await startWorker(url);
-          return worker;
-        } catch (e) {
-          console.warn("could not load worker:", url);
-        }
-        let text;
-        try {
-          const req = await fetch(url, { mode: "cors" });
-          if (!req.ok) {
-            throw new Error(`could not load: ${url}`);
-          }
-          text = await req.text();
-          url = URL.createObjectURL(new Blob([text], { type: "application/javascript" }));
-          const worker = await startWorker(url);
-          config.workerURL = url;
-          return worker;
-        } catch (e) {
-          console.warn("could not load worker via fetch:", url);
-        }
-        if (text !== void 0) {
-          try {
-            url = `data:application/javascript;base64,${btoa(text)}`;
-            const worker = await startWorker(url);
-            config.workerURL = url;
-            return worker;
-          } catch (e) {
-            console.warn("could not load worker via dataURI");
-          }
-        }
-        console.warn("workers will not be used");
-        throw new Error("can not start workers");
-      },
-      addEventListener(worker, fn) {
-        worker.addEventListener("message", fn);
-      },
-      async terminate(worker) {
-        worker.terminate();
-      }
-    };
+async function inflateRawLocal(src, type, resolve2, reject) {
+  try {
+    const dst = await decompressRaw(src);
+    resolve2(type ? new Blob([dst], { type }) : dst.buffer);
+  } catch (e) {
+    reject(e);
   }
-})();
-function inflateRawLocal(src, uncompressedSize, type, resolve2) {
-  const dst = new Uint8Array(uncompressedSize);
-  inflateRaw(src, dst);
-  resolve2(type ? new Blob([dst], { type }) : dst.buffer);
 }
 async function processWaitingForWorkerQueue() {
   if (waitingForWorkerQueue.length === 0) {
     return;
   }
   while (waitingForWorkerQueue.length) {
-    const { src, uncompressedSize, type, resolve: resolve2 } = waitingForWorkerQueue.shift();
-    let data = src;
-    if (isBlob(src)) {
-      data = await readBlobAsUint8Array(src);
-    }
-    inflateRawLocal(data, uncompressedSize, type, resolve2);
+    const { src, type, resolve: resolve2, reject } = waitingForWorkerQueue.shift();
+    const data = isBlob(src) ? await readBlobAsUint8Array(src) : src;
+    inflateRawLocal(data, type, resolve2, reject);
   }
 }
 function inflateRawAsync(src, uncompressedSize, type) {
@@ -3779,6 +4210,7 @@ class ZipEntry {
     return decodeBuffer(new Uint8Array(buffer));
   }
   // returns text with JSON.parse called on it. If you want more options decode arrayBuffer yourself
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async json() {
     const text = await this.text();
     return JSON.parse(text);
@@ -3797,7 +4229,7 @@ async function readAsBlobOrTypedArray(reader, offset, length, type) {
   }
   return await reader.read(offset, length);
 }
-const crc$1 = {
+const crc = {
   unsigned() {
     return 0;
   }
@@ -3812,7 +4244,7 @@ function getUint64LE(uint8View, offset) {
   return getUint32LE(uint8View, offset) + getUint32LE(uint8View, offset + 4) * 4294967296;
 }
 const utf8Decoder = new TextDecoder();
-function decodeBuffer(uint8View, isUTF8) {
+function decodeBuffer(uint8View, _isUTF8) {
   if (isSharedArrayBuffer(uint8View.buffer)) {
     uint8View = new Uint8Array(uint8View);
   }
@@ -3915,6 +4347,7 @@ async function readEntries(reader, centralDirectoryOffset, centralDirectorySize,
     }
     readEntryCursor += 46;
     const data = allEntriesBuffer.subarray(readEntryCursor, readEntryCursor + rawEntry.fileNameLength + rawEntry.extraFieldLength + rawEntry.fileCommentLength);
+    (rawEntry.generalPurposeBitFlag & 2048) !== 0;
     rawEntry.nameBytes = data.slice(0, rawEntry.fileNameLength);
     rawEntry.name = decodeBuffer(rawEntry.nameBytes);
     const fileCommentStart = rawEntry.fileNameLength + rawEntry.extraFieldLength;
@@ -3969,7 +4402,7 @@ async function readEntries(reader, centralDirectoryOffset, centralDirectorySize,
     }
     const nameField = rawEntry.extraFields.find((e2) => e2.id === 28789 && e2.data.length >= 6 && // too short to be meaningful
     e2.data[0] === 1 && // Version       1 byte      version of this extra field, currently 1
-    getUint32LE(e2.data, 1), crc$1.unsigned(rawEntry.nameBytes));
+    getUint32LE(e2.data, 1), crc.unsigned());
     if (nameField) {
       rawEntry.fileName = decodeBuffer(nameField.data.slice(5));
     }
@@ -4033,7 +4466,7 @@ async function readEntryDataAsArrayBuffer(reader, rawEntry) {
     return isTypedArraySameAsArrayBuffer(dataView) ? dataView.buffer : dataView.slice().buffer;
   }
   const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
-  const result = await inflateRawAsync(typedArrayOrBlob, rawEntry.uncompressedSize);
+  const result = await inflateRawAsync(typedArrayOrBlob instanceof Uint8Array ? typedArrayOrBlob : typedArrayOrBlob, rawEntry.uncompressedSize);
   return result;
 }
 async function readEntryDataAsBlob(reader, rawEntry, type) {
@@ -4043,10 +4476,10 @@ async function readEntryDataAsBlob(reader, rawEntry, type) {
     if (isBlob(typedArrayOrBlob2)) {
       return typedArrayOrBlob2;
     }
-    return new Blob([isSharedArrayBuffer(typedArrayOrBlob2.buffer) ? new Uint8Array(typedArrayOrBlob2) : typedArrayOrBlob2], { type });
+    return new Blob([typedArrayOrBlob2], { type });
   }
   const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
-  const result = await inflateRawAsync(typedArrayOrBlob, rawEntry.uncompressedSize, type);
+  const result = await inflateRawAsync(typedArrayOrBlob instanceof Uint8Array ? typedArrayOrBlob : typedArrayOrBlob, rawEntry.uncompressedSize, type);
   return result;
 }
 async function unzipRaw(source) {
@@ -4082,12 +4515,17 @@ async function unzip(source) {
     entries: Object.fromEntries(entries.map((v) => [v.name, v]))
   };
 }
-function isZipEntryInternal(entry) {
-  if (!("compressionMethod" in entry) || !("_rawEntry" in entry)) {
-    return false;
+function getRawEntry(entry) {
+  if (!("_rawEntry" in entry)) {
+    return void 0;
   }
   const rawEntry = entry._rawEntry;
-  return typeof entry.compressionMethod === "number" && typeof rawEntry === "object" && rawEntry !== null && "relativeOffsetOfLocalHeader" in rawEntry && typeof rawEntry.relativeOffsetOfLocalHeader === "number";
+  if (typeof rawEntry === "object" && rawEntry !== null && "relativeOffsetOfLocalHeader" in rawEntry && typeof rawEntry.relativeOffsetOfLocalHeader === "number") {
+    return {
+      relativeOffsetOfLocalHeader: rawEntry.relativeOffsetOfLocalHeader
+    };
+  }
+  return void 0;
 }
 class BlobReader2 {
   constructor(blob) {
@@ -4125,7 +4563,7 @@ class HTTPRangeReader {
     if (size === 0) {
       return new Uint8Array(0);
     }
-    const req = await fetch_range(this.url, offset, size, this.#overrides);
+    const req = await fetchRange(this.url, offset, size, this.#overrides);
     assert$1(req.ok, `failed http request ${this.url}, status: ${req.status} offset: ${offset} size: ${size}: ${req.statusText}`);
     return new Uint8Array(await req.arrayBuffer());
   }
@@ -4144,24 +4582,25 @@ class ZipFileStore {
    * Compute the byte offset where entry data begins in the zip file.
    * This requires reading the local file header to get filename and extra field lengths.
    */
-  async getEntryDataOffset(entry) {
-    const localHeaderOffset = entry._rawEntry.relativeOffsetOfLocalHeader;
+  async getEntryDataOffset(rawEntry) {
+    const localHeaderOffset = rawEntry.relativeOffsetOfLocalHeader;
     const header = await this.reader.read(localHeaderOffset, 30);
     const fileNameLength = header[26] + header[27] * 256;
     const extraFieldLength = header[28] + header[29] * 256;
     return localHeaderOffset + 30 + fileNameLength + extraFieldLength;
   }
   async get(key) {
-    let entry = (await this.info).entries[strip_prefix(key)];
+    let entry = (await this.info).entries[stripPrefix(key)];
     if (!entry)
       return;
     return new Uint8Array(await entry.arrayBuffer());
   }
   async getRange(key, range) {
-    const entry = (await this.info).entries[strip_prefix(key)];
+    const entry = (await this.info).entries[stripPrefix(key)];
     if (!entry)
       return void 0;
-    if (!isZipEntryInternal(entry)) {
+    const rawEntry = getRawEntry(entry);
+    if (!rawEntry) {
       throw new Error("ZipFileStore.getRange requires internal unzipit properties that are not available. This may indicate an incompatible version of unzipit.");
     }
     if (entry.compressionMethod !== 0) {
@@ -4173,7 +4612,7 @@ class ZipFileStore {
       }
       return bytes.slice(range.offset, range.offset + range.length);
     }
-    const dataOffset = await this.getEntryDataOffset(entry);
+    const dataOffset = await this.getEntryDataOffset(rawEntry);
     if ("suffixLength" in range) {
       const start = dataOffset + entry.size - range.suffixLength;
       return this.reader.read(start, range.suffixLength);
@@ -4181,7 +4620,7 @@ class ZipFileStore {
     return this.reader.read(dataOffset + range.offset, range.length);
   }
   async has(key) {
-    return strip_prefix(key) in (await this.info).entries;
+    return stripPrefix(key) in (await this.info).entries;
   }
   static fromUrl(href, opts = {}) {
     return new ZipFileStore(new HTTPRangeReader(href, opts), opts);
@@ -4294,6 +4733,8 @@ class AnnDataAutoConfig extends AbstractAutoConfig2 {
   }
   // eslint-disable-next-line class-methods-use-this
   addViews(vc, dataset, layoutOption) {
+    const geneList = vc.addView(dataset, "featureList");
+    vc.layout(geneList);
   }
 }
 class SpatialDataAutoConfig extends AbstractAutoConfig2 {
@@ -4490,9 +4931,15 @@ async function parsedUrlToZmetadata(parsedUrl) {
   let promises = [];
   try {
     try {
-      store = await withConsolidated(initialStore);
+      store = await extendStore(
+        initialStore,
+        (s) => withConsolidatedMetadata(s)
+      );
     } catch {
-      store = await withConsolidated(initialStore, { metadataKey: "zmetadata" });
+      store = await extendStore(
+        initialStore,
+        (s) => withConsolidatedMetadata(s, { metadataKey: "zmetadata" })
+      );
     }
     const contents = store.contents();
     const consolidatedRoot = await open(store, { kind: "group" });
@@ -4595,12 +5042,12 @@ var hasRequiredFetchJsonp;
 function requireFetchJsonp() {
   if (hasRequiredFetchJsonp) return fetchJsonp$2.exports;
   hasRequiredFetchJsonp = 1;
-  (function(module2, exports) {
+  (function(module, exports) {
     (function(global, factory) {
       {
-        factory(exports, module2);
+        factory(exports, module);
       }
-    })(fetchJsonp$1, function(exports2, module3) {
+    })(fetchJsonp$1, function(exports2, module2) {
       var defaultOptions = {
         timeout: 5e3,
         jsonpCallback: "callback"
@@ -4679,7 +5126,7 @@ function requireFetchJsonp() {
           };
         });
       }
-      module3.exports = fetchJsonp2;
+      module2.exports = fetchJsonp2;
     });
   })(fetchJsonp$2, fetchJsonp$2.exports);
   return fetchJsonp$2.exports;