@walkthru-earth/objex-utils 1.3.1 → 1.5.0

package/dist/index.cjs

@@ -16,6 +16,9 @@ var SQL_PREVIEW_LENGTH = 120;
 var VIEWER_DIR_EXTENSIONS = /* @__PURE__ */ new Set(["zarr", "zr3"]);
 var LAYER_HUE_MULTIPLIER = 137;
 var COPY_FEEDBACK_MS = 2e3;
+var DEFAULT_AWS_REGION = "us-east-1";
+var TILE_DEBOUNCE_MS = 200;
+var FIRST_FEATURE_FLY_ZOOM = 14;
 
 // ../../src/lib/file-icons/index.ts
 var DEFAULT_INFO = {
@@ -1150,15 +1153,15 @@ var PROVIDERS = {
     schemes: ["azure", "az", "abfs", "abfss", "wasbs", "adl"]
   },
   minio: {
-    label: "MinIO",
-    description: "Self-hosted MinIO or S3-compatible",
+    label: "MinIO / RustFS / Custom",
+    description: "MinIO, RustFS, or any custom S3-compatible endpoint",
     authMethod: "sigv4",
     needsRegion: false,
     needsEndpoint: true,
     defaultRegion: "us-east-1",
     endpointTemplate: null,
     regions: [],
-    endpointPlaceholder: "https://minio.example.com or http://localhost:9000",
+    endpointPlaceholder: "https://s3.example.com or http://localhost:9000",
     schemes: []
   },
   storj: {
@@ -1366,7 +1369,7 @@ function buildProviderBaseUrl(provider, endpoint, bucket, region) {
     const resolved = def.endpointTemplate.replace("{region}", region || def.defaultRegion);
     return `${resolved}/${bucket}`;
   }
-  return `https://s3.${region || "us-east-1"}.amazonaws.com/${bucket}`;
+  return `https://s3.${region || DEFAULT_AWS_REGION}.amazonaws.com/${bucket}`;
 }
 function isGcsProvider(provider, endpoint) {
   return provider === "gcs" || !!endpoint && /storage\.googleapis\.com/i.test(endpoint);
@@ -1426,7 +1429,475 @@ var UrlAdapter = class {
   }
 };
 
-// ../../src/lib/utils/cloud-url.ts
+// src/app-config.ts
+var DEFAULT_APP_CONFIG = {
+  defaults: { theme: "system", locale: "en", featureLimit: 1e3, mosaicItemLimit: 2e3 },
+  ui: { showConnectionRail: true, showFileTree: true, showSettings: true },
+  basemaps: [
+    {
+      id: "positron",
+      label: "Positron",
+      type: "vector",
+      url: "https://basemaps.cartocdn.com/gl/positron-gl-style/style.json",
+      variant: "light"
+    },
+    {
+      id: "dark-matter",
+      label: "Dark Matter",
+      type: "vector",
+      url: "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json",
+      variant: "dark"
+    }
+  ],
+  defaultBasemap: { light: "positron", dark: "dark-matter" },
+  connections: []
+};
+function asObject(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function coerceTheme(v) {
+  return v === "light" || v === "dark" || v === "system" ? v : void 0;
+}
+function coerceString(v) {
+  return typeof v === "string" && v.trim().length > 0 ? v.trim() : void 0;
+}
+function coercePositiveInt(v) {
+  return typeof v === "number" && Number.isFinite(v) && v >= 1 ? Math.floor(v) : void 0;
+}
+function coerceBool(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+function resolveSetting(...candidates) {
+  for (const c of candidates) {
+    if (c !== null && c !== void 0) return c;
+  }
+  return void 0;
+}
+function parseVisibilityParam(value) {
+  if (value === "hide") return false;
+  if (value === "show") return true;
+  return void 0;
+}
+function coerceBasemaps(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  for (const raw of v) {
+    const o = asObject(raw);
+    if (!o) continue;
+    const id = coerceString(o.id);
+    const label = coerceString(o.label);
+    const url = coerceString(o.url);
+    const type = o.type === "vector" || o.type === "raster" ? o.type : void 0;
+    if (!id || !label || !url || !type) continue;
+    const variant = o.variant === "light" || o.variant === "dark" ? o.variant : void 0;
+    out.push({ id, label, url, type, ...variant ? { variant } : {} });
+  }
+  return out;
+}
+function coerceConnections(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  for (const raw of v) {
+    const o = asObject(raw);
+    if (!o) continue;
+    const name = coerceString(o.name);
+    const bucket = coerceString(o.bucket);
+    if (!name || !bucket) continue;
+    const region = coerceString(o.region);
+    const endpoint = coerceString(o.endpoint);
+    const anonymous = coerceBool(o.anonymous);
+    const authMethod = o.authMethod === "sigv4" || o.authMethod === "sas-token" ? o.authMethod : void 0;
+    const rootPrefix = coerceString(o.rootPrefix);
+    out.push({
+      name,
+      bucket,
+      provider: coerceString(o.provider) ?? "s3",
+      ...region !== void 0 ? { region } : {},
+      ...endpoint !== void 0 ? { endpoint } : {},
+      ...anonymous !== void 0 ? { anonymous } : {},
+      ...authMethod !== void 0 ? { authMethod } : {},
+      ...rootPrefix !== void 0 ? { rootPrefix } : {}
+    });
+  }
+  return out;
+}
+function resolveBasemap(config, variant, userId) {
+  const list = config.basemaps;
+  if (list.length === 0) return void 0;
+  if (userId) {
+    const picked = list.find((b) => b.id === userId);
+    if (picked) return picked;
+  }
+  const defaultId = config.defaultBasemap[variant];
+  if (defaultId) {
+    const byDefault = list.find((b) => b.id === defaultId);
+    if (byDefault) return byDefault;
+  }
+  return list.find((b) => b.variant === variant) ?? list[0];
+}
+function mergeAppConfig(base, override) {
+  const o = asObject(override);
+  if (!o) return base;
+  const d = asObject(o.defaults) ?? {};
+  const u = asObject(o.ui) ?? {};
+  const db = asObject(o.defaultBasemap) ?? {};
+  return {
+    defaults: {
+      theme: coerceTheme(d.theme) ?? base.defaults.theme,
+      locale: coerceString(d.locale) ?? base.defaults.locale,
+      featureLimit: coercePositiveInt(d.featureLimit) ?? base.defaults.featureLimit,
+      mosaicItemLimit: coercePositiveInt(d.mosaicItemLimit) ?? base.defaults.mosaicItemLimit
+    },
+    ui: {
+      showConnectionRail: coerceBool(u.showConnectionRail) ?? base.ui.showConnectionRail,
+      showFileTree: coerceBool(u.showFileTree) ?? base.ui.showFileTree,
+      showSettings: coerceBool(u.showSettings) ?? base.ui.showSettings
+    },
+    basemaps: coerceBasemaps(o.basemaps) ?? base.basemaps,
+    defaultBasemap: (() => {
+      const light = coerceString(db.light) ?? base.defaultBasemap.light;
+      const dark = coerceString(db.dark) ?? base.defaultBasemap.dark;
+      return { ...light !== void 0 ? { light } : {}, ...dark !== void 0 ? { dark } : {} };
+    })(),
+    connections: coerceConnections(o.connections) ?? base.connections
+  };
+}
+
+// src/stac.ts
+var STAC_COG_ASSET_KEYS = ["visual", "image", "data", "rendered_preview"];
+function isStacItem(json) {
+  if (!json || typeof json !== "object") return false;
+  const obj = json;
+  return obj.type === "Feature" && typeof obj.stac_version === "string";
+}
+function isStacFeatureCollection(json) {
+  if (!json || typeof json !== "object") return false;
+  const obj = json;
+  if (obj.type !== "FeatureCollection") return false;
+  if (!Array.isArray(obj.features) || obj.features.length === 0) return false;
+  if (typeof obj.stac_version === "string") return true;
+  return isStacItem(obj.features[0]);
+}
+function isStacCollection(json) {
+  if (!json || typeof json !== "object") return false;
+  const obj = json;
+  return obj.type === "Collection" && typeof obj.stac_version === "string" && Array.isArray(obj.links);
+}
+function isStacCatalog(json) {
+  if (!json || typeof json !== "object") return false;
+  const obj = json;
+  return obj.type === "Catalog" && typeof obj.stac_version === "string" && Array.isArray(obj.links);
+}
+function classifyStac(json) {
+  if (isStacItem(json)) return { kind: "item", item: json };
+  if (isStacFeatureCollection(json)) return { kind: "item-collection", fc: json };
+  if (isStacCollection(json)) return { kind: "collection", payload: json };
+  if (isStacCatalog(json)) return { kind: "catalog", payload: json };
+  return { kind: "none" };
+}
+function pickCogAssetHref(item, preferred) {
+  const assets = item.assets ?? {};
+  if (preferred && assets[preferred]?.href) return assets[preferred].href;
+  for (const key of STAC_COG_ASSET_KEYS) {
+    if (assets[key]?.href) return assets[key].href;
+  }
+  for (const asset of Object.values(assets)) {
+    const t = typeof asset?.type === "string" ? asset.type.toLowerCase() : "";
+    if (asset?.href && t.includes("tiff")) return asset.href;
+  }
+  return null;
+}
+function detectMosaicCapable(item) {
+  return stacItemBbox(item) !== null && pickCogAssetHref(item) !== null;
+}
+function detectMultiCogCapable(item) {
+  if (hasRgbBands(extractSentinelBandAssets(item))) return true;
+  return hasCompositableBands(extractRasterBandAssets(item));
+}
+function stacItemBbox(item) {
+  if (Array.isArray(item.bbox) && item.bbox.length >= 4) {
+    return [Number(item.bbox[0]), Number(item.bbox[1]), Number(item.bbox[2]), Number(item.bbox[3])];
+  }
+  return null;
+}
+function buildMosaicSourceMeta(input, assetKey) {
+  if (!input || typeof input !== "object") return null;
+  if (isStacItem(input)) {
+    const bbox = stacItemBbox(input);
+    if (!bbox) return null;
+    const href = pickCogAssetHref(input, assetKey);
+    if (!href) return null;
+    return {
+      id: String(input.id ?? href),
+      bbox,
+      href
+    };
+  }
+  const raw = input;
+  if (Array.isArray(raw.bbox) && raw.bbox.length >= 4 && typeof raw.href === "string") {
+    return {
+      id: String(raw.id ?? raw.href),
+      bbox: [Number(raw.bbox[0]), Number(raw.bbox[1]), Number(raw.bbox[2]), Number(raw.bbox[3])],
+      href: raw.href
+    };
+  }
+  return null;
+}
+function spatialCellKey(item, bbox) {
+  const props = item.properties ?? {};
+  const grid = props["grid:code"];
+  if (typeof grid === "string" && grid) return `g:${grid}`;
+  const utm = props["mgrs:utm_zone"];
+  const band = props["mgrs:latitude_band"];
+  const sq = props["mgrs:grid_square"];
+  if (utm != null && band != null && sq != null) return `m:${utm}${band}${sq}`;
+  const s2 = props["s2:mgrs_tile"];
+  if (typeof s2 === "string" && s2) return `m:${s2}`;
+  return `b:${bbox[0].toFixed(3)},${bbox[1].toFixed(3)},${bbox[2].toFixed(3)},${bbox[3].toFixed(3)}`;
+}
+var BAND_KEY_FALLBACKS = {
+  red: ["red", "B04", "B4", "visual-red"],
+  green: ["green", "B03", "B3", "visual-green"],
+  blue: ["blue", "B02", "B2", "visual-blue"],
+  nir: ["nir", "nir08", "B08", "B8", "B8A"],
+  swir1: ["swir16", "swir1", "B11"],
+  swir2: ["swir22", "swir2", "B12"],
+  rededge: ["rededge1", "rededge", "B05", "B5"]
+};
+function extractSentinelBandAssets(item) {
+  const out = {};
+  const assets = item.assets ?? {};
+  for (const [key, asset] of Object.entries(assets)) {
+    if (!asset?.href) continue;
+    const bands = asset["eo:bands"];
+    if (Array.isArray(bands) && bands.length >= 1) {
+      const common = bands[0]?.common_name?.toLowerCase();
+      if (common && isBandSlot(common)) {
+        if (!out[common]) out[common] = asset.href;
+        continue;
+      }
+    }
+    for (const slot of Object.keys(BAND_KEY_FALLBACKS)) {
+      if (BAND_KEY_FALLBACKS[slot].includes(key) && !out[slot]) {
+        out[slot] = asset.href;
+        break;
+      }
+    }
+  }
+  return out;
+}
+function isBandSlot(value) {
+  return value === "red" || value === "green" || value === "blue" || value === "nir" || value === "swir1" || value === "swir2" || value === "rededge";
+}
+function hasRgbBands(map) {
+  return Boolean(map.red && map.green && map.blue);
+}
+function extractRasterBandAssets(item) {
+  const out = [];
+  const assets = item.assets ?? {};
+  for (const [key, asset] of Object.entries(assets)) {
+    if (!asset?.href) continue;
+    const mediaType = typeof asset.type === "string" ? asset.type : void 0;
+    if (mediaType && !/^image\/(tiff|geotiff)\b/i.test(mediaType)) continue;
+    const roles = Array.isArray(asset.roles) ? asset.roles : void 0;
+    if (roles && (roles.includes("thumbnail") || roles.includes("overview") || roles.includes("metadata"))) {
+      continue;
+    }
+    const eoBands = Array.isArray(asset["eo:bands"]) ? asset["eo:bands"] : void 0;
+    const assetExt = asset;
+    const rasterBands = Array.isArray(assetExt["raster:bands"]) ? assetExt["raster:bands"] : void 0;
+    const bandCount = rasterBands?.length ?? eoBands?.length;
+    if (typeof bandCount === "number" && bandCount > 1) continue;
+    const commonName = eoBands?.[0]?.common_name?.toLowerCase();
+    out.push({
+      key,
+      href: asset.href,
+      commonName,
+      bandCount: typeof bandCount === "number" ? bandCount : 1,
+      roles,
+      mediaType,
+      title: typeof asset.title === "string" ? asset.title : void 0
+    });
+  }
+  return out;
+}
+function resolveBandSlotAssetKey(assets, slot) {
+  const byCommon = assets.find((a) => a.commonName === slot);
+  if (byCommon) return byCommon.key;
+  const fallbacks = BAND_KEY_FALLBACKS[slot] ?? [];
+  const byKey = assets.find((a) => fallbacks.includes(a.key));
+  return byKey?.key;
+}
+function resolvePresetComposite(assets, composite) {
+  const r = resolveBandSlotAssetKey(assets, composite.r);
+  const g = resolveBandSlotAssetKey(assets, composite.g);
+  const b = resolveBandSlotAssetKey(assets, composite.b);
+  if (!r || !g || !b) return null;
+  return { r, g, b };
+}
+function hasCompositableBands(assets) {
+  return assets.length >= 3;
+}
+function extractMosaicAssets(item) {
+  const out = [];
+  const assets = item.assets ?? {};
+  for (const [key, asset] of Object.entries(assets)) {
+    if (!asset?.href) continue;
+    const mediaType = typeof asset.type === "string" ? asset.type : void 0;
+    if (mediaType && !/^image\/(tiff|geotiff)\b/i.test(mediaType)) continue;
+    const roles = Array.isArray(asset.roles) ? asset.roles : void 0;
+    if (roles && (roles.includes("thumbnail") || roles.includes("overview") || roles.includes("metadata"))) {
+      continue;
+    }
+    const eoBands = Array.isArray(asset["eo:bands"]) ? asset["eo:bands"] : void 0;
+    const assetExt = asset;
+    const rasterBands = Array.isArray(assetExt["raster:bands"]) ? assetExt["raster:bands"] : void 0;
+    const bandCount = rasterBands?.length ?? eoBands?.length;
+    const commonName = eoBands?.[0]?.common_name?.toLowerCase();
+    out.push({
+      key,
+      href: asset.href,
+      commonName,
+      bandCount: typeof bandCount === "number" ? bandCount : void 0,
+      roles,
+      mediaType,
+      title: typeof asset.title === "string" ? asset.title : void 0
+    });
+  }
+  return out;
+}
+
+// src/channel-composite.ts
+var PRESETS = [
+  {
+    id: "natural-color",
+    labelKey: "map.multiCogPreset.trueColor",
+    slots: { r: "red", g: "green", b: "blue" }
+  },
+  {
+    id: "false-color-ir",
+    labelKey: "map.multiCogPreset.falseColorIR",
+    slots: { r: "nir", g: "red", b: "green" }
+  },
+  {
+    id: "swir",
+    labelKey: "map.multiCogPreset.swir",
+    slots: { r: "swir2", g: "swir1", b: "red" }
+  },
+  {
+    id: "vegetation",
+    labelKey: "map.multiCogPreset.vegetation",
+    slots: { r: "nir", g: "swir1", b: "red" }
+  },
+  {
+    id: "agriculture",
+    labelKey: "map.multiCogPreset.agriculture",
+    slots: { r: "swir1", g: "nir", b: "blue" }
+  }
+];
+function toRasterBandAssets(assets) {
+  return assets.map((a) => ({
+    key: a.key,
+    href: a.href,
+    commonName: a.eoCommon[0],
+    bandCount: a.bandCount,
+    roles: a.roles,
+    mediaType: a.mediaType,
+    title: a.title
+  }));
+}
+function availablePresets(assets) {
+  const rba = toRasterBandAssets(assets);
+  return PRESETS.filter((p) => resolvePresetComposite(rba, p.slots) !== null);
+}
+function applyPreset(assets, preset) {
+  const rba = toRasterBandAssets(assets);
+  const r = resolvePresetComposite(rba, preset.slots);
+  if (!r) return null;
+  return {
+    r: { assetKey: r.r, bandIndex: 0 },
+    g: { assetKey: r.g, bandIndex: 0 },
+    b: { assetKey: r.b, bandIndex: 0 }
+  };
+}
+function presetMatchesComposite(preset, c, assets) {
+  const resolved = applyPreset(assets, preset);
+  if (!resolved) return false;
+  return resolved.r.assetKey === c.r.assetKey && resolved.g.assetKey === c.g.assetKey && resolved.b.assetKey === c.b.assetKey && c.r.bandIndex === 0 && c.g.bandIndex === 0 && c.b.bandIndex === 0;
+}
+function compositeFromUrl(params, assets) {
+  const r = params.get("r");
+  const g = params.get("g");
+  const b = params.get("b");
+  if (!r || !g || !b) return null;
+  const known = new Map(assets.map((a2) => [a2.key, a2]));
+  const ra = known.get(r);
+  const ga = known.get(g);
+  const ba = known.get(b);
+  if (!ra || !ga || !ba) return null;
+  const out = {
+    r: { assetKey: r, bandIndex: clampBand(params.get("band_r"), ra.bandCount) },
+    g: { assetKey: g, bandIndex: clampBand(params.get("band_g"), ga.bandCount) },
+    b: { assetKey: b, bandIndex: clampBand(params.get("band_b"), ba.bandCount) }
+  };
+  const a = params.get("a");
+  if (a) {
+    const aa = known.get(a);
+    if (aa) out.a = { assetKey: a, bandIndex: clampBand(params.get("band_a"), aa.bandCount) };
+  }
+  return out;
+}
+function compositeToUrl(c, presetId) {
+  const p = new URLSearchParams();
+  p.set("r", c.r.assetKey);
+  p.set("g", c.g.assetKey);
+  p.set("b", c.b.assetKey);
+  if (c.r.bandIndex !== 0) p.set("band_r", String(c.r.bandIndex));
+  if (c.g.bandIndex !== 0) p.set("band_g", String(c.g.bandIndex));
+  if (c.b.bandIndex !== 0) p.set("band_b", String(c.b.bandIndex));
+  if (c.a) {
+    p.set("a", c.a.assetKey);
+    if (c.a.bandIndex !== 0) p.set("band_a", String(c.a.bandIndex));
+  }
+  if (presetId) p.set("preset", presetId);
+  return p;
+}
+function clampBand(raw, bandCount) {
+  if (!raw) return 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return 0;
+  const i = Math.floor(n);
+  if (i < 0) return 0;
+  if (i >= bandCount) return Math.max(0, bandCount - 1);
+  return i;
+}
+
+// src/clipboard.ts
+async function copyToClipboard(text, onFeedback) {
+  try {
+    await navigator.clipboard.writeText(text);
+    onFeedback?.(true);
+    setTimeout(() => onFeedback?.(false), COPY_FEEDBACK_MS);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function wireCodeCopyButtons(root, selector) {
+  for (const btn of root.querySelectorAll(selector)) {
+    btn.addEventListener("click", async () => {
+      const code = decodeURIComponent(btn.dataset.code ?? "");
+      try {
+        await navigator.clipboard.writeText(code);
+        btn.classList.add("copied");
+        setTimeout(() => btn.classList.remove("copied"), COPY_FEEDBACK_MS);
+      } catch {
+      }
+    });
+  }
+}
+
+// src/cloud-url.ts
 var AWS_REGION_RE = /^(us|eu|ap|sa|ca|me|af|il)-(north|south|east|west|central|northeast|southeast|northwest|southwest)-\d+/;
 function getNativeScheme(provider) {
   const def = PROVIDERS[provider];
@@ -1441,15 +1912,15 @@ function safeDecodeURIComponent(s) {
   }
 }
 function resolveCloudUrl(url) {
-  const s3Match = url.match(/^s3[an]?:\/\/([^/]+)\/?(.*)$/);
+  const s3Match = url.match(/^s3[an]?:\/\/([^/]+)(?:\/(.*))?$/);
   if (s3Match) {
     const [, bucket, key] = s3Match;
     const regionMatch = bucket.match(AWS_REGION_RE);
-    const region = regionMatch ? regionMatch[0] : "us-east-1";
+    const region = regionMatch ? regionMatch[0] : DEFAULT_AWS_REGION;
     const base = buildProviderBaseUrl("s3", "", bucket, region);
     return key ? `${base}/${key}` : base;
   }
-  const gcsMatch = url.match(/^gcs?:\/\/([^/]+)\/?(.*)$/);
+  const gcsMatch = url.match(/^gcs?:\/\/([^/]+)(?:\/(.*))?$/);
   if (gcsMatch) {
     const [, bucket, key] = gcsMatch;
     const base = buildProviderBaseUrl("gcs", "", bucket, "");
@@ -1458,7 +1929,121 @@ function resolveCloudUrl(url) {
   return url;
 }
 
-// ../../src/lib/utils/cog-pure.ts
+// src/cog-asset.ts
+var TIFF_MEDIA = /^image\/(tiff|geotiff)\b/i;
+var NON_DATA_ROLES = /* @__PURE__ */ new Set(["thumbnail", "overview", "metadata"]);
+function extractCogAssets(item) {
+  const out = [];
+  const assets = item.assets ?? {};
+  const props = item.properties ?? {};
+  const itemBands = Array.isArray(props.bands) ? props.bands : void 0;
+  for (const [key, asset] of Object.entries(assets)) {
+    if (!asset?.href) continue;
+    const mediaType = typeof asset.type === "string" ? asset.type : void 0;
+    if (mediaType && !TIFF_MEDIA.test(mediaType)) continue;
+    const roles = Array.isArray(asset.roles) ? asset.roles : [];
+    if (roles.some((r) => NON_DATA_ROLES.has(r))) continue;
+    const eoBands = Array.isArray(asset["eo:bands"]) ? asset["eo:bands"] : void 0;
+    const assetExt = asset;
+    const rasterBands = Array.isArray(assetExt["raster:bands"]) ? assetExt["raster:bands"] : void 0;
+    const assetBands11 = Array.isArray(assetExt.bands) ? assetExt.bands : void 0;
+    const bandCount = assetBands11?.length ?? rasterBands?.length ?? eoBands?.length ?? itemBands?.length;
+    const bandCountKnown = typeof bandCount === "number" && bandCount > 0;
+    const commonSource = eoBands ?? assetBands11 ?? itemBands;
+    const eoCommon = commonSource ? commonSource.map((b) => {
+      const c = b?.common_name;
+      return typeof c === "string" ? c.toLowerCase() : "";
+    }) : [];
+    const dtypeSource = rasterBands ?? assetBands11 ?? itemBands;
+    const dtype = dtypeSource?.[0]?.data_type;
+    out.push({
+      key,
+      href: asset.href,
+      bandCount: bandCountKnown ? bandCount : 1,
+      bandCountKnown,
+      dtype: typeof dtype === "string" ? dtype : void 0,
+      eoCommon,
+      roles,
+      title: typeof asset.title === "string" ? asset.title : void 0,
+      mediaType
+    });
+  }
+  return out;
+}
+function syntheticSelfAsset(href, probedBandCount) {
+  const known = typeof probedBandCount === "number" && probedBandCount > 0;
+  return {
+    key: "self",
+    href,
+    bandCount: known ? probedBandCount : 1,
+    bandCountKnown: known,
+    eoCommon: [],
+    roles: []
+  };
+}
+function pickNaturalColorComposite(assets) {
+  if (assets.length === 0) return null;
+  for (const a of assets) {
+    if (a.bandCount === 3 && (a.roles.includes("visual") || hasRgbInEoCommon(a.eoCommon))) {
+      return {
+        composite: {
+          r: { assetKey: a.key, bandIndex: indexOfCommon(a.eoCommon, "red", 0) },
+          g: { assetKey: a.key, bandIndex: indexOfCommon(a.eoCommon, "green", 1) },
+          b: { assetKey: a.key, bandIndex: indexOfCommon(a.eoCommon, "blue", 2) }
+        },
+        source: "visual-asset"
+      };
+    }
+  }
+  const red = assets.find((a) => a.eoCommon[0] === "red");
+  const green = assets.find((a) => a.eoCommon[0] === "green");
+  const blue = assets.find((a) => a.eoCommon[0] === "blue");
+  if (red && green && blue) {
+    return {
+      composite: {
+        r: { assetKey: red.key, bandIndex: 0 },
+        g: { assetKey: green.key, bandIndex: 0 },
+        b: { assetKey: blue.key, bandIndex: 0 }
+      },
+      source: "rgb-bands"
+    };
+  }
+  if (assets.length >= 3) {
+    return {
+      composite: {
+        r: { assetKey: assets[0].key, bandIndex: 0 },
+        g: { assetKey: assets[1].key, bandIndex: 0 },
+        b: { assetKey: assets[2].key, bandIndex: 0 }
+      },
+      source: "fallback"
+    };
+  }
+  const only = assets[0];
+  const last = Math.max(0, only.bandCount - 1);
+  return {
+    composite: {
+      r: { assetKey: only.key, bandIndex: 0 },
+      g: { assetKey: only.key, bandIndex: Math.min(1, last) },
+      b: { assetKey: only.key, bandIndex: Math.min(2, last) }
+    },
+    source: "fallback"
+  };
+}
+function hasRgbInEoCommon(eo) {
+  return eo.includes("red") && eo.includes("green") && eo.includes("blue");
+}
+function indexOfCommon(eo, name, fallback) {
+  const i = eo.indexOf(name);
+  return i >= 0 ? i : fallback;
+}
+function isSingleAssetComposite(c) {
+  return c.r.assetKey === c.g.assetKey && c.g.assetKey === c.b.assetKey;
+}
+function allChannelsBand0(c) {
+  return c.r.bandIndex === 0 && c.g.bandIndex === 0 && c.b.bandIndex === 0;
+}
+
+// src/cog-info.ts
 var SF_LABELS = {
   1: "uint",
   2: "int",
@@ -1482,7 +2067,7 @@ function buildDataTypeLabel(sampleFormat, bitsPerSample) {
   return `${SF_LABELS[sampleFormat] ?? `sf${sampleFormat}`}${bitsPerSample ?? ""}`;
 }
 
-// ../../src/lib/utils/column-types.ts
+// src/column-types.ts
 var NUMBER_TYPES = [
   "TINYINT",
   "SMALLINT",
@@ -1536,7 +2121,9 @@ var BINARY_TYPES = ["BLOB", "BYTEA", "BINARY", "VARBINARY"];
 var JSON_TYPES = ["JSON", "JSONB"];
 function classifyType(duckdbType) {
   const upper = duckdbType.toUpperCase().trim();
-  const base = upper.replace(/\(.*\)/, "").trim();
+  const openIdx = upper.indexOf("(");
+  const closeIdx = upper.lastIndexOf(")");
+  const base = (openIdx >= 0 && closeIdx > openIdx ? upper.slice(0, openIdx) + upper.slice(closeIdx + 1) : upper).trim();
   if (NUMBER_TYPES.includes(base)) return "number";
   if (STRING_TYPES.includes(base)) return "string";
   if (DATE_TYPES.includes(base)) return "date";
@@ -1598,13 +2185,96 @@ function typeLabel(category) {
   return TYPE_LABELS[category];
 }
 
-// ../../src/lib/utils/error.ts
+// src/connection-identity.ts
+var DEFAULT_PORTS = {
+  "https:": "443",
+  "http:": "80"
+};
+var SLASH = 47;
+function stripTrailingSlashes(s) {
+  let end = s.length;
+  while (end > 0 && s.charCodeAt(end - 1) === SLASH) end--;
+  return s.slice(0, end);
+}
+function stripEdgeSlashes(s) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && s.charCodeAt(start) === SLASH) start++;
+  while (end > start && s.charCodeAt(end - 1) === SLASH) end--;
+  return s.slice(start, end);
+}
+function normalizeEndpoint(raw) {
+  if (!raw) return "";
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  try {
+    const url = new URL(trimmed);
+    const scheme = url.protocol.toLowerCase();
+    const host = url.hostname.toLowerCase();
+    const defaultPort = DEFAULT_PORTS[scheme] ?? "";
+    const port = url.port && url.port !== defaultPort ? `:${url.port}` : "";
+    const path = stripTrailingSlashes(url.pathname);
+    return `${scheme}//${host}${port}${path}`;
+  } catch {
+    return stripTrailingSlashes(trimmed.toLowerCase());
+  }
+}
+function normalizeProvider(provider) {
+  if (!provider) return "s3";
+  const p = provider.trim().toLowerCase();
+  if (!p || p === "unknown") return "s3";
+  return p;
+}
+function normalizeBucket(bucket) {
+  return stripEdgeSlashes((bucket ?? "").trim());
+}
+function normalizeRegion(region) {
+  return (region ?? "").trim().toLowerCase();
+}
+function connectionIdentityKey(input) {
+  const provider = normalizeProvider(input.provider);
+  const bucket = normalizeBucket(input.bucket);
+  if (!bucket) return "";
+  const endpoint = normalizeEndpoint(input.endpoint);
+  const region = normalizeRegion(input.region);
+  if (provider === "azure") return `azure|${endpoint}|${bucket}`;
+  if (provider === "gcs") return `gcs|${bucket}`;
+  if (provider === "s3" && !endpoint) return `s3|${bucket}|${region}`;
+  return `${provider}|${endpoint}|${bucket}`;
+}
+function isSameConnectionIdentity(a, b) {
+  const key = connectionIdentityKey(a);
+  return key !== "" && key === connectionIdentityKey(b);
+}
+
+// src/crs.ts
+var WGS84_STRINGS = /* @__PURE__ */ new Set(["epsg:4326", "epsg:4979", DEFAULT_TARGET_CRS.toLowerCase()]);
+function isWgs84(crs) {
+  if (crs === null || crs === void 0) return false;
+  if (typeof crs === "number") return Number.isFinite(crs) && WGS84_CODES.has(crs);
+  const s = crs.trim().toLowerCase();
+  if (s.length === 0) return false;
+  if (WGS84_STRINGS.has(s)) return true;
+  const m = s.match(/(?:epsg:)?(\d+)/);
+  return m ? WGS84_CODES.has(Number(m[1])) : false;
+}
+
+// src/error.ts
+function isAbortError(err) {
+  if (!err) return false;
+  if (err instanceof DOMException && err.name === "AbortError") return true;
+  const e = err;
+  if (e.name === "AbortError") return true;
+  if (typeof e.message === "string" && /\baborted?\b/i.test(e.message)) return true;
+  if (e.cause && isAbortError(e.cause)) return true;
+  return false;
+}
 function handleLoadError(err) {
-  if (err instanceof DOMException && err.name === "AbortError") return null;
+  if (isAbortError(err)) return null;
   return err instanceof Error ? err.message : String(err);
 }
 
-// ../../src/lib/utils/format.ts
+// src/format.ts
 function formatFileSize(bytes) {
   if (bytes < 0) return "0 B";
   if (bytes === 0) return "0 B";
@@ -1650,7 +2320,7 @@ function formatValue(value) {
   return String(value);
 }
 
-// ../../src/lib/utils/export.ts
+// src/export.ts
 function triggerDownload(content, filename, mimeType) {
   const blob = new Blob([content], { type: mimeType });
   const url = URL.createObjectURL(blob);
@@ -1711,7 +2381,7 @@ function exportToJson(columns, rows, filename) {
   );
 }
 
-// ../../src/lib/utils/file-sort.ts
+// src/file-sort.ts
 function sortFileEntries(entries, config) {
   const sorted = [...entries];
   const dir = config.direction === "asc" ? 1 : -1;
@@ -2316,7 +2986,49 @@ function buildGeoArrowTables(wkbArrays, attributes, knownGeomType) {
   return results;
 }
 
-// ../../src/lib/utils/hex.ts
+// src/geometry-type.ts
+var GEOMETRY_PREFIX = /^GEOMETRY(?:\s*\(([^)]*)\))?/i;
+function stripCrsQuotes(inner) {
+  let crs = inner.trim();
+  if (crs.length >= 2 && crs.startsWith("'") && crs.endsWith("'")) {
+    crs = crs.slice(1, -1).trim();
+  }
+  return crs || null;
+}
+function parseGeometryTypeCrs(typeStr) {
+  if (!typeStr) return { isGeometry: false, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
+  const match = typeStr.match(GEOMETRY_PREFIX);
+  if (!match) return { isGeometry: false, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
+  const rawCrs = match[1] != null ? stripCrsQuotes(match[1]) : null;
+  if (!rawCrs) return { isGeometry: true, hasCrs: false, rawCrs: null, nonWgs84Crs: null };
+  return {
+    isGeometry: true,
+    hasCrs: true,
+    rawCrs,
+    nonWgs84Crs: isWgs84Crs(rawCrs) ? null : rawCrs
+  };
+}
+function isWgs84Crs(crs) {
+  if (!crs) return true;
+  const trimmed = crs.trim();
+  if (trimmed === "OGC:CRS84" || trimmed === "OGC:CRS83") return true;
+  const epsgMatch = trimmed.match(/^EPSG:(\d+)$/i);
+  if (epsgMatch && WGS84_CODES.has(Number(epsgMatch[1]))) return true;
+  return false;
+}
+function buildTransformExpr(innerExpr, sourceType, sourceCrs, targetCrs) {
+  const info = parseGeometryTypeCrs(sourceType);
+  if (info.hasCrs) {
+    return `ST_Transform(${innerExpr}, '${targetCrs}')`;
+  }
+  return `ST_Transform(${innerExpr}, '${sourceCrs}', '${targetCrs}')`;
+}
+function wrapWkbWithCrs(wkbExpr, sourceCrs) {
+  if (!sourceCrs) return `ST_GeomFromWKB(${wkbExpr})`;
+  return `ST_SetCRS(ST_GeomFromWKB(${wkbExpr}), '${sourceCrs}')`;
+}
+
+// src/hex.ts
 function generateHexDump(data, bytesPerRow = 16) {
   const rows = [];
   for (let i = 0; i < data.length; i += bytesPerRow) {
@@ -2340,458 +3052,233 @@ function generateHexDump(data, bytesPerRow = 16) {
   return rows;
 }
 
-// ../../src/lib/utils/local-storage.ts
-function loadFromStorage(key, defaultValue) {
-  if (typeof window === "undefined") return defaultValue;
-  try {
-    const raw = localStorage.getItem(key);
-    if (raw) return JSON.parse(raw);
-  } catch {
-  }
-  return defaultValue;
+// src/stac-storage-extension.ts
+function emptyStorageHints() {
+  return { platform: null, region: null, requesterPays: false, endpoint: null };
 }
-function persistToStorage(key, value) {
-  if (typeof window === "undefined") return;
-  try {
-    localStorage.setItem(key, JSON.stringify(value));
-  } catch {
+function detectStorageExtensionVersion(item) {
+  const exts = item.stac_extensions;
+  if (!Array.isArray(exts)) return null;
+  for (const raw of exts) {
+    if (typeof raw !== "string") continue;
+    if (!raw.includes("stac-extensions.github.io/storage")) continue;
+    const trimmed = raw.endsWith("/schema.json") ? raw.slice(0, -"/schema.json".length) : raw;
+    const last = trimmed.slice(trimmed.lastIndexOf("/") + 1);
+    const version = last.startsWith("v") ? last.slice(1) : last;
+    if (version === "1.0.0" || version === "2.0.0") return version;
+    const major = version.split(".")[0];
+    if (major === "1") return "1.0.0";
+    if (major === "2") return "2.0.0";
   }
+  return null;
 }
-
-// ../../src/lib/utils/markdown-sql.ts
-async function parseMarkdownDocument(markdown) {
-  let frontmatter = {};
-  let content = markdown;
-  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---\n/);
-  if (fmMatch) {
-    try {
-      const { default: YAML } = await import('yaml');
-      frontmatter = YAML.parse(fmMatch[1]) || {};
-    } catch {
+function extractStorageHints(item, assetKey) {
+  const version = detectStorageExtensionVersion(item);
+  if (version === "1.0.0") return extractV1Hints(item, assetKey);
+  if (version === "2.0.0") return extractV2Hints(item, assetKey);
+  return emptyStorageHints();
+}
+function extractV1Hints(item, assetKey) {
+  const props = item.properties ?? {};
+  const asset = assetKey && item.assets && item.assets[assetKey] ? item.assets[assetKey] : null;
+  const platformRaw = pickFirstString([asset?.["storage:platform"], props["storage:platform"]]);
+  const region = pickFirstString([asset?.["storage:region"], props["storage:region"]]);
+  const requesterPays = pickFirstBoolean([
+    asset?.["storage:requester_pays"],
+    props["storage:requester_pays"]
+  ]);
+  return {
+    platform: platformRaw ? platformRaw.toUpperCase() : null,
+    region: region ?? null,
+    requesterPays: requesterPays === true,
+    endpoint: null
+  };
+}
+function extractV2Hints(item, assetKey) {
+  const props = item.properties ?? {};
+  const schemes = props["storage:schemes"] ?? {};
+  if (!schemes || typeof schemes !== "object") return emptyStorageHints();
+  const refs = collectAssetRefs(item, assetKey);
+  const scheme = pickFirstScheme(schemes, refs);
+  if (!scheme) return emptyStorageHints();
+  const storeType = typeof scheme.type === "string" ? scheme.type : "";
+  const platform = typeof scheme.platform === "string" ? scheme.platform : null;
+  const region = typeof scheme.region === "string" ? scheme.region : null;
+  const requesterPays = scheme.requester_pays === true;
+  let endpoint = null;
+  if (storeType === "custom-s3") {
+    if (typeof scheme.endpoint === "string" && scheme.endpoint && !scheme.endpoint.includes("{")) {
+      endpoint = scheme.endpoint;
+    } else if (platform && !platform.includes("{")) {
+      endpoint = platform;
     }
-    content = markdown.slice(fmMatch[0].length);
   }
-  const sqlBlocks = [];
-  const lines = content.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    const match = line.match(/^```sql\s+(\w[\w-]*)\s*$/);
-    if (match) {
-      const name = match[1];
-      const startLine = i;
-      const sqlLines = [];
-      i++;
-      while (i < lines.length && lines[i] !== "```") {
-        sqlLines.push(lines[i]);
-        i++;
-      }
-      sqlBlocks.push({
-        name,
-        sql: sqlLines.join("\n"),
-        startLine,
-        endLine: i
-      });
-    }
-    i++;
+  return {
+    platform: platform ? platform.toUpperCase() : null,
+    region,
+    requesterPays,
+    endpoint
+  };
+}
+function collectAssetRefs(item, assetKey) {
+  const assets = item.assets ?? {};
+  if (assetKey) {
+    const a = assets[assetKey];
+    const refs = a?.["storage:refs"];
+    if (Array.isArray(refs)) return refs.filter((r) => typeof r === "string");
+    return [];
   }
-  return { frontmatter, content, sqlBlocks };
+  const out = [];
+  for (const a of Object.values(assets)) {
+    if (!a || typeof a !== "object") continue;
+    const refs = a["storage:refs"];
+    if (!Array.isArray(refs)) continue;
+    for (const r of refs) if (typeof r === "string") out.push(r);
+  }
+  return out;
 }
-function interpolateTemplates(text, queryResults) {
-  return text.replace(/\{(\w+)\.rows\[(\d+)\]\.(\w+)\}/g, (match, queryName, rowIdx, colName) => {
-    const rows = queryResults.get(queryName);
-    if (!rows) return match;
-    const row = rows[parseInt(rowIdx, 10)];
-    if (!row) return match;
-    const value = row[colName];
-    return value !== void 0 ? String(value) : match;
-  });
+function pickFirstScheme(schemes, refs) {
+  for (const r of refs) {
+    const s = schemes[r];
+    if (s && typeof s === "object") return s;
+  }
+  return null;
 }
-function markSqlBlocks(content) {
-  return content.replace(
-    /```sql\s+(\w[\w-]*)\s*\n([\s\S]*?)```/g,
-    (_, name) => `<div data-sql-block="${name}"></div>`
-  );
+function pickFirstString(candidates) {
+  for (const c of candidates) {
+    if (typeof c === "string" && c.length > 0) return c;
+  }
+  return null;
+}
+function pickFirstBoolean(candidates) {
+  for (const c of candidates) {
+    if (typeof c === "boolean") return c;
+  }
+  return null;
+}
+function applyStorageHintsToConnection(conn, hints) {
+  const out = { ...conn };
+  if (hints.region && !out.region) {
+    out.region = hints.region;
+  }
+  if (hints.endpoint && !out.endpoint) {
+    out.endpoint = hints.endpoint;
+  }
+  return out;
 }
 
-// ../../src/lib/utils/parquet-metadata.ts
-function mapParquetType(col) {
-  const lt = col.logical_type;
-  if (lt) {
-    if (lt.type === "GEOMETRY" || lt.type === "GEOGRAPHY") return "GEOMETRY";
-    if (lt.type === "STRING" || lt.type === "UTF8") return "VARCHAR";
-    if (lt.type === "JSON") return "JSON";
-    if (lt.type === "UUID") return "UUID";
-    if (lt.type === "ENUM") return "VARCHAR";
-    if (lt.type === "INT" || lt.type === "INTEGER") {
-      const bits = lt.bitWidth ?? 32;
-      const signed = lt.isSigned !== false;
-      if (bits <= 8) return signed ? "TINYINT" : "UTINYINT";
-      if (bits <= 16) return signed ? "SMALLINT" : "USMALLINT";
-      if (bits <= 32) return signed ? "INTEGER" : "UINTEGER";
-      return signed ? "BIGINT" : "UBIGINT";
+// src/storage-url.ts
+function buildSchemeMap() {
+  const map = {};
+  for (const [id, def] of Object.entries(PROVIDERS)) {
+    for (const scheme of def.schemes) {
+      const key = `${scheme}://`;
+      map[key] = { provider: id, strip: key.length };
     }
-    if (lt.type === "DECIMAL") return `DECIMAL(${lt.precision ?? 18},${lt.scale ?? 0})`;
-    if (lt.type === "DATE") return "DATE";
-    if (lt.type === "TIME") return "TIME";
-    if (lt.type === "TIMESTAMP") return "TIMESTAMP";
-    if (lt.type === "BSON") return "BLOB";
-  }
-  const ct = col.converted_type;
-  if (ct === "UTF8") return "VARCHAR";
-  if (ct === "JSON") return "JSON";
-  if (ct === "DATE") return "DATE";
-  if (ct === "TIMESTAMP_MILLIS" || ct === "TIMESTAMP_MICROS") return "TIMESTAMP";
-  if (ct === "DECIMAL") return `DECIMAL(${col.precision ?? 18},${col.scale ?? 0})`;
-  if (ct === "INT_8") return "TINYINT";
-  if (ct === "INT_16") return "SMALLINT";
-  if (ct === "INT_32") return "INTEGER";
-  if (ct === "INT_64") return "BIGINT";
-  if (ct === "UINT_8") return "UTINYINT";
-  if (ct === "UINT_16") return "USMALLINT";
-  if (ct === "UINT_32") return "UINTEGER";
-  if (ct === "UINT_64") return "UBIGINT";
-  const pt = col.type;
-  if (pt === "BOOLEAN") return "BOOLEAN";
-  if (pt === "INT32") return "INTEGER";
-  if (pt === "INT64") return "BIGINT";
-  if (pt === "INT96") return "TIMESTAMP";
-  if (pt === "FLOAT") return "FLOAT";
-  if (pt === "DOUBLE") return "DOUBLE";
-  if (pt === "BYTE_ARRAY") return "BLOB";
-  if (pt === "FIXED_LEN_BYTE_ARRAY") return "BLOB";
-  return "VARCHAR";
-}
-async function readParquetMetadata(url) {
-  const { parquetMetadataAsync, asyncBufferFromUrl } = await import('hyparquet');
-  const file = await asyncBufferFromUrl({ url });
-  const metadata = await parquetMetadataAsync(file);
-  const rowCount = metadata.row_groups.reduce(
-    (sum, rg) => sum + Number(rg.num_rows),
-    0
-  );
-  const schema = metadata.schema.slice(1).filter((col) => col.num_children === void 0).map((col) => ({
-    name: col.name,
-    type: mapParquetType(col)
-  }));
-  const topLevelColumns = [];
-  const root = metadata.schema[0];
-  const rootChildren = root?.num_children ?? 0;
-  let cursor = 1;
-  for (let i = 0; i < rootChildren && cursor < metadata.schema.length; i++) {
-    const el = metadata.schema[cursor];
-    if (el?.name) topLevelColumns.push(el.name);
-    cursor += countSubtree(metadata.schema, cursor);
-  }
-  let geo = null;
-  let legacyGeoParquet = false;
-  const geoKv = metadata.key_value_metadata?.find((kv) => kv.key === "geo");
-  if (geoKv) {
-    try {
-      const geoJson = JSON.parse(geoKv.value ?? "");
-      if (geoJson.schema_version && !geoJson.version) {
-        legacyGeoParquet = true;
-      }
-      geo = {
-        primaryColumn: geoJson.primary_column ?? "geometry",
-        columns: {}
-      };
-      if (geoJson.columns) {
-        for (const [colName, colMeta] of Object.entries(geoJson.columns)) {
-          geo.columns[colName] = {
-            encoding: colMeta.encoding ?? "WKB",
-            geometryTypes: colMeta.geometry_types ?? [],
-            crs: colMeta.crs ?? null,
-            bbox: colMeta.bbox
-          };
-        }
-      }
-    } catch {
-    }
-  }
-  const createdBy = metadata.created_by ?? null;
-  const numRowGroups = metadata.row_groups.length;
-  let compression = null;
-  if (numRowGroups > 0 && metadata.row_groups[0].columns) {
-    const codecs = /* @__PURE__ */ new Set();
-    for (const col of metadata.row_groups[0].columns) {
-      const codec = col.meta_data?.codec;
-      if (codec) codecs.add(codec);
-    }
-    if (codecs.size === 1) {
-      compression = [...codecs][0];
-    } else if (codecs.size > 1) {
-      compression = [...codecs].join(", ");
-    }
-  }
-  return {
-    rowCount,
-    schema,
-    topLevelColumns,
-    geo,
-    legacyGeoParquet,
-    createdBy,
-    numRowGroups,
-    compression
-  };
-}
-function countSubtree(schema, start) {
-  const el = schema[start];
-  if (!el) return 0;
-  const n = el.num_children ?? 0;
-  let cursor = start + 1;
-  for (let i = 0; i < n; i++) {
-    cursor += countSubtree(schema, cursor);
   }
-  return cursor - start;
+  map["swift://"] = { provider: "unknown", strip: 8 };
+  return map;
 }
-function extractEpsgFromGeoMeta(geo) {
-  const primaryCol = geo.columns[geo.primaryColumn];
-  if (!primaryCol?.crs) return null;
-  const crs = primaryCol.crs;
-  if (crs.type === "name" && crs.properties?.name?.includes("CRS84")) return null;
-  if (crs.id?.authority === "EPSG") {
-    const code = crs.id.code;
-    if (WGS84_CODES.has(code)) return null;
-    return `EPSG:${code}`;
-  }
-  return null;
+var SCHEME_MAP = buildSchemeMap();
+var SLASH2 = 47;
+function stripTrailingSlashes2(s) {
+  let end = s.length;
+  while (end > 0 && s.charCodeAt(end - 1) === SLASH2) end--;
+  return s.slice(0, end);
 }
-function extractGeometryTypes(geo) {
-  const primaryCol = geo.columns[geo.primaryColumn];
-  if (!primaryCol?.geometryTypes?.length) return [];
-  const typeMap = {
-    Point: "point",
-    LineString: "linestring",
-    Polygon: "polygon",
-    MultiPoint: "multipoint",
-    MultiLineString: "multilinestring",
-    MultiPolygon: "multipolygon"
-  };
-  const types = [];
-  for (const raw of primaryCol.geometryTypes) {
-    const base = raw.split(" ")[0];
-    const mapped = typeMap[base];
-    if (mapped && !types.includes(mapped)) types.push(mapped);
-  }
-  return types;
+function stripEdgeSlashes2(s) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && s.charCodeAt(start) === SLASH2) start++;
+  while (end > start && s.charCodeAt(end - 1) === SLASH2) end--;
+  return s.slice(start, end);
 }
-function extractBounds(geo) {
-  const primaryCol = geo.columns[geo.primaryColumn];
-  if (!primaryCol?.bbox || primaryCol.bbox.length < 4) return null;
-  return [primaryCol.bbox[0], primaryCol.bbox[1], primaryCol.bbox[2], primaryCol.bbox[3]];
+var AWS_VHOST_RE = /^(.+)\.s3[.-]([a-z0-9-]+)\.amazonaws\.com$/;
+var AWS_PATH_RE = /^s3[.-]([a-z0-9-]+)\.amazonaws\.com$/;
+var AWS_GLOBAL_HOST = "s3.amazonaws.com";
+var R2_RE = /^([a-z0-9]+)\.r2\.cloudflarestorage\.com$/;
+var GCS_GLOBAL_HOST = "storage.googleapis.com";
+var GCS_VHOST_RE = /^(.+)\.storage\.googleapis\.com$/;
+var DO_VHOST_RE = /^(.+)\.([a-z0-9-]+)\.digitaloceanspaces\.com$/;
+var DO_PATH_RE = /^([a-z0-9-]+)\.digitaloceanspaces\.com$/;
+var WASABI_RE = /^s3\.([a-z0-9-]+)\.wasabisys\.com$/;
+var B2_S3_RE = /^(.+)\.s3\.([a-z0-9-]+)\.backblazeb2\.com$/;
+var B2_NATIVE_RE = /^f[a-z0-9]+\.backblazeb2\.com$/;
+var OSS_RE = /^(.+)\.(oss-[a-z0-9-]+)\.aliyuncs\.com$/;
+var COS_RE = /^(.+)\.cos\.([a-z0-9-]+)\.myqcloud\.com$/;
+var YANDEX_HOST = "storage.yandexcloud.net";
+var CONTABO_RE = /^([a-z0-9]+)\.contabostorage\.com$/;
+var HETZNER_RE = /^([a-z0-9]+)\.your-objectstorage\.com$/;
+var LINODE_VHOST_RE = /^(.+)\.([a-z0-9-]+)\.linodeobjects\.com$/;
+var LINODE_PATH_RE = /^([a-z0-9-]+)\.linodeobjects\.com$/;
+var OVH_RE = /^s3\.([a-z0-9-]+)\.io\.cloud\.ovh\.(?:net|us)$/;
+var AZURE_BLOB_RE = /^([a-z0-9]+)\.blob\.core\.windows\.net$/;
+var STORJ_GATEWAY_RE = /^gateway\.(?:([a-z0-9]+)\.)?storjshare\.io$/;
+var STORJ_LINK_RE = /^link\.(?:([a-z0-9]+)\.)?storjshare\.io$/;
+function isMinioLikeHost(host) {
+  return host.includes("minio") || host === "localhost" || host === "127.0.0.1" || host.startsWith("192.168.") || host.startsWith("10.");
 }
-
-// ../../src/lib/utils/stac-geoparquet.ts
-var STAC_GEOPARQUET_REQUIRED_COLUMNS = [
-  "stac_version",
-  "type",
-  "geometry",
-  "assets"
-];
-function isStacGeoparquetSchema(schema) {
-  if (!Array.isArray(schema) || schema.length === 0) return false;
-  const names = new Set(schema.map((c) => c.name));
-  return STAC_GEOPARQUET_REQUIRED_COLUMNS.every((c) => names.has(c));
+var STAC_API_PATH_RE = /\/(collections|items|catalogs|search)(\/|\?|$)/i;
+function isKnownBucketHost(host) {
+  if (!host) return false;
+  if (AWS_VHOST_RE.test(host)) return true;
+  if (AWS_PATH_RE.test(host)) return true;
+  if (host === AWS_GLOBAL_HOST) return true;
+  if (R2_RE.test(host)) return true;
+  if (host === GCS_GLOBAL_HOST) return true;
+  if (GCS_VHOST_RE.test(host)) return true;
+  if (DO_VHOST_RE.test(host)) return true;
+  if (DO_PATH_RE.test(host)) return true;
+  if (WASABI_RE.test(host)) return true;
+  if (B2_S3_RE.test(host)) return true;
+  if (B2_NATIVE_RE.test(host)) return true;
+  if (OSS_RE.test(host)) return true;
+  if (COS_RE.test(host)) return true;
+  if (host === YANDEX_HOST) return true;
+  if (CONTABO_RE.test(host)) return true;
+  if (HETZNER_RE.test(host)) return true;
+  if (LINODE_VHOST_RE.test(host)) return true;
+  if (LINODE_PATH_RE.test(host)) return true;
+  if (OVH_RE.test(host)) return true;
+  if (AZURE_BLOB_RE.test(host)) return true;
+  if (STORJ_GATEWAY_RE.test(host)) return true;
+  if (STORJ_LINK_RE.test(host)) return true;
+  if (isMinioLikeHost(host)) return true;
+  return false;
 }
-function flattenStacBbox(bbox) {
-  if (!bbox) return null;
-  if (Array.isArray(bbox)) {
-    if (bbox.length < 4) return null;
-    const [minX, minY, maxX, maxY] = bbox;
-    if (![minX, minY, maxX, maxY].every((v) => Number.isFinite(v))) return null;
-    return [minX, minY, maxX, maxY];
-  }
-  if (typeof bbox === "object") {
-    const { xmin, ymin, xmax, ymax } = bbox;
-    if (![xmin, ymin, xmax, ymax].every((v) => Number.isFinite(v))) return null;
-    return [xmin, ymin, xmax, ymax];
-  }
-  return null;
+function defaultResult(defaults) {
+  return {
+    bucket: "",
+    region: defaults.region || DEFAULT_AWS_REGION,
+    endpoint: defaults.endpoint || "",
+    provider: defaults.provider || "s3",
+    prefix: ""
+  };
 }
-function resolveStacAssetHref(href, baseUrl) {
-  if (!href) return href;
-  if (/^[a-z][a-z0-9+\-.]*:\/\//i.test(href)) return href;
-  try {
-    return new URL(href, baseUrl).toString();
-  } catch {
-    return href;
+function splitBucketPrefix(rest) {
+  const slashIdx = rest.indexOf("/");
+  if (slashIdx >= 0) {
+    return {
+      bucket: rest.slice(0, slashIdx),
+      prefix: stripTrailingSlashes2(rest.slice(slashIdx + 1))
+    };
   }
+  return { bucket: rest, prefix: "" };
 }
-function pickStacPrimaryAsset(assets, preferredKeys) {
-  if (!assets || typeof assets !== "object") return null;
-  const entries = Object.entries(assets).filter(
-    ([, a]) => a && typeof a === "object" && typeof a.href === "string"
-  );
-  if (entries.length === 0) return null;
-  if (preferredKeys) {
-    for (const key of preferredKeys) {
-      const match = entries.find(([k]) => k === key);
-      if (match) return { key: match[0], asset: match[1] };
-    }
-  }
-  const data = entries.find(([k]) => k === "data");
-  if (data) return { key: data[0], asset: data[1] };
-  const byRole = entries.find(([, a]) => Array.isArray(a.roles) && a.roles.includes("data"));
-  if (byRole) return { key: byRole[0], asset: byRole[1] };
-  return { key: entries[0][0], asset: entries[0][1] };
-}
-function normalizeAssetsField(value, baseUrl) {
-  if (!value || typeof value !== "object") return void 0;
-  const out = {};
-  for (const [key, raw] of Object.entries(value)) {
-    if (!raw || typeof raw !== "object") continue;
-    const asset = raw;
-    if (typeof asset.href !== "string" || !asset.href) continue;
-    out[key] = {
-      ...asset,
-      href: resolveStacAssetHref(asset.href, baseUrl)
-    };
-  }
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-function normalizeLinksField(value, baseUrl) {
-  if (!Array.isArray(value)) return void 0;
-  const links = [];
-  for (const raw of value) {
-    if (!raw || typeof raw !== "object") continue;
-    const link = raw;
-    if (typeof link.href !== "string" || typeof link.rel !== "string") continue;
-    links.push({ ...link, href: resolveStacAssetHref(link.href, baseUrl) });
-  }
-  return links.length > 0 ? links : void 0;
-}
-function stacRowToItem(row, baseUrl, opts = {}) {
-  const { wkbParser, wkbColumn = "geom_wkb", geometryColumn = "geometry" } = opts;
-  let geometry = row[geometryColumn];
-  if (!geometry) {
-    const wkb = row[wkbColumn];
-    if (wkb && wkbParser) {
-      const bytes = wkb instanceof Uint8Array ? wkb : toUint8Array(wkb);
-      if (bytes) {
-        try {
-          geometry = wkbParser(bytes) ?? void 0;
-        } catch {
-          geometry = void 0;
-        }
-      }
-    }
-  }
-  const bbox = flattenStacBbox(row.bbox) ?? void 0;
-  const assets = normalizeAssetsField(row.assets, baseUrl);
-  const links = normalizeLinksField(row.links, baseUrl);
-  const properties = {};
-  for (const [key, value] of Object.entries(row)) {
-    if (value === null || value === void 0) continue;
-    if (key.startsWith("proj:") || key.startsWith("raster:") || key.startsWith("eo:")) {
-      properties[key] = value;
-    }
-    if (key === "datetime") {
-      properties.datetime = value instanceof Date ? value.toISOString() : String(value);
-    }
-    if (key === "bands") {
-      properties.bands = value;
-    }
-  }
-  const item = {
-    type: "Feature",
-    stac_version: typeof row.stac_version === "string" ? row.stac_version : "1.0.0",
-    id: typeof row.id === "string" ? row.id : String(row.id ?? ""),
-    properties
-  };
-  if (typeof row.collection === "string") item.collection = row.collection;
-  if (Array.isArray(row.stac_extensions)) {
-    item.stac_extensions = row.stac_extensions;
-  }
-  if (bbox) item.bbox = bbox;
-  if (geometry) item.geometry = geometry;
-  if (assets) item.assets = assets;
-  if (links) item.links = links;
-  return item;
-}
-function toUint8Array(value) {
-  if (value instanceof Uint8Array) return value;
-  if (value instanceof ArrayBuffer) return new Uint8Array(value);
-  if (ArrayBuffer.isView(value)) {
-    const view = value;
-    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
-  }
-  if (Array.isArray(value)) return new Uint8Array(value);
-  return null;
-}
-
-// ../../src/lib/utils/storage-url.ts
-function buildSchemeMap() {
-  const map = {};
-  for (const [id, def] of Object.entries(PROVIDERS)) {
-    for (const scheme of def.schemes) {
-      const key = `${scheme}://`;
-      map[key] = { provider: id, strip: key.length };
-    }
-  }
-  map["swift://"] = { provider: "unknown", strip: 8 };
-  return map;
-}
-var SCHEME_MAP = buildSchemeMap();
-var AWS_VHOST_RE = /^(.+)\.s3[.-]([a-z0-9-]+)\.amazonaws\.com$/;
-var AWS_PATH_RE = /^s3[.-]([a-z0-9-]+)\.amazonaws\.com$/;
-var AWS_GLOBAL_HOST = "s3.amazonaws.com";
-var R2_RE = /^([a-z0-9]+)\.r2\.cloudflarestorage\.com$/;
-var GCS_GLOBAL_HOST = "storage.googleapis.com";
-var GCS_VHOST_RE = /^(.+)\.storage\.googleapis\.com$/;
-var DO_VHOST_RE = /^(.+)\.([a-z0-9-]+)\.digitaloceanspaces\.com$/;
-var DO_PATH_RE = /^([a-z0-9-]+)\.digitaloceanspaces\.com$/;
-var WASABI_RE = /^s3\.([a-z0-9-]+)\.wasabisys\.com$/;
-var B2_S3_RE = /^(.+)\.s3\.([a-z0-9-]+)\.backblazeb2\.com$/;
-var B2_NATIVE_RE = /^f[a-z0-9]+\.backblazeb2\.com$/;
-var OSS_RE = /^(.+)\.(oss-[a-z0-9-]+)\.aliyuncs\.com$/;
-var COS_RE = /^(.+)\.cos\.([a-z0-9-]+)\.myqcloud\.com$/;
-var YANDEX_HOST = "storage.yandexcloud.net";
-var CONTABO_RE = /^([a-z0-9]+)\.contabostorage\.com$/;
-var HETZNER_RE = /^([a-z0-9]+)\.your-objectstorage\.com$/;
-var LINODE_VHOST_RE = /^(.+)\.([a-z0-9-]+)\.linodeobjects\.com$/;
-var LINODE_PATH_RE = /^([a-z0-9-]+)\.linodeobjects\.com$/;
-var OVH_RE = /^s3\.([a-z0-9-]+)\.io\.cloud\.ovh\.(?:net|us)$/;
-var AZURE_BLOB_RE = /^([a-z0-9]+)\.blob\.core\.windows\.net$/;
-var STORJ_GATEWAY_RE = /^gateway\.(?:([a-z0-9]+)\.)?storjshare\.io$/;
-var STORJ_LINK_RE = /^link\.(?:([a-z0-9]+)\.)?storjshare\.io$/;
-function isMinioLikeHost(host) {
-  return host.includes("minio") || host === "localhost" || host === "127.0.0.1" || host.startsWith("192.168.") || host.startsWith("10.");
-}
-var STAC_API_PATH_RE = /\/(collections|items|catalogs|search)(\/|\?|$)/i;
-function defaultResult(defaults) {
-  return {
-    bucket: "",
-    region: defaults.region || "us-east-1",
-    endpoint: defaults.endpoint || "",
-    provider: defaults.provider || "s3",
-    prefix: ""
-  };
-}
-function splitBucketPrefix(rest) {
-  const slashIdx = rest.indexOf("/");
-  if (slashIdx >= 0) {
-    return {
-      bucket: rest.slice(0, slashIdx),
-      prefix: rest.slice(slashIdx + 1).replace(/\/+$/, "")
-    };
-  }
-  return { bucket: rest, prefix: "" };
-}
-function parseStorageUrl(input, defaults = {}) {
-  const trimmed = input.trim();
-  const lower = trimmed.toLowerCase();
-  for (const [scheme, { provider, strip }] of Object.entries(SCHEME_MAP)) {
-    if (lower.startsWith(scheme)) {
-      const rest = trimmed.slice(strip);
-      const { bucket, prefix } = splitBucketPrefix(rest);
-      return {
-        bucket,
-        region: defaults.region || "us-east-1",
-        endpoint: defaults.endpoint || "",
-        provider,
-        prefix
-      };
+function parseStorageUrl(input, defaults = {}) {
+  const trimmed = input.trim();
+  const lower = trimmed.toLowerCase();
+  for (const [scheme, { provider, strip }] of Object.entries(SCHEME_MAP)) {
+    if (lower.startsWith(scheme)) {
+      const rest = trimmed.slice(strip);
+      const { bucket, prefix } = splitBucketPrefix(rest);
+      return {
+        bucket,
+        region: defaults.region || DEFAULT_AWS_REGION,
+        endpoint: defaults.endpoint || "",
+        provider,
+        prefix
+      };
     }
   }
   if (lower.startsWith("http://") || lower.startsWith("https://")) {
@@ -2822,7 +3309,7 @@ function parseStorageUrl(input, defaults = {}) {
       if (host === AWS_GLOBAL_HOST && pathParts.length > 0) {
         return {
           bucket: pathParts[0],
-          region: defaults.region || "us-east-1",
+          region: defaults.region || DEFAULT_AWS_REGION,
           endpoint: "",
           provider: "s3",
           prefix: pathParts.slice(1).join("/")
@@ -2986,96 +3473,2063 @@ function parseStorageUrl(input, defaults = {}) {
           prefix: pathParts.slice(1).join("/")
         };
       }
-      if (isMinioLikeHost(host) && pathParts.length > 0) {
-        return {
-          bucket: pathParts[0],
-          region: defaults.region || "us-east-1",
-          endpoint: `${url.protocol}//${url.host}`,
-          provider: "minio",
-          prefix: pathParts.slice(1).join("/")
-        };
+      if (isMinioLikeHost(host) && pathParts.length > 0) {
+        return {
+          bucket: pathParts[0],
+          region: defaults.region || DEFAULT_AWS_REGION,
+          endpoint: `${url.protocol}//${url.host}`,
+          provider: "minio",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
+      const azureBlob = host.match(AZURE_BLOB_RE);
+      if (azureBlob && pathParts.length > 0) {
+        return {
+          bucket: pathParts[0],
+          region: defaults.region || "",
+          endpoint: `${url.protocol}//${url.host}`,
+          provider: "azure",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
+      const storjGateway = host.match(STORJ_GATEWAY_RE);
+      if (storjGateway && pathParts.length > 0) {
+        return {
+          bucket: pathParts[0],
+          region: storjGateway[1] || defaults.region || "us1",
+          endpoint: `${url.protocol}//${url.host}`,
+          provider: "storj",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
+      const storjLink = host.match(STORJ_LINK_RE);
+      if (storjLink && pathParts.length >= 3 && (pathParts[0] === "raw" || pathParts[0] === "s")) {
+        return {
+          bucket: pathParts[2],
+          region: storjLink[1] || defaults.region || "us1",
+          endpoint: `${url.protocol}//${url.host}/${pathParts[0]}/${pathParts[1]}`,
+          provider: "storj",
+          prefix: pathParts.slice(3).join("/")
+        };
+      }
+      if (STAC_API_PATH_RE.test(url.pathname)) {
+        return {
+          ...defaultResult(defaults),
+          endpoint: `${url.protocol}//${url.host}`
+        };
+      }
+      if (pathParts.length > 0) {
+        const endpoint = `${url.protocol}//${url.host}`;
+        return {
+          bucket: pathParts[0],
+          region: defaults.region || DEFAULT_AWS_REGION,
+          endpoint,
+          provider: defaults.provider || "s3",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
+      return {
+        ...defaultResult(defaults),
+        endpoint: `${url.protocol}//${url.host}`
+      };
+    } catch {
+    }
+  }
+  const cleaned = stripEdgeSlashes2(trimmed);
+  return {
+    bucket: cleaned,
+    region: defaults.region || DEFAULT_AWS_REGION,
+    endpoint: defaults.endpoint || "",
+    provider: defaults.provider || "s3",
+    prefix: ""
+  };
+}
+function looksLikeUrl(input) {
+  const lower = input.trim().toLowerCase();
+  if (lower.startsWith("http://") || lower.startsWith("https://")) return true;
+  for (const scheme of Object.keys(SCHEME_MAP)) {
+    if (lower.startsWith(scheme)) return true;
+  }
+  return false;
+}
+function describeParseResult(parsed) {
+  const parts = [];
+  if (parsed.bucket) parts.push(`bucket="${parsed.bucket}"`);
+  if (parsed.endpoint) parts.push(`endpoint="${parsed.endpoint}"`);
+  if (parsed.region && parsed.region !== DEFAULT_AWS_REGION)
+    parts.push(`region="${parsed.region}"`);
+  if (parsed.provider !== "s3") parts.push(`provider=${parsed.provider}`);
+  if (parsed.prefix) parts.push(`prefix="${parsed.prefix}"`);
+  return parts.length > 0 ? `Detected: ${parts.join(", ")}` : "";
+}
+function classifyUrl(input) {
+  const trimmed = input.trim();
+  const lower = trimmed.toLowerCase();
+  for (const scheme of Object.keys(SCHEME_MAP)) {
+    if (lower.startsWith(scheme)) {
+      return { kind: "scheme", parsed: parseStorageUrl(trimmed) };
+    }
+  }
+  if (lower.startsWith("http://") || lower.startsWith("https://")) {
+    let url;
+    try {
+      url = new URL(trimmed);
+    } catch {
+      return {
+        kind: "remote-file",
+        url: new URL(`https://${trimmed.replace(/^https?:\/\//i, "")}`)
+      };
+    }
+    const parsed = parseStorageUrl(trimmed);
+    if (parsed.bucket && isKnownBucketHost(url.hostname)) {
+      return { kind: "object-storage", parsed };
+    }
+    if (STAC_API_PATH_RE.test(url.pathname)) {
+      return { kind: "stac-api", url };
+    }
+    return { kind: "remote-file", url };
+  }
+  try {
+    return { kind: "remote-file", url: new URL(trimmed) };
+  } catch {
+    return { kind: "remote-file", url: new URL(`https://${trimmed}`) };
+  }
+}
+
+// src/host-detection.ts
+function extractRootPrefix(pathname) {
+  let clean = pathname.replace(/\/[^/]*\.[^/]*$/, "/");
+  clean = clean.replace(/^\//, "");
+  if (!clean || clean === "/") return "";
+  if (!clean.endsWith("/")) clean += "/";
+  return clean;
+}
+function buildBucketUrl(provider, endpoint, bucket, region) {
+  return buildProviderBaseUrl(
+    provider === "unknown" ? "s3" : provider,
+    endpoint,
+    bucket,
+    region || ""
+  );
+}
+function parsedToHost(parsed, host, rootPrefix) {
+  if (!parsed.bucket || !isKnownBucketHost(host)) return null;
+  const provider = parsed.provider === "unknown" ? "s3" : parsed.provider;
+  return {
+    provider,
+    bucket: parsed.bucket,
+    region: parsed.region,
+    endpoint: parsed.endpoint,
+    rootPrefix,
+    bucketUrl: buildBucketUrl(parsed.provider, parsed.endpoint, parsed.bucket, parsed.region)
+  };
+}
+function detectHostBucket() {
+  if (typeof window === "undefined") return null;
+  const url = new URL(window.location.href);
+  const urlParam = url.searchParams.get("url");
+  if (urlParam) {
+    try {
+      const paramUrl = new URL(urlParam);
+      const parsed2 = parseStorageUrl(urlParam);
+      const host = parsedToHost(parsed2, paramUrl.hostname, "");
+      if (host) return host;
+    } catch {
+    }
+  }
+  const parsed = parseStorageUrl(window.location.href);
+  if (!parsed.bucket || !isKnownBucketHost(url.hostname)) return null;
+  const prefixPath = parsed.prefix ? `/${parsed.prefix}` : "";
+  const rootPrefix = extractRootPrefix(prefixPath || "/");
+  const provider = parsed.provider === "unknown" ? "s3" : parsed.provider;
+  return {
+    provider,
+    bucket: parsed.bucket,
+    region: parsed.region,
+    endpoint: parsed.endpoint,
+    rootPrefix,
+    bucketUrl: buildBucketUrl(parsed.provider, parsed.endpoint, parsed.bucket, parsed.region)
+  };
+}
+function applyStacItemStorageHints(input, item) {
+  const hints = extractStorageHints(item);
+  const merged = applyStorageHintsToConnection(input, hints);
+  if (undefined?.DEV && (hints.region || hints.endpoint || hints.requesterPays)) {
+    console.debug("[host-detection] applied STAC storage hints", hints);
+  }
+  return merged;
+}
+
+// src/local-storage.ts
+function loadFromStorage(key, defaultValue) {
+  if (typeof window === "undefined") return defaultValue;
+  try {
+    const raw = localStorage.getItem(key);
+    if (raw) return JSON.parse(raw);
+  } catch {
+  }
+  return defaultValue;
+}
+function persistToStorage(key, value) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+
+// src/lru.ts
+var LruCache = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  onEvict;
+  constructor(opts) {
+    if (opts.max <= 0) throw new Error("LruCache: max must be > 0");
+    this.max = opts.max;
+    this.onEvict = opts.onEvict;
+  }
+  get size() {
+    return this.map.size;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    const v = this.map.get(key);
+    if (v === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, v);
+    return v;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    }
+    this.map.set(key, value);
+    while (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      const evicted = this.map.get(oldest);
+      this.map.delete(oldest);
+      this.onEvict?.(oldest, evicted);
+    }
+  }
+  delete(key) {
+    const v = this.map.get(key);
+    if (v === void 0) return false;
+    this.map.delete(key);
+    this.onEvict?.(key, v);
+    return true;
+  }
+  clear() {
+    if (this.onEvict) {
+      for (const [k, v] of this.map) this.onEvict(k, v);
+    }
+    this.map.clear();
+  }
+};
+
+// src/map-pixel-inspect.ts
+function attachPixelInspector(map, { probe, onStart, onResult }) {
+  let active = null;
+  let detached = false;
+  const handler = (event) => {
+    if (detached) return;
+    if (active) active.abort();
+    const ctrl = new AbortController();
+    active = ctrl;
+    onStart();
+    void (async () => {
+      let payload = null;
+      try {
+        payload = await probe({
+          lng: event.lngLat.lng,
+          lat: event.lngLat.lat,
+          signal: ctrl.signal
+        });
+      } catch (err) {
+        if (isHelperAbort(err, ctrl.signal)) return;
+        payload = null;
+      }
+      if (ctrl.signal.aborted && active === ctrl) {
+        return;
+      }
+      if (active === ctrl) active = null;
+      onResult(payload);
+    })();
+  };
+  map.on("click", handler);
+  return function detach() {
+    if (detached) return;
+    detached = true;
+    map.off("click", handler);
+    if (active) {
+      active.abort();
+      active = null;
+    }
+  };
+}
+function isHelperAbort(err, signal) {
+  if (!signal.aborted) return false;
+  if (err instanceof DOMException && err.name === "AbortError") return true;
+  if (err && typeof err === "object" && err.name === "AbortError") {
+    return true;
+  }
+  return false;
+}
+
+// src/markdown-sql.ts
+async function parseMarkdownDocument(markdown) {
+  let frontmatter = {};
+  let content = markdown;
+  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---\n/);
+  if (fmMatch) {
+    try {
+      const { default: YAML } = await import('yaml');
+      frontmatter = YAML.parse(fmMatch[1]) || {};
+    } catch {
+    }
+    content = markdown.slice(fmMatch[0].length);
+  }
+  const sqlBlocks = [];
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const match = line.match(/^```sql\s+(\w[\w-]*)\s*$/);
+    if (match) {
+      const name = match[1];
+      const startLine = i;
+      const sqlLines = [];
+      i++;
+      while (i < lines.length && lines[i] !== "```") {
+        sqlLines.push(lines[i]);
+        i++;
+      }
+      sqlBlocks.push({
+        name,
+        sql: sqlLines.join("\n"),
+        startLine,
+        endLine: i
+      });
+    }
+    i++;
+  }
+  return { frontmatter, content, sqlBlocks };
+}
+function interpolateTemplates(text, queryResults) {
+  return text.replace(/\{(\w+)\.rows\[(\d+)\]\.(\w+)\}/g, (match, queryName, rowIdx, colName) => {
+    const rows = queryResults.get(queryName);
+    if (!rows) return match;
+    const row = rows[parseInt(rowIdx, 10)];
+    if (!row) return match;
+    const value = row[colName];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+function markSqlBlocks(content) {
+  return content.replace(
+    /```sql[ \t]+(\w[\w-]*)[ \t]*\n([\s\S]*?)```/g,
+    (_, name) => `<div data-sql-block="${name}"></div>`
+  );
+}
+
+// src/markdown-sql-context.ts
+var MarkdownSqlContext = class {
+  engine;
+  connId;
+  prefix;
+  results = /* @__PURE__ */ new Map();
+  constructor(engine, connId, prefix = "") {
+    this.engine = engine;
+    this.connId = connId;
+    this.prefix = prefix;
+  }
+  /** Execute a SQL query and store the result under the given name. */
+  async executeSql(sql, queryName) {
+    const transformedSql = this.transformPaths(sql);
+    const result = await this.engine.query(this.connId, transformedSql);
+    const rows = result.rows ?? [];
+    this.results.set(queryName, { result, rows });
+    return rows;
+  }
+  /**
+   * Transform relative file paths in SQL to full S3 URLs.
+   * e.g. read_parquet('data.parquet') becomes read_parquet('s3://bucket/prefix/data.parquet').
+   */
+  transformPaths(sql) {
+    if (!this.connId || !this.prefix) return sql;
+    return sql.replace(/(read_(?:parquet|csv|json|csv_auto))\('([^']+)'\)/g, (match, fn, path) => {
+      if (path.startsWith("s3://") || path.startsWith("http") || path.startsWith("/")) {
+        return match;
+      }
+      const fullPath = `s3://${this.prefix}/${path}`;
+      return `${fn}('${fullPath}')`;
+    });
+  }
+  getResult(queryName) {
+    return this.results.get(queryName);
+  }
+  getAllResults() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [name, { rows }] of this.results) {
+      map.set(name, rows);
+    }
+    return map;
+  }
+  getColumns(queryName) {
+    const entry = this.results.get(queryName);
+    if (!entry) return [];
+    return entry.result.columns;
+  }
+};
+
+// src/notebook.ts
+var PREFIX = "nb-";
+function el(tag, classNames = []) {
+  const e = document.createElement(tag);
+  if (classNames.length) e.className = classNames.map((c) => PREFIX + c).join(" ");
+  return e;
+}
+function escapeHTML(raw) {
+  return raw.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function joinText(text) {
+  if (Array.isArray(text)) return text.join("");
+  return text ?? "";
+}
+var IMAGE_FORMATS = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+function renderImage(format, data) {
+  const img = el("img", ["image-output"]);
+  img.src = `data:${format};base64,${joinText(data).replace(/\n/g, "")}`;
+  return img;
+}
+function renderDisplayData(output, config) {
+  const getData = (mime) => output.data?.[mime] ?? output[mime];
+  for (const fmt of IMAGE_FORMATS) {
+    const d = getData(fmt);
+    if (d) return renderImage(fmt, d);
+  }
+  const svg = getData("image/svg+xml") ?? getData("text/svg+xml");
+  if (svg) {
+    const wrapper = el("div", ["svg-output"]);
+    wrapper.innerHTML = joinText(svg);
+    return wrapper;
+  }
+  const html = getData("text/html");
+  if (html) {
+    const wrapper = el("div", ["html-output"]);
+    wrapper.innerHTML = joinText(html);
+    return wrapper;
+  }
+  const md = getData("text/markdown");
+  if (md) {
+    const wrapper = el("div", ["html-output"]);
+    wrapper.innerHTML = config.markdown(joinText(md));
+    return wrapper;
+  }
+  const latex = getData("text/latex");
+  if (latex) {
+    const wrapper = el("div", ["latex-output"]);
+    wrapper.textContent = joinText(latex);
+    return wrapper;
+  }
+  const plain = getData("text/plain");
+  if (plain) {
+    const pre = el("pre", ["text-output"]);
+    pre.innerHTML = config.ansi(escapeHTML(joinText(plain)));
+    return pre;
+  }
+  return el("div", ["empty-output"]);
+}
+function renderStream(output, config) {
+  const streamName = output.stream ?? output.name ?? "stdout";
+  const pre = el("pre", [streamName]);
+  pre.innerHTML = config.ansi(escapeHTML(joinText(output.text ?? "")));
+  return pre;
+}
+function renderError(output, config) {
+  const pre = el("pre", ["pyerr"]);
+  const raw = (output.traceback ?? []).join("\n");
+  pre.innerHTML = config.ansi(escapeHTML(raw));
+  return pre;
+}
+function coalesceStreams(outputs) {
+  if (!outputs.length) return outputs;
+  const result = [{ ...outputs[0] }];
+  for (let i = 1; i < outputs.length; i++) {
+    const o = outputs[i];
+    const last = result[result.length - 1];
+    if (o.output_type === "stream" && last.output_type === "stream" && (o.stream ?? o.name) === (last.stream ?? last.name)) {
+      const lastText = Array.isArray(last.text) ? last.text : [last.text ?? ""];
+      const oText = Array.isArray(o.text) ? o.text : [o.text ?? ""];
+      last.text = lastText.concat(oText);
+    } else {
+      result.push({ ...o });
+    }
+  }
+  return result;
+}
+function renderCodeCell(cell, lang, config) {
+  const cellEl = el("div", ["cell", "code-cell"]);
+  const source = joinText(cell.source ?? cell.input ?? "");
+  if (source) {
+    const holder = el("div", ["input"]);
+    const num = cell.prompt_number ?? cell.execution_count;
+    if (typeof num === "number" && num > -1) {
+      holder.setAttribute("data-prompt-number", String(num));
+    }
+    const pre = el("pre");
+    const code = document.createElement("code");
+    code.setAttribute("data-language", lang);
+    code.className = `lang-${lang}`;
+    code.innerHTML = config.highlighter(escapeHTML(source), lang);
+    pre.appendChild(code);
+    holder.appendChild(pre);
+    cellEl.appendChild(holder);
+  }
+  const rawOutputs = coalesceStreams(cell.outputs ?? []);
+  for (const output of rawOutputs) {
+    const outer = el("div", ["output"]);
+    let inner;
+    switch (output.output_type) {
+      case "display_data":
+      case "execute_result":
+      case "pyout":
+        inner = renderDisplayData(output, config);
+        break;
+      case "stream":
+        inner = renderStream(output, config);
+        break;
+      case "error":
+      case "pyerr":
+        inner = renderError(output, config);
+        break;
+      default:
+        inner = el("div", ["empty-output"]);
+    }
+    outer.appendChild(inner);
+    cellEl.appendChild(outer);
+  }
+  return cellEl;
+}
+function renderMarkdownCell(cell, config) {
+  const cellEl = el("div", ["cell", "markdown-cell"]);
+  const source = joinText(cell.source ?? cell.input ?? "");
+  cellEl.innerHTML = config.markdown(source);
+  return cellEl;
+}
+function renderHeadingCell(cell) {
+  const level = Math.min(Math.max(cell.level ?? 1, 1), 6);
+  const heading = el(`h${level}`, ["cell", "heading-cell"]);
+  heading.innerHTML = escapeHTML(joinText(cell.source ?? cell.input ?? ""));
+  return heading;
+}
+function renderRawCell(cell) {
+  const cellEl = el("div", ["cell", "raw-cell"]);
+  cellEl.innerHTML = escapeHTML(joinText(cell.source ?? cell.input ?? ""));
+  return cellEl;
+}
+function renderNotebook(raw, config) {
+  const meta = raw.metadata ?? {};
+  const lang = meta.kernelspec?.language ?? meta.language_info?.name ?? meta.language ?? "python";
+  const kernelName = meta.kernelspec?.display_name ?? meta.language_info?.name ?? "";
+  let allCells = [];
+  if (Array.isArray(raw.cells)) {
+    allCells = raw.cells;
+  } else if (Array.isArray(raw.worksheets)) {
+    for (const ws of raw.worksheets) {
+      if (Array.isArray(ws.cells)) allCells.push(...ws.cells);
+    }
+  }
+  const notebook = el("div", ["notebook"]);
+  for (const cell of allCells) {
+    let rendered;
+    switch (cell.cell_type) {
+      case "code":
+        rendered = renderCodeCell(cell, cell.language ?? lang, config);
+        break;
+      case "markdown":
+        rendered = renderMarkdownCell(cell, config);
+        break;
+      case "heading":
+        rendered = renderHeadingCell(cell);
+        break;
+      case "raw":
+        rendered = renderRawCell(cell);
+        break;
+      default:
+        rendered = renderRawCell(cell);
+    }
+    notebook.appendChild(rendered);
+  }
+  return {
+    element: notebook,
+    meta: { kernelName, language: lang, cellCount: allCells.length }
+  };
+}
+
+// src/parquet-metadata.ts
+function mapParquetType(col) {
+  const lt = col.logical_type;
+  if (lt) {
+    if (lt.type === "GEOMETRY" || lt.type === "GEOGRAPHY") return "GEOMETRY";
+    if (lt.type === "STRING" || lt.type === "UTF8") return "VARCHAR";
+    if (lt.type === "JSON") return "JSON";
+    if (lt.type === "UUID") return "UUID";
+    if (lt.type === "ENUM") return "VARCHAR";
+    if (lt.type === "INT" || lt.type === "INTEGER") {
+      const bits = lt.bitWidth ?? 32;
+      const signed = lt.isSigned !== false;
+      if (bits <= 8) return signed ? "TINYINT" : "UTINYINT";
+      if (bits <= 16) return signed ? "SMALLINT" : "USMALLINT";
+      if (bits <= 32) return signed ? "INTEGER" : "UINTEGER";
+      return signed ? "BIGINT" : "UBIGINT";
+    }
+    if (lt.type === "DECIMAL") return `DECIMAL(${lt.precision ?? 18},${lt.scale ?? 0})`;
+    if (lt.type === "DATE") return "DATE";
+    if (lt.type === "TIME") return "TIME";
+    if (lt.type === "TIMESTAMP") return "TIMESTAMP";
+    if (lt.type === "BSON") return "BLOB";
+  }
+  const ct = col.converted_type;
+  if (ct === "UTF8") return "VARCHAR";
+  if (ct === "JSON") return "JSON";
+  if (ct === "DATE") return "DATE";
+  if (ct === "TIMESTAMP_MILLIS" || ct === "TIMESTAMP_MICROS") return "TIMESTAMP";
+  if (ct === "DECIMAL") return `DECIMAL(${col.precision ?? 18},${col.scale ?? 0})`;
+  if (ct === "INT_8") return "TINYINT";
+  if (ct === "INT_16") return "SMALLINT";
+  if (ct === "INT_32") return "INTEGER";
+  if (ct === "INT_64") return "BIGINT";
+  if (ct === "UINT_8") return "UTINYINT";
+  if (ct === "UINT_16") return "USMALLINT";
+  if (ct === "UINT_32") return "UINTEGER";
+  if (ct === "UINT_64") return "UBIGINT";
+  const pt = col.type;
+  if (pt === "BOOLEAN") return "BOOLEAN";
+  if (pt === "INT32") return "INTEGER";
+  if (pt === "INT64") return "BIGINT";
+  if (pt === "INT96") return "TIMESTAMP";
+  if (pt === "FLOAT") return "FLOAT";
+  if (pt === "DOUBLE") return "DOUBLE";
+  if (pt === "BYTE_ARRAY") return "BLOB";
+  if (pt === "FIXED_LEN_BYTE_ARRAY") return "BLOB";
+  return "VARCHAR";
+}
+async function readParquetMetadata(url) {
+  const { parquetMetadataAsync, asyncBufferFromUrl } = await import('hyparquet');
+  const file = await asyncBufferFromUrl({ url });
+  const metadata = await parquetMetadataAsync(file);
+  const rowCount = metadata.row_groups.reduce(
+    (sum, rg) => sum + Number(rg.num_rows),
+    0
+  );
+  const schema = metadata.schema.slice(1).filter((col) => col.num_children === void 0).map((col) => ({
+    name: col.name,
+    type: mapParquetType(col)
+  }));
+  const topLevelColumns = [];
+  const root = metadata.schema[0];
+  const rootChildren = root?.num_children ?? 0;
+  let cursor = 1;
+  for (let i = 0; i < rootChildren && cursor < metadata.schema.length; i++) {
+    const el2 = metadata.schema[cursor];
+    if (el2?.name) topLevelColumns.push(el2.name);
+    cursor += countSubtree(metadata.schema, cursor);
+  }
+  let geo = null;
+  let legacyGeoParquet = false;
+  const geoKv = metadata.key_value_metadata?.find((kv) => kv.key === "geo");
+  if (geoKv) {
+    try {
+      const geoJson = JSON.parse(geoKv.value ?? "");
+      if (geoJson.schema_version && !geoJson.version) {
+        legacyGeoParquet = true;
+      }
+      geo = {
+        primaryColumn: geoJson.primary_column ?? "geometry",
+        columns: {}
+      };
+      if (geoJson.columns) {
+        for (const [colName, colMeta] of Object.entries(geoJson.columns)) {
+          geo.columns[colName] = {
+            encoding: colMeta.encoding ?? "WKB",
+            geometryTypes: colMeta.geometry_types ?? [],
+            crs: colMeta.crs ?? null,
+            bbox: colMeta.bbox
+          };
+        }
+      }
+    } catch {
+    }
+  }
+  const createdBy = metadata.created_by ?? null;
+  const numRowGroups = metadata.row_groups.length;
+  let compression = null;
+  if (numRowGroups > 0 && metadata.row_groups[0].columns) {
+    const codecs = /* @__PURE__ */ new Set();
+    for (const col of metadata.row_groups[0].columns) {
+      const codec = col.meta_data?.codec;
+      if (codec) codecs.add(codec);
+    }
+    if (codecs.size === 1) {
+      compression = [...codecs][0];
+    } else if (codecs.size > 1) {
+      compression = [...codecs].join(", ");
+    }
+  }
+  return {
+    rowCount,
+    schema,
+    topLevelColumns,
+    geo,
+    legacyGeoParquet,
+    createdBy,
+    numRowGroups,
+    compression
+  };
+}
+function countSubtree(schema, start) {
+  const el2 = schema[start];
+  if (!el2) return 0;
+  const n = el2.num_children ?? 0;
+  let cursor = start + 1;
+  for (let i = 0; i < n; i++) {
+    cursor += countSubtree(schema, cursor);
+  }
+  return cursor - start;
+}
+function extractEpsgFromGeoMeta(geo) {
+  const primaryCol = geo.columns[geo.primaryColumn];
+  if (!primaryCol?.crs) return null;
+  const crs = primaryCol.crs;
+  if (crs.type === "name" && crs.properties?.name?.includes("CRS84")) return null;
+  if (crs.id?.authority === "EPSG") {
+    const code = crs.id.code;
+    if (WGS84_CODES.has(code)) return null;
+    return `EPSG:${code}`;
+  }
+  return null;
+}
+function extractGeometryTypes(geo) {
+  const primaryCol = geo.columns[geo.primaryColumn];
+  if (!primaryCol?.geometryTypes?.length) return [];
+  const typeMap = {
+    Point: "point",
+    LineString: "linestring",
+    Polygon: "polygon",
+    MultiPoint: "multipoint",
+    MultiLineString: "multilinestring",
+    MultiPolygon: "multipolygon"
+  };
+  const types = [];
+  for (const raw of primaryCol.geometryTypes) {
+    const base = raw.split(" ")[0];
+    const mapped = typeMap[base];
+    if (mapped && !types.includes(mapped)) types.push(mapped);
+  }
+  return types;
+}
+function extractBounds(geo) {
+  const primaryCol = geo.columns[geo.primaryColumn];
+  if (!primaryCol?.bbox || primaryCol.bbox.length < 4) return null;
+  return [primaryCol.bbox[0], primaryCol.bbox[1], primaryCol.bbox[2], primaryCol.bbox[3]];
+}
+
+// src/stac-facets.ts
+var THUMBNAIL_ROLES = ["thumbnail", "overview", "visual"];
+var THUMBNAIL_KEYS = ["thumbnail", "preview", "overview", "rendered_preview", "visual"];
+var BROWSER_IMAGE_MIME_RE = /^image\/(png|jpe?g|webp|gif|avif|svg\+xml|svg)\b/i;
+function isBrowserRenderableAsset(asset) {
+  if (!asset.type) return true;
+  return BROWSER_IMAGE_MIME_RE.test(asset.type);
+}
+function extractThumbnailHref(item) {
+  const assets = item.assets ?? {};
+  for (const role of THUMBNAIL_ROLES) {
+    for (const asset of Object.values(assets)) {
+      if (Array.isArray(asset?.roles) && asset.roles.includes(role) && asset.href && isBrowserRenderableAsset(asset)) {
+        return asset.href;
+      }
+    }
+  }
+  for (const key of THUMBNAIL_KEYS) {
+    const asset = assets[key];
+    if (asset?.href && isBrowserRenderableAsset(asset)) return asset.href;
+  }
+  return null;
+}
+function collectAssetRoles(item) {
+  const out = /* @__PURE__ */ new Set();
+  for (const asset of Object.values(item.assets ?? {})) {
+    if (Array.isArray(asset?.roles)) {
+      for (const role of asset.roles) {
+        if (typeof role === "string") out.add(role);
+      }
+    }
+  }
+  return [...out].sort();
+}
+function readNumber(props, key) {
+  const v = props[key];
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function readString(props, key) {
+  const v = props[key];
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function readStringArray(props, key) {
+  const v = props[key];
+  if (!Array.isArray(v)) return [];
+  return v.filter((x) => typeof x === "string");
+}
+function extractItemView(item) {
+  const props = item.properties ?? {};
+  const bbox = Array.isArray(item.bbox) && item.bbox.length >= 4 ? [
+    Number(item.bbox[0]),
+    Number(item.bbox[1]),
+    Number(item.bbox[2]),
+    Number(item.bbox[3])
+  ] : null;
+  return {
+    id: String(item.id ?? ""),
+    collection: typeof item.collection === "string" ? item.collection : null,
+    bbox,
+    datetime: readString(props, "datetime") ?? readString(props, "start_datetime"),
+    endDatetime: readString(props, "end_datetime"),
+    cloudCover: readNumber(props, "eo:cloud_cover"),
+    gsd: readNumber(props, "gsd"),
+    platform: readString(props, "platform"),
+    constellation: readString(props, "constellation"),
+    instruments: readStringArray(props, "instruments"),
+    epsg: readNumber(props, "proj:epsg"),
+    thumbnailHref: extractThumbnailHref(item),
+    assetRoles: collectAssetRoles(item),
+    raw: item
+  };
+}
+var DATETIME_HISTOGRAM_BINS_MAX = 64;
+var DATETIME_HISTOGRAM_BINS = 32;
+var MS_PER_DAY = 864e5;
+var MS_PER_YEAR = MS_PER_DAY * 365.25;
+var NUMERIC_FIELDS = ["cloudCover", "gsd"];
+var ENUM_FIELDS = [
+  "collection",
+  "platform",
+  "constellation",
+  "instruments",
+  "assetRoles"
+];
+function buildNumericFacet(views, field) {
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+  let count = 0;
+  for (const v of views) {
+    const value = v[field];
+    if (value == null || !Number.isFinite(value)) continue;
+    if (value < min) min = value;
+    if (value > max) max = value;
+    count++;
+  }
+  if (count === 0 || min === max) return null;
+  return { kind: "numeric", field, min, max, count };
+}
+function buildEnumFacet(views, field) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const v of views) {
+    const raw = v[field];
+    if (raw == null) continue;
+    if (Array.isArray(raw)) {
+      for (const item of raw) counts.set(item, (counts.get(item) ?? 0) + 1);
+    } else if (typeof raw === "string" && raw.length > 0) {
+      counts.set(raw, (counts.get(raw) ?? 0) + 1);
+    }
+  }
+  if (counts.size < 2) return null;
+  const values = [...counts.entries()].map(([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
+  return { kind: "enum", field, values };
+}
+function pickGranularity(spanMs) {
+  if (spanMs <= 90 * MS_PER_DAY) return "day";
+  if (spanMs <= 2 * MS_PER_YEAR) return "week";
+  if (spanMs <= 20 * MS_PER_YEAR) return "month";
+  return "year";
+}
+function floorUtcDay(t) {
+  const d = new Date(t);
+  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+}
+function floorIsoWeek(t) {
+  const dayStart = floorUtcDay(t);
+  const dow = new Date(dayStart).getUTCDay();
+  const offsetDays = (dow + 6) % 7;
+  return dayStart - offsetDays * MS_PER_DAY;
+}
+function floorUtcMonth(t) {
+  const d = new Date(t);
+  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1);
+}
+function floorUtcYear(t) {
+  const d = new Date(t);
+  return Date.UTC(d.getUTCFullYear(), 0, 1);
+}
+function floorBin(t, g) {
+  switch (g) {
+    case "day":
+      return floorUtcDay(t);
+    case "week":
+      return floorIsoWeek(t);
+    case "month":
+      return floorUtcMonth(t);
+    case "year":
+      return floorUtcYear(t);
+  }
+}
+function nextBin(t, g) {
+  const d = new Date(t);
+  switch (g) {
+    case "day":
+      return t + MS_PER_DAY;
+    case "week":
+      return t + 7 * MS_PER_DAY;
+    case "month":
+      return Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 1);
+    case "year":
+      return Date.UTC(d.getUTCFullYear() + 1, 0, 1);
+  }
+}
+function buildDatetimeFacet(views) {
+  const timestamps = [];
+  for (const v of views) {
+    if (!v.datetime) continue;
+    const t = Date.parse(v.datetime);
+    if (Number.isFinite(t)) timestamps.push(t);
+  }
+  if (timestamps.length < 2) return null;
+  let min = timestamps[0];
+  let max = timestamps[0];
+  for (const t of timestamps) {
+    if (t < min) min = t;
+    if (t > max) max = t;
+  }
+  if (min === max) return null;
+  let granularity = pickGranularity(max - min);
+  let binEdges = computeBinEdges(min, max, granularity);
+  while (binEdges.length > DATETIME_HISTOGRAM_BINS_MAX && granularity !== "year") {
+    granularity = coarsenGranularity(granularity);
+    binEdges = computeBinEdges(min, max, granularity);
+  }
+  const bins = new Array(binEdges.length).fill(0);
+  for (const t of timestamps) {
+    const idx = findBinIndex(binEdges, t);
+    bins[idx]++;
+  }
+  return {
+    kind: "datetime",
+    field: "datetime",
+    min: new Date(min).toISOString(),
+    max: new Date(max).toISOString(),
+    count: timestamps.length,
+    bins,
+    granularity,
+    binEdges
+  };
+}
+function coarsenGranularity(g) {
+  switch (g) {
+    case "day":
+      return "week";
+    case "week":
+      return "month";
+    case "month":
+    case "year":
+      return "year";
+  }
+}
+function computeBinEdges(min, max, g) {
+  const edges = [];
+  let cursor = floorBin(min, g);
+  const stop = max;
+  for (let i = 0; i < DATETIME_HISTOGRAM_BINS_MAX * 4 && cursor <= stop; i++) {
+    edges.push(cursor);
+    cursor = nextBin(cursor, g);
+  }
+  return edges;
+}
+function findBinIndex(edges, t) {
+  if (t <= edges[0]) return 0;
+  if (t >= edges[edges.length - 1]) return edges.length - 1;
+  let lo = 0;
+  let hi = edges.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >>> 1;
+    if (edges[mid] <= t) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+function buildFacets(views) {
+  const numeric = [];
+  for (const field of NUMERIC_FIELDS) {
+    const f = buildNumericFacet(views, field);
+    if (f) numeric.push(f);
+  }
+  const enums = [];
+  for (const field of ENUM_FIELDS) {
+    const f = buildEnumFacet(views, field);
+    if (f) enums.push(f);
+  }
+  return {
+    datetime: buildDatetimeFacet(views),
+    numeric,
+    enums,
+    total: views.length
+  };
+}
+function inNumericRange(value, range) {
+  if (value == null || !Number.isFinite(value)) return false;
+  if (range.min != null && value < range.min) return false;
+  if (range.max != null && value > range.max) return false;
+  return true;
+}
+function inEnumSet(value, allow) {
+  if (allow.length === 0) return true;
+  if (value == null) return false;
+  if (Array.isArray(value)) return value.some((v) => allow.includes(v));
+  return allow.includes(value);
+}
+function inDatetimeRange(value, range) {
+  if (!value) return false;
+  const t = Date.parse(value);
+  if (!Number.isFinite(t)) return false;
+  if (range.min) {
+    const m = Date.parse(range.min);
+    if (Number.isFinite(m) && t < m) return false;
+  }
+  if (range.max) {
+    const m = Date.parse(range.max);
+    if (Number.isFinite(m) && t > m) return false;
+  }
+  return true;
+}
+function applyFacets(views, state) {
+  if (!state) return views;
+  const dt = state.datetime;
+  const num = state.numeric;
+  const enums = state.enums;
+  const hasDatetime = dt && (dt.min || dt.max);
+  const hasNumeric = num && Object.values(num).some((r) => r && (r.min != null || r.max != null));
+  const hasEnums = enums && Object.values(enums).some((a) => Array.isArray(a) && a.length > 0);
+  if (!hasDatetime && !hasNumeric && !hasEnums) return views;
+  return views.filter((view) => {
+    if (hasDatetime && dt && !inDatetimeRange(view.datetime, dt)) return false;
+    if (hasNumeric && num) {
+      for (const field of NUMERIC_FIELDS) {
+        const range = num[field];
+        if (!range || range.min == null && range.max == null) continue;
+        if (!inNumericRange(view[field], range)) return false;
+      }
+    }
+    if (hasEnums && enums) {
+      for (const field of ENUM_FIELDS) {
+        const allow = enums[field];
+        if (!Array.isArray(allow) || allow.length === 0) continue;
+        if (!inEnumSet(view[field], allow)) return false;
+      }
+    }
+    return true;
+  });
+}
+function sortViews(views, sort) {
+  const arr = views.slice();
+  const cmp = getComparator(sort);
+  arr.sort(cmp);
+  return arr;
+}
+function getComparator(sort) {
+  switch (sort) {
+    case "datetime-desc":
+      return (a, b) => compareNullableNumber(parseTime(b.datetime), parseTime(a.datetime));
+    case "datetime-asc":
+      return (a, b) => compareNullableNumber(parseTime(a.datetime), parseTime(b.datetime));
+    case "cloud-asc":
+      return (a, b) => compareNullableNumber(a.cloudCover, b.cloudCover);
+    case "cloud-desc":
+      return (a, b) => compareNullableNumber(b.cloudCover, a.cloudCover);
+    case "gsd-asc":
+      return (a, b) => compareNullableNumber(a.gsd, b.gsd);
+    case "gsd-desc":
+      return (a, b) => compareNullableNumber(b.gsd, a.gsd);
+    case "id-asc":
+      return (a, b) => a.id.localeCompare(b.id);
+  }
+}
+function parseTime(s) {
+  if (!s) return null;
+  const t = Date.parse(s);
+  return Number.isFinite(t) ? t : null;
+}
+function compareNullableNumber(a, b) {
+  const aMissing = a == null || !Number.isFinite(a);
+  const bMissing = b == null || !Number.isFinite(b);
+  if (aMissing && bMissing) return 0;
+  if (aMissing) return 1;
+  if (bMissing) return -1;
+  return a - b;
+}
+function hasActiveFilters(state) {
+  if (!state) return false;
+  if (state.datetime && (state.datetime.min || state.datetime.max)) return true;
+  if (state.numeric) {
+    for (const r of Object.values(state.numeric)) {
+      if (r && (r.min != null || r.max != null)) return true;
+    }
+  }
+  if (state.enums) {
+    for (const a of Object.values(state.enums)) {
+      if (Array.isArray(a) && a.length > 0) return true;
+    }
+  }
+  return false;
+}
+function emptyFacetState() {
+  return {};
+}
+
+// src/stac-geoparquet.ts
+function plainifyArrowValue(value) {
+  if (value === null || value === void 0) return value;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === "bigint") return value;
+  if (value instanceof Uint8Array || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(plainifyArrowValue);
+  const obj = value;
+  if (typeof obj.toJSON === "function") {
+    return plainifyArrowValue(obj.toJSON());
+  }
+  if (typeof obj.toArray === "function") {
+    return obj.toArray().map(plainifyArrowValue);
+  }
+  if (t === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = plainifyArrowValue(v);
+    }
+    return out;
+  }
+  return value;
+}
+var STAC_GEOPARQUET_REQUIRED_COLUMNS = [
+  "stac_version",
+  "type",
+  "geometry",
+  "assets"
+];
+function isStacGeoparquetSchema(schema) {
+  if (!Array.isArray(schema) || schema.length === 0) return false;
+  const names = new Set(schema.map((c) => c.name));
+  return STAC_GEOPARQUET_REQUIRED_COLUMNS.every((c) => names.has(c));
+}
+function flattenStacBbox(bbox) {
+  if (!bbox) return null;
+  if (Array.isArray(bbox)) {
+    if (bbox.length < 4) return null;
+    const [minX, minY, maxX, maxY] = bbox;
+    if (![minX, minY, maxX, maxY].every((v) => Number.isFinite(v))) return null;
+    return [minX, minY, maxX, maxY];
+  }
+  if (typeof bbox === "object") {
+    const { xmin, ymin, xmax, ymax } = bbox;
+    if (![xmin, ymin, xmax, ymax].every((v) => Number.isFinite(v))) return null;
+    return [xmin, ymin, xmax, ymax];
+  }
+  return null;
+}
+function resolveStacAssetHref(href, baseUrl) {
+  if (!href) return href;
+  if (/^[a-z][a-z0-9+\-.]*:\/\//i.test(href)) return href;
+  try {
+    return new URL(href, baseUrl).toString();
+  } catch {
+    return href;
+  }
+}
+function pickStacPrimaryAsset(assets, preferredKeys) {
+  if (!assets || typeof assets !== "object") return null;
+  const entries = Object.entries(assets).filter(
+    ([, a]) => a && typeof a === "object" && typeof a.href === "string"
+  );
+  if (entries.length === 0) return null;
+  if (preferredKeys) {
+    for (const key of preferredKeys) {
+      const match = entries.find(([k]) => k === key);
+      if (match) return { key: match[0], asset: match[1] };
+    }
+  }
+  const data = entries.find(([k]) => k === "data");
+  if (data) return { key: data[0], asset: data[1] };
+  const byRole = entries.find(([, a]) => Array.isArray(a.roles) && a.roles.includes("data"));
+  if (byRole) return { key: byRole[0], asset: byRole[1] };
+  return { key: entries[0][0], asset: entries[0][1] };
+}
+function normalizeAssetsField(value, baseUrl) {
+  if (!value || typeof value !== "object") return void 0;
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (!raw || typeof raw !== "object") continue;
+    const asset = raw;
+    if (typeof asset.href !== "string" || !asset.href) continue;
+    out[key] = {
+      ...asset,
+      href: resolveStacAssetHref(asset.href, baseUrl)
+    };
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function coerceDatetimeToIso(value) {
+  if (value == null) return void 0;
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : void 0;
+  }
+  if (typeof value === "bigint") {
+    const ms = Number(value / 1000n);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ms = Math.abs(value) > 1e14 ? Math.floor(value / 1e3) : value;
+    return new Date(ms).toISOString();
+  }
+  if (typeof value === "string") {
+    const t = Date.parse(value);
+    return Number.isFinite(t) ? new Date(t).toISOString() : void 0;
+  }
+  return void 0;
+}
+function normalizeLinksField(value, baseUrl) {
+  if (!Array.isArray(value)) return void 0;
+  const links = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object") continue;
+    const link = raw;
+    if (typeof link.href !== "string" || typeof link.rel !== "string") continue;
+    links.push({ ...link, href: resolveStacAssetHref(link.href, baseUrl) });
+  }
+  return links.length > 0 ? links : void 0;
+}
+function stacRowToItem(row, baseUrl, opts = {}) {
+  const { wkbParser, wkbColumn = "geom_wkb", geometryColumn = "geometry" } = opts;
+  for (const key of ["bbox", "assets", "links", "bands", "stac_extensions"]) {
+    if (row[key] !== void 0 && row[key] !== null) {
+      row[key] = plainifyArrowValue(row[key]);
+    }
+  }
+  let geometry = row[geometryColumn];
+  if (!geometry) {
+    const wkb = row[wkbColumn];
+    if (wkb && wkbParser) {
+      const bytes = wkb instanceof Uint8Array ? wkb : toUint8Array(wkb);
+      if (bytes) {
+        try {
+          geometry = wkbParser(bytes) ?? void 0;
+        } catch {
+          geometry = void 0;
+        }
+      }
+    }
+  }
+  const bbox = flattenStacBbox(row.bbox) ?? void 0;
+  const assets = normalizeAssetsField(row.assets, baseUrl);
+  const links = normalizeLinksField(row.links, baseUrl);
+  const properties = {};
+  const SCALAR_PROP_KEYS = /* @__PURE__ */ new Set([
+    "gsd",
+    "platform",
+    "constellation",
+    "instruments",
+    "mission",
+    "license"
+  ]);
+  const TIMESTAMP_PROP_KEYS = /* @__PURE__ */ new Set([
+    "datetime",
+    "start_datetime",
+    "end_datetime",
+    "created",
+    "updated"
+  ]);
+  for (const [key, value] of Object.entries(row)) {
+    if (value === null || value === void 0) continue;
+    if (key.startsWith("proj:") || key.startsWith("raster:") || key.startsWith("eo:")) {
+      properties[key] = value;
+      continue;
+    }
+    if (TIMESTAMP_PROP_KEYS.has(key)) {
+      const iso = coerceDatetimeToIso(value);
+      if (iso) properties[key] = iso;
+      continue;
+    }
+    if (SCALAR_PROP_KEYS.has(key)) {
+      properties[key] = value;
+      continue;
+    }
+    if (key === "bands") {
+      properties.bands = value;
+    }
+  }
+  const item = {
+    type: "Feature",
+    stac_version: typeof row.stac_version === "string" ? row.stac_version : "1.0.0",
+    id: typeof row.id === "string" ? row.id : String(row.id ?? ""),
+    properties
+  };
+  if (typeof row.collection === "string") item.collection = row.collection;
+  if (Array.isArray(row.stac_extensions)) {
+    item.stac_extensions = row.stac_extensions;
+  }
+  if (bbox) item.bbox = bbox;
+  if (geometry) item.geometry = geometry;
+  if (assets) item.assets = assets;
+  if (links) item.links = links;
+  return item;
+}
+function toUint8Array(value) {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+  }
+  if (Array.isArray(value)) return new Uint8Array(value);
+  return null;
+}
+
+// src/stac-hydrate.ts
+async function hydrateStacItems(root, baseHref, adapter, opts) {
+  const limit = opts.limit ?? 2e3;
+  const concurrency = opts.concurrency ?? 12;
+  const followPagination = opts.followPagination ?? true;
+  const signal = opts.signal;
+  const urlToKey = opts.urlToKey;
+  const items = [];
+  let truncated = false;
+  const emit = (batch) => {
+    if (batch.length === 0) return;
+    items.push(...batch);
+    opts.onBatch?.(batch);
+    opts.onProgress?.(items.length, void 0);
+  };
+  if (root.kind === "item") {
+    emit([absolutizeItemAssets(root.item, baseHref)]);
+    return { items, truncated: false, rootBaseHref: baseHref };
+  }
+  if (root.kind === "item-collection") {
+    await consumeFeatureCollection(root.fc, baseHref, adapter, {
+      signal,
+      concurrency,
+      limit,
+      followPagination,
+      urlToKey,
+      itemsQuery: opts.itemsQuery,
+      onAccept: (batch) => emit(batch),
+      stopCheck: () => items.length >= limit,
+      onTruncate: () => {
+        truncated = true;
+      }
+    });
+    return { items: items.slice(0, limit), truncated, rootBaseHref: baseHref };
+  }
+  if (root.kind === "collection" || root.kind === "catalog") {
+    const itemLinks = collectItemLinks(root.payload, baseHref);
+    const childLinks = root.kind === "catalog" || itemLinks.length === 0 ? collectChildLinks(root.payload, baseHref) : [];
+    const itemsEndpoint = itemLinks.length === 0 ? collectItemsEndpoint(root.payload, baseHref, opts.itemsQuery) : null;
+    if (itemLinks.length > 0) {
+      await fetchItems(itemLinks, adapter, baseHref, {
+        signal,
+        concurrency,
+        urlToKey,
+        onBatch: (batch) => emit(batch),
+        stopCheck: () => items.length >= limit,
+        onTruncate: () => {
+          truncated = true;
+        }
+      });
+    } else if (itemsEndpoint) {
+      try {
+        const json = await fetchJson(adapter, itemsEndpoint, baseHref, signal, urlToKey);
+        if (isStacFeatureCollection(json)) {
+          await consumeFeatureCollection(json, itemsEndpoint, adapter, {
+            signal,
+            concurrency,
+            limit,
+            followPagination,
+            urlToKey,
+            itemsQuery: opts.itemsQuery,
+            onAccept: (batch) => emit(batch),
+            stopCheck: () => items.length >= limit,
+            onTruncate: () => {
+              truncated = true;
+            }
+          });
+        }
+      } catch {
       }
-      const azureBlob = host.match(AZURE_BLOB_RE);
-      if (azureBlob && pathParts.length > 0) {
-        return {
-          bucket: pathParts[0],
-          region: defaults.region || "",
-          endpoint: `${url.protocol}//${url.host}`,
-          provider: "azure",
-          prefix: pathParts.slice(1).join("/")
-        };
+    }
+    if (!truncated && items.length < limit && childLinks.length > 0) {
+      const queue = [...childLinks];
+      const stopCheck = () => items.length >= limit || signal.aborted;
+      const workerCount = Math.min(concurrency, queue.length);
+      const workers = [];
+      for (let i = 0; i < workerCount; i++) {
+        workers.push(
+          (async () => {
+            while (queue.length > 0) {
+              if (stopCheck()) {
+                if (items.length >= limit) truncated = true;
+                queue.length = 0;
+                return;
+              }
+              const childHref = queue.shift();
+              if (!childHref) return;
+              try {
+                const childJson = await fetchJson(adapter, childHref, baseHref, signal, urlToKey);
+                if (stopCheck()) {
+                  if (items.length >= limit) truncated = true;
+                  queue.length = 0;
+                  return;
+                }
+                const childKind = classifyFetchedJson(childJson);
+                if (childKind.kind === "none") continue;
+                const sub = await hydrateStacItems(childKind, childHref, adapter, {
+                  ...opts,
+                  limit: limit - items.length,
+                  onBatch: (batch) => emit(batch),
+                  onProgress: void 0
+                });
+                if (sub.truncated) truncated = true;
+              } catch {
+              }
+            }
+          })()
+        );
       }
-      const storjGateway = host.match(STORJ_GATEWAY_RE);
-      if (storjGateway && pathParts.length > 0) {
-        return {
-          bucket: pathParts[0],
-          region: storjGateway[1] || defaults.region || "us1",
-          endpoint: `${url.protocol}//${url.host}`,
-          provider: "storj",
-          prefix: pathParts.slice(1).join("/")
-        };
+      await Promise.all(workers);
+    }
+    return { items: items.slice(0, limit), truncated, rootBaseHref: baseHref };
+  }
+  return { items, truncated: false, rootBaseHref: baseHref };
+}
+function collectItemLinks(payload, baseHref) {
+  return (payload.links ?? []).filter((l) => !!l && typeof l.href === "string" && l.rel === "item").map((l) => absolutizeHref(l.href, baseHref));
+}
+function collectChildLinks(payload, baseHref) {
+  return (payload.links ?? []).filter((l) => !!l && typeof l.href === "string" && l.rel === "child").map((l) => absolutizeHref(l.href, baseHref));
+}
+function hasStacItemsEndpoint(payload) {
+  return (payload.links ?? []).some((l) => !!l && typeof l.href === "string" && l.rel === "items");
+}
+function collectItemsEndpoint(payload, baseHref, query) {
+  const link = (payload.links ?? []).find(
+    (l) => !!l && typeof l.href === "string" && l.rel === "items"
+  );
+  if (!link) return null;
+  return applyItemsQuery(absolutizeHref(link.href, baseHref), query);
+}
+function applyItemsQuery(absolute, query) {
+  if (!query) return absolute;
+  try {
+    const url = new URL(absolute);
+    if (query.bbox && query.bbox.length === 4 && !url.searchParams.has("bbox")) {
+      url.searchParams.set("bbox", query.bbox.join(","));
+    }
+    if (query.datetime && !url.searchParams.has("datetime")) {
+      url.searchParams.set("datetime", query.datetime);
+    }
+    if (typeof query.limit === "number" && query.limit > 0 && !url.searchParams.has("limit")) {
+      url.searchParams.set("limit", String(Math.floor(query.limit)));
+    }
+    if (query.filter !== void 0 && query.filter !== null && !url.searchParams.has("filter")) {
+      try {
+        url.searchParams.set("filter", JSON.stringify(query.filter));
+        if (!url.searchParams.has("filter-lang")) {
+          url.searchParams.set("filter-lang", "cql2-json");
+        }
+      } catch {
       }
-      const storjLink = host.match(STORJ_LINK_RE);
-      if (storjLink && pathParts.length >= 3 && (pathParts[0] === "raw" || pathParts[0] === "s")) {
-        return {
-          bucket: pathParts[2],
-          region: storjLink[1] || defaults.region || "us1",
-          endpoint: `${url.protocol}//${url.host}/${pathParts[0]}/${pathParts[1]}`,
-          provider: "storj",
-          prefix: pathParts.slice(3).join("/")
-        };
+    }
+    return url.toString();
+  } catch {
+    return absolute;
+  }
+}
+async function consumeFeatureCollection(fc, baseHref, adapter, ctx) {
+  const accepted = fc.features.filter(isStacItem).map((item) => absolutizeItemAssets(item, baseHref));
+  ctx.onAccept(accepted);
+  if (ctx.stopCheck()) {
+    ctx.onTruncate();
+    return;
+  }
+  if (!ctx.followPagination) return;
+  const next = (fc.links ?? []).find((l) => l && l.rel === "next" && typeof l.href === "string");
+  if (!next) return;
+  const nextHref = applyItemsQuery(absolutizeHref(next.href, baseHref), ctx.itemsQuery);
+  if (ctx.signal.aborted) return;
+  try {
+    const json = await fetchJson(adapter, nextHref, baseHref, ctx.signal, ctx.urlToKey);
+    if (!isStacFeatureCollection(json)) return;
+    await consumeFeatureCollection(json, nextHref, adapter, ctx);
+  } catch {
+  }
+}
+async function fetchItems(hrefs, adapter, baseHref, ctx) {
+  const queue = [...hrefs];
+  const workers = [];
+  const workerCount = Math.min(ctx.concurrency, queue.length);
+  for (let i = 0; i < workerCount; i++) {
+    workers.push(
+      (async () => {
+        while (queue.length > 0) {
+          if (ctx.signal.aborted) return;
+          if (ctx.stopCheck()) {
+            ctx.onTruncate();
+            queue.length = 0;
+            return;
+          }
+          const href = queue.shift();
+          if (!href) return;
+          try {
+            const json = await fetchJson(adapter, href, baseHref, ctx.signal, ctx.urlToKey);
+            if (isStacItem(json)) ctx.onBatch([absolutizeItemAssets(json, href)]);
+          } catch {
+          }
+        }
+      })()
+    );
+  }
+  await Promise.all(workers);
+}
+async function fetchJson(adapter, href, _baseHref, signal, urlToKey) {
+  if (/^https?:/i.test(href)) {
+    const ownKey = urlToKey ? urlToKey(href) : null;
+    if (ownKey !== null) {
+      const buf2 = await adapter.read(ownKey, void 0, void 0, signal);
+      return JSON.parse(new TextDecoder().decode(buf2));
+    }
+    const res = await fetch(href, { signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status} for ${href}`);
+    return await res.json();
+  }
+  const buf = await adapter.read(href, void 0, void 0, signal);
+  return JSON.parse(new TextDecoder().decode(buf));
+}
+function classifyFetchedJson(json) {
+  if (isStacItem(json)) return { kind: "item", item: json };
+  if (isStacFeatureCollection(json)) return { kind: "item-collection", fc: json };
+  if (isStacCollection(json)) return { kind: "collection", payload: json };
+  if (isStacCatalog(json)) return { kind: "catalog", payload: json };
+  return { kind: "none" };
+}
+function absolutizeHref(href, baseHref) {
+  if (/^https?:/i.test(href) || /^s3:/i.test(href) || /^azure:/i.test(href)) return href;
+  try {
+    return new URL(href, baseHref).toString();
+  } catch {
+    return href;
+  }
+}
+function absolutizeItemAssets(item, itemHref) {
+  const assets = item.assets;
+  if (!assets) return item;
+  let changed = false;
+  const resolved = {};
+  for (const [key, asset] of Object.entries(assets)) {
+    if (asset?.href && typeof asset.href === "string") {
+      const abs = absolutizeHref(asset.href, itemHref);
+      if (abs !== asset.href) changed = true;
+      resolved[key] = { ...asset, href: abs };
+    } else {
+      resolved[key] = asset;
+    }
+  }
+  return changed ? { ...item, assets: resolved } : item;
+}
+
+// src/stac-pushdown.ts
+var CONFORMANCE_SIGNATURES = [
+  {
+    key: "bbox",
+    matchers: [/ogc-api[/-]features.*\/conf\/core/i, /stac-api.*\/item-search/i]
+  },
+  {
+    key: "datetime",
+    matchers: [/ogc-api[/-]features.*\/conf\/core/i, /stac-api.*\/item-search/i]
+  },
+  {
+    key: "collections",
+    matchers: [/stac-api.*\/item-search/i]
+  },
+  {
+    key: "cql2",
+    matchers: [/stac-api.*\/item-search.*\/filter/i, /ogc-api[/-]features.*\/cql2/i, /cql2-json/i]
+  },
+  {
+    key: "queryables",
+    matchers: [/stac-api.*\/item-search.*\/queryables/i, /ogc-api[/-]features.*\/queryables/i]
+  }
+];
+function sniffApiCapabilities(conformsTo) {
+  const caps = {
+    bbox: false,
+    datetime: false,
+    collections: false,
+    cql2: false,
+    queryables: false
+  };
+  if (!Array.isArray(conformsTo)) return caps;
+  const normalised = conformsTo.filter((s) => typeof s === "string");
+  for (const sig of CONFORMANCE_SIGNATURES) {
+    if (normalised.some((uri) => sig.matchers.some((re) => re.test(uri)))) {
+      caps[sig.key] = true;
+    }
+  }
+  return caps;
+}
+function toNativeQuery(state, caps, opts = {}) {
+  const out = {};
+  if (opts.bbox && caps.bbox) out.bbox = opts.bbox;
+  if (typeof opts.limit === "number" && opts.limit > 0) out.limit = Math.floor(opts.limit);
+  if (!state) return out;
+  if (caps.datetime && state.datetime && (state.datetime.min || state.datetime.max)) {
+    out.datetime = formatDatetimeInterval(state.datetime.min, state.datetime.max);
+  }
+  if (caps.collections && state.enums?.collection?.length) {
+    out.collections = [...state.enums.collection];
+  }
+  if (caps.cql2) {
+    const filter = toCql2Filter(state, caps);
+    if (filter) {
+      out.filter = filter;
+      out["filter-lang"] = "cql2-json";
+    }
+  }
+  return out;
+}
+function formatDatetimeInterval(min, max) {
+  const lo = min ?? "..";
+  const hi = max ?? "..";
+  if (lo === ".." && hi === "..") return "..";
+  if (lo === hi) return lo;
+  return `${lo}/${hi}`;
+}
+function toCql2Filter(state, caps) {
+  if (!state) return null;
+  const clauses = [];
+  if (state.numeric) {
+    const n = state.numeric;
+    pushBetween(clauses, "eo:cloud_cover", n.cloudCover);
+    pushBetween(clauses, "gsd", n.gsd);
+  }
+  if (state.enums) {
+    const e = state.enums;
+    pushIn(clauses, "platform", e.platform);
+    pushIn(clauses, "constellation", e.constellation);
+    pushOverlap(clauses, "instruments", e.instruments);
+    if (!caps.collections) pushIn(clauses, "collection", e.collection);
+  }
+  if (!caps.datetime && state.datetime && (state.datetime.min || state.datetime.max)) {
+    const lo = state.datetime.min;
+    const hi = state.datetime.max;
+    if (lo && hi) {
+      clauses.push({
+        op: "t_intersects",
+        args: [{ property: "datetime" }, { interval: [lo, hi] }]
+      });
+    } else if (lo) {
+      clauses.push({ op: ">=", args: [{ property: "datetime" }, { timestamp: lo }] });
+    } else if (hi) {
+      clauses.push({ op: "<=", args: [{ property: "datetime" }, { timestamp: hi }] });
+    }
+  }
+  if (clauses.length === 0) return null;
+  if (clauses.length === 1) return clauses[0];
+  return { op: "and", args: clauses };
+}
+function pushBetween(out, property, range) {
+  if (!range) return;
+  const { min, max } = range;
+  if (min == null && max == null) return;
+  if (min != null && max != null) {
+    out.push({ op: "between", args: [{ property }, [min, max]] });
+    return;
+  }
+  if (min != null) out.push({ op: ">=", args: [{ property }, min] });
+  if (max != null) out.push({ op: "<=", args: [{ property }, max] });
+}
+function pushIn(out, property, values) {
+  if (!values || values.length === 0) return;
+  if (values.length === 1) {
+    out.push({ op: "=", args: [{ property }, values[0]] });
+    return;
+  }
+  out.push({ op: "in", args: [{ property }, values] });
+}
+function pushOverlap(out, property, values) {
+  if (!values || values.length === 0) return;
+  out.push({ op: "a_overlaps", args: [{ property }, values] });
+}
+function residualState(state, caps) {
+  if (!state) return {};
+  const out = {};
+  if (state.datetime && !caps.datetime && !caps.cql2) out.datetime = state.datetime;
+  else if (state.datetime && (caps.datetime || caps.cql2)) ;
+  if (state.numeric) {
+    const remaining = {};
+    for (const [field, range] of Object.entries(state.numeric)) {
+      if (!range) continue;
+      if (caps.cql2) continue;
+      remaining[field] = range;
+    }
+    if (Object.keys(remaining).length > 0) out.numeric = remaining;
+  }
+  if (state.enums) {
+    const remaining = {};
+    for (const [field, values] of Object.entries(state.enums)) {
+      if (!Array.isArray(values) || values.length === 0) continue;
+      if (field === "collection" && caps.collections) continue;
+      if (caps.cql2 && (field === "platform" || field === "constellation" || field === "instruments")) {
+        continue;
       }
-      if (STAC_API_PATH_RE.test(url.pathname)) {
-        return {
-          ...defaultResult(defaults),
-          endpoint: `${url.protocol}//${url.host}`
+      remaining[field] = values;
+    }
+    if (Object.keys(remaining).length > 0) out.enums = remaining;
+  }
+  return out;
+}
+
+// src/stac-source.ts
+function emptyPushdown() {
+  return {
+    bbox: false,
+    datetime: false,
+    collection: false,
+    cloudCover: false,
+    gsd: false,
+    epsg: false,
+    platform: false,
+    constellation: false,
+    instruments: false,
+    assetRoles: false
+  };
+}
+
+// src/stac-source-api.ts
+function subtractState(full, residual) {
+  if (!full) return {};
+  const out = {};
+  if (full.datetime && !residual.datetime) out.datetime = full.datetime;
+  if (full.numeric) {
+    const kept = {};
+    const residualNumeric = residual.numeric ?? {};
+    for (const [k, v] of Object.entries(full.numeric)) {
+      if (!v) continue;
+      if (residualNumeric[k]) continue;
+      kept[k] = v;
+    }
+    if (Object.keys(kept).length > 0) out.numeric = kept;
+  }
+  if (full.enums) {
+    const kept = {};
+    const residualEnums = residual.enums ?? {};
+    for (const [k, v] of Object.entries(full.enums)) {
+      if (!Array.isArray(v) || v.length === 0) continue;
+      if (Array.isArray(residualEnums[k])) continue;
+      kept[k] = v;
+    }
+    if (Object.keys(kept).length > 0) out.enums = kept;
+  }
+  return out;
+}
+function datetimeFacetToRfc3339(dt) {
+  if (!dt) return void 0;
+  const lo = dt.min;
+  const hi = dt.max;
+  if (!lo && !hi) return void 0;
+  if (lo && hi) return lo === hi ? lo : `${lo}/${hi}`;
+  if (lo) return `${lo}/..`;
+  return `../${hi}`;
+}
+function createApiSource(kind, deps) {
+  const capabilities = {
+    kind: "api",
+    label: "STAC API",
+    countAvailable: false,
+    streaming: true,
+    pushdown: {
+      ...emptyPushdown(),
+      bbox: true,
+      datetime: true,
+      collection: true,
+      cloudCover: true,
+      gsd: true,
+      platform: true,
+      constellation: true,
+      instruments: true
+    }
+  };
+  let capsPromise = null;
+  const getCaps = (signal) => {
+    if (!capsPromise) {
+      capsPromise = sniffSourceCapabilities(kind, deps, signal).catch(() => SLICE_1_CAPS);
+    }
+    return capsPromise;
+  };
+  return {
+    capabilities,
+    query(req) {
+      return apiQueryIterable(kind, deps, req, getCaps);
+    }
+  };
+}
+var SLICE_1_CAPS = {
+  bbox: true,
+  datetime: true,
+  collections: false,
+  cql2: false,
+  queryables: false
+};
+async function sniffSourceCapabilities(kind, deps, signal) {
+  const inline = readConformsTo(kind);
+  if (inline && inline.length > 0) return sniffApiCapabilities(inline);
+  const json = await fetchRootJson(deps, signal);
+  if (json && typeof json === "object") {
+    const conformsTo = json.conformsTo;
+    if (Array.isArray(conformsTo)) return sniffApiCapabilities(conformsTo);
+  }
+  return SLICE_1_CAPS;
+}
+function readConformsTo(kind) {
+  if (kind.kind === "catalog" || kind.kind === "collection") {
+    const ct = kind.payload.conformsTo;
+    return Array.isArray(ct) ? ct : null;
+  }
+  if (kind.kind === "item-collection") {
+    const ct = kind.fc.conformsTo;
+    return Array.isArray(ct) ? ct : null;
+  }
+  return null;
+}
+async function fetchRootJson(deps, signal) {
+  const href = deps.baseHref;
+  if (/^https?:/i.test(href)) {
+    const ownKey = deps.urlToKey ? deps.urlToKey(href) : null;
+    if (ownKey !== null) {
+      const buf2 = await deps.adapter.read(ownKey, void 0, void 0, signal);
+      return JSON.parse(new TextDecoder().decode(buf2));
+    }
+    const res = await fetch(href, { signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status} for ${href}`);
+    return await res.json();
+  }
+  const buf = await deps.adapter.read(href, void 0, void 0, signal);
+  return JSON.parse(new TextDecoder().decode(buf));
+}
+async function* apiQueryIterable(kind, deps, req, getCaps) {
+  if (req.signal.aborted) throw new DOMException("Aborted", "AbortError");
+  const caps = await getCaps(req.signal);
+  if (req.signal.aborted) throw new DOMException("Aborted", "AbortError");
+  const native = toNativeQuery(req.filter, caps, {
+    bbox: req.bbox,
+    limit: req.pageSize ?? req.limit
+  });
+  const datetime = native.datetime ?? datetimeFacetToRfc3339(req.filter.datetime);
+  const itemsQuery = {
+    bbox: native.bbox ?? req.bbox,
+    datetime,
+    limit: native.limit ?? req.pageSize ?? req.limit,
+    filter: native.filter
+  };
+  const residual = residualState(req.filter, caps);
+  const pushedDown = subtractState(req.filter, residual);
+  if (!caps.cql2) {
+    itemsQuery.filter = void 0;
+  } else if (itemsQuery.filter === void 0) {
+    const cql = toCql2Filter(req.filter, caps);
+    if (cql) itemsQuery.filter = cql;
+  }
+  const buffer = [];
+  let pendingResolve = null;
+  const push = (s) => {
+    if (pendingResolve) {
+      const r = pendingResolve;
+      pendingResolve = null;
+      r(s);
+    } else {
+      buffer.push(s);
+    }
+  };
+  const next = () => {
+    if (buffer.length > 0) return Promise.resolve(buffer.shift());
+    return new Promise((resolve) => {
+      pendingResolve = resolve;
+    });
+  };
+  const onAbort = () => push({ kind: "error", error: new DOMException("Aborted", "AbortError") });
+  req.signal.addEventListener("abort", onAbort, { once: true });
+  void (async () => {
+    try {
+      await hydrateStacItems(kind, deps.baseHref, deps.adapter, {
+        signal: req.signal,
+        concurrency: deps.concurrency ?? 12,
+        limit: req.limit,
+        urlToKey: deps.urlToKey,
+        itemsQuery,
+        onBatch: (batch) => {
+          if (batch.length > 0) push({ kind: "value", batch });
+        }
+      });
+      push({ kind: "done" });
+    } catch (err) {
+      push({ kind: "error", error: err });
+    }
+  })();
+  try {
+    while (true) {
+      const state = await next();
+      if (state.kind === "value") {
+        yield {
+          items: state.batch,
+          pushedDown,
+          residual,
+          done: false
         };
+        continue;
       }
-      if (pathParts.length > 0) {
-        const endpoint = `${url.protocol}//${url.host}`;
-        return {
-          bucket: pathParts[0],
-          region: defaults.region || "us-east-1",
-          endpoint,
-          provider: defaults.provider || "s3",
-          prefix: pathParts.slice(1).join("/")
+      if (state.kind === "done") {
+        yield {
+          items: [],
+          pushedDown,
+          residual,
+          done: true
         };
+        return;
       }
-      return {
-        ...defaultResult(defaults),
-        endpoint: `${url.protocol}//${url.host}`
-      };
-    } catch {
+      throw state.error;
     }
+  } finally {
+    req.signal.removeEventListener("abort", onAbort);
   }
-  const cleaned = trimmed.replace(/^\/+|\/+$/g, "");
+}
+
+// src/stac-source-static.ts
+function createStaticSource(kind, deps) {
+  const capabilities = {
+    kind: "static",
+    label: "Static catalog",
+    countAvailable: false,
+    streaming: true,
+    pushdown: { ...emptyPushdown() }
+  };
   return {
-    bucket: cleaned,
-    region: defaults.region || "us-east-1",
-    endpoint: defaults.endpoint || "",
-    provider: defaults.provider || "s3",
-    prefix: ""
+    capabilities,
+    query(req) {
+      return staticQueryIterable(kind, deps, req);
+    }
   };
 }
-function looksLikeUrl(input) {
-  const lower = input.trim().toLowerCase();
-  if (lower.startsWith("http://") || lower.startsWith("https://")) return true;
-  for (const scheme of Object.keys(SCHEME_MAP)) {
-    if (lower.startsWith(scheme)) return true;
+async function* staticQueryIterable(kind, deps, req) {
+  if (req.signal.aborted) throw new DOMException("Aborted", "AbortError");
+  const pushedDown = {};
+  const residual = req.filter;
+  const buffer = [];
+  let pendingResolve = null;
+  const push = (s) => {
+    if (pendingResolve) {
+      const r = pendingResolve;
+      pendingResolve = null;
+      r(s);
+    } else {
+      buffer.push(s);
+    }
+  };
+  const next = () => {
+    if (buffer.length > 0) return Promise.resolve(buffer.shift());
+    return new Promise((resolve) => {
+      pendingResolve = resolve;
+    });
+  };
+  const onAbort = () => push({ kind: "error", error: new DOMException("Aborted", "AbortError") });
+  req.signal.addEventListener("abort", onAbort, { once: true });
+  void (async () => {
+    try {
+      await hydrateStacItems(kind, deps.baseHref, deps.adapter, {
+        signal: req.signal,
+        concurrency: deps.concurrency ?? 12,
+        limit: req.limit,
+        urlToKey: deps.urlToKey,
+        onBatch: (batch) => {
+          if (batch.length > 0) push({ kind: "value", batch });
+        }
+      });
+      push({ kind: "done" });
+    } catch (err) {
+      push({ kind: "error", error: err });
+    }
+  })();
+  try {
+    while (true) {
+      const state = await next();
+      if (state.kind === "value") {
+        yield {
+          items: state.batch,
+          pushedDown,
+          residual,
+          done: false
+        };
+        continue;
+      }
+      if (state.kind === "done") {
+        yield { items: [], pushedDown, residual, done: true };
+        return;
+      }
+      throw state.error;
+    }
+  } finally {
+    req.signal.removeEventListener("abort", onAbort);
   }
-  return false;
 }
-function describeParseResult(parsed) {
-  const parts = [];
-  if (parsed.bucket) parts.push(`bucket="${parsed.bucket}"`);
-  if (parsed.endpoint) parts.push(`endpoint="${parsed.endpoint}"`);
-  if (parsed.region && parsed.region !== "us-east-1") parts.push(`region="${parsed.region}"`);
-  if (parsed.provider !== "s3") parts.push(`provider=${parsed.provider}`);
-  if (parsed.prefix) parts.push(`prefix="${parsed.prefix}"`);
-  return parts.length > 0 ? `Detected: ${parts.join(", ")}` : "";
+
+// src/storage-smoketest.ts
+async function smokeTestHref(href, signal) {
+  let response;
+  try {
+    response = await fetch(href, {
+      method: "GET",
+      headers: { Range: "bytes=0-0" },
+      signal,
+      redirect: "follow"
+    });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") throw err;
+    const reason2 = err instanceof Error ? err.message : String(err);
+    return { ok: false, status: null, reason: reason2 };
+  }
+  if (response.ok || response.status === 206) {
+    await response.body?.cancel().catch(() => {
+    });
+    return { ok: true };
+  }
+  const reason = `${response.status} ${response.statusText || ""}`.trim();
+  return { ok: false, status: response.status, reason };
 }
 
-// ../../src/lib/utils/wkb.ts
+// src/wkb.ts
 var WKB_POINT = 1;
 var WKB_LINESTRING = 2;
 var WKB_POLYGON = 3;
@@ -3286,17 +5740,29 @@ function looksLikeWKB(value) {
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   let typeInt = view.getUint32(1, le);
   typeInt = (typeInt & 65535) % 1e3;
-  return typeInt >= 1 && typeInt <= 7;
+  return typeInt >= 1 && typeInt <= 6;
 }
 function findGeoColumnFromRows(rows, schema) {
   if (rows.length === 0) return null;
-  const sample = rows[0];
+  const MAX_SCAN = 50;
+  const scan = rows.slice(0, MAX_SCAN);
+  const firstNonNull = (key) => {
+    for (const row of scan) {
+      const v = row[key];
+      if (v !== null && v !== void 0) return v;
+    }
+    return void 0;
+  };
   for (const f of schema) {
     const t = f.type.toLowerCase();
     const isBinary = t.includes("blob") || t.includes("binary") || t.includes("bytea");
-    if (isBinary && looksLikeWKB(sample[f.name])) return f.name;
+    if (isBinary && looksLikeWKB(firstNonNull(f.name))) return f.name;
   }
-  for (const [key, value] of Object.entries(sample)) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const row of scan) for (const k of Object.keys(row)) keys.add(k);
+  for (const key of keys) {
+    const value = firstNonNull(key);
+    if (value === void 0) continue;
     if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
       if (looksLikeWKB(value)) return key;
     }
@@ -3331,34 +5797,81 @@ function isWKT(value) {
 }
 
 exports.COPY_FEEDBACK_MS = COPY_FEEDBACK_MS;
+exports.DATETIME_HISTOGRAM_BINS = DATETIME_HISTOGRAM_BINS;
+exports.DATETIME_HISTOGRAM_BINS_MAX = DATETIME_HISTOGRAM_BINS_MAX;
+exports.DEFAULT_APP_CONFIG = DEFAULT_APP_CONFIG;
+exports.DEFAULT_AWS_REGION = DEFAULT_AWS_REGION;
 exports.DEFAULT_TARGET_CRS = DEFAULT_TARGET_CRS;
 exports.DUCKDB_INIT_TIMEOUT_MS = DUCKDB_INIT_TIMEOUT_MS;
+exports.FIRST_FEATURE_FLY_ZOOM = FIRST_FEATURE_FLY_ZOOM;
 exports.LAYER_HUE_MULTIPLIER = LAYER_HUE_MULTIPLIER;
+exports.LruCache = LruCache;
 exports.MAX_QUERY_HISTORY_ENTRIES = MAX_QUERY_HISTORY_ENTRIES;
+exports.MarkdownSqlContext = MarkdownSqlContext;
+exports.PRESETS = PRESETS;
 exports.PROVIDERS = PROVIDERS;
 exports.PROVIDER_IDS = PROVIDER_IDS;
 exports.QueryCancelledError = QueryCancelledError;
 exports.SF_LABELS = SF_LABELS;
 exports.SQL_PREVIEW_LENGTH = SQL_PREVIEW_LENGTH;
+exports.STAC_API_PATH_RE = STAC_API_PATH_RE;
+exports.STAC_COG_ASSET_KEYS = STAC_COG_ASSET_KEYS;
 exports.STAC_GEOPARQUET_REQUIRED_COLUMNS = STAC_GEOPARQUET_REQUIRED_COLUMNS;
 exports.STORAGE_KEYS = STORAGE_KEYS;
+exports.TILE_DEBOUNCE_MS = TILE_DEBOUNCE_MS;
 exports.UrlAdapter = UrlAdapter;
 exports.VIEWER_DIR_EXTENSIONS = VIEWER_DIR_EXTENSIONS;
 exports.WGS84_CODES = WGS84_CODES;
+exports.absolutizeHref = absolutizeHref;
+exports.allChannelsBand0 = allChannelsBand0;
+exports.applyFacets = applyFacets;
+exports.applyPreset = applyPreset;
+exports.applyStacItemStorageHints = applyStacItemStorageHints;
+exports.applyStorageHintsToConnection = applyStorageHintsToConnection;
+exports.attachPixelInspector = attachPixelInspector;
+exports.availablePresets = availablePresets;
 exports.buildDataTypeLabel = buildDataTypeLabel;
 exports.buildDuckDbSource = buildDuckDbSource;
 exports.buildEndpointFromTemplate = buildEndpointFromTemplate;
+exports.buildFacets = buildFacets;
 exports.buildGeoArrowTables = buildGeoArrowTables;
+exports.buildMosaicSourceMeta = buildMosaicSourceMeta;
 exports.buildProviderBaseUrl = buildProviderBaseUrl;
+exports.buildTransformExpr = buildTransformExpr;
 exports.clampBounds = clampBounds;
+exports.classifyStac = classifyStac;
 exports.classifyType = classifyType;
+exports.classifyUrl = classifyUrl;
+exports.coerceBool = coerceBool;
+exports.coercePositiveInt = coercePositiveInt;
+exports.coerceString = coerceString;
+exports.coerceTheme = coerceTheme;
+exports.compositeFromUrl = compositeFromUrl;
+exports.compositeToUrl = compositeToUrl;
+exports.connectionIdentityKey = connectionIdentityKey;
+exports.copyToClipboard = copyToClipboard;
+exports.createApiSource = createApiSource;
+exports.createStaticSource = createStaticSource;
 exports.describeParseResult = describeParseResult;
+exports.detectHostBucket = detectHostBucket;
+exports.detectMosaicCapable = detectMosaicCapable;
+exports.detectMultiCogCapable = detectMultiCogCapable;
+exports.detectStorageExtensionVersion = detectStorageExtensionVersion;
+exports.emptyFacetState = emptyFacetState;
+exports.emptyPushdown = emptyPushdown;
+exports.emptyStorageHints = emptyStorageHints;
 exports.escapeCsvField = escapeCsvField;
 exports.exportToCsv = exportToCsv;
 exports.exportToJson = exportToJson;
 exports.extractBounds = extractBounds;
+exports.extractCogAssets = extractCogAssets;
 exports.extractEpsgFromGeoMeta = extractEpsgFromGeoMeta;
 exports.extractGeometryTypes = extractGeometryTypes;
+exports.extractItemView = extractItemView;
+exports.extractMosaicAssets = extractMosaicAssets;
+exports.extractRasterBandAssets = extractRasterBandAssets;
+exports.extractSentinelBandAssets = extractSentinelBandAssets;
+exports.extractStorageHints = extractStorageHints;
 exports.findGeoColumn = findGeoColumn;
 exports.findGeoColumnFromRows = findGeoColumnFromRows;
 exports.flattenStacBbox = flattenStacBbox;
@@ -3375,36 +5888,76 @@ exports.getNativeScheme = getNativeScheme;
 exports.getProvider = getProvider;
 exports.getViewerKind = getViewerKind;
 exports.handleLoadError = handleLoadError;
+exports.hasActiveFilters = hasActiveFilters;
+exports.hasCompositableBands = hasCompositableBands;
+exports.hasRgbBands = hasRgbBands;
+exports.hasStacItemsEndpoint = hasStacItemsEndpoint;
+exports.hydrateStacItems = hydrateStacItems;
 exports.interpolateTemplates = interpolateTemplates;
+exports.isAbortError = isAbortError;
 exports.isCloudNativeFormat = isCloudNativeFormat;
 exports.isGcsProvider = isGcsProvider;
+exports.isKnownBucketHost = isKnownBucketHost;
 exports.isPubliclyStreamable = isPubliclyStreamable;
 exports.isQueryable = isQueryable;
+exports.isSameConnectionIdentity = isSameConnectionIdentity;
+exports.isSingleAssetComposite = isSingleAssetComposite;
+exports.isStacCatalog = isStacCatalog;
+exports.isStacCollection = isStacCollection;
+exports.isStacFeatureCollection = isStacFeatureCollection;
 exports.isStacGeoparquetSchema = isStacGeoparquetSchema;
+exports.isStacItem = isStacItem;
+exports.isWgs84 = isWgs84;
+exports.isWgs84Crs = isWgs84Crs;
 exports.jsonReplacerBigInt = jsonReplacerBigInt;
 exports.loadFromStorage = loadFromStorage;
 exports.looksLikeUrl = looksLikeUrl;
 exports.markSqlBlocks = markSqlBlocks;
+exports.mergeAppConfig = mergeAppConfig;
+exports.normalizeEndpoint = normalizeEndpoint;
 exports.normalizeGeomType = normalizeGeomType;
+exports.normalizeProvider = normalizeProvider;
+exports.parseGeometryTypeCrs = parseGeometryTypeCrs;
 exports.parseMarkdownDocument = parseMarkdownDocument;
 exports.parseStorageUrl = parseStorageUrl;
+exports.parseVisibilityParam = parseVisibilityParam;
 exports.parseWKB = parseWKB;
 exports.persistToStorage = persistToStorage;
+exports.pickCogAssetHref = pickCogAssetHref;
+exports.pickGranularity = pickGranularity;
+exports.pickNaturalColorComposite = pickNaturalColorComposite;
 exports.pickStacPrimaryAsset = pickStacPrimaryAsset;
+exports.presetMatchesComposite = presetMatchesComposite;
 exports.readParquetMetadata = readParquetMetadata;
+exports.renderNotebook = renderNotebook;
+exports.residualState = residualState;
+exports.resolveBandSlotAssetKey = resolveBandSlotAssetKey;
+exports.resolveBasemap = resolveBasemap;
 exports.resolveCloudUrl = resolveCloudUrl;
+exports.resolvePresetComposite = resolvePresetComposite;
 exports.resolveProviderEndpoint = resolveProviderEndpoint;
+exports.resolveSetting = resolveSetting;
 exports.resolveStacAssetHref = resolveStacAssetHref;
 exports.safeClamp = safeClamp;
 exports.safeDecodeURIComponent = safeDecodeURIComponent;
 exports.serializeToCsv = serializeToCsv;
 exports.serializeToJson = serializeToJson;
+exports.smokeTestHref = smokeTestHref;
+exports.sniffApiCapabilities = sniffApiCapabilities;
 exports.sortFileEntries = sortFileEntries;
+exports.sortViews = sortViews;
+exports.spatialCellKey = spatialCellKey;
+exports.stacItemBbox = stacItemBbox;
 exports.stacRowToItem = stacRowToItem;
+exports.syntheticSelfAsset = syntheticSelfAsset;
 exports.toBinary = toBinary;
+exports.toCql2Filter = toCql2Filter;
+exports.toNativeQuery = toNativeQuery;
 exports.toggleSortField = toggleSortField;
 exports.typeBadgeClass = typeBadgeClass;
 exports.typeColor = typeColor;
 exports.typeLabel = typeLabel;
+exports.wireCodeCopyButtons = wireCodeCopyButtons;
+exports.wrapWkbWithCrs = wrapWkbWithCrs;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map