@dclimate/zarr-map 0.1.0

package/dist/react/index.cjs

@@ -0,0 +1,3953 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// 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;
+  }
+};
+function isGridError(error) {
+  return error instanceof GridError;
+}
+
+// src/core/color.ts
+var builtinPalettes = {
+  viridis: ["#440154", "#31688e", "#35b779", "#fde725"],
+  inferno: ["#000004", "#57106e", "#bc3754", "#f98e09", "#fcffa4"],
+  magma: ["#000004", "#3b0f70", "#8c2981", "#de4968", "#fe9f6d", "#fcfdbf"],
+  plasma: ["#0d0887", "#7e03a8", "#cc4778", "#f89540", "#f0f921"],
+  cividis: ["#00204c", "#31446b", "#666870", "#958f78", "#c6b866", "#ffe945"],
+  turbo: ["#30123b", "#466be3", "#35ab6b", "#faba39", "#7a0403"],
+  greys: ["#000000", "#777777", "#ffffff"],
+  grays: ["#000000", "#777777", "#ffffff"],
+  temperature: ["#2c5ab4", "#67b0f0", "#e0e4dc", "#ffb266", "#cd4434"],
+  precipitation: ["#bae6fd", "#60a5fa", "#2563eb", "#4f46e5", "#6d28d9"],
+  humidity: ["#374151", "#2d5a6e", "#1890b0", "#2dd4bf", "#99f6e4"],
+  vegetation: ["#f7fee7", "#bef264", "#4ade80", "#15803d", "#064e3b"],
+  wind: ["#e2e8f0", "#7dd3fc", "#2dd4bf", "#14b8a6"]
+};
+function validateColorScale(colorScale) {
+  const [min, max] = colorScale.domain;
+  if (!Number.isFinite(min) || !Number.isFinite(max) || min >= max) {
+    throw new GridError({
+      code: "INVALID_COLOR_SCALE",
+      message: "Color scale domain must be finite and ordered as [min, max].",
+      context: { domain: colorScale.domain }
+    });
+  }
+  if (!colorScale.palette) {
+    throw new GridError({
+      code: "INVALID_COLOR_SCALE",
+      message: "Color scale must include a palette name or color stop array."
+    });
+  }
+  paletteToRendererColorMap(colorScale.palette);
+  return colorScale;
+}
+function colorScaleToRendererOptions(colorScale) {
+  if (!colorScale) {
+    return void 0;
+  }
+  validateColorScale(colorScale);
+  return {
+    colormap: paletteToRendererColorMap(colorScale.palette),
+    clim: colorScale.domain
+  };
+}
+function paletteToRendererColorMap(palette) {
+  if (typeof palette !== "string") {
+    if (palette.length < 2) {
+      throw new GridError({
+        code: "INVALID_COLOR_SCALE",
+        message: "Custom color palettes must include at least two color stops.",
+        context: { palette }
+      });
+    }
+    const colors2 = palette.map((color) => color.trim());
+    const invalid = colors2.find((color) => color.length === 0);
+    if (invalid !== void 0) {
+      throw new GridError({
+        code: "INVALID_COLOR_SCALE",
+        message: "Custom color palettes cannot include empty color stops.",
+        context: { palette }
+      });
+    }
+    return colors2;
+  }
+  const normalized = palette.toLowerCase();
+  const colors = builtinPalettes[normalized];
+  if (!colors) {
+    throw new GridError({
+      code: "INVALID_COLOR_SCALE",
+      message: `Unsupported renderer palette "${palette}". Use one of: ${Object.keys(builtinPalettes).join(", ")}.`,
+      context: { palette }
+    });
+  }
+  return colors;
+}
+function colorScaleDisplayDomain(colorScale) {
+  const { displayUnit, quantity, unit } = colorScale;
+  if (!displayUnit || !unit || displayUnit === unit || !quantity) {
+    return colorScale.domain;
+  }
+  return [
+    convertDisplayValue(colorScale.domain[0], {
+      fromUnit: unit,
+      quantity,
+      toUnit: displayUnit
+    }),
+    convertDisplayValue(colorScale.domain[1], {
+      fromUnit: unit,
+      quantity,
+      toUnit: displayUnit
+    })
+  ];
+}
+function convertDisplayValue(value, options) {
+  if (!Number.isFinite(value)) {
+    return value;
+  }
+  if (options.quantity === "temperature") {
+    return temperatureFromKelvin(temperatureToKelvin(value, options.fromUnit), options.toUnit);
+  }
+  return precipitationFromMeters(precipitationToMeters(value, options.fromUnit), options.toUnit);
+}
+function temperatureToKelvin(value, unit) {
+  const normalized = normalizeUnit(unit);
+  if (normalized === "k" || normalized === "kelvin") {
+    return value;
+  }
+  if (["c", "degc", "celsius"].includes(normalized)) {
+    return value + 273.15;
+  }
+  if (["f", "degf", "fahrenheit"].includes(normalized)) {
+    return (value - 32) * 5 / 9 + 273.15;
+  }
+  throw unsupportedUnit(unit, "temperature");
+}
+function temperatureFromKelvin(value, unit) {
+  const normalized = normalizeUnit(unit);
+  if (normalized === "k" || normalized === "kelvin") {
+    return value;
+  }
+  if (["c", "degc", "celsius"].includes(normalized)) {
+    return value - 273.15;
+  }
+  if (["f", "degf", "fahrenheit"].includes(normalized)) {
+    return (value - 273.15) * 9 / 5 + 32;
+  }
+  throw unsupportedUnit(unit, "temperature");
+}
+function precipitationToMeters(value, unit) {
+  const normalized = normalizeUnit(unit);
+  if (["m", "meter", "meters"].includes(normalized)) {
+    return value;
+  }
+  if (["mm", "millimeter", "millimeters"].includes(normalized)) {
+    return value / 1e3;
+  }
+  if (isKilogramPerSquareMeter(normalized)) {
+    return value / 1e3;
+  }
+  if (["in", "inch", "inches"].includes(normalized)) {
+    return value * 0.0254;
+  }
+  throw unsupportedUnit(unit, "precipitation");
+}
+function precipitationFromMeters(value, unit) {
+  const normalized = normalizeUnit(unit);
+  if (["m", "meter", "meters"].includes(normalized)) {
+    return value;
+  }
+  if (["mm", "millimeter", "millimeters"].includes(normalized)) {
+    return value * 1e3;
+  }
+  if (isKilogramPerSquareMeter(normalized)) {
+    return value * 1e3;
+  }
+  if (["in", "inch", "inches"].includes(normalized)) {
+    return value / 0.0254;
+  }
+  throw unsupportedUnit(unit, "precipitation");
+}
+function isKilogramPerSquareMeter(normalizedUnit) {
+  const compact = normalizedUnit.replace(/\s+/g, "");
+  return ["kgm**-2", "kgm^-2", "kgm-2", "kg/m2", "kg/m^2"].includes(compact);
+}
+function normalizeUnit(unit) {
+  return unit.trim().toLowerCase().replace(/^degrees?_?/, "deg").replace("\xB0", "deg");
+}
+function unsupportedUnit(unit, quantity) {
+  return new GridError({
+    code: "UNSUPPORTED_UNIT",
+    message: `Unsupported ${quantity} display unit "${unit}".`,
+    context: { quantity, unit }
+  });
+}
+
+// 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 toRendererSelectors(selectors) {
+  const output = {};
+  for (const [dimensionName, selector] of Object.entries(selectors)) {
+    if (selector.kind === "index") {
+      output[dimensionName] = { selected: selector.index, type: "index" };
+      continue;
+    }
+    if (selector.kind === "isoTime") {
+      output[dimensionName] = {
+        selected: selector.value ?? selector.iso,
+        type: "value"
+      };
+      continue;
+    }
+    output[dimensionName] = { selected: selector.value, type: "value" };
+  }
+  return output;
+}
+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 listTimeCoordinates(source, dimensionName = "time") {
+  const dimension = findDimension(source, dimensionName);
+  if (!dimension) {
+    throw new GridError({
+      code: "MISSING_DIMENSION",
+      message: `Time dimension "${dimensionName}" is not present in the grid source.`,
+      dimension: dimensionName,
+      sourceId: source.id
+    });
+  }
+  if (!dimension.coordinates) {
+    throw new GridError({
+      code: "MISSING_COORDINATES",
+      message: `Time dimension "${dimensionName}" needs coordinate values for a slider.`,
+      dimension: dimensionName,
+      sourceId: source.id
+    });
+  }
+  const coordinates = dimension.coordinates.map((coordinate, index) => {
+    const decoded = decodeTimeCoordinate(coordinate, dimension.units);
+    const forecastLabel = formatForecastStepLabel(source, dimension, coordinate);
+    return {
+      index,
+      value: decoded.value,
+      label: forecastLabel ?? (decoded.iso ? formatHumanUtcDateTime(decoded.iso) : String(decoded.value)),
+      ...decoded.iso ? { iso: decoded.iso } : {}
+    };
+  });
+  assertMonotonicTimeCoordinates(coordinates, dimension.name, source.id);
+  return coordinates;
+}
+function formatForecastStepLabel(source, dimension, coordinate) {
+  if (!isForecastStepDimension(dimension.name)) {
+    return void 0;
+  }
+  const reference = forecastReferenceDate(source);
+  const offsetMs = forecastStepOffsetMs(coordinate, dimension.units);
+  if (!reference || offsetMs === void 0) {
+    return void 0;
+  }
+  return formatHumanUtcDateTime(new Date(reference.getTime() + offsetMs));
+}
+function isForecastStepDimension(name) {
+  return normalizeDimensionName(name) === "step";
+}
+function forecastReferenceDate(source) {
+  const referenceDimension = source.dimensions.find(
+    (dimension) => ["forecastreferencetime", "forecastreferencedate"].includes(
+      normalizeDimensionName(dimension.name)
+    )
+  );
+  if (!referenceDimension) {
+    return void 0;
+  }
+  const referenceCoordinate = referenceDimension.coordinates?.[0];
+  if (referenceCoordinate === void 0) {
+    return void 0;
+  }
+  const decoded = decodeTimeCoordinate(referenceCoordinate, referenceDimension.units);
+  const referenceValue = decoded.iso ?? (typeof decoded.value === "string" ? decoded.value : void 0);
+  if (!referenceValue) {
+    return void 0;
+  }
+  const date = new Date(referenceValue);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+function forecastStepOffsetMs(coordinate, units) {
+  const value = numericCoordinateValue(coordinate);
+  if (value === void 0) {
+    return void 0;
+  }
+  return value * forecastStepUnitMultiplier(units);
+}
+function numericCoordinateValue(coordinate) {
+  if (typeof coordinate === "number") {
+    return Number.isFinite(coordinate) ? coordinate : void 0;
+  }
+  if (typeof coordinate !== "string") {
+    return void 0;
+  }
+  const value = Number(coordinate);
+  return Number.isFinite(value) ? value : void 0;
+}
+function forecastStepUnitMultiplier(units) {
+  const normalizedUnits = units?.toLowerCase() ?? "";
+  if (normalizedUnits.includes("second")) {
+    return 1e3;
+  }
+  if (normalizedUnits.includes("minute")) {
+    return 6e4;
+  }
+  if (normalizedUnits.includes("day")) {
+    return 864e5;
+  }
+  return 36e5;
+}
+function normalizeDimensionName(name) {
+  return name.toLowerCase().replace(/[_\-\s]+/g, "");
+}
+var UTC_MONTH_LABELS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function formatHumanUtcDateTime(input) {
+  const date = input instanceof Date ? input : new Date(input);
+  return [
+    UTC_MONTH_LABELS[date.getUTCMonth()],
+    " ",
+    date.getUTCDate(),
+    ", ",
+    date.getUTCFullYear(),
+    ", ",
+    padDatePart(date.getUTCHours()),
+    ":",
+    padDatePart(date.getUTCMinutes()),
+    " UTC"
+  ].join("");
+}
+function padDatePart(value) {
+  return String(value).padStart(2, "0");
+}
+function createDebouncer(callback, waitMs) {
+  let timeout;
+  let lastArgs;
+  const flush = () => {
+    if (!lastArgs) {
+      return;
+    }
+    const args = lastArgs;
+    lastArgs = void 0;
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+    callback(...args);
+  };
+  return {
+    call(...args) {
+      lastArgs = args;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      timeout = setTimeout(flush, waitMs);
+    },
+    flush,
+    cancel() {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      timeout = void 0;
+      lastArgs = void 0;
+    }
+  };
+}
+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 assertMonotonicTimeCoordinates(coordinates, dimensionName, sourceId) {
+  let direction;
+  for (let index = 1; index < coordinates.length; index += 1) {
+    const previous = comparableTimeValue(coordinates[index - 1]);
+    const current = comparableTimeValue(coordinates[index]);
+    if (previous === current) {
+      throw new GridError({
+        code: "UNSUPPORTED_DIMENSION",
+        message: `Time dimension "${dimensionName}" has duplicate coordinate values.`,
+        dimension: dimensionName,
+        sourceId
+      });
+    }
+    const pairDirection = current > previous ? "ascending" : "descending";
+    direction ??= pairDirection;
+    if (pairDirection !== direction) {
+      throw new GridError({
+        code: "UNSUPPORTED_DIMENSION",
+        message: `Time dimension "${dimensionName}" must be monotonic for slider controls.`,
+        dimension: dimensionName,
+        sourceId
+      });
+    }
+  }
+}
+function comparableTimeValue(coordinate) {
+  if (!coordinate) {
+    return 0;
+  }
+  if (coordinate.iso) {
+    return new Date(coordinate.iso).getTime();
+  }
+  if (typeof coordinate.value === "number") {
+    return coordinate.value;
+  }
+  const parsed = new Date(coordinate.value).getTime();
+  return Number.isNaN(parsed) ? coordinate.index : parsed;
+}
+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/core/query.ts
+async function queryPoint(source, variableName, coordinates, selectors = {}, signal) {
+  const context = queryContext(source, variableName, selectors);
+  const xIndex = nearestCoordinateIndex(context.xDimension, coordinates[0], source.bounds, "x");
+  const yIndex = nearestCoordinateIndex(context.yDimension, coordinates[1], source.bounds, "y");
+  const sample = await readSample(source, context, xIndex, yIndex, signal);
+  return {
+    variable: variableName,
+    selectors: context.normalizedSelectors,
+    geometry: { type: "Point", coordinates },
+    unit: context.variable.units,
+    samples: [sample],
+    warnings: []
+  };
+}
+function queryContext(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 spatialDimensions = inferSpatialDimensions(source, variable.name);
+  if (!spatialDimensions) {
+    throw new GridError({
+      code: "MISSING_SPATIAL_DIMENSIONS",
+      message: `Variable "${variable.name}" needs spatial dimensions for map queries.`,
+      variable: variable.name,
+      sourceId: source.id
+    });
+  }
+  const xDimension = findDimension(source, spatialDimensions.x);
+  const yDimension = findDimension(source, spatialDimensions.y);
+  if (!xDimension || !yDimension) {
+    throw new GridError({
+      code: "MISSING_SPATIAL_DIMENSIONS",
+      message: "Spatial dimensions are missing from the grid source.",
+      variable: variable.name,
+      sourceId: source.id
+    });
+  }
+  if (!source.readSlice) {
+    throw new GridError({
+      code: "SOURCE_LOAD_FAILED",
+      message: "GridDataSource must implement readSlice or queryGeometry before query helpers can read values.",
+      sourceId: source.id,
+      variable: variable.name
+    });
+  }
+  return {
+    variable,
+    normalizedSelectors: normalizeSelectors(source, variable.name, selectors),
+    xDimension,
+    yDimension,
+    spatialDimensions
+  };
+}
+async function readSample(source, context, xIndex, yIndex, signal) {
+  const selectors = selectorsWithSpatialIndexes(
+    context.normalizedSelectors,
+    context.spatialDimensions.x,
+    xIndex,
+    context.spatialDimensions.y,
+    yIndex
+  );
+  const slice = await source.readSlice?.({
+    variable: context.variable.name,
+    selectors,
+    signal
+  });
+  const rawValue = slice?.data[0];
+  const value = rawValue === void 0 || rawValue === context.variable.fillValue ? null : rawValue * (context.variable.scaleFactor ?? 1) + (context.variable.addOffset ?? 0);
+  return {
+    coordinates: [
+      coordinateAt(context.xDimension, xIndex, source.bounds, "x"),
+      coordinateAt(context.yDimension, yIndex, source.bounds, "y")
+    ],
+    indexes: {
+      [context.spatialDimensions.x]: xIndex,
+      [context.spatialDimensions.y]: yIndex
+    },
+    rawValue: rawValue ?? null,
+    value
+  };
+}
+function selectorsWithSpatialIndexes(selectors, xDimension, xIndex, yDimension, yIndex) {
+  return {
+    ...selectors,
+    [xDimension]: { kind: "index", index: xIndex },
+    [yDimension]: { kind: "index", index: yIndex }
+  };
+}
+function nearestCoordinateIndex(dimension, value, bounds, axis) {
+  if (!dimension.coordinates) {
+    return boundedCoordinateIndex(dimension, value, bounds, axis);
+  }
+  let bestIndex = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  dimension.coordinates.forEach((coordinate, index) => {
+    if (typeof coordinate !== "number") {
+      return;
+    }
+    const distance = Math.abs(coordinate - value);
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      bestIndex = index;
+    }
+  });
+  return bestIndex;
+}
+function coordinateAt(dimension, index, bounds, axis) {
+  const coordinate = dimension.coordinates?.[index];
+  if (typeof coordinate === "number") {
+    return coordinate;
+  }
+  return boundedCoordinateAt(dimension, index, bounds, axis);
+}
+function boundedCoordinateIndex(dimension, value, bounds, axis) {
+  const range = spatialRange2(bounds, axis);
+  if (!range) {
+    return clamp(Math.round(value), 0, dimension.size - 1);
+  }
+  const [min, max] = range;
+  const span = max - min;
+  if (span <= 0 || dimension.size <= 1) {
+    return 0;
+  }
+  const ascending = dimension.ascending !== false;
+  const ratio = ascending ? (value - min) / span : (max - value) / span;
+  return clamp(Math.round(ratio * (dimension.size - 1)), 0, dimension.size - 1);
+}
+function boundedCoordinateAt(dimension, index, bounds, axis) {
+  const range = spatialRange2(bounds, axis);
+  if (!range || dimension.size <= 1) {
+    return index;
+  }
+  const [min, max] = range;
+  const ratio = clamp(index, 0, dimension.size - 1) / (dimension.size - 1);
+  return dimension.ascending === false ? max - ratio * (max - min) : min + ratio * (max - min);
+}
+function spatialRange2(bounds, axis) {
+  if (!bounds) {
+    return void 0;
+  }
+  return axis === "x" ? [bounds[0], bounds[2]] : [bounds[1], bounds[3]];
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+// 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 selectionBounds2 = options.selection?.bounds ? normalizeSelectionBounds(options.selection.bounds, options.selection.boundsOptions).bounds : void 0;
+  const result = preflightGridRequest({
+    bounds: config.bounds ?? selectionBounds2,
+    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";
+}
+
+// src/renderers/maplibre.ts
+function createMapLibreGridLayer(options) {
+  return new MapLibreGridLayerController(options);
+}
+function buildZarrLayerOptions(options) {
+  assertValidGridDataSource(options.source, {
+    variable: options.variable,
+    requireRenderable: true
+  });
+  const variable = options.source.variables.find(
+    (candidate) => candidate.name === options.variable || candidate.path === options.variable
+  );
+  if (!variable) {
+    throw new GridError({
+      code: "MISSING_VARIABLE",
+      message: `Variable "${options.variable}" is not present in the grid source.`,
+      variable: options.variable,
+      sourceId: options.source.id
+    });
+  }
+  const spatialDimensions = inferSpatialDimensions(options.source, variable.name);
+  if (!spatialDimensions) {
+    throw new GridError({
+      code: "MISSING_SPATIAL_DIMENSIONS",
+      message: `Variable "${variable.name}" needs spatial dimensions before rendering.`,
+      variable: variable.name,
+      sourceId: options.source.id
+    });
+  }
+  const colorOptions = colorScaleToRendererOptions(options.colorScale);
+  const rendererVariable = variable.path ?? variable.name;
+  const normalizedSelectors = normalizeSelectors(options.source, variable.name, options.selectors);
+  const rendererSelectors = omitSpatialSelectors(normalizedSelectors, spatialDimensions);
+  const yDimension = options.source.dimensions.find(
+    (dimension) => dimension.name === spatialDimensions.y
+  );
+  const shaderOptions = buildColorScaleShaderOptions(options.colorScale, rendererVariable);
+  return {
+    id: options.layerId ?? `zarr-map-${options.source.id ?? variable.name}`,
+    source: options.source.source,
+    store: options.source.store,
+    variable: rendererVariable,
+    selector: toRendererSelectors(rendererSelectors),
+    spatialDimensions: { lon: spatialDimensions.x, lat: spatialDimensions.y },
+    zarrVersion: options.source.zarrVersion,
+    crs: options.source.crs,
+    proj4: options.source.proj4,
+    bounds: options.source.bounds,
+    fillValue: variable.fillValue,
+    colormap: colorOptions?.colormap,
+    clim: colorOptions?.clim,
+    opacity: options.opacity,
+    latIsAscending: yDimension?.ascending,
+    customFrag: shaderOptions?.customFrag,
+    uniforms: shaderOptions?.uniforms,
+    onLoad: () => {
+      options.onLoadingChange?.(false);
+      options.onLoadingStateChange?.(completeLoadingState());
+    },
+    onLoadingStateChange: (state) => {
+      const loadingState = normalizeLoadingState(state);
+      options.onLoadingChange?.(loadingState.loading);
+      options.onLoadingStateChange?.(loadingState);
+    },
+    onError: (error) => options.onError?.(
+      new GridError({
+        code: "CHUNK_LOAD_FAILED",
+        message: "Zarr renderer reported a metadata or chunk loading error.",
+        cause: error,
+        sourceId: options.source.id,
+        variable: options.variable
+      })
+    )
+  };
+}
+function buildColorScaleShaderOptions(colorScale, rendererVariable) {
+  const transparentPalette = transparentPaletteKind(colorScale);
+  if (!transparentPalette || !isValidGlslIdentifier(rendererVariable)) {
+    return void 0;
+  }
+  return {
+    customFrag: transparentPalette === "vegetation" ? vegetationOverlayShader(rendererVariable) : transparentPalette === "magma" ? magmaTransparentLowerBoundShader(rendererVariable) : precipitationOverlayShader(rendererVariable),
+    uniforms: {}
+  };
+}
+function precipitationOverlayShader(rendererVariable) {
+  return `
+  if (${rendererVariable} <= 0.0) {
+    discard;
+  }
+
+  float rescaled = clamp((${rendererVariable} - clim.x) / (clim.y - clim.x), 0.0, 1.0);
+  vec4 c = texture(colormap, vec2(rescaled, 0.5));
+  float precipAlpha = opacity * mix(0.22, 1.0, rescaled);
+  fragColor = vec4(c.rgb, precipAlpha);
+  fragColor.rgb *= fragColor.a;
+`;
+}
+function vegetationOverlayShader(rendererVariable) {
+  return `
+  float vegetationRange = clim.y - clim.x;
+  float noVegetationCutoff = clim.x + vegetationRange * 0.04;
+  if (${rendererVariable} <= noVegetationCutoff) {
+    discard;
+  }
+
+  float rescaled = clamp((${rendererVariable} - clim.x) / vegetationRange, 0.0, 1.0);
+  vec4 c = texture(colormap, vec2(rescaled, 0.5));
+  float vegetationAlpha = opacity * mix(0.14, 1.0, smoothstep(0.04, 0.85, rescaled));
+  fragColor = vec4(c.rgb, vegetationAlpha);
+  fragColor.rgb *= fragColor.a;
+`;
+}
+function magmaTransparentLowerBoundShader(rendererVariable) {
+  return `
+  float rescaled = clamp((${rendererVariable} - clim.x) / (clim.y - clim.x), 0.0, 1.0);
+  vec4 c = texture(colormap, vec2(rescaled, 0.5));
+  float magmaAlpha = opacity * smoothstep(0.0, 0.2, rescaled);
+  fragColor = vec4(c.rgb, magmaAlpha);
+  fragColor.rgb *= fragColor.a;
+`;
+}
+function transparentPaletteKind(colorScale) {
+  if (typeof colorScale?.palette !== "string") {
+    return void 0;
+  }
+  const palette = colorScale.palette.toLowerCase();
+  if (palette === "magma" || palette === "precipitation" || palette === "vegetation") {
+    return palette;
+  }
+  return void 0;
+}
+function isValidGlslIdentifier(value) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+function colorScaleShaderSignature(options) {
+  const variable = options.source.variables.find(
+    (candidate) => candidate.name === options.variable || candidate.path === options.variable
+  );
+  const rendererVariable = variable?.path ?? variable?.name ?? options.variable;
+  return buildColorScaleShaderOptions(options.colorScale, rendererVariable)?.customFrag ?? "";
+}
+var MapLibreGridLayerController = class {
+  id;
+  ownsMap;
+  options;
+  map;
+  layer;
+  removed = false;
+  constructor(options) {
+    this.id = options.layerId ?? `zarr-map-${options.source.id ?? options.variable}`;
+    this.options = { ...options, layerId: this.id };
+    this.map = options.map;
+    this.ownsMap = !options.map;
+  }
+  async mount() {
+    if (this.layer || this.removed) {
+      return;
+    }
+    this.options.onLoadingChange?.(true);
+    this.options.onLoadingStateChange?.({
+      loading: true,
+      metadata: false,
+      chunks: false,
+      percent: 5,
+      stage: "map"
+    });
+    try {
+      this.map ??= await this.createMap();
+      await this.whenMapReady(this.map);
+      this.options.onLoadingStateChange?.({
+        loading: true,
+        metadata: false,
+        chunks: false,
+        percent: 25,
+        stage: "layer"
+      });
+      this.layer = await (this.options.layerFactory ?? createDefaultZarrLayer)(
+        buildZarrLayerOptions(this.options)
+      );
+      this.map.addLayer(this.layer, this.options.beforeId);
+      this.options.onLoadingStateChange?.({
+        loading: true,
+        metadata: false,
+        chunks: true,
+        percent: 65,
+        stage: "chunks"
+      });
+    } catch (error) {
+      this.options.onLoadingChange?.(false);
+      this.handleError("RENDERER_SETUP_FAILED", "Failed to create the MapLibre Zarr layer.", error);
+    }
+  }
+  async update(update) {
+    const nextOptions = {
+      ...this.options,
+      ...update
+    };
+    if (!this.layer) {
+      this.options = nextOptions;
+      await this.mount();
+      return;
+    }
+    try {
+      if (update.source && update.source !== this.options.source) {
+        await this.replaceLayer(nextOptions);
+        this.options = nextOptions;
+        return;
+      }
+      if (colorScaleShaderSignature(nextOptions) !== colorScaleShaderSignature(this.options)) {
+        await this.replaceLayer(nextOptions);
+        this.options = nextOptions;
+        return;
+      }
+      this.options = nextOptions;
+      if (update.colorScale) {
+        const colorOptions = colorScaleToRendererOptions(update.colorScale);
+        this.layer.setColormap?.(colorOptions?.colormap ?? []);
+        this.layer.setClim?.(colorOptions?.clim ?? update.colorScale.domain);
+      }
+      if (typeof update.opacity === "number") {
+        this.layer.setOpacity?.(update.opacity);
+      }
+      if (update.variable) {
+        this.layer.setVariable?.(update.variable);
+      }
+      if (update.selectors || update.variable || update.source) {
+        const variable = update.variable ?? this.options.variable;
+        const source = update.source ?? this.options.source;
+        const spatialDimensions = inferSpatialDimensions(source, variable);
+        const normalizedSelectors = normalizeSelectors(source, variable, this.options.selectors);
+        const rendererSelectors = spatialDimensions ? omitSpatialSelectors(normalizedSelectors, spatialDimensions) : normalizedSelectors;
+        this.layer.setSelector?.(toRendererSelectors(rendererSelectors));
+      }
+    } catch (error) {
+      this.handleError("RENDERER_SETUP_FAILED", "Failed to update the MapLibre Zarr layer.", error);
+    }
+  }
+  async replaceLayer(nextOptions) {
+    if (!this.map) {
+      this.options = nextOptions;
+      await this.mount();
+      return;
+    }
+    this.options.onLoadingChange?.(true);
+    this.options.onLoadingStateChange?.({
+      loading: true,
+      metadata: false,
+      chunks: false,
+      percent: 5,
+      stage: "layer"
+    });
+    const previousLayer = this.layer;
+    if (previousLayer && this.map.getLayer(previousLayer.id)) {
+      this.map.removeLayer(previousLayer.id);
+    }
+    if (previousLayer?.id && this.map.getSource?.(previousLayer.id)) {
+      this.map.removeSource?.(previousLayer.id);
+    }
+    this.layer = void 0;
+    try {
+      this.options.onLoadingStateChange?.({
+        loading: true,
+        metadata: false,
+        chunks: false,
+        percent: 35,
+        stage: "layer"
+      });
+      const nextLayer = await (nextOptions.layerFactory ?? createDefaultZarrLayer)(
+        buildZarrLayerOptions(nextOptions)
+      );
+      this.layer = nextLayer;
+      this.map.addLayer(nextLayer, nextOptions.beforeId);
+      this.options.onLoadingStateChange?.({
+        loading: true,
+        metadata: false,
+        chunks: true,
+        percent: 65,
+        stage: "chunks"
+      });
+    } catch (error) {
+      this.options.onLoadingChange?.(false);
+      this.handleError("RENDERER_SETUP_FAILED", "Failed to update the MapLibre Zarr layer.", error);
+    }
+  }
+  remove() {
+    if (this.removed) {
+      return;
+    }
+    this.removed = true;
+    if (this.layer && this.map?.getLayer(this.layer.id)) {
+      this.map.removeLayer(this.layer.id);
+    }
+    if (this.layer?.id && this.map?.getSource?.(this.layer.id)) {
+      this.map.removeSource?.(this.layer.id);
+    }
+    if (this.ownsMap) {
+      this.map?.remove?.();
+    }
+    this.layer = void 0;
+    this.map = void 0;
+  }
+  async query(geometry) {
+    if (!this.layer?.queryData) {
+      throw new GridError({
+        code: "UNSUPPORTED_GEOMETRY",
+        message: "The active renderer layer does not expose queryData."
+      });
+    }
+    return this.layer.queryData(geometry);
+  }
+  getMap() {
+    return this.map;
+  }
+  getLayer() {
+    return this.layer;
+  }
+  async createMap() {
+    if (!this.options.mapConfig) {
+      throw new GridError({
+        code: "RENDERER_SETUP_FAILED",
+        message: "Provide either an existing map instance or mapConfig to create one."
+      });
+    }
+    if (this.options.mapFactory) {
+      return this.options.mapFactory(this.options.mapConfig);
+    }
+    const maplibre = await import('maplibre-gl');
+    return new maplibre.Map(
+      this.options.mapConfig
+    );
+  }
+  async whenMapReady(map) {
+    if (this.isStyleReady(map) || !map.once) {
+      return;
+    }
+    if (map.isStyleLoaded) {
+      await new Promise((resolve) => {
+        let resolved = false;
+        const resolveWhenStyleReady = () => {
+          if (resolved) {
+            return;
+          }
+          if (this.isStyleReady(map)) {
+            resolved = true;
+            resolve();
+            return;
+          }
+          map.once?.("styledata", resolveWhenStyleReady);
+        };
+        map.once?.("styledata", resolveWhenStyleReady);
+        map.once?.("load", resolveWhenStyleReady);
+      });
+      return;
+    }
+    if (!map.loaded || map.loaded()) {
+      return;
+    }
+    await new Promise((resolve) => {
+      map.once?.("load", () => resolve());
+    });
+  }
+  isStyleReady(map) {
+    return map.isStyleLoaded?.() ?? map.loaded?.() ?? true;
+  }
+  handleError(code, message, cause) {
+    const gridError = cause instanceof GridError ? cause : new GridError({
+      code,
+      message: errorMessageWithCause(message, cause),
+      cause,
+      sourceId: this.options.source.id,
+      variable: this.options.variable
+    });
+    this.options.onError?.(gridError);
+    throw gridError;
+  }
+};
+function errorMessageWithCause(message, cause) {
+  if (cause instanceof Error && cause.message) {
+    return `${message} ${cause.message}`;
+  }
+  return message;
+}
+function omitSpatialSelectors(selectors, spatialDimensions) {
+  return Object.fromEntries(
+    Object.entries(selectors).filter(([dimensionName]) => {
+      return dimensionName !== spatialDimensions.x && dimensionName !== spatialDimensions.y;
+    })
+  );
+}
+function normalizeLoadingState(state) {
+  if (typeof state === "boolean") {
+    return {
+      loading: state,
+      metadata: state,
+      chunks: false,
+      percent: state ? 35 : 100,
+      stage: state ? "metadata" : "complete"
+    };
+  }
+  const loading = Boolean(state.loading ?? state.metadata ?? state.chunks);
+  const metadata = Boolean(state.metadata);
+  const chunks = Boolean(state.chunks);
+  return {
+    loading,
+    metadata,
+    chunks,
+    stage: state.stage ?? loadingStage(loading, metadata, chunks),
+    percent: typeof state.percent === "number" ? Math.max(0, Math.min(100, state.percent)) : loading ? loadingPercent(metadata, chunks) : 100
+  };
+}
+function loadingStage(loading, metadata, chunks) {
+  if (!loading) {
+    return "complete";
+  }
+  if (chunks) {
+    return "chunks";
+  }
+  if (metadata) {
+    return "metadata";
+  }
+  return "layer";
+}
+function loadingPercent(metadata, chunks) {
+  if (chunks) {
+    return 85;
+  }
+  if (metadata) {
+    return 45;
+  }
+  return 65;
+}
+function completeLoadingState() {
+  return {
+    loading: false,
+    metadata: false,
+    chunks: false,
+    percent: 100,
+    stage: "complete"
+  };
+}
+var zarrLayerConstructorPromise;
+async function createDefaultZarrLayer(options) {
+  const ZarrLayer = await loadDefaultZarrLayerConstructor();
+  return new ZarrLayer(options);
+}
+async function loadDefaultZarrLayerConstructor() {
+  zarrLayerConstructorPromise ??= import('@carbonplan/zarr-layer').then((module) => {
+    const zarrLayerModule = module;
+    const ZarrLayer = zarrLayerModule.ZarrLayer ?? zarrLayerModule.default;
+    if (!ZarrLayer) {
+      throw new GridError({
+        code: "RENDERER_SETUP_FAILED",
+        message: "@carbonplan/zarr-layer did not export ZarrLayer."
+      });
+    }
+    return ZarrLayer;
+  }).catch((error) => {
+    zarrLayerConstructorPromise = void 0;
+    throw error;
+  });
+  return zarrLayerConstructorPromise;
+}
+function useMountEffect(effect) {
+  react.useEffect(effect, []);
+}
+var BASE_PLAYBACK_INTERVAL_MS = 700;
+var PLAYBACK_SPEED_OPTIONS = [1, 1.5, 2, 3];
+function Legend({ colorScale, label }) {
+  validateColorScale(colorScale);
+  const [min, max] = colorScaleDisplayDomain(colorScale);
+  const unit = colorScale.displayUnit ?? colorScale.unit;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: legendStyle, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: legendHeaderStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: label ?? "Value" }),
+      unit ? /* @__PURE__ */ jsxRuntime.jsx("span", { children: unit }) : null
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: gradientStyle(colorScale.palette) }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: legendScaleStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: formatNumber(min) }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: formatNumber(max) })
+    ] })
+  ] });
+}
+function TimeSlider({
+  source,
+  dimension = "time",
+  value,
+  defaultValue = 0,
+  debounceMs = 150,
+  autoPlay = false,
+  playback = false,
+  playbackIntervalMs = BASE_PLAYBACK_INTERVAL_MS,
+  onChange
+}) {
+  const coordinates = listTimeCoordinates(source, dimension);
+  const playbackTimerRef = react.useRef(void 0);
+  const playbackRef = react.useRef(void 0);
+  const playbackSpeedIndexRef = react.useRef(0);
+  const [isPlaying, setIsPlaying] = react.useState(false);
+  const [playbackSpeedIndex, setPlaybackSpeedIndex] = react.useState(0);
+  const [uncontrolledIndex, setUncontrolledIndex] = react.useState(defaultValue);
+  const maxIndex = Math.max(coordinates.length - 1, 0);
+  const activeIndex = clampIndex(value ?? uncontrolledIndex, maxIndex);
+  const activeCoordinate = coordinates[activeIndex] ?? coordinates[0];
+  const playbackSpeed = PLAYBACK_SPEED_OPTIONS[playbackSpeedIndex] ?? 1;
+  const activePlaybackIntervalMs = playbackIntervalMs / playbackSpeed;
+  const debouncer = react.useMemo(
+    () => createDebouncer((coordinate) => {
+      onChange?.(coordinate);
+    }, debounceMs),
+    [debounceMs, onChange]
+  );
+  const debouncerRef = react.useRef(debouncer);
+  debouncerRef.current = debouncer;
+  playbackSpeedIndexRef.current = playbackSpeedIndex;
+  const stopPlayback = react.useCallback(() => {
+    if (playbackTimerRef.current) {
+      clearInterval(playbackTimerRef.current);
+      playbackTimerRef.current = void 0;
+    }
+    setIsPlaying(false);
+  }, []);
+  const selectCoordinate = (nextIndex, options = { debounced: true }) => {
+    const boundedIndex = clampIndex(nextIndex, maxIndex);
+    if (value === void 0) {
+      setUncontrolledIndex(boundedIndex);
+    }
+    const coordinate = coordinates[boundedIndex];
+    if (!coordinate) {
+      stopPlayback();
+      return;
+    }
+    if (options.debounced) {
+      debouncer.call(coordinate);
+      return;
+    }
+    debouncer.cancel();
+    onChange?.(coordinate);
+  };
+  playbackRef.current = {
+    activeIndex,
+    coordinates,
+    selectCoordinate
+  };
+  const advancePlayback = react.useCallback(() => {
+    const frameState = playbackRef.current;
+    if (!frameState || frameState.coordinates.length <= 1) {
+      stopPlayback();
+      return;
+    }
+    frameState.selectCoordinate((frameState.activeIndex + 1) % frameState.coordinates.length, {
+      debounced: false
+    });
+  }, [stopPlayback]);
+  const startPlaybackTimer = react.useCallback(
+    (intervalMs) => {
+      if (playbackTimerRef.current) {
+        clearInterval(playbackTimerRef.current);
+      }
+      playbackTimerRef.current = setInterval(advancePlayback, intervalMs);
+    },
+    [advancePlayback]
+  );
+  const startPlayback = () => {
+    if (coordinates.length <= 1) {
+      return;
+    }
+    setIsPlaying(true);
+    advancePlayback();
+    startPlaybackTimer(activePlaybackIntervalMs);
+  };
+  const togglePlayback = () => {
+    if (playbackTimerRef.current) {
+      stopPlayback();
+      return;
+    }
+    startPlayback();
+  };
+  const cyclePlaybackSpeed = () => {
+    const nextIndex = (playbackSpeedIndexRef.current + 1) % PLAYBACK_SPEED_OPTIONS.length;
+    const nextSpeed = PLAYBACK_SPEED_OPTIONS[nextIndex] ?? 1;
+    playbackSpeedIndexRef.current = nextIndex;
+    setPlaybackSpeedIndex(nextIndex);
+    if (playbackTimerRef.current) {
+      startPlaybackTimer(playbackIntervalMs / nextSpeed);
+    }
+  };
+  useMountEffect(() => {
+    if (autoPlay && playback) {
+      startPlayback();
+    }
+    return () => {
+      debouncerRef.current.cancel();
+      stopPlayback();
+    };
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: playback ? sliderShellStyle : sliderShellWithoutPlaybackStyle, children: [
+    playback ? /* @__PURE__ */ jsxRuntime.jsxs("div", { style: playbackControlsStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          "aria-label": isPlaying ? "Pause time playback" : "Play time playback",
+          disabled: coordinates.length <= 1,
+          onClick: togglePlayback,
+          style: playButtonStyle,
+          type: "button",
+          children: /* @__PURE__ */ jsxRuntime.jsx(PlaybackIcon, { playing: isPlaying })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          "aria-label": `Playback speed ${formatPlaybackSpeed(playbackSpeed)}. Click to cycle speed.`,
+          disabled: coordinates.length <= 1,
+          onClick: cyclePlaybackSpeed,
+          style: playbackSpeedButtonStyle,
+          type: "button",
+          children: formatPlaybackSpeed(playbackSpeed)
+        }
+      )
+    ] }) : null,
+    /* @__PURE__ */ jsxRuntime.jsxs("label", { style: sliderBodyStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { style: sliderLabelStyle, children: activeCoordinate?.label ?? "No time coordinates" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          "aria-label": "Time",
+          disabled: coordinates.length === 0,
+          max: maxIndex,
+          min: 0,
+          onChange: (event) => {
+            selectCoordinate(Number(event.currentTarget.value));
+          },
+          step: 1,
+          style: sliderStyle,
+          type: "range",
+          value: activeIndex
+        }
+      )
+    ] })
+  ] });
+}
+function formatPlaybackSpeed(speed) {
+  return `${Number.isInteger(speed) ? speed.toFixed(0) : String(speed)}x`;
+}
+function clampIndex(index, maxIndex) {
+  if (!Number.isFinite(index)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(maxIndex, Math.round(index)));
+}
+function PlaybackIcon({ playing }) {
+  if (playing) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("span", { "aria-hidden": "true", style: pauseIconStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { style: pauseBarStyle }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { style: pauseBarStyle })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", style: playIconStyle });
+}
+function ZarrMap(props) {
+  const instanceKey = JSON.stringify(props.map);
+  return /* @__PURE__ */ jsxRuntime.jsx(ZarrMapInstance, { ...props }, instanceKey);
+}
+function ZarrMapInstance({
+  source,
+  variable,
+  selector,
+  initialSelector,
+  colorScale,
+  opacity,
+  map,
+  timeDimension,
+  controls,
+  className,
+  style,
+  renderer,
+  formatInspectValue,
+  onSelectorChange,
+  onInspect,
+  onLoadingStateChange,
+  onReady,
+  children
+}) {
+  const controllerRef = react.useRef(void 0);
+  const hoverInspectTargetRef = react.useRef(void 0);
+  const hoverInspectTimerRef = react.useRef(void 0);
+  const inspectCleanupRef = react.useRef(void 0);
+  const inspectRequestIdRef = react.useRef(0);
+  const mapContainerRef = react.useRef(void 0);
+  const propsRef = react.useRef(void 0);
+  const lastUpdateSignatureRef = react.useRef(void 0);
+  const lastSourceRef = react.useRef(void 0);
+  const [status, setStatus] = react.useState("idle");
+  const [errorMessage, setErrorMessage] = react.useState();
+  const [inspectState, setInspectState] = react.useState();
+  const [loadingPercent2, setLoadingPercent] = react.useState(0);
+  const [currentSelector, setCurrentSelector] = react.useState(
+    selector ?? initialSelector ?? {}
+  );
+  const resolvedTimeDimension = timeDimension ?? source.dimensions.find((dimension) => dimension.kind === "time")?.name ?? "time";
+  const activeSelector = selector ?? currentSelector;
+  const updateSignature = JSON.stringify({
+    colorScale,
+    opacity,
+    selector: activeSelector,
+    sourceId: source.id,
+    variable
+  });
+  const inspectControl = normalizeInspectControl(controls?.inspect);
+  const inspectSample = inspectState?.result.samples[0];
+  const visibleInspectState = inspectControl.enabled && inspectState?.mode === inspectControl.mode && inspectSample && (inspectState.mode !== "hover" || inspectSample.value !== null) ? inspectState : void 0;
+  const visibleInspectSample = visibleInspectState ? inspectSample : void 0;
+  propsRef.current = {
+    colorScale,
+    controls,
+    currentSelector,
+    map,
+    formatInspectValue,
+    onInspect,
+    onLoadingStateChange,
+    onReady,
+    opacity,
+    renderer,
+    resolvedTimeDimension,
+    selector,
+    source,
+    updateSignature,
+    variable
+  };
+  const clearHoverInspect = react.useCallback((clearResult = false) => {
+    hoverInspectTargetRef.current = void 0;
+    if (hoverInspectTimerRef.current) {
+      clearTimeout(hoverInspectTimerRef.current);
+      hoverInspectTimerRef.current = void 0;
+    }
+    inspectRequestIdRef.current += 1;
+    if (clearResult) {
+      setInspectState(void 0);
+    }
+  }, []);
+  const queryInspect = react.useCallback(
+    (mounted, coordinates, mode, point) => {
+      const requestId = inspectRequestIdRef.current += 1;
+      void queryInspectPoint(controllerRef.current, mounted, coordinates).then((result) => {
+        if (inspectRequestIdRef.current !== requestId) {
+          return;
+        }
+        setInspectState({ mode, point, result });
+        propsRef.current?.onInspect?.(result);
+      }).catch((error) => {
+        if (inspectRequestIdRef.current !== requestId) {
+          return;
+        }
+        setErrorMessage(error instanceof Error ? error.message : String(error));
+        setStatus("error");
+      });
+    },
+    []
+  );
+  const handleMapClick = react.useCallback(
+    (event) => {
+      const mounted = propsRef.current;
+      const inspect = normalizeInspectControl(mounted?.controls?.inspect);
+      const coordinates = extractLngLat(event);
+      if (!mounted || !inspect.enabled || inspect.mode !== "click" || !coordinates) {
+        return;
+      }
+      clearHoverInspect();
+      queryInspect(mounted, coordinates, "click");
+    },
+    [clearHoverInspect, queryInspect]
+  );
+  const handleMapMouseMove = react.useCallback(
+    (event) => {
+      const mounted = propsRef.current;
+      const inspect = normalizeInspectControl(mounted?.controls?.inspect);
+      const coordinates = extractLngLat(event);
+      const point = extractInspectTooltipPoint(event, mapContainerRef.current);
+      if (!mounted || !inspect.enabled || inspect.mode !== "hover" || !coordinates || !point) {
+        return;
+      }
+      const runQuery = () => {
+        hoverInspectTimerRef.current = void 0;
+        const current = propsRef.current;
+        const currentInspect = normalizeInspectControl(current?.controls?.inspect);
+        if (!current || !currentInspect.enabled || currentInspect.mode !== "hover") {
+          return;
+        }
+        queryInspect(current, coordinates, "hover", point);
+      };
+      clearHoverInspect();
+      hoverInspectTargetRef.current = { coordinates, point };
+      if (inspect.debounceMs > 0) {
+        hoverInspectTimerRef.current = setTimeout(runQuery, inspect.debounceMs);
+        return;
+      }
+      runQuery();
+    },
+    [clearHoverInspect, queryInspect]
+  );
+  const handleMapMouseOut = react.useCallback(() => {
+    const inspect = normalizeInspectControl(propsRef.current?.controls?.inspect);
+    if (!inspect.enabled || inspect.mode !== "hover") {
+      return;
+    }
+    clearHoverInspect(true);
+  }, [clearHoverInspect]);
+  const attachContainer = react.useCallback(
+    (container) => {
+      if (!container) {
+        mapContainerRef.current = void 0;
+        clearHoverInspect();
+        inspectCleanupRef.current?.();
+        inspectCleanupRef.current = void 0;
+        controllerRef.current?.remove();
+        controllerRef.current = void 0;
+        return;
+      }
+      mapContainerRef.current = container;
+      const mounted = propsRef.current;
+      if (!mounted || controllerRef.current) {
+        return;
+      }
+      lastUpdateSignatureRef.current = mounted.updateSignature;
+      lastSourceRef.current = mounted.source;
+      setStatus("loading");
+      const controller = createMapLibreGridLayer({
+        source: mounted.source,
+        variable: mounted.variable,
+        selectors: mounted.selector ?? mounted.currentSelector,
+        colorScale: mounted.colorScale,
+        opacity: mounted.opacity,
+        mapConfig: {
+          ...mounted.map,
+          container
+        },
+        layerFactory: mounted.renderer?.layerFactory,
+        mapFactory: mounted.renderer?.mapFactory,
+        onLoadingChange: (loading) => setStatus(loading ? "loading" : "ready"),
+        onLoadingStateChange: (loadingState) => {
+          setLoadingPercent(loadingState.percent);
+          setStatus(loadingState.loading ? "loading" : "ready");
+          propsRef.current?.onLoadingStateChange?.(loadingState);
+        },
+        onError: (error) => {
+          setErrorMessage(error.message);
+          setStatus("error");
+        }
+      });
+      controllerRef.current = controller;
+      controller.mount().then(() => {
+        const activeMap = controller.getMap();
+        if (activeMap?.on) {
+          activeMap.on("click", handleMapClick);
+          activeMap.on("mousemove", handleMapMouseMove);
+          activeMap.on("mouseout", handleMapMouseOut);
+          activeMap.on("mouseleave", handleMapMouseOut);
+          inspectCleanupRef.current = () => {
+            activeMap.off?.("click", handleMapClick);
+            activeMap.off?.("mousemove", handleMapMouseMove);
+            activeMap.off?.("mouseout", handleMapMouseOut);
+            activeMap.off?.("mouseleave", handleMapMouseOut);
+          };
+        }
+        propsRef.current?.onReady?.(controller);
+      }).catch((error) => {
+        setErrorMessage(error instanceof Error ? error.message : String(error));
+        setStatus("error");
+      });
+    },
+    [clearHoverInspect, handleMapClick, handleMapMouseMove, handleMapMouseOut]
+  );
+  react.useLayoutEffect(() => {
+    const controller = controllerRef.current;
+    if (!controller) {
+      return;
+    }
+    const sourceChanged = lastSourceRef.current !== source;
+    if (!sourceChanged && lastUpdateSignatureRef.current === updateSignature) {
+      return;
+    }
+    lastSourceRef.current = source;
+    lastUpdateSignatureRef.current = updateSignature;
+    void controller.update({
+      source,
+      variable,
+      selectors: activeSelector,
+      colorScale,
+      opacity
+    }).then(() => {
+      const mounted = propsRef.current;
+      const hoverTarget = hoverInspectTargetRef.current;
+      const inspect = normalizeInspectControl(mounted?.controls?.inspect);
+      if (!mounted || !hoverTarget || !inspect.enabled || inspect.mode !== "hover") {
+        return;
+      }
+      queryInspect(mounted, hoverTarget.coordinates, "hover", hoverTarget.point);
+    }).catch((error) => {
+      setErrorMessage(error instanceof Error ? error.message : String(error));
+      setStatus("error");
+    });
+  }, [activeSelector, colorScale, opacity, queryInspect, source, updateSignature, variable]);
+  const handleTimeChange = (coordinate) => {
+    const nextSelector = {
+      ...activeSelector,
+      [resolvedTimeDimension]: coordinate.iso ? { kind: "isoTime", iso: coordinate.iso } : { kind: "coordinate", value: coordinate.value }
+    };
+    setCurrentSelector(nextSelector);
+    onSelectorChange?.(nextSelector);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, style: { ...mapShellStyle, ...style }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: attachContainer, style: mapContainerStyle }),
+    controls?.legend && colorScale ? /* @__PURE__ */ jsxRuntime.jsx("div", { style: legendOverlayStyle, children: /* @__PURE__ */ jsxRuntime.jsx(Legend, { colorScale, label: variable }) }) : null,
+    controls?.timeSlider ? /* @__PURE__ */ jsxRuntime.jsx("div", { style: sliderOverlayStyle, children: /* @__PURE__ */ jsxRuntime.jsx(
+      TimeSlider,
+      {
+        dimension: resolvedTimeDimension,
+        autoPlay: controls.timePlaybackAutoPlay,
+        playback: controls.timePlayback,
+        value: timeIndexForSelector(source, resolvedTimeDimension, activeSelector),
+        source,
+        onChange: handleTimeChange
+      },
+      `${source.id}:${resolvedTimeDimension}`
+    ) }) : null,
+    visibleInspectState && visibleInspectSample ? /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        role: visibleInspectState.mode === "hover" ? "tooltip" : void 0,
+        style: visibleInspectState.mode === "hover" && visibleInspectState.point ? inspectTooltipStyle(visibleInspectState.point) : inspectOverlayStyle,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: formatCoordinatePair(visibleInspectSample.coordinates) }),
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { children: formatInspectSample(visibleInspectState.result, colorScale, formatInspectValue) })
+        ]
+      }
+    ) : null,
+    status === "loading" ? /* @__PURE__ */ jsxRuntime.jsx(LoadingStatus, { label: "Loading raster", percent: loadingPercent2 }) : null,
+    status === "error" ? /* @__PURE__ */ jsxRuntime.jsx("div", { style: errorStyle, children: errorMessage ?? "Failed to render raster" }) : null,
+    children
+  ] });
+}
+function LoadingStatus({ label, percent }) {
+  const percentLabel = typeof percent === "number" ? formatPercent(percent) : void 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { "aria-live": "polite", role: "status", style: statusStyle, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: statusHeaderStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { children: label }),
+      percentLabel ? /* @__PURE__ */ jsxRuntime.jsx("strong", { style: statusPercentStyle, children: percentLabel }) : null
+    ] }),
+    percentLabel ? /* @__PURE__ */ jsxRuntime.jsx("div", { style: statusTrackStyle, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { ...statusProgressStyle, width: percentLabel } }) }) : null
+  ] });
+}
+function formatPercent(percent) {
+  return `${Math.max(0, Math.min(100, Math.round(percent)))}%`;
+}
+function normalizeInspectControl(control) {
+  if (!control) {
+    return { enabled: false, mode: "click", debounceMs: 0 };
+  }
+  if (control === true) {
+    return { enabled: true, mode: "click", debounceMs: 0 };
+  }
+  if (control === "click") {
+    return { enabled: true, mode: "click", debounceMs: 0 };
+  }
+  if (control === "hover") {
+    return { enabled: true, mode: "hover", debounceMs: 100 };
+  }
+  const mode = control.mode ?? "click";
+  return {
+    enabled: true,
+    mode,
+    debounceMs: Math.max(0, control.debounceMs ?? (mode === "hover" ? 100 : 0))
+  };
+}
+function DClimateZarrMap(props) {
+  const sourceOptions = normalizeDClimateSourceOptions(props);
+  const loadKey = `${JSON.stringify(props.dataset)}:${props.gatewayUrl ?? ""}:${JSON.stringify(sourceOptions ?? {})}:${JSON.stringify(props.preflight ?? {})}`;
+  return /* @__PURE__ */ jsxRuntime.jsx(DClimateZarrMapLoader, { ...props, sourceOptions }, loadKey);
+}
+function normalizeDClimateSourceOptions({
+  bounds,
+  boundsOptions,
+  sourceOptions,
+  timeRange
+}) {
+  const selection = {
+    ...sourceOptions?.selection
+  };
+  if (bounds) {
+    selection.bounds = bounds;
+  }
+  if (boundsOptions) {
+    selection.boundsOptions = boundsOptions;
+  }
+  if (timeRange) {
+    selection.timeRange = timeRange;
+  }
+  return Object.keys(selection).length === 0 ? sourceOptions : {
+    ...sourceOptions,
+    selection
+  };
+}
+function normalizePreflightConfig(preflight, onPreflight, defaults) {
+  if (!preflight && !onPreflight) {
+    return void 0;
+  }
+  return {
+    ...preflight,
+    bounds: preflight?.bounds ?? defaults.bounds,
+    onResult: (result) => {
+      preflight?.onResult?.(result);
+      onPreflight?.(result);
+    },
+    timeRange: preflight?.timeRange ?? defaults.timeRange,
+    variable: preflight?.variable ?? defaults.variable
+  };
+}
+function selectionBounds(selection) {
+  const bounds = selection?.bounds;
+  if (!bounds) {
+    return void 0;
+  }
+  return isSelectionBoundsTuple2(bounds) ? [bounds[0], bounds[1], bounds[2], bounds[3]] : [bounds.west, bounds.south, bounds.east, bounds.north];
+}
+function isSelectionBoundsTuple2(bounds) {
+  return Array.isArray(bounds);
+}
+function DClimateZarrMapLoader({
+  dataset,
+  sourceOptions,
+  preflight,
+  onPreflight,
+  client,
+  clientOptions,
+  gatewayUrl,
+  openIpfsStore,
+  ...mapProps
+}) {
+  const [source, setSource] = react.useState();
+  const [error, setError] = react.useState();
+  useMountEffect(() => {
+    let mounted = true;
+    void createDClimateSource(dataset, {
+      ...sourceOptions,
+      client,
+      clientOptions,
+      gatewayUrl,
+      openIpfsStore,
+      preflight: normalizePreflightConfig(preflight, onPreflight, {
+        bounds: selectionBounds(sourceOptions?.selection),
+        timeRange: sourceOptions?.selection?.timeRange,
+        variable: mapProps.variable
+      })
+    }).then((loadedSource) => {
+      if (mounted) {
+        setSource(loadedSource);
+      }
+    }).catch((loadError) => {
+      if (mounted) {
+        setError(loadError instanceof Error ? loadError.message : String(loadError));
+      }
+    });
+    return () => {
+      mounted = false;
+    };
+  });
+  if (error) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { style: errorStyle, children: error });
+  }
+  if (!source) {
+    return /* @__PURE__ */ jsxRuntime.jsx(LoadingStatus, { label: "Loading dClimate dataset" });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(ZarrMap, { ...mapProps, source });
+}
+var mapShellStyle = {
+  background: "#020304",
+  minHeight: 420,
+  overflow: "hidden",
+  position: "relative",
+  width: "100%"
+};
+var mapContainerStyle = {
+  height: "100%",
+  minHeight: 420,
+  width: "100%"
+};
+var legendOverlayStyle = {
+  bottom: 24,
+  left: 24,
+  position: "absolute",
+  zIndex: 2
+};
+var sliderOverlayStyle = {
+  bottom: 24,
+  left: 230,
+  maxWidth: "calc(100% - 254px)",
+  position: "absolute",
+  right: 24,
+  zIndex: 2
+};
+var statusStyle = {
+  WebkitBackdropFilter: "blur(18px)",
+  backdropFilter: "blur(18px)",
+  background: "rgba(4, 8, 12, 0.78)",
+  border: "1px solid rgba(125, 211, 252, 0.2)",
+  borderRadius: 8,
+  boxShadow: "0 20px 54px rgba(0, 0, 0, 0.42)",
+  color: "#f8fafc",
+  fontSize: 13,
+  minWidth: 210,
+  padding: "12px 13px",
+  position: "absolute",
+  right: 24,
+  top: 24,
+  zIndex: 3
+};
+var statusHeaderStyle = {
+  alignItems: "center",
+  display: "flex",
+  gap: 14,
+  fontWeight: 650,
+  justifyContent: "space-between",
+  lineHeight: 1.2
+};
+var statusPercentStyle = {
+  color: "#fde725",
+  fontSize: 12,
+  fontWeight: 720
+};
+var statusTrackStyle = {
+  background: "rgba(148, 163, 184, 0.2)",
+  borderRadius: 999,
+  height: 4,
+  marginTop: 10,
+  overflow: "hidden",
+  width: "100%"
+};
+var statusProgressStyle = {
+  background: "linear-gradient(90deg, #31688e, #35b779, #fde725)",
+  borderRadius: 999,
+  boxShadow: "0 0 14px rgba(53, 183, 121, 0.5)",
+  height: "100%",
+  transition: "width 150ms ease"
+};
+var inspectBaseStyle = {
+  WebkitBackdropFilter: "blur(18px)",
+  backdropFilter: "blur(18px)",
+  background: "rgba(4, 8, 12, 0.78)",
+  border: "1px solid rgba(125, 211, 252, 0.2)",
+  borderRadius: 8,
+  boxShadow: "0 20px 54px rgba(0, 0, 0, 0.42)",
+  color: "#f8fafc",
+  display: "grid",
+  gap: 4,
+  fontSize: 13,
+  padding: "11px 13px",
+  zIndex: 3
+};
+var inspectOverlayStyle = {
+  ...inspectBaseStyle,
+  position: "absolute",
+  right: 24,
+  top: 24
+};
+var errorStyle = {
+  ...statusStyle,
+  background: "rgba(69, 10, 10, 0.78)",
+  borderColor: "rgba(248, 113, 113, 0.5)",
+  color: "#fecaca"
+};
+var legendStyle = {
+  WebkitBackdropFilter: "blur(18px)",
+  backdropFilter: "blur(18px)",
+  background: "rgba(4, 8, 12, 0.78)",
+  border: "1px solid rgba(125, 211, 252, 0.2)",
+  borderRadius: 8,
+  boxShadow: "0 20px 54px rgba(0, 0, 0, 0.42)",
+  color: "#f8fafc",
+  padding: 13,
+  width: 182
+};
+var legendHeaderStyle = {
+  color: "#f8fafc",
+  display: "flex",
+  fontSize: 12,
+  fontWeight: 700,
+  justifyContent: "space-between",
+  marginBottom: 8
+};
+var legendScaleStyle = {
+  color: "#cbd5e1",
+  display: "flex",
+  fontSize: 12,
+  justifyContent: "space-between",
+  marginTop: 6
+};
+var sliderShellStyle = {
+  alignItems: "center",
+  WebkitBackdropFilter: "blur(18px)",
+  backdropFilter: "blur(18px)",
+  background: "rgba(4, 8, 12, 0.74)",
+  border: "1px solid rgba(125, 211, 252, 0.2)",
+  borderRadius: 8,
+  boxShadow: "0 20px 54px rgba(0, 0, 0, 0.42)",
+  color: "#f8fafc",
+  display: "grid",
+  gap: 12,
+  gridTemplateColumns: "88px minmax(0, 1fr)",
+  padding: "11px 13px"
+};
+var sliderShellWithoutPlaybackStyle = {
+  ...sliderShellStyle,
+  gridTemplateColumns: "minmax(0, 1fr)"
+};
+var sliderBodyStyle = {
+  alignItems: "center",
+  display: "grid",
+  gap: 12,
+  gridTemplateColumns: "minmax(150px, 240px) minmax(160px, 1fr)",
+  minWidth: 0
+};
+var playbackControlsStyle = {
+  alignItems: "center",
+  display: "flex",
+  gap: 8
+};
+var playButtonStyle = {
+  alignItems: "center",
+  background: "rgba(15, 23, 42, 0.86)",
+  border: "1px solid rgba(125, 211, 252, 0.28)",
+  borderRadius: 6,
+  color: "#f8fafc",
+  cursor: "pointer",
+  display: "inline-flex",
+  height: 40,
+  justifyContent: "center",
+  padding: 0,
+  width: 40
+};
+var playbackSpeedButtonStyle = {
+  ...playButtonStyle,
+  fontSize: 12,
+  fontVariantNumeric: "tabular-nums",
+  fontWeight: 760,
+  lineHeight: 1
+};
+var playIconStyle = {
+  borderBottom: "7px solid transparent",
+  borderLeft: "11px solid #f8fafc",
+  borderTop: "7px solid transparent",
+  display: "block",
+  height: 0,
+  marginLeft: 3,
+  width: 0
+};
+var pauseIconStyle = {
+  display: "inline-flex",
+  gap: 4,
+  height: 16
+};
+var pauseBarStyle = {
+  background: "#f8fafc",
+  borderRadius: 2,
+  display: "block",
+  height: 16,
+  width: 5
+};
+var sliderLabelStyle = {
+  color: "#cbd5e1",
+  fontSize: 12,
+  fontWeight: 600,
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap"
+};
+var sliderStyle = {
+  accentColor: "#35b779",
+  width: "100%"
+};
+function inspectTooltipStyle(point) {
+  return {
+    ...inspectBaseStyle,
+    left: point.x,
+    maxWidth: 220,
+    pointerEvents: "none",
+    position: "absolute",
+    top: point.y,
+    transform: `translate(${point.horizontal === "left" ? "calc(-100% - 12px)" : "12px"}, ${point.vertical === "above" ? "calc(-100% - 12px)" : "12px"})`
+  };
+}
+function gradientStyle(palette) {
+  const gradient = `linear-gradient(90deg, ${paletteToCssGradientColors(palette).join(", ")})`;
+  return {
+    background: gradient,
+    borderRadius: 4,
+    boxShadow: "0 0 18px rgba(53, 183, 121, 0.2)",
+    height: 10,
+    width: "100%"
+  };
+}
+function paletteToCssGradientColors(palette) {
+  const colors = paletteToRendererColorMap(palette);
+  if (hasTransparentLowerBound(palette)) {
+    return ["rgba(0, 0, 0, 0)", ...colors];
+  }
+  return colors;
+}
+function hasTransparentLowerBound(palette) {
+  if (typeof palette !== "string") {
+    return false;
+  }
+  const normalized = palette.toLowerCase();
+  return normalized === "magma" || normalized === "precipitation" || normalized === "vegetation";
+}
+function formatInspectSample(result, colorScale, formatter) {
+  const sample = result.samples[0];
+  if (!sample) {
+    return "No data";
+  }
+  if (formatter) {
+    return formatter(sample, result);
+  }
+  if (sample.value === null) {
+    return "No data";
+  }
+  const display = inspectDisplayValue(sample.value, result.unit, colorScale);
+  return `${formatNumber(display.value)}${display.unit ? ` ${display.unit}` : ""}`;
+}
+function inspectDisplayValue(value, sourceUnit, colorScale) {
+  const fromUnit = colorScale?.unit ?? sourceUnit;
+  const toUnit = colorScale?.displayUnit;
+  if (fromUnit && toUnit && colorScale?.quantity) {
+    return {
+      value: convertDisplayValue(value, {
+        fromUnit,
+        quantity: colorScale.quantity,
+        toUnit
+      }),
+      unit: toUnit
+    };
+  }
+  return {
+    value,
+    unit: toUnit ?? sourceUnit
+  };
+}
+function formatNumber(value) {
+  if (value !== 0 && Math.abs(value) < 0.01) {
+    return new Intl.NumberFormat("en", {
+      maximumSignificantDigits: 2
+    }).format(value);
+  }
+  return new Intl.NumberFormat("en", {
+    maximumFractionDigits: Math.abs(value) < 10 ? 2 : 0
+  }).format(value);
+}
+function formatCoordinatePair(coordinates) {
+  return `${coordinates[1].toFixed(3)}, ${coordinates[0].toFixed(3)}`;
+}
+function timeIndexForSelector(source, dimensionName, selectors) {
+  const selector = selectors[dimensionName];
+  if (!selector) {
+    return void 0;
+  }
+  const coordinates = listTimeCoordinates(source, dimensionName);
+  if (typeof selector !== "object" || selector instanceof Date) {
+    const value = selector instanceof Date ? selector.toISOString() : selector;
+    const index = coordinates.findIndex(
+      (coordinate) => coordinate.value === selector || coordinate.iso === value
+    );
+    return index === -1 ? void 0 : index;
+  }
+  if (selector.kind === "index") {
+    return clampIndex(selector.index, Math.max(coordinates.length - 1, 0));
+  }
+  if (selector.kind === "isoTime") {
+    const index = coordinates.findIndex((coordinate) => coordinate.iso === selector.iso);
+    return index === -1 ? void 0 : index;
+  }
+  if (selector.kind === "coordinate") {
+    const index = coordinates.findIndex((coordinate) => coordinate.value === selector.value);
+    return index === -1 ? void 0 : index;
+  }
+  return void 0;
+}
+function extractLngLat(event) {
+  if (typeof event !== "object" || event === null || !("lngLat" in event)) {
+    return void 0;
+  }
+  const lngLat = event.lngLat;
+  if (typeof lngLat !== "object" || lngLat === null) {
+    return void 0;
+  }
+  if ("toArray" in lngLat && typeof lngLat.toArray === "function") {
+    const value = lngLat.toArray();
+    return Array.isArray(value) && typeof value[0] === "number" && typeof value[1] === "number" ? [value[0], value[1]] : void 0;
+  }
+  if ("lng" in lngLat && "lat" in lngLat && typeof lngLat.lng === "number" && typeof lngLat.lat === "number") {
+    return [lngLat.lng, lngLat.lat];
+  }
+  return void 0;
+}
+function extractInspectTooltipPoint(event, container) {
+  const point = extractMapPoint(event) ?? extractClientPoint(event, container);
+  if (!point) {
+    return void 0;
+  }
+  const width = container?.clientWidth ?? 0;
+  const height = container?.clientHeight ?? 0;
+  return {
+    x: point[0],
+    y: point[1],
+    horizontal: width > 0 && point[0] > width - 240 ? "left" : "right",
+    vertical: height > 0 && point[1] > height - 110 ? "above" : "below"
+  };
+}
+function extractMapPoint(event) {
+  if (!isRecord2(event) || !isRecord2(event.point)) {
+    return void 0;
+  }
+  const { x, y } = event.point;
+  return typeof x === "number" && typeof y === "number" ? [x, y] : void 0;
+}
+function extractClientPoint(event, container) {
+  if (!container || !isRecord2(event)) {
+    return void 0;
+  }
+  const originalEvent = event.originalEvent;
+  if (!isRecord2(originalEvent)) {
+    return void 0;
+  }
+  const { clientX, clientY } = originalEvent;
+  if (typeof clientX !== "number" || typeof clientY !== "number") {
+    return void 0;
+  }
+  const rect = container.getBoundingClientRect();
+  return [clientX - rect.left, clientY - rect.top];
+}
+async function queryInspectPoint(controller, context, coordinates) {
+  const selectors = context.selector ?? context.currentSelector;
+  if (controller) {
+    try {
+      const rendered = await controller.query({ type: "Point", coordinates });
+      const result = renderedPointQueryToGridResult(rendered, context, coordinates, selectors);
+      if (result) {
+        return result;
+      }
+    } catch (error) {
+      if (!isGridError(error) || error.code !== "UNSUPPORTED_GEOMETRY") {
+        throw error;
+      }
+    }
+  }
+  return queryPoint(context.source, context.variable, coordinates, selectors);
+}
+function renderedPointQueryToGridResult(rendered, context, clickedCoordinates, selectors) {
+  if (!isRecord2(rendered)) {
+    return void 0;
+  }
+  const variable = context.source.variables.find(
+    (candidate) => candidate.name === context.variable || candidate.path === context.variable
+  );
+  const renderedValues = findRenderedVariableValues(rendered, [
+    context.variable,
+    variable?.name,
+    variable?.path
+  ]);
+  if (renderedValues === void 0) {
+    return void 0;
+  }
+  const value = firstFiniteNumber(renderedValues) ?? null;
+  return {
+    variable: context.variable,
+    selectors: normalizeSelectors(context.source, context.variable, selectors),
+    geometry: { type: "Point", coordinates: clickedCoordinates },
+    unit: variable?.units,
+    samples: [
+      {
+        coordinates: renderedPointCoordinates(rendered, clickedCoordinates),
+        indexes: {},
+        rawValue: value,
+        value
+      }
+    ],
+    warnings: []
+  };
+}
+function findRenderedVariableValues(rendered, preferredKeys) {
+  for (const key of preferredKeys) {
+    if (key && key in rendered) {
+      return rendered[key];
+    }
+  }
+  return Object.entries(rendered).find(
+    ([key]) => key !== "coordinates" && key !== "dimensions"
+  )?.[1];
+}
+function renderedPointCoordinates(rendered, fallback) {
+  const coordinates = rendered.coordinates;
+  if (!isRecord2(coordinates)) {
+    return fallback;
+  }
+  const longitude = firstFiniteNumber(coordinates.lon) ?? firstFiniteNumber(coordinates.lng) ?? fallback[0];
+  const latitude = firstFiniteNumber(coordinates.lat) ?? fallback[1];
+  return [longitude, latitude];
+}
+function firstFiniteNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const number = firstFiniteNumber(item);
+      if (number !== void 0) {
+        return number;
+      }
+    }
+  }
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+    const values = value;
+    for (let index = 0; index < values.length; index += 1) {
+      const number = firstFiniteNumber(values[index]);
+      if (number !== void 0) {
+        return number;
+      }
+    }
+  }
+  return void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+exports.BASE_PLAYBACK_INTERVAL_MS = BASE_PLAYBACK_INTERVAL_MS;
+exports.DClimateZarrMap = DClimateZarrMap;
+exports.Legend = Legend;
+exports.PLAYBACK_SPEED_OPTIONS = PLAYBACK_SPEED_OPTIONS;
+exports.TimeSlider = TimeSlider;
+exports.ZarrMap = ZarrMap;
+exports.useMountEffect = useMountEffect;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map