@dclimate/zarr-map 0.1.0

package/dist/dclimate/index.cjs

@@ -0,0 +1,1859 @@
+'use strict';
+
+// src/core/errors.ts
+var GridError = class extends Error {
+  code;
+  cause;
+  dimension;
+  variable;
+  sourceId;
+  context;
+  constructor(details) {
+    super(details.message);
+    this.name = "GridError";
+    this.code = details.code;
+    this.cause = details.cause;
+    this.dimension = details.dimension;
+    this.variable = details.variable;
+    this.sourceId = details.sourceId;
+    this.context = details.context;
+  }
+};
+
+// src/core/validation.ts
+var xAliases = /* @__PURE__ */ new Set(["x", "lon", "lng", "longitude"]);
+var yAliases = /* @__PURE__ */ new Set(["y", "lat", "latitude"]);
+var numericDtypes = /* @__PURE__ */ new Set([
+  "int8",
+  "uint8",
+  "int16",
+  "uint16",
+  "int32",
+  "uint32",
+  "float32",
+  "float64",
+  "i1",
+  "u1",
+  "i2",
+  "u2",
+  "i4",
+  "u4",
+  "f4",
+  "f8"
+]);
+function findVariable(source, variableName) {
+  return source.variables.find(
+    (variable) => variable.name === variableName || variable.path === variableName
+  );
+}
+function findDimension(source, dimensionName) {
+  return source.dimensions.find((dimension) => dimension.name === dimensionName);
+}
+function inferSpatialDimensions(source, variableName = source.variables[0]?.name) {
+  const variable = variableName ? findVariable(source, variableName) : source.variables[0];
+  if (source.spatialDimensions) {
+    return variableIncludesSpatialDimensions(variable, source.spatialDimensions) ? source.spatialDimensions : void 0;
+  }
+  const candidateNames = variable?.dimensions ?? source.dimensions.map((dimension) => dimension.name);
+  let x;
+  let y;
+  for (const name of candidateNames) {
+    const dimension = findDimension(source, name);
+    const normalizedName = name.toLowerCase();
+    const standardName = String(dimension?.standardName ?? "").toLowerCase();
+    const kind = dimension?.kind;
+    if (!x && (kind === "x" || xAliases.has(normalizedName) || standardName === "longitude")) {
+      x = name;
+    }
+    if (!y && (kind === "y" || yAliases.has(normalizedName) || standardName === "latitude")) {
+      y = name;
+    }
+  }
+  return x && y ? { x, y } : void 0;
+}
+function variableIncludesSpatialDimensions(variable, spatialDimensions) {
+  if (!variable) {
+    return false;
+  }
+  return variable.dimensions.includes(spatialDimensions.x) && variable.dimensions.includes(spatialDimensions.y);
+}
+function validateGridDataSource(source, options = {}) {
+  const errors = [];
+  const warnings = [];
+  if (source.variables.length === 0) {
+    errors.push(
+      new GridError({
+        code: "MISSING_VARIABLE",
+        message: "GridDataSource must expose at least one variable.",
+        sourceId: source.id
+      })
+    );
+  }
+  const variable = options.variable ? findVariable(source, options.variable) : source.variables[0];
+  if (options.variable && !variable) {
+    errors.push(
+      new GridError({
+        code: "MISSING_VARIABLE",
+        message: `Variable "${options.variable}" is not present in the grid source.`,
+        sourceId: source.id,
+        variable: options.variable
+      })
+    );
+  }
+  for (const dimension of source.dimensions) {
+    if (!Number.isInteger(dimension.size) || dimension.size <= 0) {
+      errors.push(
+        new GridError({
+          code: "UNSUPPORTED_DIMENSION",
+          message: `Dimension "${dimension.name}" must have a positive integer size.`,
+          dimension: dimension.name,
+          sourceId: source.id
+        })
+      );
+    }
+    if (dimension.coordinates && dimension.coordinates.length !== dimension.size) {
+      errors.push(
+        new GridError({
+          code: "MISSING_COORDINATES",
+          message: `Dimension "${dimension.name}" has ${dimension.coordinates.length} coordinates for size ${dimension.size}.`,
+          dimension: dimension.name,
+          sourceId: source.id
+        })
+      );
+    }
+  }
+  if (variable) {
+    if (!isNumericDType(variable.dtype)) {
+      errors.push(
+        new GridError({
+          code: "UNSUPPORTED_DTYPE",
+          message: `Variable "${variable.name}" has unsupported dtype "${variable.dtype}".`,
+          variable: variable.name,
+          sourceId: source.id
+        })
+      );
+    }
+    if (variable.dimensions.length !== variable.shape.length) {
+      errors.push(
+        new GridError({
+          code: "MISSING_DIMENSION",
+          message: `Variable "${variable.name}" has ${variable.dimensions.length} dimensions but ${variable.shape.length} shape entries.`,
+          variable: variable.name,
+          sourceId: source.id
+        })
+      );
+    }
+    variable.dimensions.forEach((dimensionName, index) => {
+      const dimension = findDimension(source, dimensionName);
+      if (!dimension) {
+        errors.push(
+          new GridError({
+            code: "MISSING_DIMENSION",
+            message: `Variable "${variable.name}" references missing dimension "${dimensionName}".`,
+            dimension: dimensionName,
+            variable: variable.name,
+            sourceId: source.id
+          })
+        );
+        return;
+      }
+      const expectedSize = variable.shape[index];
+      if (expectedSize !== dimension.size) {
+        warnings.push(
+          `Variable "${variable.name}" shape for dimension "${dimensionName}" is ${expectedSize}, but the dimension size is ${dimension.size}.`
+        );
+      }
+    });
+    const spatialDimensions = inferSpatialDimensions(source, variable.name);
+    if (!spatialDimensions) {
+      errors.push(
+        new GridError({
+          code: "MISSING_SPATIAL_DIMENSIONS",
+          message: `Variable "${variable.name}" needs latitude/longitude or x/y spatial dimensions before it can render.`,
+          variable: variable.name,
+          sourceId: source.id
+        })
+      );
+    }
+    if (options.requireRenderable && !source.bounds) {
+      errors.push(
+        new GridError({
+          code: "MISSING_BOUNDS",
+          message: "Renderable grid sources must include explicit [west, south, east, north] bounds.",
+          variable: variable.name,
+          sourceId: source.id
+        })
+      );
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function assertValidGridDataSource(source, options = {}) {
+  const result = validateGridDataSource(source, options);
+  if (!result.ok) {
+    throw result.errors[0];
+  }
+}
+function isNumericDType(dtype) {
+  return numericDtypes.has(dtype.toLowerCase()) || /^[<>|]?[ifu]\d+$/.test(dtype.toLowerCase());
+}
+
+// src/core/selectors.ts
+function normalizeSelectors(source, variableName, selectors = {}) {
+  const variable = findVariable(source, variableName);
+  if (!variable) {
+    throw new GridError({
+      code: "MISSING_VARIABLE",
+      message: `Variable "${variableName}" is not present in the grid source.`,
+      variable: variableName,
+      sourceId: source.id
+    });
+  }
+  const normalized = {};
+  for (const dimensionName of variable.dimensions) {
+    const dimension = findDimension(source, dimensionName);
+    if (!dimension) {
+      throw new GridError({
+        code: "MISSING_DIMENSION",
+        message: `Selector normalization cannot find dimension "${dimensionName}".`,
+        dimension: dimensionName,
+        variable: variableName,
+        sourceId: source.id
+      });
+    }
+    const input = selectors[dimensionName];
+    if (input === void 0) {
+      normalized[dimensionName] = defaultSelectorForDimension(dimension);
+      continue;
+    }
+    normalized[dimensionName] = normalizeSelectorValue(dimension, input, source.id);
+  }
+  return normalized;
+}
+function normalizeSelectorValue(dimension, input, sourceId) {
+  if (input instanceof Date) {
+    return { kind: "coordinate", value: input.toISOString() };
+  }
+  if (typeof input !== "object") {
+    return normalizeCoordinateSelector(dimension, input, sourceId);
+  }
+  if (input.kind === "coordinate") {
+    const value = input.value instanceof Date ? input.value.toISOString() : input.value;
+    return normalizeCoordinateSelector(dimension, value, sourceId);
+  }
+  if (input.kind === "index") {
+    assertIndexInRange(dimension, input.index, sourceId);
+    const value = dimension.coordinates?.[input.index];
+    return {
+      kind: "index",
+      index: input.index,
+      value: value instanceof Date ? value.toISOString() : value
+    };
+  }
+  if (input.kind === "isoTime") {
+    const value = findCoordinateForIso(dimension, input.iso);
+    return value === void 0 ? { kind: "isoTime", iso: input.iso } : { kind: "isoTime", iso: input.iso, value };
+  }
+  throw new GridError({
+    code: "UNSUPPORTED_SELECTOR",
+    message: `Unsupported selector for dimension "${dimension.name}".`,
+    dimension: dimension.name,
+    sourceId
+  });
+}
+function selectorToIndex(dimension, selector) {
+  if (selector.kind === "index") {
+    return selector.index;
+  }
+  const selected = selector.kind === "isoTime" ? selector.value ?? selector.iso : selector.value;
+  const index = dimension.coordinates?.findIndex((coordinate) => sameCoordinate(coordinate, selected)) ?? -1;
+  if (index >= 0) {
+    return index;
+  }
+  throw new GridError({
+    code: "UNSUPPORTED_SELECTOR",
+    message: `Selector value "${String(selected)}" does not match coordinates for dimension "${dimension.name}".`,
+    dimension: dimension.name
+  });
+}
+function defaultSelectorForDimension(dimension) {
+  const firstValue = dimension.coordinates?.[0];
+  if (firstValue !== void 0) {
+    return {
+      kind: "coordinate",
+      value: firstValue instanceof Date ? firstValue.toISOString() : firstValue
+    };
+  }
+  return { kind: "index", index: 0 };
+}
+function normalizeCoordinateSelector(dimension, value, sourceId) {
+  if (dimension.coordinates && !dimension.coordinates.some((coordinate) => sameCoordinate(coordinate, value))) {
+    throw new GridError({
+      code: "UNSUPPORTED_SELECTOR",
+      message: `Selector value "${String(value)}" does not match coordinates for dimension "${dimension.name}".`,
+      dimension: dimension.name,
+      sourceId
+    });
+  }
+  return { kind: "coordinate", value };
+}
+function assertIndexInRange(dimension, index, sourceId) {
+  if (!Number.isInteger(index) || index < 0 || index >= dimension.size) {
+    throw new GridError({
+      code: "UNSUPPORTED_SELECTOR",
+      message: `Index selector ${index} is outside dimension "${dimension.name}" size ${dimension.size}.`,
+      dimension: dimension.name,
+      sourceId
+    });
+  }
+}
+function findCoordinateForIso(dimension, iso) {
+  return dimension.coordinates?.map((coordinate) => decodeTimeCoordinate(coordinate, dimension.units)).find((coordinate) => coordinate.iso === iso || coordinate.value === iso)?.value;
+}
+function decodeTimeCoordinate(coordinate, units) {
+  if (coordinate instanceof Date) {
+    return { value: coordinate.toISOString(), iso: coordinate.toISOString() };
+  }
+  if (typeof coordinate === "string") {
+    const date = new Date(coordinate);
+    return Number.isNaN(date.getTime()) ? { value: coordinate } : { value: coordinate, iso: date.toISOString() };
+  }
+  const cfTime = decodeCfTime(coordinate, units);
+  return cfTime ? { value: coordinate, iso: cfTime } : { value: coordinate };
+}
+function decodeCfTime(value, units) {
+  if (!units) {
+    return void 0;
+  }
+  const match = /^(seconds|minutes|hours|days) since ([0-9]{4}-[0-9]{2}-[0-9]{2})(?:[ T]([0-9:.Z+-]+))?/i.exec(
+    units
+  );
+  if (!match) {
+    return void 0;
+  }
+  const unit = match[1]?.toLowerCase();
+  const date = match[2];
+  const time = match[3] ?? "00:00:00Z";
+  const origin = /* @__PURE__ */ new Date(`${date}T${time.replace(/Z?$/, "Z")}`);
+  if (Number.isNaN(origin.getTime())) {
+    return void 0;
+  }
+  const multiplier = unit === "seconds" ? 1e3 : unit === "minutes" ? 6e4 : unit === "hours" ? 36e5 : 864e5;
+  return new Date(origin.getTime() + value * multiplier).toISOString();
+}
+function sameCoordinate(left, right) {
+  const normalizedLeft = left instanceof Date ? left.toISOString() : left;
+  return normalizedLeft === right || String(normalizedLeft) === String(right);
+}
+
+// src/core/jaxray.ts
+function createJaxraySource(input, options = {}) {
+  const dataset = isDatasetLike(input) ? input : arrayToDataset(input);
+  const variables = inferVariables(dataset, options);
+  const dimensions = inferDimensions(dataset, variables, options);
+  const source = {
+    id: options.id ?? dataset.id,
+    label: options.label,
+    source: options.source,
+    store: options.store ?? dataset.store,
+    zarrVersion: options.zarrVersion,
+    crs: options.crs ?? stringAttr(dataset.attrs, "crs") ?? "EPSG:4326",
+    proj4: options.proj4 ?? stringAttr(dataset.attrs, "proj4"),
+    bounds: options.bounds ?? inferBounds(dimensions, dataset.attrs),
+    spatialDimensions: options.spatialDimensions,
+    dimensions,
+    variables,
+    metadata: dataset.attrs,
+    readSlice: async (request) => readJaxraySlice(dataset, source, request.variable, request.selectors)
+  };
+  const firstSpatialVariable = variables.find(
+    (variable) => inferSpatialDimensions(source, variable.name)
+  );
+  source.spatialDimensions = options.spatialDimensions ?? inferSpatialDimensions(source) ?? (firstSpatialVariable ? inferSpatialDimensions(source, firstSpatialVariable.name) : void 0);
+  assertValidGridDataSource(source, {
+    variable: firstSpatialVariable?.name ?? variables[0]?.name
+  });
+  return source;
+}
+function isDatasetLike(input) {
+  return "data_vars" in input || "dataVars" in input || "variables" in input && !("shape" in input) || "sizes" in input;
+}
+function arrayToDataset(array) {
+  const name = array.name ?? "variable";
+  return {
+    data_vars: { [name]: array },
+    coords: array.coords,
+    attrs: array.attrs
+  };
+}
+function inferVariables(dataset, options) {
+  return Array.from(variableEntries(dataset)).map(([name, array]) => {
+    const dimensions = array.dims ?? array.dimensions;
+    if (!dimensions) {
+      throw new GridError({
+        code: "MISSING_DIMENSION",
+        message: `Jaxray variable "${name}" does not expose dims/dimensions metadata.`,
+        variable: name
+      });
+    }
+    const shape = array.shape ?? dimensions.map((dimensionName) => dimensionSize(dataset, dimensionName));
+    if (!shape) {
+      throw new GridError({
+        code: "MISSING_DIMENSION",
+        message: `Jaxray variable "${name}" does not expose shape metadata.`,
+        variable: name
+      });
+    }
+    const override = options.variables?.[name] ?? {};
+    return {
+      name,
+      path: stringAttr(array.attrs, "path"),
+      dtype: override.dtype ?? array.dtype ?? stringAttr(array.attrs, "dtype") ?? "float32",
+      dimensions,
+      shape,
+      chunks: override.chunks ?? array.chunks,
+      units: override.units ?? stringAttr(array.attrs, "units"),
+      longName: override.longName ?? stringAttr(array.attrs, "long_name"),
+      standardName: override.standardName ?? stringAttr(array.attrs, "standard_name"),
+      fillValue: override.fillValue ?? numberAttr(array.attrs, "_FillValue") ?? numberAttr(array.attrs, "fill_value") ?? null,
+      scaleFactor: override.scaleFactor ?? numberAttr(array.attrs, "scale_factor"),
+      addOffset: override.addOffset ?? numberAttr(array.attrs, "add_offset"),
+      attrs: array.attrs
+    };
+  });
+}
+function inferDimensions(dataset, variables, options) {
+  const dimensions = /* @__PURE__ */ new Map();
+  const coords = dataset.coords;
+  for (const variable of variables) {
+    variable.dimensions.forEach((name, index) => {
+      const existing = dimensions.get(name);
+      const coordinates = normalizeCoordinateArray(coordinateValue(coords, name));
+      const override = options.dimensions?.[name] ?? {};
+      const inferredKind = inferDimensionKind(name);
+      const size = variable.shape[index] ?? coordinates?.length ?? 0;
+      dimensions.set(name, {
+        ...existing,
+        name,
+        size: override.size ?? existing?.size ?? size,
+        kind: override.kind ?? existing?.kind ?? inferredKind,
+        coordinates: override.coordinates ?? existing?.coordinates ?? coordinates,
+        units: override.units ?? existing?.units,
+        calendar: override.calendar ?? existing?.calendar,
+        longName: override.longName ?? existing?.longName,
+        standardName: override.standardName ?? existing?.standardName,
+        ascending: override.ascending ?? existing?.ascending ?? inferAscending(coordinates),
+        attrs: override.attrs ?? existing?.attrs
+      });
+    });
+  }
+  return Array.from(dimensions.values());
+}
+function inferDimensionKind(name) {
+  const normalized = name.toLowerCase();
+  if (["lon", "lng", "longitude", "x"].includes(normalized)) {
+    return "x";
+  }
+  if (["lat", "latitude", "y"].includes(normalized)) {
+    return "y";
+  }
+  if (["time", "valid_time", "date"].includes(normalized)) {
+    return "time";
+  }
+  if (["band", "month"].includes(normalized)) {
+    return "band";
+  }
+  if (["level", "height", "pressure"].includes(normalized)) {
+    return "vertical";
+  }
+  return "other";
+}
+function inferBounds(dimensions, attrs) {
+  const attrBounds = attrs?.bounds;
+  if (Array.isArray(attrBounds) && attrBounds.length === 4 && attrBounds.every((value) => typeof value === "number")) {
+    return attrBounds;
+  }
+  const x = dimensions.find((dimension) => dimension.kind === "x");
+  const y = dimensions.find((dimension) => dimension.kind === "y");
+  const xCoordinates = x?.coordinates?.filter(
+    (value) => typeof value === "number"
+  );
+  const yCoordinates = y?.coordinates?.filter(
+    (value) => typeof value === "number"
+  );
+  if (!xCoordinates?.length || !yCoordinates?.length) {
+    return void 0;
+  }
+  return [
+    Math.min(...xCoordinates),
+    Math.min(...yCoordinates),
+    Math.max(...xCoordinates),
+    Math.max(...yCoordinates)
+  ];
+}
+async function readJaxraySlice(dataset, source, variableName, selectors = {}) {
+  const entry = variableEntries(dataset).find(([name2]) => name2 === variableName);
+  if (!entry) {
+    throw new GridError({
+      code: "MISSING_VARIABLE",
+      message: `Jaxray source cannot read missing variable "${variableName}".`,
+      variable: variableName,
+      sourceId: source.id
+    });
+  }
+  const [name, array] = entry;
+  const variable = source.variables.find((candidate) => candidate.name === name);
+  if (!variable) {
+    throw new GridError({
+      code: "MISSING_VARIABLE",
+      message: `Jaxray source metadata is missing variable "${name}".`,
+      variable: name,
+      sourceId: source.id
+    });
+  }
+  const normalizedSelectors = isNormalizedSelectors(selectors) ? selectors : normalizeSelectors(source, variable.name, selectors);
+  const selection = variable.dimensions.reduce(
+    (accumulator, dimensionName) => {
+      const dimension = findDimension(source, dimensionName);
+      if (!dimension) {
+        return accumulator;
+      }
+      accumulator[dimensionName] = selectorToIndex(
+        dimension,
+        normalizedSelectors[dimensionName] ?? { kind: "index", index: 0 }
+      );
+      return accumulator;
+    },
+    {}
+  );
+  const value = await readArrayValue(array, variable, selection);
+  return {
+    variable: name,
+    selectors: normalizedSelectors,
+    dimensions: [],
+    shape: [],
+    data: [value],
+    unit: variable.units,
+    fillValue: variable.fillValue
+  };
+}
+async function readArrayValue(array, variable, selection) {
+  if (array.get) {
+    return array.get(selection);
+  }
+  if (array.isel) {
+    const selected = await array.isel(selection);
+    const computed = selected.isLazy && selected.compute ? await selected.compute() : selected;
+    return scalarFromArrayLike(computed.data ?? computed.values);
+  }
+  const data = array.data ?? array.values;
+  if (!data) {
+    throw new GridError({
+      code: "SOURCE_LOAD_FAILED",
+      message: `Jaxray variable "${variable.name}" does not expose readable data for query helpers.`,
+      variable: variable.name
+    });
+  }
+  let offset = 0;
+  let stride = 1;
+  for (let index = variable.dimensions.length - 1; index >= 0; index -= 1) {
+    const dimensionName = variable.dimensions[index];
+    if (!dimensionName) {
+      continue;
+    }
+    offset += (selection[dimensionName] ?? 0) * stride;
+    stride *= variable.shape[index] ?? 1;
+  }
+  return data[offset] ?? Number.NaN;
+}
+function scalarFromArrayLike(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+    const first = Array.from(value)[0];
+    return scalarFromArrayLike(first);
+  }
+  return Number.NaN;
+}
+function variableEntries(dataset) {
+  if (Array.isArray(dataset.dataVars) && typeof dataset.getVariable === "function") {
+    return dataset.dataVars.map((name) => [name, dataset.getVariable?.(name) ?? {}]);
+  }
+  if (Array.isArray(dataset.dataVars)) {
+    throw new GridError({
+      code: "MISSING_VARIABLE",
+      message: "Jaxray Dataset exposes dataVars names but no getVariable(name) method."
+    });
+  }
+  const variables = dataset.data_vars ?? dataset.dataVars ?? dataset.variables ?? {};
+  if (variables instanceof Map) {
+    return Array.from(variables.entries());
+  }
+  return Object.entries(variables);
+}
+function normalizeCoordinateArray(input) {
+  const raw = Array.isArray(input) ? input : ArrayBuffer.isView(input) ? Array.from(input) : typeof input === "object" && input !== null && "values" in input && isArrayLike(input.values) ? Array.from(input.values) : typeof input === "object" && input !== null && "data" in input && isArrayLike(input.data) ? Array.from(input.data) : void 0;
+  return raw?.filter(
+    (value) => typeof value === "number" || typeof value === "string"
+  );
+}
+function coordinateValue(coords, name) {
+  if (!coords) {
+    return void 0;
+  }
+  return coords instanceof Map ? coords.get(name) : coords[name];
+}
+function dimensionSize(dataset, dimensionName) {
+  const sizes = dataset.sizes;
+  if (!sizes) {
+    return 0;
+  }
+  return sizes instanceof Map ? sizes.get(dimensionName) ?? 0 : sizes[dimensionName] ?? 0;
+}
+function isArrayLike(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value) || typeof value === "object" && value !== null && "length" in value && typeof value.length === "number";
+}
+function inferAscending(coordinates) {
+  if (!coordinates || coordinates.length < 2) {
+    return void 0;
+  }
+  const first = coordinates[0];
+  const second = coordinates[1];
+  return typeof first === "number" && typeof second === "number" ? second > first : void 0;
+}
+function stringAttr(attrs, name) {
+  const value = attrs?.[name];
+  return typeof value === "string" ? value : void 0;
+}
+function numberAttr(attrs, name) {
+  const value = attrs?.[name];
+  return typeof value === "number" ? value : void 0;
+}
+function isNormalizedSelectors(selectors) {
+  return Object.values(selectors).every(
+    (value) => typeof value === "object" && value !== null && "kind" in value
+  );
+}
+
+// src/core/preflight.ts
+var dtypeByteSizes = {
+  int8: 1,
+  uint8: 1,
+  i1: 1,
+  u1: 1,
+  int16: 2,
+  uint16: 2,
+  i2: 2,
+  u2: 2,
+  int32: 4,
+  uint32: 4,
+  float32: 4,
+  i4: 4,
+  u4: 4,
+  f4: 4,
+  float64: 8,
+  f8: 8
+};
+function preflightGridRequest(options) {
+  const errors = [];
+  const warnings = [];
+  const dimensions = {};
+  const variable = findVariable(options.source, options.variable);
+  if (!variable) {
+    errors.push(
+      new GridError({
+        code: "MISSING_VARIABLE",
+        message: `Variable "${options.variable}" is not present in the grid source.`,
+        sourceId: options.source.id,
+        variable: options.variable
+      })
+    );
+    return { ok: false, dimensions, warnings, errors };
+  }
+  const spatialDimensions = inferSpatialDimensions(options.source, variable.name);
+  for (const dimensionName of variable.dimensions) {
+    const dimension = findDimension(options.source, dimensionName);
+    if (!dimension) {
+      errors.push(
+        new GridError({
+          code: "MISSING_DIMENSION",
+          message: `Variable "${variable.name}" references missing dimension "${dimensionName}".`,
+          dimension: dimensionName,
+          sourceId: options.source.id,
+          variable: variable.name
+        })
+      );
+      continue;
+    }
+    dimensions[dimension.name] = selectedDimensionSize({
+      bounds: options.bounds,
+      dimension,
+      isSpatialX: spatialDimensions?.x === dimension.name,
+      isSpatialY: spatialDimensions?.y === dimension.name,
+      selectorIsPresent: options.selectors?.[dimension.name] !== void 0,
+      sourceBounds: options.source.bounds,
+      timeRange: options.timeRange,
+      warnings
+    });
+  }
+  const cells = Object.values(dimensions).reduce((total, size) => total * size, 1);
+  const byteSize = dtypeByteSize(variable.dtype);
+  const bytes = byteSize === void 0 ? void 0 : cells * byteSize;
+  if (byteSize === void 0) {
+    warnings.push(`Variable "${variable.name}" has unknown dtype byte size "${variable.dtype}".`);
+  }
+  if (options.limits?.maxCells !== void 0 && cells > options.limits.maxCells) {
+    errors.push(
+      new GridError({
+        code: "QUERY_TOO_EXPENSIVE",
+        message: `Grid request would select approximately ${cells} cells, above the limit of ${options.limits.maxCells}.`,
+        context: { cells, maxCells: options.limits.maxCells },
+        sourceId: options.source.id,
+        variable: variable.name
+      })
+    );
+  }
+  if (bytes !== void 0 && options.limits?.maxBytes !== void 0 && bytes > options.limits.maxBytes) {
+    errors.push(
+      new GridError({
+        code: "QUERY_TOO_EXPENSIVE",
+        message: `Grid request would read approximately ${bytes} uncompressed bytes, above the limit of ${options.limits.maxBytes}.`,
+        context: { bytes, maxBytes: options.limits.maxBytes },
+        sourceId: options.source.id,
+        variable: variable.name
+      })
+    );
+  }
+  return {
+    ok: errors.length === 0,
+    cells,
+    bytes,
+    dimensions,
+    warnings,
+    errors
+  };
+}
+function selectedDimensionSize(options) {
+  if (options.selectorIsPresent) {
+    return 1;
+  }
+  if (options.bounds && options.isSpatialX) {
+    return spatialCount(options.dimension, options.bounds[0], options.bounds[2], {
+      axis: "x",
+      sourceBounds: options.sourceBounds,
+      warnings: options.warnings
+    });
+  }
+  if (options.bounds && options.isSpatialY) {
+    return spatialCount(options.dimension, options.bounds[1], options.bounds[3], {
+      axis: "y",
+      sourceBounds: options.sourceBounds,
+      warnings: options.warnings
+    });
+  }
+  if (options.timeRange && options.dimension.kind === "time") {
+    return timeRangeCount(options.dimension, options.timeRange, options.warnings);
+  }
+  return options.dimension.size;
+}
+function spatialCount(dimension, lowerBound, upperBound, options) {
+  const low = Math.min(lowerBound, upperBound);
+  const high = Math.max(lowerBound, upperBound);
+  const numericCoordinates2 = dimension.coordinates?.filter(
+    (coordinate) => typeof coordinate === "number"
+  );
+  if (numericCoordinates2?.length) {
+    return numericCoordinates2.filter((coordinate) => coordinate >= low && coordinate <= high).length;
+  }
+  const sourceRange = spatialRange(options.sourceBounds, options.axis);
+  if (!sourceRange) {
+    options.warnings.push(
+      `Dimension "${dimension.name}" has no coordinates or source bounds, so preflight used the full dimension size.`
+    );
+    return dimension.size;
+  }
+  const [sourceLow, sourceHigh] = sourceRange;
+  const span = sourceHigh - sourceLow;
+  if (span <= 0 || dimension.size <= 0) {
+    return 0;
+  }
+  const overlap = Math.max(0, Math.min(high, sourceHigh) - Math.max(low, sourceLow));
+  if (overlap === 0) {
+    return 0;
+  }
+  return Math.max(1, Math.min(dimension.size, Math.ceil(overlap / span * dimension.size)));
+}
+function timeRangeCount(dimension, timeRange, warnings) {
+  if (!dimension.coordinates?.length) {
+    warnings.push(
+      `Time dimension "${dimension.name}" has no coordinates, so preflight used the full time size.`
+    );
+    return dimension.size;
+  }
+  const start = timeToMillis(timeRange.start, dimension.units);
+  const end = timeToMillis(timeRange.end, dimension.units);
+  if (start === void 0 || end === void 0) {
+    warnings.push(
+      `Time range for "${dimension.name}" could not be parsed, so preflight used the full time size.`
+    );
+    return dimension.size;
+  }
+  const low = Math.min(start, end);
+  const high = Math.max(start, end);
+  let count = 0;
+  for (const coordinate of dimension.coordinates) {
+    const value = timeToMillis(coordinate, dimension.units);
+    if (value !== void 0 && value >= low && value <= high) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function timeToMillis(value, units) {
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  }
+  if (typeof value === "number") {
+    return numericTimeToMillis(value, units);
+  }
+  return void 0;
+}
+function numericTimeToMillis(value, units) {
+  if (!units) {
+    return void 0;
+  }
+  const match = /^(seconds?|minutes?|hours?|days?) since (.+)$/i.exec(units.trim());
+  if (!match) {
+    return void 0;
+  }
+  const [, unit, epoch] = match;
+  if (!unit || !epoch) {
+    return void 0;
+  }
+  const epochMillis = Date.parse(epoch);
+  if (Number.isNaN(epochMillis)) {
+    return void 0;
+  }
+  const multiplier = unit.toLowerCase().startsWith("second") ? 1e3 : unit.toLowerCase().startsWith("minute") ? 60 * 1e3 : unit.toLowerCase().startsWith("hour") ? 60 * 60 * 1e3 : 24 * 60 * 60 * 1e3;
+  return epochMillis + value * multiplier;
+}
+function spatialRange(bounds, axis) {
+  if (!bounds) {
+    return void 0;
+  }
+  return axis === "x" ? [bounds[0], bounds[2]] : [bounds[1], bounds[3]];
+}
+function dtypeByteSize(dtype) {
+  const normalized = dtype.toLowerCase().replace(/^[<>|]/, "");
+  return dtypeByteSizes[normalized];
+}
+
+// src/dclimate/index.ts
+var DEFAULT_TIME_KEYS = [
+  "time",
+  "valid_time",
+  "datetime",
+  "date",
+  "forecast_reference_time",
+  "forecast_time",
+  "analysis_time",
+  "initial_time",
+  "verification_time",
+  "step",
+  "t"
+];
+var DClimateAdapterError = class extends GridError {
+  constructor(code, message, cause, context) {
+    super({
+      code: code === "unsupported" ? "UNSUPPORTED_DIMENSION" : "SOURCE_LOAD_FAILED",
+      message,
+      cause,
+      context: {
+        adapter: "dclimate",
+        adapterCode: code,
+        ...context
+      }
+    });
+    this.name = "DClimateAdapterError";
+  }
+};
+function reportProgress(options, progress) {
+  options.onProgress?.({
+    ...progress,
+    percent: Math.max(0, Math.min(100, progress.percent))
+  });
+}
+function runDClimatePreflight(source, options) {
+  const config = options.preflight;
+  if (!config) {
+    return;
+  }
+  const selectionBounds = options.selection?.bounds ? normalizeSelectionBounds(options.selection.bounds, options.selection.boundsOptions).bounds : void 0;
+  const result = preflightGridRequest({
+    bounds: config.bounds ?? selectionBounds,
+    limits: config.limits,
+    selectors: config.selectors,
+    source,
+    timeRange: config.timeRange ?? options.selection?.timeRange,
+    variable: config.variable ?? source.variables[0]?.name ?? ""
+  });
+  config.onResult?.(result);
+  if (!result.ok) {
+    throw result.errors[0];
+  }
+}
+async function createDClimateSource(request, options = {}) {
+  try {
+    reportProgress(options, {
+      stage: "request",
+      message: "Preparing dClimate request",
+      percent: 2
+    });
+    const loaded = await loadDClimateDataset(request, options);
+    reportProgress(options, {
+      stage: "dataset",
+      message: "Dataset metadata loaded",
+      percent: 45
+    });
+    const metadata = extractMetadata(loaded);
+    const cid = extractString(loaded, ["cid", "rootCid", "hash"]) ?? metadata?.cid ?? request.cid;
+    const dataset = extractDataset(loaded);
+    const selectedForRendering = Boolean(options.selection?.bounds);
+    if (!dataset) {
+      const existingStore = options.store ?? extractStore(loaded);
+      const hasExternalSource = Boolean(
+        existingStore || options.source || request.cid || options.openIpfsStore || options.gatewayUrl
+      );
+      throw new DClimateAdapterError(
+        "metadata",
+        hasExternalSource ? "dClimate CID/store loading requires dataset metadata before it can be normalized. Provide a dClimate client response with variables, dimensions, coordinates, bounds, CRS, fill values, and units, or use createJaxraySource with explicit metadata overrides." : "dClimate response did not include a dataset, readable store, source URL, or CID.",
+        void 0,
+        { request, cid, hasStore: Boolean(existingStore), source: options.source }
+      );
+    }
+    reportProgress(options, {
+      stage: "source",
+      message: "Normalizing raster metadata",
+      percent: 55
+    });
+    const source = createJaxraySource(dataset, {
+      ...options,
+      id: options.id ?? sourceIdForRequest(request),
+      source: options.source ?? (selectedForRendering ? void 0 : gatewaySourceForCid(cid, options.gatewayUrl)),
+      store: options.store ?? (selectedForRendering ? void 0 : extractStore(loaded)),
+      label: options.label ?? labelForRequest(request)
+    });
+    runDClimatePreflight(source, options);
+    reportProgress(options, {
+      stage: "store",
+      message: selectedForRendering ? "Preparing bounded raster chunks" : "Preparing raster source",
+      percent: selectedForRendering ? 62 : 72
+    });
+    const selectedStore = selectedForRendering ? await createInMemoryZarrStore(dataset) : void 0;
+    const selectedStoreByteLength = selectedStore?.byteLength;
+    reportProgress(options, {
+      stage: "store",
+      message: selectedForRendering ? "Prepared bounded raster chunks" : "Prepared raster source",
+      percent: selectedForRendering ? 78 : 80,
+      byteLength: selectedStoreByteLength
+    });
+    reportProgress(options, {
+      stage: "source",
+      message: "Normalizing raster metadata",
+      percent: 84,
+      byteLength: selectedStoreByteLength
+    });
+    const store = options.store ?? selectedStore ?? (selectedForRendering ? void 0 : source.store ?? extractStore(loaded)) ?? (!selectedForRendering && cid && (options.gatewayUrl || options.openIpfsStore) ? await openStore(cid, options) : void 0);
+    reportProgress(options, {
+      stage: "ready",
+      message: "dClimate source ready",
+      percent: 100,
+      byteLength: selectedStoreByteLength
+    });
+    return {
+      ...source,
+      store,
+      metadata: {
+        ...source.metadata,
+        dclimate: {
+          request,
+          cid,
+          clientMetadata: metadata,
+          gatewayUrl: options.gatewayUrl,
+          selectedStoreByteLength
+        }
+      }
+    };
+  } catch (error) {
+    if (error instanceof DClimateAdapterError || error instanceof GridError) {
+      throw error;
+    }
+    throw new DClimateAdapterError(
+      "catalog",
+      "Failed to resolve or load the dClimate dataset.",
+      error,
+      {
+        request
+      }
+    );
+  }
+}
+async function loadDClimateDataset(request, options) {
+  if (options.client) {
+    reportProgress(options, {
+      stage: "client",
+      message: "Using injected dClimate client",
+      percent: 8
+    });
+    return callClient(options.client, request, options);
+  }
+  if (request.cid && !request.collection && !request.dataset) {
+    reportProgress(options, {
+      stage: "dataset",
+      message: "Using CID dataset reference",
+      percent: 35
+    });
+    return { cid: request.cid };
+  }
+  reportProgress(options, {
+    stage: "client",
+    message: "Loading dClimate client",
+    percent: 8
+  });
+  const module = await import('@dclimate/dclimate-client-js');
+  const Client = module.DClimateClient ?? module.default;
+  if (!Client) {
+    throw new DClimateAdapterError(
+      "catalog",
+      "@dclimate/dclimate-client-js did not export DClimateClient."
+    );
+  }
+  reportProgress(options, {
+    stage: "dataset",
+    message: "Resolving dClimate dataset",
+    percent: 18
+  });
+  return callClient(new Client(options.clientOptions), request, options);
+}
+async function callClient(client, request, options) {
+  if (options.selection?.bounds && client.loadDataset) {
+    return loadBoundedDataset(client, request, options);
+  }
+  if (options.selection) {
+    if (client.selectDataset) {
+      return client.selectDataset({
+        request,
+        selection: options.selection,
+        options: {
+          ...options.loadDatasetOptions,
+          gatewayUrl: options.gatewayUrl,
+          returnJaxrayDataset: false
+        }
+      });
+    }
+    if (options.selection.bounds) {
+      return loadBoundedDataset(client, request, options);
+    }
+    throw new DClimateAdapterError(
+      "unsupported",
+      "Injected dClimate client must expose selectDataset when source selection is requested."
+    );
+  }
+  if (client.loadDataset) {
+    return client.loadDataset({
+      request,
+      options: {
+        ...options.loadDatasetOptions,
+        gatewayUrl: options.gatewayUrl,
+        returnJaxrayDataset: true
+      }
+    });
+  }
+  if (client.getDataset) {
+    return client.getDataset(request);
+  }
+  if (client.resolveDataset) {
+    return client.resolveDataset(request);
+  }
+  throw new DClimateAdapterError(
+    "catalog",
+    "Injected dClimate client must expose loadDataset, selectDataset, getDataset, or resolveDataset."
+  );
+}
+async function loadBoundedDataset(client, request, options) {
+  if (!client.loadDataset) {
+    throw new DClimateAdapterError(
+      "unsupported",
+      "Injected dClimate client must expose loadDataset when bounds selection is requested."
+    );
+  }
+  const loaded = await client.loadDataset({
+    request,
+    options: {
+      ...options.loadDatasetOptions,
+      gatewayUrl: options.gatewayUrl,
+      returnJaxrayDataset: false
+    }
+  });
+  reportProgress(options, {
+    stage: "selection",
+    message: "Selecting requested time and bounds",
+    percent: 35
+  });
+  const selected = await applyBoundedSelection(loaded, options.selection);
+  reportProgress(options, {
+    stage: "selection",
+    message: "Selected bounded raster window",
+    percent: 52
+  });
+  return replaceLoadedDataset(loaded, selected);
+}
+async function applyBoundedSelection(loaded, selection) {
+  const dataset = extractGeoTemporalDataset(loaded);
+  if (!dataset) {
+    throw new DClimateAdapterError(
+      "unsupported",
+      "dClimate bounds selection requires a GeoTemporalDataset response."
+    );
+  }
+  const timeSelected = selection?.timeRange ? await applyTimeRangeSelection(dataset, selection.timeRange) : dataset;
+  const coordinateSelected = await applyCoordinateSelection(timeSelected, selection?.coordinates);
+  if (!selection?.bounds) {
+    return coordinateSelected;
+  }
+  const { bounds, boundsOptions } = normalizeSelectionBounds(
+    selection.bounds,
+    selection.boundsOptions
+  );
+  const [west, south, east, north] = bounds;
+  const gridSelected = await selectGriddedBounds(coordinateSelected, bounds, boundsOptions);
+  if (gridSelected) {
+    return gridSelected;
+  }
+  if (!hasRectangleSelection(coordinateSelected)) {
+    throw new DClimateAdapterError(
+      "unsupported",
+      "dClimate bounds selection requires rectangle or gridded axis selection support."
+    );
+  }
+  return coordinateSelected.rectangle(south, west, north, east, boundsOptions);
+}
+async function applyTimeRangeSelection(value, timeRange) {
+  const gridSelected = await selectGriddedTimeRange(value, timeRange);
+  if (gridSelected) {
+    return gridSelected;
+  }
+  if (!hasTimeRange(value)) {
+    return value;
+  }
+  return value.timeRange(timeRange);
+}
+async function selectGriddedTimeRange(value, timeRange) {
+  const grid = extractSelectableGrid(value);
+  if (!grid?.coords || typeof grid.sel !== "function") {
+    return void 0;
+  }
+  const timeKey = inferCoordinateKey(grid.coords, DEFAULT_TIME_KEYS);
+  if (!timeKey) {
+    return void 0;
+  }
+  const coordinates = coordinateValues(grid.coords[timeKey]);
+  if (!coordinates?.length) {
+    return void 0;
+  }
+  const range = timeCoordinateRange(coordinates, timeRange, timeCoordinateUnits(grid, timeKey));
+  if (!range) {
+    return void 0;
+  }
+  return grid.sel({
+    [timeKey]: range
+  });
+}
+async function applyCoordinateSelection(value, coordinates) {
+  if (!coordinates || Object.keys(coordinates).length === 0) {
+    return value;
+  }
+  const grid = extractSelectableGrid(value);
+  if (!grid || typeof grid.sel !== "function") {
+    throw new DClimateAdapterError(
+      "unsupported",
+      "dClimate coordinate selection requires gridded axis selection support."
+    );
+  }
+  return grid.sel(normalizeCoordinateSelection(coordinates));
+}
+function normalizeCoordinateSelection(coordinates) {
+  return Object.fromEntries(
+    Object.entries(coordinates).map(([dimension, value]) => [
+      dimension,
+      normalizeCoordinateSelectionValue(value)
+    ])
+  );
+}
+function normalizeCoordinateSelectionValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  return {
+    start: value.start instanceof Date ? value.start.toISOString() : value.start,
+    stop: value.stop instanceof Date ? value.stop.toISOString() : value.stop
+  };
+}
+async function selectGriddedBounds(value, bounds, boundsOptions) {
+  const grid = extractSelectableGrid(value);
+  if (!grid?.coords || typeof grid.sel !== "function") {
+    return void 0;
+  }
+  const latitudeKey = boundsOptions?.latitudeKey ?? inferCoordinateKey(grid.coords, ["latitude", "lat", "y"]);
+  const longitudeKey = boundsOptions?.longitudeKey ?? inferCoordinateKey(grid.coords, ["longitude", "lon", "lng", "x"]);
+  if (!latitudeKey || !longitudeKey) {
+    return void 0;
+  }
+  const latitudeCoords = numericCoordinates(grid.coords[latitudeKey]);
+  const longitudeCoords = numericCoordinates(grid.coords[longitudeKey]);
+  if (!latitudeCoords || !longitudeCoords || !hasGriddedSpatialAxes(grid, latitudeKey, longitudeKey)) {
+    return void 0;
+  }
+  const [west, south, east, north] = bounds;
+  return grid.sel({
+    [latitudeKey]: coordinateRange(latitudeCoords, south, north),
+    [longitudeKey]: coordinateRange(longitudeCoords, west, east)
+  });
+}
+function extractSelectableGrid(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const data = value.data;
+  if (isSelectableGrid(data)) {
+    return data;
+  }
+  return isSelectableGrid(value) ? value : void 0;
+}
+function isSelectableGrid(value) {
+  return isRecord(value) && isRecord(value.coords) && typeof value.sel === "function";
+}
+function timeCoordinateRange(coordinates, timeRange, units) {
+  const start = timeRangeBoundaryMillis(timeRange.start);
+  const end = timeRangeBoundaryMillis(timeRange.end);
+  if (start === void 0 || end === void 0) {
+    return void 0;
+  }
+  const lowerBound = Math.min(start, end);
+  const upperBound = Math.max(start, end);
+  const matchingCoordinates = coordinates.map((value) => ({ value, millis: timeCoordinateMillis(value, units) })).filter(
+    (coordinate) => coordinate.millis !== void 0 && coordinate.millis >= lowerBound && coordinate.millis <= upperBound
+  );
+  if (matchingCoordinates.length === 0) {
+    throw new DClimateAdapterError(
+      "unsupported",
+      "dClimate time range selection did not include any available time coordinates.",
+      void 0,
+      { timeRange }
+    );
+  }
+  return {
+    start: matchingCoordinates[0]?.value,
+    stop: matchingCoordinates.at(-1)?.value
+  };
+}
+function timeCoordinateUnits(grid, timeKey) {
+  const attrs = grid.coordAttrs?.[timeKey];
+  if (isRecord(attrs) && typeof attrs.units === "string") {
+    return attrs.units;
+  }
+  return void 0;
+}
+function timeRangeBoundaryMillis(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date.getTime();
+}
+function timeCoordinateMillis(value, units) {
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? void 0 : date.getTime();
+  }
+  if (typeof value === "number" && Number.isFinite(value) && units) {
+    return cfTimeCoordinateMillis(value, units);
+  }
+  return void 0;
+}
+function cfTimeCoordinateMillis(value, units) {
+  const match = /^(seconds?|minutes?|hours?|days?) since ([0-9]{4}-[0-9]{2}-[0-9]{2})(?:[ T]([0-9:.Z+-]+))?/i.exec(
+    units
+  );
+  if (!match) {
+    return void 0;
+  }
+  const unit = match[1]?.toLowerCase();
+  const date = match[2];
+  const time = match[3] ?? "00:00:00Z";
+  const origin = /* @__PURE__ */ new Date(`${date}T${time.replace(/Z?$/, "Z")}`);
+  if (Number.isNaN(origin.getTime())) {
+    return void 0;
+  }
+  return origin.getTime() + value * cfTimeUnitMultiplier(unit);
+}
+function cfTimeUnitMultiplier(unit) {
+  if (unit?.startsWith("second")) {
+    return 1e3;
+  }
+  if (unit?.startsWith("minute")) {
+    return 6e4;
+  }
+  if (unit?.startsWith("hour")) {
+    return 36e5;
+  }
+  return 864e5;
+}
+function inferCoordinateKey(coords, candidates) {
+  const keys = Object.keys(coords);
+  const normalizedKeys = keys.map((key) => key.toLowerCase().replace(/[_\-\s]+/g, ""));
+  for (const candidate of candidates) {
+    const index = normalizedKeys.indexOf(candidate.toLowerCase().replace(/[_\-\s]+/g, ""));
+    if (index !== -1) {
+      return keys[index];
+    }
+  }
+  return void 0;
+}
+function numericCoordinates(values) {
+  const raw = coordinateValues(values);
+  if (!raw?.length) {
+    return void 0;
+  }
+  const coordinates = raw.map((value) => typeof value === "number" ? value : Number(value));
+  return coordinates.every((value) => Number.isFinite(value)) ? coordinates : void 0;
+}
+function hasGriddedSpatialAxes(grid, latitudeKey, longitudeKey) {
+  if (!Array.isArray(grid.dataVars) || typeof grid.getVariable !== "function") {
+    return false;
+  }
+  return grid.dataVars.some((name) => {
+    if (typeof name !== "string") {
+      return false;
+    }
+    const variable = grid.getVariable?.(name);
+    return isRecord(variable) && Array.isArray(variable.dims) ? variable.dims.includes(latitudeKey) && variable.dims.includes(longitudeKey) : false;
+  });
+}
+function coordinateRange(coordinates, lowerBound, upperBound) {
+  const first = coordinates[0];
+  const last = coordinates.at(-1);
+  const ascending = first === void 0 || last === void 0 || first <= last;
+  const start = ascending ? firstCoordinateAtOrAbove(coordinates, lowerBound) : firstCoordinateAtOrBelow(coordinates, upperBound);
+  const stop = ascending ? lastCoordinateAtOrBelow(coordinates, upperBound) : lastCoordinateAtOrAbove(coordinates, lowerBound);
+  return { start, stop };
+}
+function firstCoordinateAtOrAbove(coordinates, bound) {
+  return binarySearchCoordinate(coordinates, (coordinate) => coordinate >= bound, "first") ?? nearestCoordinate(coordinates, bound);
+}
+function firstCoordinateAtOrBelow(coordinates, bound) {
+  return binarySearchCoordinate(coordinates, (coordinate) => coordinate <= bound, "first") ?? nearestCoordinate(coordinates, bound);
+}
+function lastCoordinateAtOrBelow(coordinates, bound) {
+  return binarySearchCoordinate(coordinates, (coordinate) => coordinate <= bound, "last") ?? nearestCoordinate(coordinates, bound);
+}
+function lastCoordinateAtOrAbove(coordinates, bound) {
+  return binarySearchCoordinate(coordinates, (coordinate) => coordinate >= bound, "last") ?? nearestCoordinate(coordinates, bound);
+}
+function binarySearchCoordinate(coordinates, matches, position) {
+  let low = 0;
+  let high = coordinates.length - 1;
+  let found;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const coordinate = coordinates[middle];
+    if (coordinate === void 0) {
+      break;
+    }
+    if (matches(coordinate)) {
+      found = coordinate;
+      if (position === "first") {
+        high = middle - 1;
+      } else {
+        low = middle + 1;
+      }
+      continue;
+    }
+    if (position === "first") {
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return found;
+}
+function nearestCoordinate(coordinates, value) {
+  return coordinates.reduce(
+    (nearest, coordinate) => Math.abs(coordinate - value) < Math.abs(nearest - value) ? coordinate : nearest
+  );
+}
+function replaceLoadedDataset(loaded, dataset) {
+  if (Array.isArray(loaded)) {
+    return [dataset, loaded[1]];
+  }
+  return dataset;
+}
+async function createInMemoryZarrStore(dataset) {
+  if (!dataset?.coords || !Array.isArray(dataset.dataVars) || typeof dataset.getVariable !== "function") {
+    return void 0;
+  }
+  const entries = /* @__PURE__ */ new Map();
+  const encoder = new TextEncoder();
+  const addJson = (path, value) => {
+    entries.set(path, encoder.encode(JSON.stringify(value)));
+  };
+  const addBytes = (path, value) => {
+    entries.set(path, value);
+  };
+  addJson(".zgroup", { zarr_format: 2 });
+  addJson(".zattrs", {});
+  for (const [dimensionName, coordinateValues2] of coordinateEntries(dataset.coords)) {
+    const coordinates = numericCoordinates(coordinateValues2);
+    const strings = coordinates ? void 0 : stringCoordinates(coordinateValues2);
+    if (!coordinates && !strings) {
+      continue;
+    }
+    if (strings) {
+      addJson(`${dimensionName}/.zarray`, {
+        zarr_format: 2,
+        shape: [strings.length],
+        chunks: [strings.length],
+        dtype: "|O",
+        compressor: null,
+        fill_value: null,
+        order: "C",
+        filters: [{ id: "vlen-utf8" }]
+      });
+      addJson(`${dimensionName}/.zattrs`, {
+        _ARRAY_DIMENSIONS: [dimensionName]
+      });
+      addBytes(`${dimensionName}/0`, encodeVLenUtf8(strings));
+      continue;
+    }
+    if (!coordinates) {
+      continue;
+    }
+    addJson(`${dimensionName}/.zarray`, {
+      zarr_format: 2,
+      shape: [coordinates.length],
+      chunks: [coordinates.length],
+      dtype: "<f8",
+      compressor: null,
+      fill_value: null,
+      order: "C",
+      filters: null
+    });
+    addJson(`${dimensionName}/.zattrs`, {
+      _ARRAY_DIMENSIONS: [dimensionName]
+    });
+    addBytes(`${dimensionName}/0`, encodeFloat64(coordinates));
+  }
+  for (const variableName of dataset.dataVars) {
+    if (typeof variableName !== "string") {
+      continue;
+    }
+    const variable = dataset.getVariable(variableName);
+    if (!variable?.dims?.length || !variable.shape?.length) {
+      continue;
+    }
+    const computed = await variable.compute?.();
+    const values = flattenNumericValues(
+      computed?.data ?? computed?.values ?? variable.data ?? variable.values
+    );
+    if (!values) {
+      return void 0;
+    }
+    const chunks = chunkShapeFor(variable.shape);
+    addJson(`${variableName}/.zarray`, {
+      zarr_format: 2,
+      shape: variable.shape,
+      chunks,
+      dtype: "<f4",
+      compressor: null,
+      fill_value: "NaN",
+      order: "C",
+      filters: null
+    });
+    addJson(`${variableName}/.zattrs`, {
+      ...variable.attrs,
+      _ARRAY_DIMENSIONS: variable.dims
+    });
+    addVariableChunks(entries, variableName, values, variable.shape, chunks);
+  }
+  const byteLength = Array.from(entries.values()).reduce(
+    (total, value) => total + value.byteLength,
+    0
+  );
+  return {
+    byteLength,
+    get: async (key) => entries.get(normalizeStoreKey(key))
+  };
+}
+function coordinateEntries(coords) {
+  if (!coords) {
+    return [];
+  }
+  return coords instanceof Map ? Array.from(coords.entries()) : Object.entries(coords);
+}
+function coordinateValues(values) {
+  if (Array.isArray(values)) {
+    return values;
+  }
+  if (ArrayBuffer.isView(values)) {
+    return arrayBufferViewValues(values);
+  }
+  if (!isRecord(values)) {
+    return void 0;
+  }
+  if (Array.isArray(values.values)) {
+    return values.values;
+  }
+  if (ArrayBuffer.isView(values.values)) {
+    return arrayBufferViewValues(values.values);
+  }
+  if (Array.isArray(values.data)) {
+    return values.data;
+  }
+  if (ArrayBuffer.isView(values.data)) {
+    return arrayBufferViewValues(values.data);
+  }
+  return void 0;
+}
+function arrayBufferViewValues(values) {
+  return "length" in values ? Array.from(values) : void 0;
+}
+function stringCoordinates(values) {
+  const raw = coordinateValues(values);
+  if (!raw?.length) {
+    return void 0;
+  }
+  const coordinates = raw.map((value) => {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    return typeof value === "string" ? value : void 0;
+  });
+  return coordinates.every((value) => value !== void 0) ? coordinates : void 0;
+}
+function normalizeStoreKey(key) {
+  return key.replace(/^\/+/, "");
+}
+function chunkShapeFor(shape) {
+  if (shape.length === 0) {
+    return [];
+  }
+  return shape.map((size, index) => index === 0 && shape.length > 2 ? 1 : size);
+}
+function addVariableChunks(entries, variableName, values, shape, chunks) {
+  if (shape.length === 0) {
+    entries.set(`${variableName}/0`, encodeFloat32(values));
+    return;
+  }
+  const chunkCounts = shape.map((size, index) => Math.ceil(size / (chunks[index] ?? size)));
+  const chunkIndices = enumerateChunkIndices(chunkCounts);
+  for (const chunkIndex of chunkIndices) {
+    const contiguousRange = leadingContiguousChunkRange(shape, chunks, chunkIndex);
+    const bytes = contiguousRange ? encodeFloat32(values, contiguousRange.start, contiguousRange.length) : encodeFloat32(extractChunk(values, shape, chunks, chunkIndex));
+    entries.set(`${variableName}/${chunkIndex.join(".")}`, bytes);
+  }
+}
+function leadingContiguousChunkRange(shape, chunks, chunkIndex) {
+  if (shape.length === 0) {
+    return { start: 0, length: 1 };
+  }
+  const starts = chunkIndex.map((index, dimension) => index * (chunks[dimension] ?? 1));
+  const stops = starts.map(
+    (start, dimension) => Math.min(start + (chunks[dimension] ?? 1), shape[dimension] ?? start)
+  );
+  for (let dimension = 1; dimension < shape.length; dimension += 1) {
+    if ((starts[dimension] ?? 0) !== 0 || (stops[dimension] ?? 0) !== (shape[dimension] ?? 0)) {
+      return void 0;
+    }
+  }
+  const trailingSize = shape.slice(1).reduce((total, size) => total * size, 1);
+  const leadingStart = starts[0] ?? 0;
+  const leadingStop = stops[0] ?? leadingStart;
+  return {
+    start: leadingStart * trailingSize,
+    length: Math.max(0, leadingStop - leadingStart) * trailingSize
+  };
+}
+function enumerateChunkIndices(chunkCounts) {
+  const results = [];
+  const visit = (prefix, dimension) => {
+    if (dimension === chunkCounts.length) {
+      results.push(prefix);
+      return;
+    }
+    const count = chunkCounts[dimension] ?? 0;
+    for (let index = 0; index < count; index += 1) {
+      visit([...prefix, index], dimension + 1);
+    }
+  };
+  visit([], 0);
+  return results;
+}
+function extractChunk(values, shape, chunks, chunkIndex) {
+  const starts = chunkIndex.map((index, dimension) => index * (chunks[dimension] ?? 1));
+  const stops = starts.map(
+    (start, dimension) => Math.min(start + (chunks[dimension] ?? 1), shape[dimension] ?? start)
+  );
+  const result = [];
+  const visit = (indices, dimension) => {
+    if (dimension === shape.length) {
+      result.push(values[flatIndex(indices, shape)] ?? Number.NaN);
+      return;
+    }
+    const start = starts[dimension] ?? 0;
+    const stop = stops[dimension] ?? start;
+    for (let index = start; index < stop; index += 1) {
+      visit([...indices, index], dimension + 1);
+    }
+  };
+  visit([], 0);
+  return result;
+}
+function flatIndex(indices, shape) {
+  return indices.reduce((offset, index, dimension) => offset * (shape[dimension] ?? 1) + index, 0);
+}
+function flattenNumericValues(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return [value];
+  }
+  if (isFlatNumericArrayLike(value)) {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const result = [];
+  const visit = (current) => {
+    if (typeof current === "number") {
+      result.push(current);
+      return;
+    }
+    if (isFlatNumericArrayLike(current)) {
+      for (let index = 0; index < current.length; index += 1) {
+        result.push(current[index] ?? Number.NaN);
+      }
+      return;
+    }
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        visit(item);
+      }
+    }
+  };
+  visit(value);
+  return result;
+}
+function isFlatNumericArrayLike(value) {
+  if (Array.isArray(value)) {
+    return value.every((item) => typeof item === "number");
+  }
+  return ArrayBuffer.isView(value) && "length" in value && typeof value.length === "number" && !isBigIntArray(value);
+}
+function isBigIntArray(value) {
+  return typeof BigInt64Array !== "undefined" && value instanceof BigInt64Array ? true : typeof BigUint64Array !== "undefined" && value instanceof BigUint64Array;
+}
+function encodeFloat32(values, start = 0, length = values.length - start) {
+  if (length <= 0) {
+    return new Uint8Array();
+  }
+  if (values instanceof Float32Array && isNativeLittleEndian()) {
+    return new Uint8Array(values.buffer, values.byteOffset + start * 4, length * 4);
+  }
+  const bytes = new Uint8Array(length * 4);
+  const view = new DataView(bytes.buffer);
+  for (let index = 0; index < length; index += 1) {
+    view.setFloat32(index * 4, values[start + index] ?? Number.NaN, true);
+  }
+  return bytes;
+}
+var nativeLittleEndian;
+function isNativeLittleEndian() {
+  nativeLittleEndian ??= new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+  return nativeLittleEndian;
+}
+function encodeFloat64(values) {
+  const bytes = new Uint8Array(values.length * 8);
+  const view = new DataView(bytes.buffer);
+  values.forEach((value, index) => view.setFloat64(index * 8, value, true));
+  return bytes;
+}
+function encodeVLenUtf8(values) {
+  const encoder = new TextEncoder();
+  const encodedValues = values.map((value) => encoder.encode(value));
+  const byteLength = 4 + encodedValues.reduce((total, value) => total + 4 + value.byteLength, 0);
+  const bytes = new Uint8Array(byteLength);
+  const view = new DataView(bytes.buffer);
+  let offset = 0;
+  view.setUint32(offset, encodedValues.length, true);
+  offset += 4;
+  for (const value of encodedValues) {
+    view.setUint32(offset, value.byteLength, true);
+    offset += 4;
+    bytes.set(value, offset);
+    offset += value.byteLength;
+  }
+  return bytes;
+}
+function normalizeSelectionBounds(bounds, fallbackOptions) {
+  const isTuple = isSelectionBoundsTuple(bounds);
+  const normalizedBounds = isTuple ? bounds : [bounds.west, bounds.south, bounds.east, bounds.north];
+  if (normalizedBounds.length !== 4 || normalizedBounds.some((value) => typeof value !== "number" || !Number.isFinite(value))) {
+    throw new DClimateAdapterError(
+      "metadata",
+      "dClimate selection bounds must be finite [west, south, east, north] numbers."
+    );
+  }
+  const [west, south, east, north] = normalizedBounds;
+  if (west >= east || south >= north) {
+    throw new DClimateAdapterError(
+      "metadata",
+      "dClimate selection bounds must satisfy west < east and south < north."
+    );
+  }
+  return {
+    bounds: [west, south, east, north],
+    boundsOptions: isTuple ? fallbackOptions : bounds.options ?? fallbackOptions
+  };
+}
+function isSelectionBoundsTuple(bounds) {
+  return Array.isArray(bounds);
+}
+async function openStore(cid, options) {
+  try {
+    if (options.openIpfsStore) {
+      return options.openIpfsStore(cid, { gatewayUrl: options.gatewayUrl });
+    }
+    const module = await import('@dclimate/jaxray');
+    const opened = await module.openIpfsStore?.(cid, { gatewayUrl: options.gatewayUrl });
+    if (isRecord(opened) && "store" in opened && isReadableStore(opened.store)) {
+      return opened.store;
+    }
+    return isReadableStore(opened) ? opened : void 0;
+  } catch (error) {
+    throw new DClimateAdapterError(
+      "gateway",
+      `Failed to open dClimate CID "${cid}" through Jaxray.`,
+      error,
+      {
+        cid,
+        gatewayUrl: options.gatewayUrl
+      }
+    );
+  }
+}
+function extractDataset(value) {
+  if (Array.isArray(value)) {
+    return extractDataset(value[0]);
+  }
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const candidate = value.data ?? value.dataset ?? value.jaxrayDataset ?? value.geoTemporalDataset ?? (hasDatasetShape(value) ? value : void 0);
+  return isRecord(candidate) ? candidate : void 0;
+}
+function extractGeoTemporalDataset(value) {
+  if (Array.isArray(value)) {
+    return extractGeoTemporalDataset(value[0]);
+  }
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return hasRectangleSelection(value) || hasTimeRange(value) ? value : void 0;
+}
+function hasTimeRange(value) {
+  return isRecord(value) && typeof value.timeRange === "function";
+}
+function hasRectangleSelection(value) {
+  return isRecord(value) && typeof value.rectangle === "function";
+}
+function extractMetadata(value) {
+  if (Array.isArray(value)) {
+    return isRecord(value[1]) ? value[1] : void 0;
+  }
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const metadata = value.metadata ?? value.clientMetadata;
+  return isRecord(metadata) ? metadata : void 0;
+}
+function extractStore(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const candidate = value.store ?? value.zarrStore ?? value.ipfsStore;
+  return isReadableStore(candidate) ? candidate : void 0;
+}
+function extractString(value, keys) {
+  const metadata = extractMetadata(value);
+  if (metadata) {
+    for (const key of keys) {
+      const candidate = metadata[key];
+      if (typeof candidate === "string") {
+        return candidate;
+      }
+    }
+  }
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === "string") {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function gatewaySourceForCid(cid, gatewayUrl) {
+  if (!cid || !gatewayUrl) {
+    return void 0;
+  }
+  return `${gatewayUrl.replace(/\/$/, "")}/ipfs/${cid}`;
+}
+function sourceIdForRequest(request) {
+  if (request.cid) {
+    return `dclimate-${request.cid.slice(0, 12)}`;
+  }
+  return [request.collection, request.dataset, request.variant].filter(Boolean).join("-");
+}
+function labelForRequest(request) {
+  return [request.collection, request.dataset, request.variant].filter(Boolean).join(" / ") || request.cid;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasDatasetShape(value) {
+  return "data_vars" in value || "dataVars" in value || "variables" in value;
+}
+function isReadableStore(value) {
+  return isRecord(value) && typeof value.get === "function";
+}
+
+exports.DClimateAdapterError = DClimateAdapterError;
+exports.createDClimateSource = createDClimateSource;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map