@walkthru-earth/objex-utils 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -1,6 +1,11 @@
 'use strict';
 
 var apacheArrow = require('apache-arrow');
+var YAML = require('yaml');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var YAML__default = /*#__PURE__*/_interopDefault(YAML);
 
 // ../../src/lib/constants.ts
 var STORAGE_KEYS = {
@@ -1059,959 +1064,6 @@ var QueryCancelledError = class extends Error {
   }
 };
 
-// ../../src/lib/storage/url-adapter.ts
-var UrlAdapter = class {
-  supportsWrite = false;
-  async read(url, offset, length, signal) {
-    const headers = {};
-    if (offset !== void 0 && length !== void 0) {
-      headers.Range = `bytes=${offset}-${offset + length - 1}`;
-    } else if (offset !== void 0) {
-      headers.Range = `bytes=${offset}-`;
-    }
-    const res = await fetch(url, { headers, signal });
-    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-    return new Uint8Array(await res.arrayBuffer());
-  }
-  async head(url, signal) {
-    const res = await fetch(url, { method: "HEAD", signal });
-    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
-    const name = url.split("/").pop()?.split("?")[0] || "file";
-    const ext = name.includes(".") ? name.split(".").pop().toLowerCase() : "";
-    return {
-      name,
-      path: url,
-      is_dir: false,
-      size: Number(res.headers.get("content-length") || 0),
-      modified: new Date(res.headers.get("last-modified") || 0).getTime(),
-      extension: ext
-    };
-  }
-  async list() {
-    return [];
-  }
-  async put() {
-    throw new Error("Write not supported for direct URL sources");
-  }
-  async delete() {
-    throw new Error("Delete not supported for direct URL sources");
-  }
-  async deletePrefix() {
-    throw new Error("Delete not supported for direct URL sources");
-  }
-  async copy() {
-    throw new Error("Copy not supported for direct URL sources");
-  }
-};
-
-// ../../src/lib/utils/column-types.ts
-var NUMBER_TYPES = [
-  "TINYINT",
-  "SMALLINT",
-  "INTEGER",
-  "BIGINT",
-  "HUGEINT",
-  "UTINYINT",
-  "USMALLINT",
-  "UINTEGER",
-  "UBIGINT",
-  "FLOAT",
-  "DOUBLE",
-  "DECIMAL",
-  "NUMERIC",
-  "REAL",
-  "INT",
-  "INT1",
-  "INT2",
-  "INT4",
-  "INT8",
-  "SIGNED",
-  "SHORT",
-  "LONG"
-];
-var STRING_TYPES = ["VARCHAR", "TEXT", "STRING", "CHAR", "BPCHAR", "NAME", "UUID", "ENUM"];
-var DATE_TYPES = [
-  "DATE",
-  "TIME",
-  "TIMESTAMP",
-  "TIMESTAMP_S",
-  "TIMESTAMP_MS",
-  "TIMESTAMP_NS",
-  "TIMESTAMP WITH TIME ZONE",
-  "TIMESTAMPTZ",
-  "INTERVAL",
-  "TIMESTAMP_TZ"
-];
-var BOOLEAN_TYPES = ["BOOLEAN", "BOOL", "LOGICAL"];
-var GEO_TYPES = [
-  "GEOMETRY",
-  "POINT",
-  "LINESTRING",
-  "POLYGON",
-  "MULTIPOINT",
-  "MULTILINESTRING",
-  "MULTIPOLYGON",
-  "GEOMETRYCOLLECTION",
-  "WKB_GEOMETRY"
-];
-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();
-  if (NUMBER_TYPES.includes(base)) return "number";
-  if (STRING_TYPES.includes(base)) return "string";
-  if (DATE_TYPES.includes(base)) return "date";
-  if (BOOLEAN_TYPES.includes(base)) return "boolean";
-  if (GEO_TYPES.includes(base)) return "geo";
-  if (BINARY_TYPES.includes(base)) return "binary";
-  if (JSON_TYPES.includes(base)) return "json";
-  if (base.startsWith("STRUCT") || base.startsWith("MAP") || base.startsWith("UNION"))
-    return "json";
-  if (base.endsWith("[]") || base.startsWith("LIST")) return "json";
-  if (upper.includes("INT") || upper.includes("FLOAT") || upper.includes("DOUBLE") || upper.includes("DECIMAL") || upper.includes("NUMERIC"))
-    return "number";
-  if (upper.includes("CHAR") || upper.includes("TEXT") || upper.includes("STRING")) return "string";
-  if (upper.includes("TIME") || upper.includes("DATE")) return "date";
-  if (upper.includes("BOOL")) return "boolean";
-  if (upper.includes("GEOMETRY") || upper.includes("GEO") || upper.includes("WKB")) return "geo";
-  if (upper.includes("BLOB") || upper.includes("BINARY")) return "binary";
-  if (upper.includes("JSON") || upper.includes("STRUCT") || upper.includes("MAP") || upper.includes("LIST"))
-    return "json";
-  return "other";
-}
-var TYPE_COLORS = {
-  number: "text-blue-500",
-  string: "text-green-500",
-  date: "text-amber-500",
-  boolean: "text-purple-500",
-  geo: "text-teal-500",
-  binary: "text-zinc-500",
-  json: "text-orange-500",
-  other: "text-zinc-400"
-};
-var TYPE_BADGE_CLASSES = {
-  number: "bg-blue-500/10 text-blue-600 dark:text-blue-400 border-blue-500/20",
-  string: "bg-green-500/10 text-green-600 dark:text-green-400 border-green-500/20",
-  date: "bg-amber-500/10 text-amber-600 dark:text-amber-400 border-amber-500/20",
-  boolean: "bg-purple-500/10 text-purple-600 dark:text-purple-400 border-purple-500/20",
-  geo: "bg-teal-500/10 text-teal-600 dark:text-teal-400 border-teal-500/20",
-  binary: "bg-zinc-500/10 text-zinc-600 dark:text-zinc-400 border-zinc-500/20",
-  json: "bg-orange-500/10 text-orange-600 dark:text-orange-400 border-orange-500/20",
-  other: "bg-zinc-500/10 text-zinc-500 dark:text-zinc-400 border-zinc-500/20"
-};
-var TYPE_LABELS = {
-  number: "#",
-  string: "Aa",
-  date: "dt",
-  boolean: "T/F",
-  geo: "geo",
-  binary: "01",
-  json: "{}",
-  other: "?"
-};
-function typeColor(category) {
-  return TYPE_COLORS[category];
-}
-function typeBadgeClass(category) {
-  return TYPE_BADGE_CLASSES[category];
-}
-function typeLabel(category) {
-  return TYPE_LABELS[category];
-}
-
-// ../../src/lib/utils/error.ts
-function handleLoadError(err) {
-  if (err instanceof DOMException && err.name === "AbortError") return null;
-  return err instanceof Error ? err.message : String(err);
-}
-
-// ../../src/lib/utils/format.ts
-function formatFileSize(bytes) {
-  if (bytes < 0) return "0 B";
-  if (bytes === 0) return "0 B";
-  const units = ["B", "KB", "MB", "GB", "TB"];
-  const base = 1024;
-  const exponent = Math.min(Math.floor(Math.log(bytes) / Math.log(base)), units.length - 1);
-  const value = bytes / base ** exponent;
-  if (exponent === 0) return `${bytes} B`;
-  return `${value.toFixed(1)} ${units[exponent]}`;
-}
-function formatDate(timestamp) {
-  if (!timestamp || timestamp <= 0 || !Number.isFinite(timestamp)) return "--";
-  const date = new Date(timestamp);
-  const now = Date.now();
-  const diffMs = now - timestamp;
-  const diffSeconds = Math.floor(diffMs / 1e3);
-  const diffMinutes = Math.floor(diffSeconds / 60);
-  const diffHours = Math.floor(diffMinutes / 60);
-  const diffDays = Math.floor(diffHours / 24);
-  if (diffSeconds < 60) return "Just now";
-  if (diffMinutes < 60) return `${diffMinutes}m ago`;
-  if (diffHours < 24) return `${diffHours}h ago`;
-  if (diffDays < 7) return `${diffDays}d ago`;
-  return date.toLocaleDateString(void 0, {
-    year: "numeric",
-    month: "short",
-    day: "numeric"
-  });
-}
-function getFileExtension(filename) {
-  const lastDot = filename.lastIndexOf(".");
-  if (lastDot <= 0) return "";
-  return filename.slice(lastDot).toLowerCase();
-}
-function jsonReplacerBigInt(_key, value) {
-  return typeof value === "bigint" ? value.toString() : value;
-}
-function formatValue(value) {
-  if (value === null || value === void 0) return "NULL";
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "bigint") return value.toString();
-  if (typeof value === "object") return JSON.stringify(value, jsonReplacerBigInt);
-  return String(value);
-}
-function normalizeGeomType(raw) {
-  const s = raw.toUpperCase().replace(/\s+/g, "");
-  if (s === "POINT") return "point";
-  if (s === "LINESTRING") return "linestring";
-  if (s === "POLYGON") return "polygon";
-  if (s === "MULTIPOINT") return "multipoint";
-  if (s === "MULTILINESTRING") return "multilinestring";
-  if (s === "MULTIPOLYGON") return "multipolygon";
-  return "polygon";
-}
-var EXTENSION_NAMES = {
-  point: "geoarrow.point",
-  linestring: "geoarrow.linestring",
-  polygon: "geoarrow.polygon",
-  multipoint: "geoarrow.multipoint",
-  multilinestring: "geoarrow.multilinestring",
-  multipolygon: "geoarrow.multipolygon"
-};
-function readWkbHeader(wkb) {
-  if (wkb.length < 5) return null;
-  const le = wkb[0] === 1;
-  const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-  const rawType = dv.getUint32(1, le);
-  let headerSize = 5;
-  if ((rawType & 536870912) !== 0) headerSize += 4;
-  const ewkbZ = (rawType & 2147483648) !== 0;
-  const ewkbM = (rawType & 1073741824) !== 0;
-  let type = rawType & 268435455;
-  let isoZ = false;
-  let isoM = false;
-  if (type > 3e3) {
-    isoZ = true;
-    isoM = true;
-    type -= 3e3;
-  } else if (type > 2e3) {
-    isoM = true;
-    type -= 2e3;
-  } else if (type > 1e3) {
-    isoZ = true;
-    type -= 1e3;
-  }
-  const dims = (ewkbZ || isoZ ? 1 : 0) + (ewkbM || isoM ? 1 : 0);
-  const coordStride = (2 + dims) * 8;
-  return { type, le, coordStride, dataOffset: headerSize };
-}
-function classifyWkbType(wkb) {
-  const h = readWkbHeader(wkb);
-  if (!h) return null;
-  switch (h.type) {
-    case 1:
-      return "point";
-    case 2:
-      return "linestring";
-    case 3:
-      return "polygon";
-    case 4:
-      return "multipoint";
-    case 5:
-      return "multilinestring";
-    case 6:
-      return "multipolygon";
-    default:
-      return null;
-  }
-}
-function newBounds() {
-  return { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
-}
-function expandBounds(b, x, y) {
-  if (Number.isNaN(x) || Number.isNaN(y)) return;
-  if (x < b.minX) b.minX = x;
-  if (y < b.minY) b.minY = y;
-  if (x > b.maxX) b.maxX = x;
-  if (y > b.maxY) b.maxY = y;
-}
-var coordField = new apacheArrow.Field("xy", new apacheArrow.Float64());
-var coordType = new apacheArrow.FixedSizeList(2, coordField);
-function makeCoordData(coords, numPoints) {
-  const floatData = apacheArrow.makeData({ type: new apacheArrow.Float64(), length: coords.length, data: coords });
-  return apacheArrow.makeData({ type: coordType, length: numPoints, nullCount: 0, child: floatData });
-}
-function buildPointData(wkbs, b) {
-  const n = wkbs.length;
-  const coords = new Float64Array(n * 2);
-  for (let i = 0; i < n; i++) {
-    const wkb = wkbs[i];
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 1) {
-      coords[i * 2] = 0;
-      coords[i * 2 + 1] = 0;
-      continue;
-    }
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const x = dv.getFloat64(h.dataOffset, h.le);
-    const y = dv.getFloat64(h.dataOffset + 8, h.le);
-    coords[i * 2] = x;
-    coords[i * 2 + 1] = y;
-    expandBounds(b, x, y);
-  }
-  return makeCoordData(coords, n);
-}
-function buildLineStringData(wkbs, b) {
-  const n = wkbs.length;
-  const geomOffsets = new Int32Array(n + 1);
-  let totalCoords = 0;
-  for (let i = 0; i < n; i++) {
-    geomOffsets[i] = totalCoords;
-    const h = readWkbHeader(wkbs[i]);
-    if (!h || h.type !== 2) continue;
-    const dv = new DataView(wkbs[i].buffer, wkbs[i].byteOffset, wkbs[i].byteLength);
-    const numPts = dv.getUint32(h.dataOffset, h.le);
-    totalCoords += numPts;
-  }
-  geomOffsets[n] = totalCoords;
-  const coords = new Float64Array(totalCoords * 2);
-  let ci = 0;
-  for (const wkb of wkbs) {
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 2) continue;
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const numPts = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let j = 0; j < numPts; j++) {
-      const x = dv.getFloat64(off, h.le);
-      const y = dv.getFloat64(off + 8, h.le);
-      coords[ci++] = x;
-      coords[ci++] = y;
-      expandBounds(b, x, y);
-      off += h.coordStride;
-    }
-  }
-  const fslData = makeCoordData(coords, totalCoords);
-  const listType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
-  return apacheArrow.makeData({
-    type: listType,
-    length: n,
-    nullCount: 0,
-    valueOffsets: geomOffsets,
-    child: fslData
-  });
-}
-function buildPolygonData(wkbs, b) {
-  const n = wkbs.length;
-  const geomOffsets = new Int32Array(n + 1);
-  let totalRings = 0;
-  let totalCoords = 0;
-  for (let i = 0; i < n; i++) {
-    geomOffsets[i] = totalRings;
-    const h = readWkbHeader(wkbs[i]);
-    if (!h || h.type !== 3) continue;
-    const dv = new DataView(wkbs[i].buffer, wkbs[i].byteOffset, wkbs[i].byteLength);
-    const numRings = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let r = 0; r < numRings; r++) {
-      const numPts = dv.getUint32(off, h.le);
-      off += 4 + numPts * h.coordStride;
-      totalCoords += numPts;
-      totalRings++;
-    }
-  }
-  geomOffsets[n] = totalRings;
-  const ringOffsets = new Int32Array(totalRings + 1);
-  const coords = new Float64Array(totalCoords * 2);
-  let ri = 0;
-  let ci = 0;
-  for (const wkb of wkbs) {
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 3) continue;
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const numRings = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let r = 0; r < numRings; r++) {
-      ringOffsets[ri++] = ci >> 1;
-      const numPts = dv.getUint32(off, h.le);
-      off += 4;
-      for (let j = 0; j < numPts; j++) {
-        const x = dv.getFloat64(off, h.le);
-        const y = dv.getFloat64(off + 8, h.le);
-        coords[ci++] = x;
-        coords[ci++] = y;
-        expandBounds(b, x, y);
-        off += h.coordStride;
-      }
-    }
-  }
-  ringOffsets[totalRings] = ci >> 1;
-  const coordCount = ci >> 1;
-  const fslData = makeCoordData(coords, coordCount);
-  const ringListType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
-  const ringListData = apacheArrow.makeData({
-    type: ringListType,
-    length: totalRings,
-    nullCount: 0,
-    valueOffsets: ringOffsets,
-    child: fslData
-  });
-  const polyType = new apacheArrow.List(new apacheArrow.Field("rings", ringListType));
-  return apacheArrow.makeData({
-    type: polyType,
-    length: n,
-    nullCount: 0,
-    valueOffsets: geomOffsets,
-    child: ringListData
-  });
-}
-function buildMultiPointData(wkbs, b) {
-  const n = wkbs.length;
-  const geomOffsets = new Int32Array(n + 1);
-  let totalCoords = 0;
-  for (let i = 0; i < n; i++) {
-    geomOffsets[i] = totalCoords;
-    const h = readWkbHeader(wkbs[i]);
-    if (!h || h.type !== 4) continue;
-    const dv = new DataView(wkbs[i].buffer, wkbs[i].byteOffset, wkbs[i].byteLength);
-    totalCoords += dv.getUint32(h.dataOffset, h.le);
-  }
-  geomOffsets[n] = totalCoords;
-  const coords = new Float64Array(totalCoords * 2);
-  let ci = 0;
-  for (const wkb of wkbs) {
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 4) continue;
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const numPts = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let j = 0; j < numPts; j++) {
-      const innerH = readWkbHeader(
-        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
-      );
-      if (innerH) {
-        const x = dv.getFloat64(off + innerH.dataOffset, innerH.le);
-        const y = dv.getFloat64(off + innerH.dataOffset + 8, innerH.le);
-        coords[ci++] = x;
-        coords[ci++] = y;
-        expandBounds(b, x, y);
-        off += innerH.dataOffset + innerH.coordStride;
-      } else {
-        coords[ci++] = 0;
-        coords[ci++] = 0;
-        off += 21;
-      }
-    }
-  }
-  const fslData = makeCoordData(coords, totalCoords);
-  const listType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
-  return apacheArrow.makeData({
-    type: listType,
-    length: n,
-    nullCount: 0,
-    valueOffsets: geomOffsets,
-    child: fslData
-  });
-}
-function buildMultiLineStringData(wkbs, b) {
-  const n = wkbs.length;
-  const geomOffsetsArr = [0];
-  let totalLines = 0;
-  let totalCoords = 0;
-  for (const wkb of wkbs) {
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 5) {
-      geomOffsetsArr.push(totalLines);
-      continue;
-    }
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const numLines = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let l = 0; l < numLines; l++) {
-      const innerH = readWkbHeader(
-        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
-      );
-      if (!innerH) break;
-      const innerDv = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off);
-      const numPts = innerDv.getUint32(innerH.dataOffset, innerH.le);
-      totalCoords += numPts;
-      off += innerH.dataOffset + 4 + numPts * innerH.coordStride;
-      totalLines++;
-    }
-    geomOffsetsArr.push(totalLines);
-  }
-  const geomOffsets = new Int32Array(geomOffsetsArr);
-  const lineOffsets = new Int32Array(totalLines + 1);
-  const coords = new Float64Array(totalCoords * 2);
-  let li = 0;
-  let ci = 0;
-  for (const wkb of wkbs) {
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 5) continue;
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const numLines = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let l = 0; l < numLines; l++) {
-      lineOffsets[li++] = ci >> 1;
-      const innerH = readWkbHeader(
-        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
-      );
-      if (!innerH) break;
-      const numPts = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off).getUint32(
-        innerH.dataOffset,
-        innerH.le
-      );
-      let ptOff = off + innerH.dataOffset + 4;
-      for (let j = 0; j < numPts; j++) {
-        const x = dv.getFloat64(ptOff, innerH.le);
-        const y = dv.getFloat64(ptOff + 8, innerH.le);
-        coords[ci++] = x;
-        coords[ci++] = y;
-        expandBounds(b, x, y);
-        ptOff += innerH.coordStride;
-      }
-      off = ptOff;
-    }
-  }
-  lineOffsets[totalLines] = ci >> 1;
-  const fslData = makeCoordData(coords, ci >> 1);
-  const lineListType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
-  const lineListData = apacheArrow.makeData({
-    type: lineListType,
-    length: totalLines,
-    nullCount: 0,
-    valueOffsets: lineOffsets,
-    child: fslData
-  });
-  const multiLineType = new apacheArrow.List(new apacheArrow.Field("lines", lineListType));
-  return apacheArrow.makeData({
-    type: multiLineType,
-    length: n,
-    nullCount: 0,
-    valueOffsets: geomOffsets,
-    child: lineListData
-  });
-}
-function buildMultiPolygonData(wkbs, b) {
-  const n = wkbs.length;
-  const geomOffsetsArr = [0];
-  let totalPolys = 0;
-  let totalRings = 0;
-  let totalCoords = 0;
-  for (const wkb of wkbs) {
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 6) {
-      geomOffsetsArr.push(totalPolys);
-      continue;
-    }
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const numPolys = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let p = 0; p < numPolys; p++) {
-      const innerH = readWkbHeader(
-        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
-      );
-      if (!innerH) break;
-      const innerDv = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off);
-      const numRings = innerDv.getUint32(innerH.dataOffset, innerH.le);
-      let ringOff = innerH.dataOffset + 4;
-      for (let r = 0; r < numRings; r++) {
-        const numPts = innerDv.getUint32(ringOff, innerH.le);
-        ringOff += 4 + numPts * innerH.coordStride;
-        totalCoords += numPts;
-        totalRings++;
-      }
-      off += ringOff;
-      totalPolys++;
-    }
-    geomOffsetsArr.push(totalPolys);
-  }
-  const geomOffsets = new Int32Array(geomOffsetsArr);
-  const polyOffsets = new Int32Array(totalPolys + 1);
-  const ringOffsets = new Int32Array(totalRings + 1);
-  const coords = new Float64Array(totalCoords * 2);
-  let pi = 0;
-  let ri = 0;
-  let ci = 0;
-  for (const wkb of wkbs) {
-    const h = readWkbHeader(wkb);
-    if (!h || h.type !== 6) continue;
-    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
-    const numPolys = dv.getUint32(h.dataOffset, h.le);
-    let off = h.dataOffset + 4;
-    for (let p = 0; p < numPolys; p++) {
-      polyOffsets[pi++] = ri;
-      const innerH = readWkbHeader(
-        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
-      );
-      if (!innerH) break;
-      const innerDv = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off);
-      const numRings = innerDv.getUint32(innerH.dataOffset, innerH.le);
-      let ringOff = off + innerH.dataOffset + 4;
-      for (let r = 0; r < numRings; r++) {
-        ringOffsets[ri++] = ci >> 1;
-        const numPts = dv.getUint32(ringOff, innerH.le);
-        ringOff += 4;
-        for (let j = 0; j < numPts; j++) {
-          const x = dv.getFloat64(ringOff, innerH.le);
-          const y = dv.getFloat64(ringOff + 8, innerH.le);
-          coords[ci++] = x;
-          coords[ci++] = y;
-          expandBounds(b, x, y);
-          ringOff += innerH.coordStride;
-        }
-      }
-      off = ringOff;
-    }
-  }
-  polyOffsets[totalPolys] = ri;
-  ringOffsets[totalRings] = ci >> 1;
-  const fslData = makeCoordData(coords, ci >> 1);
-  const ringListType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
-  const ringListData = apacheArrow.makeData({
-    type: ringListType,
-    length: totalRings,
-    nullCount: 0,
-    valueOffsets: ringOffsets,
-    child: fslData
-  });
-  const polyListType = new apacheArrow.List(new apacheArrow.Field("rings", ringListType));
-  const polyListData = apacheArrow.makeData({
-    type: polyListType,
-    length: totalPolys,
-    nullCount: 0,
-    valueOffsets: polyOffsets,
-    child: ringListData
-  });
-  const multiPolyType = new apacheArrow.List(new apacheArrow.Field("polygons", polyListType));
-  return apacheArrow.makeData({
-    type: multiPolyType,
-    length: n,
-    nullCount: 0,
-    valueOffsets: geomOffsets,
-    child: polyListData
-  });
-}
-function buildAttributeColumns(indices, attributes) {
-  const n = indices.length;
-  const fields = [];
-  const dataArr = [];
-  for (const [name, col] of attributes) {
-    const { values } = col;
-    let isNumeric = true;
-    const sampleEnd = Math.min(n, 100);
-    for (let i = 0; i < sampleEnd; i++) {
-      if (values[indices[i]] != null && typeof values[indices[i]] !== "number") {
-        isNumeric = false;
-        break;
-      }
-    }
-    if (isNumeric) {
-      const arr = new Float64Array(n);
-      for (let i = 0; i < n; i++) arr[i] = values[indices[i]] ?? NaN;
-      const data = apacheArrow.makeData({ type: new apacheArrow.Float64(), length: n, data: arr });
-      fields.push(new apacheArrow.Field(name, new apacheArrow.Float64(), true));
-      dataArr.push(data);
-    } else {
-      const encoder = new TextEncoder();
-      const offsets = new Int32Array(n + 1);
-      let totalBytes = 0;
-      const strParts = [];
-      for (let i = 0; i < n; i++) {
-        offsets[i] = totalBytes;
-        const s = values[indices[i]] != null ? String(values[indices[i]]) : "";
-        const encoded = encoder.encode(s);
-        strParts.push(encoded);
-        totalBytes += encoded.length;
-      }
-      offsets[n] = totalBytes;
-      const valueBuffer = new Uint8Array(totalBytes);
-      let pos = 0;
-      for (const sv of strParts) {
-        valueBuffer.set(sv, pos);
-        pos += sv.length;
-      }
-      const data = apacheArrow.makeData({
-        type: new apacheArrow.Utf8(),
-        length: n,
-        valueOffsets: offsets,
-        data: valueBuffer
-      });
-      fields.push(new apacheArrow.Field(name, new apacheArrow.Utf8(), true));
-      dataArr.push(data);
-    }
-  }
-  return { fields, data: dataArr };
-}
-function buildSingleTable(geomType, wkbs, indices, attributes, b) {
-  const n = wkbs.length;
-  let geomData;
-  switch (geomType) {
-    case "point":
-      geomData = buildPointData(wkbs, b);
-      break;
-    case "linestring":
-      geomData = buildLineStringData(wkbs, b);
-      break;
-    case "polygon":
-      geomData = buildPolygonData(wkbs, b);
-      break;
-    case "multipoint":
-      geomData = buildMultiPointData(wkbs, b);
-      break;
-    case "multilinestring":
-      geomData = buildMultiLineStringData(wkbs, b);
-      break;
-    case "multipolygon":
-      geomData = buildMultiPolygonData(wkbs, b);
-      break;
-  }
-  const extensionName = EXTENSION_NAMES[geomType];
-  const geomMetadata = /* @__PURE__ */ new Map([
-    ["ARROW:extension:name", extensionName],
-    [
-      "ARROW:extension:metadata",
-      JSON.stringify({
-        crs: {
-          type: "name",
-          properties: { name: "urn:ogc:def:crs:OGC:1.3:CRS84" }
-        }
-      })
-    ]
-  ]);
-  const geomField = new apacheArrow.Field("geometry", geomData.type, false, geomMetadata);
-  const attrCols = buildAttributeColumns(indices, attributes);
-  const fields = [geomField, ...attrCols.fields];
-  const childrenData = [geomData, ...attrCols.data];
-  const arrowSchema = new apacheArrow.Schema(fields);
-  const structType = new apacheArrow.Struct(fields);
-  const structData = apacheArrow.makeData({
-    type: structType,
-    length: n,
-    nullCount: 0,
-    children: childrenData
-  });
-  const batch = new apacheArrow.RecordBatch(arrowSchema, structData);
-  const table = new apacheArrow.Table(arrowSchema, batch);
-  return {
-    table,
-    geometryType: geomType,
-    bounds: [b.minX, b.minY, b.maxX, b.maxY],
-    sourceIndices: indices
-  };
-}
-function buildGeoArrowTables(wkbArrays, attributes, knownGeomType) {
-  if (wkbArrays.length === 0) return [];
-  if (knownGeomType) {
-    const globalBounds2 = newBounds();
-    const indices = Array.from({ length: wkbArrays.length }, (_, i) => i);
-    const result = buildSingleTable(knownGeomType, wkbArrays, indices, attributes, globalBounds2);
-    return [result];
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (let i = 0; i < wkbArrays.length; i++) {
-    const geomType = classifyWkbType(wkbArrays[i]);
-    if (!geomType) continue;
-    let group = groups.get(geomType);
-    if (!group) {
-      group = { wkbs: [], indices: [] };
-      groups.set(geomType, group);
-    }
-    group.wkbs.push(wkbArrays[i]);
-    group.indices.push(i);
-  }
-  if (groups.size === 0) return [];
-  const globalBounds = newBounds();
-  const results = [];
-  for (const [geomType, { wkbs, indices }] of groups) {
-    const result = buildSingleTable(geomType, wkbs, indices, attributes, globalBounds);
-    results.push(result);
-  }
-  const mergedBounds = [
-    globalBounds.minX,
-    globalBounds.minY,
-    globalBounds.maxX,
-    globalBounds.maxY
-  ];
-  for (const r of results) r.bounds = mergedBounds;
-  return results;
-}
-
-// ../../src/lib/utils/hex.ts
-function generateHexDump(data, bytesPerRow = 16) {
-  const rows = [];
-  for (let i = 0; i < data.length; i += bytesPerRow) {
-    const slice = data.slice(i, i + bytesPerRow);
-    const offset = i.toString(16).padStart(8, "0");
-    const hex = [];
-    for (let j = 0; j < bytesPerRow; j++) {
-      if (j < slice.length) {
-        hex.push(slice[j].toString(16).padStart(2, "0"));
-      } else {
-        hex.push("  ");
-      }
-    }
-    let ascii = "";
-    for (let j = 0; j < slice.length; j++) {
-      const byte = slice[j];
-      ascii += byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : ".";
-    }
-    rows.push({ offset, hex, ascii });
-  }
-  return rows;
-}
-
-// ../../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";
-    }
-    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)
-  }));
-  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, geo, legacyGeoParquet, createdBy, numRowGroups, compression };
-}
-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/lib/storage/providers.ts
 var PROVIDERS = {
   s3: {
@@ -2271,7 +1323,1165 @@ var PROVIDERS = {
     endpointPlaceholder: "https://s3.gra.io.cloud.ovh.net",
     schemes: []
   }
-};
+};
+var PROVIDER_IDS = [
+  "s3",
+  "gcs",
+  "r2",
+  "azure",
+  "b2",
+  "digitalocean",
+  "wasabi",
+  "storj",
+  "hetzner",
+  "contabo",
+  "linode",
+  "ovhcloud",
+  "minio"
+];
+function getProvider(id) {
+  return PROVIDERS[id] ?? PROVIDERS.s3;
+}
+function buildEndpointFromTemplate(id, region) {
+  const def = PROVIDERS[id];
+  if (!def?.endpointTemplate) return "";
+  return def.endpointTemplate.replace("{region}", region);
+}
+function buildProviderBaseUrl(provider, endpoint, bucket, region) {
+  if (endpoint) {
+    return `${endpoint.replace(/\/$/, "")}/${bucket}`;
+  }
+  const def = PROVIDERS[provider];
+  if (def?.endpointTemplate) {
+    const resolved = def.endpointTemplate.replace("{region}", region || def.defaultRegion);
+    return `${resolved}/${bucket}`;
+  }
+  return `https://s3.${region || "us-east-1"}.amazonaws.com/${bucket}`;
+}
+function isGcsProvider(provider, endpoint) {
+  return provider === "gcs" || !!endpoint && /storage\.googleapis\.com/i.test(endpoint);
+}
+
+// ../../src/lib/storage/url-adapter.ts
+var UrlAdapter = class {
+  supportsWrite = false;
+  async read(url, offset, length, signal) {
+    const headers = {};
+    if (offset !== void 0 && length !== void 0) {
+      headers.Range = `bytes=${offset}-${offset + length - 1}`;
+    } else if (offset !== void 0) {
+      headers.Range = `bytes=${offset}-`;
+    }
+    const res = await fetch(url, { headers, signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  async head(url, signal) {
+    const res = await fetch(url, { method: "HEAD", signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    const name = url.split("/").pop()?.split("?")[0] || "file";
+    const ext = name.includes(".") ? name.split(".").pop().toLowerCase() : "";
+    return {
+      name,
+      path: url,
+      is_dir: false,
+      size: Number(res.headers.get("content-length") || 0),
+      modified: new Date(res.headers.get("last-modified") || 0).getTime(),
+      extension: ext
+    };
+  }
+  async list() {
+    return [];
+  }
+  async put() {
+    throw new Error("Write not supported for direct URL sources");
+  }
+  async delete() {
+    throw new Error("Delete not supported for direct URL sources");
+  }
+  async deletePrefix() {
+    throw new Error("Delete not supported for direct URL sources");
+  }
+  async copy() {
+    throw new Error("Copy not supported for direct URL sources");
+  }
+};
+
+// ../../src/lib/utils/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];
+  if (def?.schemes.length) return def.schemes[0];
+  return "s3";
+}
+function safeDecodeURIComponent(s) {
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s;
+  }
+}
+function resolveCloudUrl(url) {
+  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 base = buildProviderBaseUrl("s3", "", bucket, region);
+    return key ? `${base}/${key}` : base;
+  }
+  const gcsMatch = url.match(/^gcs?:\/\/([^/]+)\/?(.*)$/);
+  if (gcsMatch) {
+    const [, bucket, key] = gcsMatch;
+    const base = buildProviderBaseUrl("gcs", "", bucket, "");
+    return key ? `${base}/${key}` : base;
+  }
+  return url;
+}
+
+// ../../src/lib/utils/column-types.ts
+var NUMBER_TYPES = [
+  "TINYINT",
+  "SMALLINT",
+  "INTEGER",
+  "BIGINT",
+  "HUGEINT",
+  "UTINYINT",
+  "USMALLINT",
+  "UINTEGER",
+  "UBIGINT",
+  "FLOAT",
+  "DOUBLE",
+  "DECIMAL",
+  "NUMERIC",
+  "REAL",
+  "INT",
+  "INT1",
+  "INT2",
+  "INT4",
+  "INT8",
+  "SIGNED",
+  "SHORT",
+  "LONG"
+];
+var STRING_TYPES = ["VARCHAR", "TEXT", "STRING", "CHAR", "BPCHAR", "NAME", "UUID", "ENUM"];
+var DATE_TYPES = [
+  "DATE",
+  "TIME",
+  "TIMESTAMP",
+  "TIMESTAMP_S",
+  "TIMESTAMP_MS",
+  "TIMESTAMP_NS",
+  "TIMESTAMP WITH TIME ZONE",
+  "TIMESTAMPTZ",
+  "INTERVAL",
+  "TIMESTAMP_TZ"
+];
+var BOOLEAN_TYPES = ["BOOLEAN", "BOOL", "LOGICAL"];
+var GEO_TYPES = [
+  "GEOMETRY",
+  "POINT",
+  "LINESTRING",
+  "POLYGON",
+  "MULTIPOINT",
+  "MULTILINESTRING",
+  "MULTIPOLYGON",
+  "GEOMETRYCOLLECTION",
+  "WKB_GEOMETRY"
+];
+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();
+  if (NUMBER_TYPES.includes(base)) return "number";
+  if (STRING_TYPES.includes(base)) return "string";
+  if (DATE_TYPES.includes(base)) return "date";
+  if (BOOLEAN_TYPES.includes(base)) return "boolean";
+  if (GEO_TYPES.includes(base)) return "geo";
+  if (BINARY_TYPES.includes(base)) return "binary";
+  if (JSON_TYPES.includes(base)) return "json";
+  if (base.startsWith("STRUCT") || base.startsWith("MAP") || base.startsWith("UNION"))
+    return "json";
+  if (base.endsWith("[]") || base.startsWith("LIST")) return "json";
+  if (upper.includes("INT") || upper.includes("FLOAT") || upper.includes("DOUBLE") || upper.includes("DECIMAL") || upper.includes("NUMERIC"))
+    return "number";
+  if (upper.includes("CHAR") || upper.includes("TEXT") || upper.includes("STRING")) return "string";
+  if (upper.includes("TIME") || upper.includes("DATE")) return "date";
+  if (upper.includes("BOOL")) return "boolean";
+  if (upper.includes("GEOMETRY") || upper.includes("GEO") || upper.includes("WKB")) return "geo";
+  if (upper.includes("BLOB") || upper.includes("BINARY")) return "binary";
+  if (upper.includes("JSON") || upper.includes("STRUCT") || upper.includes("MAP") || upper.includes("LIST"))
+    return "json";
+  return "other";
+}
+var TYPE_COLORS = {
+  number: "text-blue-500",
+  string: "text-green-500",
+  date: "text-amber-500",
+  boolean: "text-purple-500",
+  geo: "text-teal-500",
+  binary: "text-zinc-500",
+  json: "text-orange-500",
+  other: "text-zinc-400"
+};
+var TYPE_BADGE_CLASSES = {
+  number: "bg-blue-500/10 text-blue-600 dark:text-blue-400 border-blue-500/20",
+  string: "bg-green-500/10 text-green-600 dark:text-green-400 border-green-500/20",
+  date: "bg-amber-500/10 text-amber-600 dark:text-amber-400 border-amber-500/20",
+  boolean: "bg-purple-500/10 text-purple-600 dark:text-purple-400 border-purple-500/20",
+  geo: "bg-teal-500/10 text-teal-600 dark:text-teal-400 border-teal-500/20",
+  binary: "bg-zinc-500/10 text-zinc-600 dark:text-zinc-400 border-zinc-500/20",
+  json: "bg-orange-500/10 text-orange-600 dark:text-orange-400 border-orange-500/20",
+  other: "bg-zinc-500/10 text-zinc-500 dark:text-zinc-400 border-zinc-500/20"
+};
+var TYPE_LABELS = {
+  number: "#",
+  string: "Aa",
+  date: "dt",
+  boolean: "T/F",
+  geo: "geo",
+  binary: "01",
+  json: "{}",
+  other: "?"
+};
+function typeColor(category) {
+  return TYPE_COLORS[category];
+}
+function typeBadgeClass(category) {
+  return TYPE_BADGE_CLASSES[category];
+}
+function typeLabel(category) {
+  return TYPE_LABELS[category];
+}
+
+// ../../src/lib/utils/error.ts
+function handleLoadError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") return null;
+  return err instanceof Error ? err.message : String(err);
+}
+
+// ../../src/lib/utils/format.ts
+function formatFileSize(bytes) {
+  if (bytes < 0) return "0 B";
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const base = 1024;
+  const exponent = Math.min(Math.floor(Math.log(bytes) / Math.log(base)), units.length - 1);
+  const value = bytes / base ** exponent;
+  if (exponent === 0) return `${bytes} B`;
+  return `${value.toFixed(1)} ${units[exponent]}`;
+}
+function formatDate(timestamp) {
+  if (!timestamp || timestamp <= 0 || !Number.isFinite(timestamp)) return "--";
+  const date = new Date(timestamp);
+  const now = Date.now();
+  const diffMs = now - timestamp;
+  const diffSeconds = Math.floor(diffMs / 1e3);
+  const diffMinutes = Math.floor(diffSeconds / 60);
+  const diffHours = Math.floor(diffMinutes / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffSeconds < 60) return "Just now";
+  if (diffMinutes < 60) return `${diffMinutes}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function getFileExtension(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot <= 0) return "";
+  return filename.slice(lastDot).toLowerCase();
+}
+function jsonReplacerBigInt(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function formatValue(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object") return JSON.stringify(value, jsonReplacerBigInt);
+  return String(value);
+}
+
+// ../../src/lib/utils/export.ts
+function formatCellValue(value) {
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object") return JSON.stringify(value, jsonReplacerBigInt);
+  return String(value);
+}
+function escapeCsvField(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function serializeToCsv(columns, rows) {
+  const header = columns.map(escapeCsvField).join(",");
+  const body = rows.map((row) => columns.map((col) => escapeCsvField(formatCellValue(row[col]))).join(",")).join("\n");
+  return `${header}
+${body}`;
+}
+function serializeToJson(columns, rows) {
+  const data = rows.map((row) => {
+    const obj = {};
+    for (const col of columns) {
+      const val = row[col];
+      if (val instanceof Date) {
+        obj[col] = val.toISOString();
+      } else {
+        obj[col] = val ?? null;
+      }
+    }
+    return obj;
+  });
+  return JSON.stringify(data, jsonReplacerBigInt, 2);
+}
+
+// ../../src/lib/utils/file-sort.ts
+function sortFileEntries(entries, config) {
+  const sorted = [...entries];
+  const dir = config.direction === "asc" ? 1 : -1;
+  sorted.sort((a, b) => {
+    if (a.is_dir && !b.is_dir) return -1;
+    if (!a.is_dir && b.is_dir) return 1;
+    switch (config.field) {
+      case "name":
+        return dir * a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+      case "size":
+        return dir * (a.size - b.size);
+      case "modified":
+        return dir * (a.modified - b.modified);
+      case "extension":
+        return dir * a.extension.localeCompare(b.extension, void 0, { sensitivity: "base" });
+      default:
+        return 0;
+    }
+  });
+  return sorted;
+}
+function toggleSortField(current, field) {
+  if (current.field === field) {
+    return { field, direction: current.direction === "asc" ? "desc" : "asc" };
+  }
+  return { field, direction: "asc" };
+}
+function normalizeGeomType(raw) {
+  const s = raw.toUpperCase().replace(/\s+/g, "");
+  if (s === "POINT") return "point";
+  if (s === "LINESTRING") return "linestring";
+  if (s === "POLYGON") return "polygon";
+  if (s === "MULTIPOINT") return "multipoint";
+  if (s === "MULTILINESTRING") return "multilinestring";
+  if (s === "MULTIPOLYGON") return "multipolygon";
+  return "polygon";
+}
+var EXTENSION_NAMES = {
+  point: "geoarrow.point",
+  linestring: "geoarrow.linestring",
+  polygon: "geoarrow.polygon",
+  multipoint: "geoarrow.multipoint",
+  multilinestring: "geoarrow.multilinestring",
+  multipolygon: "geoarrow.multipolygon"
+};
+function readWkbHeader(wkb) {
+  if (wkb.length < 5) return null;
+  const le = wkb[0] === 1;
+  const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+  const rawType = dv.getUint32(1, le);
+  let headerSize = 5;
+  if ((rawType & 536870912) !== 0) headerSize += 4;
+  const ewkbZ = (rawType & 2147483648) !== 0;
+  const ewkbM = (rawType & 1073741824) !== 0;
+  let type = rawType & 268435455;
+  let isoZ = false;
+  let isoM = false;
+  if (type > 3e3) {
+    isoZ = true;
+    isoM = true;
+    type -= 3e3;
+  } else if (type > 2e3) {
+    isoM = true;
+    type -= 2e3;
+  } else if (type > 1e3) {
+    isoZ = true;
+    type -= 1e3;
+  }
+  const dims = (ewkbZ || isoZ ? 1 : 0) + (ewkbM || isoM ? 1 : 0);
+  const coordStride = (2 + dims) * 8;
+  return { type, le, coordStride, dataOffset: headerSize };
+}
+function classifyWkbType(wkb) {
+  const h = readWkbHeader(wkb);
+  if (!h) return null;
+  switch (h.type) {
+    case 1:
+      return "point";
+    case 2:
+      return "linestring";
+    case 3:
+      return "polygon";
+    case 4:
+      return "multipoint";
+    case 5:
+      return "multilinestring";
+    case 6:
+      return "multipolygon";
+    default:
+      return null;
+  }
+}
+function newBounds() {
+  return { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+}
+function expandBounds(b, x, y) {
+  if (Number.isNaN(x) || Number.isNaN(y)) return;
+  if (x < b.minX) b.minX = x;
+  if (y < b.minY) b.minY = y;
+  if (x > b.maxX) b.maxX = x;
+  if (y > b.maxY) b.maxY = y;
+}
+var coordField = new apacheArrow.Field("xy", new apacheArrow.Float64());
+var coordType = new apacheArrow.FixedSizeList(2, coordField);
+function makeCoordData(coords, numPoints) {
+  const floatData = apacheArrow.makeData({ type: new apacheArrow.Float64(), length: coords.length, data: coords });
+  return apacheArrow.makeData({ type: coordType, length: numPoints, nullCount: 0, child: floatData });
+}
+function buildPointData(wkbs, b) {
+  const n = wkbs.length;
+  const coords = new Float64Array(n * 2);
+  for (let i = 0; i < n; i++) {
+    const wkb = wkbs[i];
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 1) {
+      coords[i * 2] = 0;
+      coords[i * 2 + 1] = 0;
+      continue;
+    }
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const x = dv.getFloat64(h.dataOffset, h.le);
+    const y = dv.getFloat64(h.dataOffset + 8, h.le);
+    coords[i * 2] = x;
+    coords[i * 2 + 1] = y;
+    expandBounds(b, x, y);
+  }
+  return makeCoordData(coords, n);
+}
+function buildLineStringData(wkbs, b) {
+  const n = wkbs.length;
+  const geomOffsets = new Int32Array(n + 1);
+  let totalCoords = 0;
+  for (let i = 0; i < n; i++) {
+    geomOffsets[i] = totalCoords;
+    const h = readWkbHeader(wkbs[i]);
+    if (!h || h.type !== 2) continue;
+    const dv = new DataView(wkbs[i].buffer, wkbs[i].byteOffset, wkbs[i].byteLength);
+    const numPts = dv.getUint32(h.dataOffset, h.le);
+    totalCoords += numPts;
+  }
+  geomOffsets[n] = totalCoords;
+  const coords = new Float64Array(totalCoords * 2);
+  let ci = 0;
+  for (const wkb of wkbs) {
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 2) continue;
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const numPts = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let j = 0; j < numPts; j++) {
+      const x = dv.getFloat64(off, h.le);
+      const y = dv.getFloat64(off + 8, h.le);
+      coords[ci++] = x;
+      coords[ci++] = y;
+      expandBounds(b, x, y);
+      off += h.coordStride;
+    }
+  }
+  const fslData = makeCoordData(coords, totalCoords);
+  const listType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
+  return apacheArrow.makeData({
+    type: listType,
+    length: n,
+    nullCount: 0,
+    valueOffsets: geomOffsets,
+    child: fslData
+  });
+}
+function buildPolygonData(wkbs, b) {
+  const n = wkbs.length;
+  const geomOffsets = new Int32Array(n + 1);
+  let totalRings = 0;
+  let totalCoords = 0;
+  for (let i = 0; i < n; i++) {
+    geomOffsets[i] = totalRings;
+    const h = readWkbHeader(wkbs[i]);
+    if (!h || h.type !== 3) continue;
+    const dv = new DataView(wkbs[i].buffer, wkbs[i].byteOffset, wkbs[i].byteLength);
+    const numRings = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let r = 0; r < numRings; r++) {
+      const numPts = dv.getUint32(off, h.le);
+      off += 4 + numPts * h.coordStride;
+      totalCoords += numPts;
+      totalRings++;
+    }
+  }
+  geomOffsets[n] = totalRings;
+  const ringOffsets = new Int32Array(totalRings + 1);
+  const coords = new Float64Array(totalCoords * 2);
+  let ri = 0;
+  let ci = 0;
+  for (const wkb of wkbs) {
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 3) continue;
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const numRings = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let r = 0; r < numRings; r++) {
+      ringOffsets[ri++] = ci >> 1;
+      const numPts = dv.getUint32(off, h.le);
+      off += 4;
+      for (let j = 0; j < numPts; j++) {
+        const x = dv.getFloat64(off, h.le);
+        const y = dv.getFloat64(off + 8, h.le);
+        coords[ci++] = x;
+        coords[ci++] = y;
+        expandBounds(b, x, y);
+        off += h.coordStride;
+      }
+    }
+  }
+  ringOffsets[totalRings] = ci >> 1;
+  const coordCount = ci >> 1;
+  const fslData = makeCoordData(coords, coordCount);
+  const ringListType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
+  const ringListData = apacheArrow.makeData({
+    type: ringListType,
+    length: totalRings,
+    nullCount: 0,
+    valueOffsets: ringOffsets,
+    child: fslData
+  });
+  const polyType = new apacheArrow.List(new apacheArrow.Field("rings", ringListType));
+  return apacheArrow.makeData({
+    type: polyType,
+    length: n,
+    nullCount: 0,
+    valueOffsets: geomOffsets,
+    child: ringListData
+  });
+}
+function buildMultiPointData(wkbs, b) {
+  const n = wkbs.length;
+  const geomOffsets = new Int32Array(n + 1);
+  let totalCoords = 0;
+  for (let i = 0; i < n; i++) {
+    geomOffsets[i] = totalCoords;
+    const h = readWkbHeader(wkbs[i]);
+    if (!h || h.type !== 4) continue;
+    const dv = new DataView(wkbs[i].buffer, wkbs[i].byteOffset, wkbs[i].byteLength);
+    totalCoords += dv.getUint32(h.dataOffset, h.le);
+  }
+  geomOffsets[n] = totalCoords;
+  const coords = new Float64Array(totalCoords * 2);
+  let ci = 0;
+  for (const wkb of wkbs) {
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 4) continue;
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const numPts = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let j = 0; j < numPts; j++) {
+      const innerH = readWkbHeader(
+        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
+      );
+      if (innerH) {
+        const x = dv.getFloat64(off + innerH.dataOffset, innerH.le);
+        const y = dv.getFloat64(off + innerH.dataOffset + 8, innerH.le);
+        coords[ci++] = x;
+        coords[ci++] = y;
+        expandBounds(b, x, y);
+        off += innerH.dataOffset + innerH.coordStride;
+      } else {
+        coords[ci++] = 0;
+        coords[ci++] = 0;
+        off += 21;
+      }
+    }
+  }
+  const fslData = makeCoordData(coords, totalCoords);
+  const listType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
+  return apacheArrow.makeData({
+    type: listType,
+    length: n,
+    nullCount: 0,
+    valueOffsets: geomOffsets,
+    child: fslData
+  });
+}
+function buildMultiLineStringData(wkbs, b) {
+  const n = wkbs.length;
+  const geomOffsetsArr = [0];
+  let totalLines = 0;
+  let totalCoords = 0;
+  for (const wkb of wkbs) {
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 5) {
+      geomOffsetsArr.push(totalLines);
+      continue;
+    }
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const numLines = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let l = 0; l < numLines; l++) {
+      const innerH = readWkbHeader(
+        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
+      );
+      if (!innerH) break;
+      const innerDv = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off);
+      const numPts = innerDv.getUint32(innerH.dataOffset, innerH.le);
+      totalCoords += numPts;
+      off += innerH.dataOffset + 4 + numPts * innerH.coordStride;
+      totalLines++;
+    }
+    geomOffsetsArr.push(totalLines);
+  }
+  const geomOffsets = new Int32Array(geomOffsetsArr);
+  const lineOffsets = new Int32Array(totalLines + 1);
+  const coords = new Float64Array(totalCoords * 2);
+  let li = 0;
+  let ci = 0;
+  for (const wkb of wkbs) {
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 5) continue;
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const numLines = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let l = 0; l < numLines; l++) {
+      lineOffsets[li++] = ci >> 1;
+      const innerH = readWkbHeader(
+        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
+      );
+      if (!innerH) break;
+      const numPts = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off).getUint32(
+        innerH.dataOffset,
+        innerH.le
+      );
+      let ptOff = off + innerH.dataOffset + 4;
+      for (let j = 0; j < numPts; j++) {
+        const x = dv.getFloat64(ptOff, innerH.le);
+        const y = dv.getFloat64(ptOff + 8, innerH.le);
+        coords[ci++] = x;
+        coords[ci++] = y;
+        expandBounds(b, x, y);
+        ptOff += innerH.coordStride;
+      }
+      off = ptOff;
+    }
+  }
+  lineOffsets[totalLines] = ci >> 1;
+  const fslData = makeCoordData(coords, ci >> 1);
+  const lineListType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
+  const lineListData = apacheArrow.makeData({
+    type: lineListType,
+    length: totalLines,
+    nullCount: 0,
+    valueOffsets: lineOffsets,
+    child: fslData
+  });
+  const multiLineType = new apacheArrow.List(new apacheArrow.Field("lines", lineListType));
+  return apacheArrow.makeData({
+    type: multiLineType,
+    length: n,
+    nullCount: 0,
+    valueOffsets: geomOffsets,
+    child: lineListData
+  });
+}
+function buildMultiPolygonData(wkbs, b) {
+  const n = wkbs.length;
+  const geomOffsetsArr = [0];
+  let totalPolys = 0;
+  let totalRings = 0;
+  let totalCoords = 0;
+  for (const wkb of wkbs) {
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 6) {
+      geomOffsetsArr.push(totalPolys);
+      continue;
+    }
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const numPolys = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let p = 0; p < numPolys; p++) {
+      const innerH = readWkbHeader(
+        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
+      );
+      if (!innerH) break;
+      const innerDv = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off);
+      const numRings = innerDv.getUint32(innerH.dataOffset, innerH.le);
+      let ringOff = innerH.dataOffset + 4;
+      for (let r = 0; r < numRings; r++) {
+        const numPts = innerDv.getUint32(ringOff, innerH.le);
+        ringOff += 4 + numPts * innerH.coordStride;
+        totalCoords += numPts;
+        totalRings++;
+      }
+      off += ringOff;
+      totalPolys++;
+    }
+    geomOffsetsArr.push(totalPolys);
+  }
+  const geomOffsets = new Int32Array(geomOffsetsArr);
+  const polyOffsets = new Int32Array(totalPolys + 1);
+  const ringOffsets = new Int32Array(totalRings + 1);
+  const coords = new Float64Array(totalCoords * 2);
+  let pi = 0;
+  let ri = 0;
+  let ci = 0;
+  for (const wkb of wkbs) {
+    const h = readWkbHeader(wkb);
+    if (!h || h.type !== 6) continue;
+    const dv = new DataView(wkb.buffer, wkb.byteOffset, wkb.byteLength);
+    const numPolys = dv.getUint32(h.dataOffset, h.le);
+    let off = h.dataOffset + 4;
+    for (let p = 0; p < numPolys; p++) {
+      polyOffsets[pi++] = ri;
+      const innerH = readWkbHeader(
+        new Uint8Array(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off)
+      );
+      if (!innerH) break;
+      const innerDv = new DataView(wkb.buffer, wkb.byteOffset + off, wkb.byteLength - off);
+      const numRings = innerDv.getUint32(innerH.dataOffset, innerH.le);
+      let ringOff = off + innerH.dataOffset + 4;
+      for (let r = 0; r < numRings; r++) {
+        ringOffsets[ri++] = ci >> 1;
+        const numPts = dv.getUint32(ringOff, innerH.le);
+        ringOff += 4;
+        for (let j = 0; j < numPts; j++) {
+          const x = dv.getFloat64(ringOff, innerH.le);
+          const y = dv.getFloat64(ringOff + 8, innerH.le);
+          coords[ci++] = x;
+          coords[ci++] = y;
+          expandBounds(b, x, y);
+          ringOff += innerH.coordStride;
+        }
+      }
+      off = ringOff;
+    }
+  }
+  polyOffsets[totalPolys] = ri;
+  ringOffsets[totalRings] = ci >> 1;
+  const fslData = makeCoordData(coords, ci >> 1);
+  const ringListType = new apacheArrow.List(new apacheArrow.Field("vertices", coordType));
+  const ringListData = apacheArrow.makeData({
+    type: ringListType,
+    length: totalRings,
+    nullCount: 0,
+    valueOffsets: ringOffsets,
+    child: fslData
+  });
+  const polyListType = new apacheArrow.List(new apacheArrow.Field("rings", ringListType));
+  const polyListData = apacheArrow.makeData({
+    type: polyListType,
+    length: totalPolys,
+    nullCount: 0,
+    valueOffsets: polyOffsets,
+    child: ringListData
+  });
+  const multiPolyType = new apacheArrow.List(new apacheArrow.Field("polygons", polyListType));
+  return apacheArrow.makeData({
+    type: multiPolyType,
+    length: n,
+    nullCount: 0,
+    valueOffsets: geomOffsets,
+    child: polyListData
+  });
+}
+function buildAttributeColumns(indices, attributes) {
+  const n = indices.length;
+  const fields = [];
+  const dataArr = [];
+  for (const [name, col] of attributes) {
+    const { values } = col;
+    let isNumeric = true;
+    const sampleEnd = Math.min(n, 100);
+    for (let i = 0; i < sampleEnd; i++) {
+      if (values[indices[i]] != null && typeof values[indices[i]] !== "number") {
+        isNumeric = false;
+        break;
+      }
+    }
+    if (isNumeric) {
+      const arr = new Float64Array(n);
+      for (let i = 0; i < n; i++) arr[i] = values[indices[i]] ?? NaN;
+      const data = apacheArrow.makeData({ type: new apacheArrow.Float64(), length: n, data: arr });
+      fields.push(new apacheArrow.Field(name, new apacheArrow.Float64(), true));
+      dataArr.push(data);
+    } else {
+      const encoder = new TextEncoder();
+      const offsets = new Int32Array(n + 1);
+      let totalBytes = 0;
+      const strParts = [];
+      for (let i = 0; i < n; i++) {
+        offsets[i] = totalBytes;
+        const s = values[indices[i]] != null ? String(values[indices[i]]) : "";
+        const encoded = encoder.encode(s);
+        strParts.push(encoded);
+        totalBytes += encoded.length;
+      }
+      offsets[n] = totalBytes;
+      const valueBuffer = new Uint8Array(totalBytes);
+      let pos = 0;
+      for (const sv of strParts) {
+        valueBuffer.set(sv, pos);
+        pos += sv.length;
+      }
+      const data = apacheArrow.makeData({
+        type: new apacheArrow.Utf8(),
+        length: n,
+        valueOffsets: offsets,
+        data: valueBuffer
+      });
+      fields.push(new apacheArrow.Field(name, new apacheArrow.Utf8(), true));
+      dataArr.push(data);
+    }
+  }
+  return { fields, data: dataArr };
+}
+function buildSingleTable(geomType, wkbs, indices, attributes, b) {
+  const n = wkbs.length;
+  let geomData;
+  switch (geomType) {
+    case "point":
+      geomData = buildPointData(wkbs, b);
+      break;
+    case "linestring":
+      geomData = buildLineStringData(wkbs, b);
+      break;
+    case "polygon":
+      geomData = buildPolygonData(wkbs, b);
+      break;
+    case "multipoint":
+      geomData = buildMultiPointData(wkbs, b);
+      break;
+    case "multilinestring":
+      geomData = buildMultiLineStringData(wkbs, b);
+      break;
+    case "multipolygon":
+      geomData = buildMultiPolygonData(wkbs, b);
+      break;
+  }
+  const extensionName = EXTENSION_NAMES[geomType];
+  const geomMetadata = /* @__PURE__ */ new Map([
+    ["ARROW:extension:name", extensionName],
+    [
+      "ARROW:extension:metadata",
+      JSON.stringify({
+        crs: {
+          type: "name",
+          properties: { name: "urn:ogc:def:crs:OGC:1.3:CRS84" }
+        }
+      })
+    ]
+  ]);
+  const geomField = new apacheArrow.Field("geometry", geomData.type, false, geomMetadata);
+  const attrCols = buildAttributeColumns(indices, attributes);
+  const fields = [geomField, ...attrCols.fields];
+  const childrenData = [geomData, ...attrCols.data];
+  const arrowSchema = new apacheArrow.Schema(fields);
+  const structType = new apacheArrow.Struct(fields);
+  const structData = apacheArrow.makeData({
+    type: structType,
+    length: n,
+    nullCount: 0,
+    children: childrenData
+  });
+  const batch = new apacheArrow.RecordBatch(arrowSchema, structData);
+  const table = new apacheArrow.Table(arrowSchema, batch);
+  return {
+    table,
+    geometryType: geomType,
+    bounds: [b.minX, b.minY, b.maxX, b.maxY],
+    sourceIndices: indices
+  };
+}
+function buildGeoArrowTables(wkbArrays, attributes, knownGeomType) {
+  if (wkbArrays.length === 0) return [];
+  if (knownGeomType) {
+    const globalBounds2 = newBounds();
+    const indices = Array.from({ length: wkbArrays.length }, (_, i) => i);
+    const result = buildSingleTable(knownGeomType, wkbArrays, indices, attributes, globalBounds2);
+    return [result];
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < wkbArrays.length; i++) {
+    const geomType = classifyWkbType(wkbArrays[i]);
+    if (!geomType) continue;
+    let group = groups.get(geomType);
+    if (!group) {
+      group = { wkbs: [], indices: [] };
+      groups.set(geomType, group);
+    }
+    group.wkbs.push(wkbArrays[i]);
+    group.indices.push(i);
+  }
+  if (groups.size === 0) return [];
+  const globalBounds = newBounds();
+  const results = [];
+  for (const [geomType, { wkbs, indices }] of groups) {
+    const result = buildSingleTable(geomType, wkbs, indices, attributes, globalBounds);
+    results.push(result);
+  }
+  const mergedBounds = [
+    globalBounds.minX,
+    globalBounds.minY,
+    globalBounds.maxX,
+    globalBounds.maxY
+  ];
+  for (const r of results) r.bounds = mergedBounds;
+  return results;
+}
+
+// ../../src/lib/utils/hex.ts
+function generateHexDump(data, bytesPerRow = 16) {
+  const rows = [];
+  for (let i = 0; i < data.length; i += bytesPerRow) {
+    const slice = data.slice(i, i + bytesPerRow);
+    const offset = i.toString(16).padStart(8, "0");
+    const hex = [];
+    for (let j = 0; j < bytesPerRow; j++) {
+      if (j < slice.length) {
+        hex.push(slice[j].toString(16).padStart(2, "0"));
+      } else {
+        hex.push("  ");
+      }
+    }
+    let ascii = "";
+    for (let j = 0; j < slice.length; j++) {
+      const byte = slice[j];
+      ascii += byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : ".";
+    }
+    rows.push({ offset, hex, ascii });
+  }
+  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;
+}
+function persistToStorage(key, value) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+function parseMarkdownDocument(markdown) {
+  let frontmatter = {};
+  let content = markdown;
+  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---\n/);
+  if (fmMatch) {
+    try {
+      frontmatter = YAML__default.default.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\s+(\w[\w-]*)\s*\n([\s\S]*?)```/g,
+    (_, name) => `<div data-sql-block="${name}"></div>`
+  );
+}
+
+// ../../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";
+    }
+    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)
+  }));
+  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, geo, legacyGeoParquet, createdBy, numRowGroups, compression };
+}
+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/lib/utils/storage-url.ts
 function buildSchemeMap() {
@@ -2854,6 +3064,8 @@ exports.DEFAULT_TARGET_CRS = DEFAULT_TARGET_CRS;
 exports.DUCKDB_INIT_TIMEOUT_MS = DUCKDB_INIT_TIMEOUT_MS;
 exports.LAYER_HUE_MULTIPLIER = LAYER_HUE_MULTIPLIER;
 exports.MAX_QUERY_HISTORY_ENTRIES = MAX_QUERY_HISTORY_ENTRIES;
+exports.PROVIDERS = PROVIDERS;
+exports.PROVIDER_IDS = PROVIDER_IDS;
 exports.QueryCancelledError = QueryCancelledError;
 exports.SQL_PREVIEW_LENGTH = SQL_PREVIEW_LENGTH;
 exports.STORAGE_KEYS = STORAGE_KEYS;
@@ -2861,9 +3073,12 @@ exports.UrlAdapter = UrlAdapter;
 exports.VIEWER_DIR_EXTENSIONS = VIEWER_DIR_EXTENSIONS;
 exports.WGS84_CODES = WGS84_CODES;
 exports.buildDuckDbSource = buildDuckDbSource;
+exports.buildEndpointFromTemplate = buildEndpointFromTemplate;
 exports.buildGeoArrowTables = buildGeoArrowTables;
+exports.buildProviderBaseUrl = buildProviderBaseUrl;
 exports.classifyType = classifyType;
 exports.describeParseResult = describeParseResult;
+exports.escapeCsvField = escapeCsvField;
 exports.extractBounds = extractBounds;
 exports.extractEpsgFromGeoMeta = extractEpsgFromGeoMeta;
 exports.extractGeometryTypes = extractGeometryTypes;
@@ -2877,17 +3092,31 @@ exports.getDuckDbReadFn = getDuckDbReadFn;
 exports.getFileExtension = getFileExtension;
 exports.getFileTypeInfo = getFileTypeInfo;
 exports.getMimeType = getMimeType;
+exports.getNativeScheme = getNativeScheme;
+exports.getProvider = getProvider;
 exports.getViewerKind = getViewerKind;
 exports.handleLoadError = handleLoadError;
+exports.interpolateTemplates = interpolateTemplates;
 exports.isCloudNativeFormat = isCloudNativeFormat;
+exports.isGcsProvider = isGcsProvider;
 exports.isQueryable = isQueryable;
 exports.jsonReplacerBigInt = jsonReplacerBigInt;
+exports.loadFromStorage = loadFromStorage;
 exports.looksLikeUrl = looksLikeUrl;
+exports.markSqlBlocks = markSqlBlocks;
 exports.normalizeGeomType = normalizeGeomType;
+exports.parseMarkdownDocument = parseMarkdownDocument;
 exports.parseStorageUrl = parseStorageUrl;
 exports.parseWKB = parseWKB;
+exports.persistToStorage = persistToStorage;
 exports.readParquetMetadata = readParquetMetadata;
+exports.resolveCloudUrl = resolveCloudUrl;
+exports.safeDecodeURIComponent = safeDecodeURIComponent;
+exports.serializeToCsv = serializeToCsv;
+exports.serializeToJson = serializeToJson;
+exports.sortFileEntries = sortFileEntries;
 exports.toBinary = toBinary;
+exports.toggleSortField = toggleSortField;
 exports.typeBadgeClass = typeBadgeClass;
 exports.typeColor = typeColor;
 exports.typeLabel = typeLabel;