lakeql 0.1.8 → 0.2.0

package/dist/{chunk-TFD5RFKB.js → chunk-WGHR35QU.js}

@@ -35,6 +35,8 @@ var ERROR_CODES = [
   "LAKEQL_BUDGET_EXCEEDED",
   "LAKEQL_GROUP_LIMIT_EXCEEDED",
   "LAKEQL_OBJECT_NOT_FOUND",
+  "LAKEQL_NO_FILES_MATCHED",
+  "LAKEQL_SCHEMA_CONFLICT",
   "LAKEQL_CATALOG_ERROR",
   "LAKEQL_UNSUPPORTED_ICEBERG_FEATURE",
   "LAKEQL_UNSUPPORTED_PARQUET_FEATURE",
@@ -157,6 +159,147 @@ function fractionForUnit(nanos, unit) {
   }
 }
 
+// ../core/dist/interval.js
+var NANOS_PER_SECOND = 1000000000n;
+var NANOS_PER_MILLI2 = 1000000n;
+var NANOS_PER_MICRO2 = 1000n;
+function intervalValue(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0)
+    throwInterval(input);
+  let rest = trimmed;
+  let months = 0;
+  let days = 0;
+  let nanoseconds = 0n;
+  let matchedAny = false;
+  const leadingTime = /^([+-]?\d{1,2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?)\b/u.exec(rest);
+  if (leadingTime?.[1] !== void 0) {
+    nanoseconds += parseIntervalTime(leadingTime[1], input);
+    rest = rest.slice(leadingTime[0].length).trim();
+    matchedAny = true;
+  }
+  const partPattern = /([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*(years?|mons?|months?|days?|hours?|hrs?|minutes?|mins?|seconds?|secs?|milliseconds?|millis?|microseconds?|micros?|nanoseconds?|nanos?)\b/giu;
+  let cursor = 0;
+  for (const match of rest.matchAll(partPattern)) {
+    if (match.index === void 0 || rest.slice(cursor, match.index).trim().length > 0) {
+      throwInterval(input);
+    }
+    const amount = Number(match[1]);
+    const unit = match[2]?.toLowerCase() ?? "";
+    if (!Number.isFinite(amount))
+      throwInterval(input);
+    if (unit.startsWith("year"))
+      months += integerAmount(amount, unit, input) * 12;
+    else if (unit === "mon" || unit === "mons" || unit.startsWith("month"))
+      months += integerAmount(amount, unit, input);
+    else if (unit.startsWith("day"))
+      days += integerAmount(amount, unit, input);
+    else if (unit.startsWith("hour") || unit === "hr" || unit === "hrs")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", 60n * 60n * NANOS_PER_SECOND);
+    else if (unit.startsWith("minute") || unit === "min" || unit === "mins")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", 60n * NANOS_PER_SECOND);
+    else if (unit.startsWith("second") || unit === "sec" || unit === "secs")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", NANOS_PER_SECOND);
+    else if (unit.startsWith("millisecond") || unit === "milli" || unit === "millis")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", NANOS_PER_MILLI2);
+    else if (unit.startsWith("microsecond") || unit === "micro" || unit === "micros")
+      nanoseconds += decimalNanoseconds(match[1] ?? "", NANOS_PER_MICRO2);
+    else if (unit.startsWith("nanosecond") || unit === "nano" || unit === "nanos")
+      nanoseconds += BigInt(integerAmount(amount, unit, input));
+    else
+      throwInterval(input);
+    matchedAny = true;
+    cursor = match.index + match[0].length;
+    const after = rest.slice(cursor).trimStart();
+    const time = /^(\d{1,2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?)\b/u.exec(after);
+    if (time?.[1] !== void 0) {
+      nanoseconds += parseIntervalTime(time[1], input);
+      cursor = rest.length - after.slice(time[0].length).length;
+    }
+  }
+  if (!matchedAny || rest.slice(cursor).trim().length > 0)
+    throwInterval(input);
+  return { kind: "interval", months, days, nanoseconds: nanoseconds.toString() };
+}
+function isIntervalValue(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "interval" && "months" in value && Number.isInteger(value.months) && "days" in value && Number.isInteger(value.days) && "nanoseconds" in value && typeof value.nanoseconds === "string" && /^-?[0-9]+$/u.test(value.nanoseconds);
+}
+function isNonNegativeInterval(value) {
+  return value.months >= 0 && value.days >= 0 && BigInt(value.nanoseconds) >= 0n;
+}
+function intervalToString(value) {
+  const parts = [];
+  if (value.months !== 0)
+    parts.push(`${value.months} months`);
+  if (value.days !== 0)
+    parts.push(`${value.days} days`);
+  const nanos = BigInt(value.nanoseconds);
+  if (nanos !== 0n || parts.length === 0)
+    parts.push(`${nanos} nanoseconds`);
+  return parts.join(" ");
+}
+function applyIntervalToTimestamp(value, interval, direction) {
+  const date = new Date(Number(value.epochNanoseconds / NANOS_PER_MILLI2));
+  if (interval.months !== 0)
+    shiftUtcMonthsClamped(date, direction * interval.months);
+  if (interval.days !== 0)
+    date.setUTCDate(date.getUTCDate() + direction * interval.days);
+  const nanosWithinMilli = value.epochNanoseconds % NANOS_PER_MILLI2;
+  const epochNanoseconds2 = BigInt(date.getTime()) * NANOS_PER_MILLI2 + nanosWithinMilli + BigInt(direction) * BigInt(interval.nanoseconds);
+  return new TimestampValue(epochNanoseconds2, value.unit, value.isAdjustedToUTC);
+}
+function integerAmount(value, unit, input) {
+  if (!Number.isInteger(value)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `Interval ${unit} component must be an integer`, {
+      interval: input,
+      unit
+    });
+  }
+  return value;
+}
+function decimalNanoseconds(value, unitNanos) {
+  const match = /^([+-]?)(?:(\d+)(?:\.(\d+))?|\.(\d+))$/u.exec(value);
+  if (match === null) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Interval component exceeds nanosecond precision");
+  }
+  const sign = match[1] === "-" ? -1n : 1n;
+  const whole = BigInt(match[2] ?? "0");
+  const fraction = match[3] ?? match[4] ?? "";
+  const scale = 10n ** BigInt(fraction.length);
+  const numerator = whole * scale + BigInt(fraction || "0");
+  const scaled = numerator * unitNanos;
+  if (scaled % scale !== 0n) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Interval component exceeds nanosecond precision");
+  }
+  return sign * (scaled / scale);
+}
+function shiftUtcMonthsClamped(date, months) {
+  const day = date.getUTCDate();
+  const targetMonthStart = new Date(date.getTime());
+  targetMonthStart.setUTCDate(1);
+  targetMonthStart.setUTCMonth(targetMonthStart.getUTCMonth() + months);
+  const daysInTargetMonth = new Date(Date.UTC(targetMonthStart.getUTCFullYear(), targetMonthStart.getUTCMonth() + 1, 0)).getUTCDate();
+  date.setUTCFullYear(targetMonthStart.getUTCFullYear(), targetMonthStart.getUTCMonth(), Math.min(day, daysInTargetMonth));
+}
+function parseIntervalTime(value, input) {
+  const match = /^([+-]?\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?$/u.exec(value);
+  if (match === null || match[1] === void 0 || match[2] === void 0)
+    throwInterval(input);
+  const sign = match[1].startsWith("-") ? -1n : 1n;
+  const hours = BigInt(Math.abs(Number(match[1])));
+  const minutes = BigInt(Number(match[2]));
+  const seconds = BigInt(Number(match[3] ?? "0"));
+  if (minutes >= 60n || seconds >= 60n)
+    throwInterval(input);
+  const fraction = BigInt((match[4] ?? "").padEnd(9, "0") || "0");
+  return sign * ((hours * 60n + minutes) * 60n * NANOS_PER_SECOND + seconds * NANOS_PER_SECOND + fraction);
+}
+function throwInterval(input) {
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `Invalid interval literal ${input}`, {
+    interval: input
+  });
+}
+
 // ../core/dist/regex-functions.js
 function regexpMatchesValue(value, pattern, options = "") {
   const regexOptions = parseRegexOptions("regexp_matches", options, { allowGlobal: false });
@@ -234,6 +377,7 @@ var GEO_BACKEND_FUNCTIONS = /* @__PURE__ */ new Set([
   "st_disjoint",
   "st_contains",
   "st_within",
+  "st_dwithin",
   "h3_within",
   "h3_cell",
   "h3_parent"
@@ -251,7 +395,7 @@ function requireGeoBackend() {
 async function loadGeoBackend() {
   if (geoBackend !== null)
     return;
-  const module = await import('./geo-backend-TSQJWAAB.js');
+  const module = await import('./geo-backend-WYCTLPNS.js');
   module.installGeoBackend();
 }
 async function ensureGeoBackendForExprs(exprs) {
@@ -341,6 +485,10 @@ function matches(expr, row) {
 function jsonSafeValue(value) {
   if (isTimestampValue(value))
     return value.toJSON();
+  if (isIntervalValue(value))
+    return intervalToString(value);
+  if (value instanceof Uint8Array)
+    return bytesToHex(value);
   if (typeof value === "bigint") {
     const asNumber = Number(value);
     return Number.isSafeInteger(asNumber) ? asNumber : value.toString();
@@ -364,7 +512,7 @@ function rowValue(row, name) {
     throw new LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown column ${name}`, { column: name });
   }
   const value = row[name];
-  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || isTimestampValue(value)) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || value instanceof Uint8Array || isTimestampValue(value) || isIntervalValue(value)) {
     return value;
   }
   throw new LakeqlError("LAKEQL_TYPE_ERROR", `Column ${name} is not a scalar value`, {
@@ -384,6 +532,12 @@ function toSqlBoolean(value) {
 function compare(op, left, right) {
   if (left === null || right === null)
     return null;
+  if (left instanceof Uint8Array || right instanceof Uint8Array) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare binary values", {
+      leftType: evalValueType(left),
+      rightType: evalValueType(right)
+    });
+  }
   if (isTimestampValue(left) || isTimestampValue(right)) {
     const leftTimestamp = timestampEvalValue(left);
     const rightTimestamp = timestampEvalValue(right);
@@ -395,6 +549,12 @@ function compare(op, left, right) {
     }
     return compareOrder(op, compareTimestampValues(leftTimestamp, rightTimestamp));
   }
+  if (isIntervalValue(left) || isIntervalValue(right)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare interval values", {
+      leftType: evalValueType(left),
+      rightType: evalValueType(right)
+    });
+  }
   if (typeof left !== typeof right && !(isNumberLike(left) && isNumberLike(right))) {
     throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare values of different types", {
       leftType: typeof left,
@@ -428,6 +588,10 @@ function timestampEvalValue(value) {
   return void 0;
 }
 function evalValueType(value) {
+  if (value instanceof Uint8Array)
+    return "binary";
+  if (isIntervalValue(value))
+    return "interval";
   return isTimestampValue(value) ? "timestamp" : typeof value;
 }
 function arithmetic(op, left, right) {
@@ -572,6 +736,8 @@ function callFunction(name, args) {
       return spatialPredicate(fn, args, "within");
     case "st_disjoint":
       return spatialPredicate(fn, args, "disjoint");
+    case "st_dwithin":
+      return stDWithin(fn, args);
     case "st_distance":
       return spatialMeasurement(fn, args, bboxDistance);
     case "st_area":
@@ -731,6 +897,24 @@ function spatialPredicate(name, args, op) {
       return bboxContains(eb, ea) && geo.booleanContains(b, a);
   }
 }
+function stDWithin(name, args) {
+  requireArgCount(name, args, 3);
+  const left = args[0] ?? null;
+  const right = args[1] ?? null;
+  const distance = args[2] ?? null;
+  if (left === null || right === null || distance === null)
+    return null;
+  if (typeof distance !== "number" || !Number.isFinite(distance) || distance < 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "st_dwithin() expects a non-negative distance");
+  }
+  const a = toGeometry(parseGeometry(left, name), name);
+  const b = toGeometry(parseGeometry(right, name), name);
+  const ea = envelopeOf(a);
+  const eb = envelopeOf(b);
+  if (bboxDistance(ea, eb) > distance)
+    return false;
+  return geometryDistance(a, b) <= distance;
+}
 function envelopeOf(geometry) {
   switch (geometry.type) {
     case "Point":
@@ -874,8 +1058,10 @@ function envelope(value, name) {
   return envelopeFromGeometry(parseGeometry(value, name), name);
 }
 function parseGeometry(value, name) {
+  if (value instanceof Uint8Array)
+    return parseWkbGeometry(value, name);
   if (typeof value !== "string")
-    throwType(name, "GeoJSON or BBox JSON string", value);
+    throwType(name, "GeoJSON, WKT point, BBox JSON, or WKB bytes", value);
   const wkt = parseWktGeometry(value);
   if (wkt !== void 0)
     return wkt;
@@ -892,6 +1078,129 @@ function parseGeometry(value, name) {
   }
   return parsed;
 }
+function parseWkbGeometry(value, name) {
+  const reader = new WkbReader(value, name);
+  const geometry = reader.geometry();
+  if (!reader.done()) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() received trailing WKB bytes`);
+  }
+  return geometry;
+}
+var WkbReader = class {
+  bytes;
+  name;
+  offset = 0;
+  littleEndian = true;
+  constructor(bytes, name) {
+    this.bytes = bytes;
+    this.name = name;
+  }
+  done() {
+    return this.offset === this.bytes.byteLength;
+  }
+  geometry() {
+    this.byteOrder();
+    const header = this.typeHeader();
+    if (header.hasSrid)
+      this.uint32();
+    switch (header.type) {
+      case 1:
+        return { type: "Point", coordinates: this.position(header.dimensions) };
+      case 2:
+        return { type: "LineString", coordinates: this.positions(header.dimensions) };
+      case 3:
+        return {
+          type: "Polygon",
+          coordinates: this.rings(header.dimensions)
+        };
+      default:
+        throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() supports WKB Point, LineString, or Polygon geometry`, { wkbType: header.rawType });
+    }
+  }
+  byteOrder() {
+    const order = this.uint8();
+    if (order === 0) {
+      this.littleEndian = false;
+      return;
+    }
+    if (order === 1) {
+      this.littleEndian = true;
+      return;
+    }
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() WKB byte order is invalid`);
+  }
+  typeHeader() {
+    const rawType = this.uint32();
+    const hasZFlag = (rawType & 2147483648) !== 0;
+    const hasMFlag = (rawType & 1073741824) !== 0;
+    const hasSrid = (rawType & 536870912) !== 0;
+    const baseWithEwkbFlags = rawType & 268435455;
+    const isoFamily = Math.trunc(baseWithEwkbFlags / 1e3);
+    const type = baseWithEwkbFlags % 1e3;
+    const hasZ = hasZFlag || isoFamily === 1 || isoFamily === 3;
+    const hasM = hasMFlag || isoFamily === 2 || isoFamily === 3;
+    return {
+      rawType,
+      type,
+      dimensions: 2 + (hasZ ? 1 : 0) + (hasM ? 1 : 0),
+      hasSrid
+    };
+  }
+  rings(dimensions) {
+    const count = this.uint32();
+    const rings = [];
+    for (let index = 0; index < count; index += 1) {
+      rings.push(this.positions(dimensions));
+    }
+    return rings;
+  }
+  positions(dimensions) {
+    const count = this.uint32();
+    const points = [];
+    for (let index = 0; index < count; index += 1) {
+      points.push(this.position(dimensions));
+    }
+    return points;
+  }
+  position(dimensions) {
+    if (dimensions < 2) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() WKB coordinate dimension is invalid`);
+    }
+    const x = this.float64();
+    const y = this.float64();
+    for (let index = 2; index < dimensions; index += 1)
+      this.float64();
+    if (!Number.isFinite(x) || !Number.isFinite(y)) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() WKB coordinates must be finite`);
+    }
+    return [x, y];
+  }
+  uint8() {
+    this.require(1);
+    const value = this.bytes[this.offset];
+    this.offset += 1;
+    return value ?? 0;
+  }
+  uint32() {
+    this.require(4);
+    const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 4);
+    const value = view.getUint32(0, this.littleEndian);
+    this.offset += 4;
+    return value;
+  }
+  float64() {
+    this.require(8);
+    const view = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 8);
+    const value = view.getFloat64(0, this.littleEndian);
+    this.offset += 8;
+    return value;
+  }
+  require(bytes) {
+    if (this.offset + bytes > this.bytes.byteLength) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${this.name}() received truncated WKB`);
+    }
+  }
+};
 function parseWktGeometry(value) {
   const point = /^POINT\s*\(\s*([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s+([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)\s*\)$/iu.exec(value);
   if (point !== null) {
@@ -956,6 +1265,113 @@ function bboxDistance(left, right) {
   const dy = left.maxy < right.miny ? right.miny - left.maxy : right.maxy < left.miny ? left.miny - right.maxy : 0;
   return Math.hypot(dx, dy);
 }
+function geometryDistance(left, right) {
+  if (requireGeoBackend().booleanIntersects(left, right))
+    return 0;
+  const leftSegments = geometrySegments(left);
+  const rightSegments = geometrySegments(right);
+  const leftPoints = geometryPoints(left);
+  const rightPoints = geometryPoints(right);
+  let best = Number.POSITIVE_INFINITY;
+  for (const point of leftPoints) {
+    for (const other of rightPoints)
+      best = Math.min(best, pointDistance(point, other));
+    for (const segment of rightSegments)
+      best = Math.min(best, pointSegmentDistance(point, segment));
+  }
+  for (const point of rightPoints) {
+    for (const segment of leftSegments)
+      best = Math.min(best, pointSegmentDistance(point, segment));
+  }
+  for (const leftSegment of leftSegments) {
+    for (const rightSegment of rightSegments) {
+      best = Math.min(best, segmentDistance(leftSegment, rightSegment));
+    }
+  }
+  return best;
+}
+function geometryPoints(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      return [geometry.coordinates];
+    case "LineString":
+      return geometry.coordinates;
+    case "Polygon":
+      return geometry.coordinates.flat();
+  }
+}
+function geometrySegments(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      return [];
+    case "LineString":
+      return pathSegments(geometry.coordinates, false);
+    case "Polygon":
+      return geometry.coordinates.flatMap((ring) => pathSegments(ring, true));
+  }
+}
+function pathSegments(points, closed) {
+  const out = [];
+  for (let index = 1; index < points.length; index += 1) {
+    const previous = points[index - 1];
+    const current = points[index];
+    if (previous !== void 0 && current !== void 0)
+      out.push([previous, current]);
+  }
+  if (closed && points.length > 1) {
+    const first = points[0];
+    const last = points[points.length - 1];
+    if (first !== void 0 && last !== void 0 && (first[0] !== last[0] || first[1] !== last[1])) {
+      out.push([last, first]);
+    }
+  }
+  return out;
+}
+function segmentDistance(left, right) {
+  if (segmentsIntersect(left, right))
+    return 0;
+  return Math.min(pointSegmentDistance(left[0], right), pointSegmentDistance(left[1], right), pointSegmentDistance(right[0], left), pointSegmentDistance(right[1], left));
+}
+function pointDistance(left, right) {
+  return Math.hypot(left[0] - right[0], left[1] - right[1]);
+}
+function pointSegmentDistance(point, segment) {
+  const [start, end] = segment;
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const lengthSq = dx * dx + dy * dy;
+  if (lengthSq === 0)
+    return pointDistance(point, start);
+  const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / lengthSq));
+  return pointDistance(point, [start[0] + t * dx, start[1] + t * dy]);
+}
+function segmentsIntersect(left, right) {
+  const [a, b] = left;
+  const [c, d] = right;
+  const abC = orientation(a, b, c);
+  const abD = orientation(a, b, d);
+  const cdA = orientation(c, d, a);
+  const cdB = orientation(c, d, b);
+  if (abC === 0 && pointOnSegment(c, left))
+    return true;
+  if (abD === 0 && pointOnSegment(d, left))
+    return true;
+  if (cdA === 0 && pointOnSegment(a, right))
+    return true;
+  if (cdB === 0 && pointOnSegment(b, right))
+    return true;
+  return abC * abD < 0 && cdA * cdB < 0;
+}
+function orientation(a, b, c) {
+  const cross = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+  if (Math.abs(cross) < Number.EPSILON)
+    return 0;
+  return cross > 0 ? 1 : -1;
+}
+function pointOnSegment(point, segment) {
+  const [start, end] = segment;
+  return point[0] >= Math.min(start[0], end[0]) && point[0] <= Math.max(start[0], end[0]) && point[1] >= Math.min(start[1], end[1]) && point[1] <= Math.max(start[1], end[1]);
+}
 function geometryArea(geometry, name) {
   if (geometry.type === "BBox") {
     const box = bboxFromRecord(geometry, name);
@@ -1148,5 +1564,11 @@ function throwType(name, expected, value) {
 function pad(value) {
   return String(value).padStart(2, "0");
 }
+function bytesToHex(bytes) {
+  let out = "";
+  for (const byte of bytes)
+    out += byte.toString(16).padStart(2, "0");
+  return out;
+}
 
-export { ERROR_CODES, LakeqlError, TimestampValue, __commonJS, __toESM, bboxIntersects, compareTimestampValues, encodeJsonLine, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, evaluate, isLakeqlError, isTimestampValue, jsonSafeValue, loadGeoBackend, matches, parseGeometry, regexpMatchesValue, regexpReplaceValue, requireGeoBackend, setGeoBackend, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry };
+export { ERROR_CODES, LakeqlError, TimestampValue, __commonJS, __toESM, applyIntervalToTimestamp, bboxDistance, bboxIntersects, compareTimestampValues, encodeJsonLine, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, evaluate, geometryDistance, intervalToString, intervalValue, isIntervalValue, isLakeqlError, isNonNegativeInterval, isTimestampValue, jsonSafeValue, loadGeoBackend, matches, parseGeometry, regexpMatchesValue, regexpReplaceValue, requireGeoBackend, setGeoBackend, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry };

package/dist/cloudflare.d.ts

@@ -1,5 +1,5 @@
 import { CacheAdapter, ObjectStore } from './index.js';
-export { AggregateExpr, AggregateGroupSnapshot, AggregateOp, AggregateOperatorState, AggregateOptions, AggregateParquetGroupTaskOptions, AggregateParquetGroupTasksOptions, AggregateParquetTaskOptions, AggregateParquetTasksOptions, AggregateResult, AggregateSnapshotValue, AggregateSpec, AggregateStateSnapshot, AggregationBuilder, ApplyIcebergDeletesOptions, ArithmeticExpr, BBox, BBoxIndex, Batch, BatchExprValues, BetweenExpr, Bookmark, BookmarkInit, BookmarkPosition, BookmarkQuery, BroadcastJoinOptions, CacheApiCache, CacheApiCacheOptions, CacheEntry, CachePolicy, CallExpr, CaseExpr, CaseWhenExpr, CheckpointAdapter, CheckpointStore, Clock, ColumnExpr, ColumnInput, CompareExpr, CompareOp, ConditionalObjectStore, ConditionalPutOptions, CreateParquetTableAsOptions, CreateParquetTableAsQuery, CreateParquetTableAsResult, CsvStreamOptions, DecodedIcebergDeletes, DecodedIcebergParquetDeletes, ERROR_CODES, EngineFilePlan, EngineTable, ErrorDetails, ExplainJson, ExplainResult, Expr, GeoBackend, GeoJsonGeometry, IcebergAppendFile, IcebergAppendOptions, IcebergAppendOutputManifestOptions, IcebergAppendResult, IcebergCatalog, IcebergCommitCatalog, IcebergCommitInput, IcebergCommitResult, IcebergDeleteFile, IcebergDeletionVector, IcebergEnginePlan, IcebergEngineTable, IcebergEqualityDelete, IcebergField, IcebergGlueCatalogOptions, IcebergLoadTableOptions, IcebergNessieCatalogOptions, IcebergParquetDeleteFile, IcebergParquetDeleteFileContent, IcebergPartitionField, IcebergPartitionSpec, IcebergPlan, IcebergPositionDelete, IcebergReadMode, IcebergRestAccessDelegation, IcebergRestCatalog, IcebergRestCatalogConfig, IcebergRestCatalogOptions, IcebergRestLoadContext, IcebergRestLoadTableOptions, IcebergRestLoadTableResult, IcebergRestStorageCredential, IcebergRowBatch, IcebergSortOrder, IcebergTable, IcebergTableIdentifier, IcebergUnsupportedCatalog, IdGenerator, InExpr, InMemoryLakeOptions, InMemoryRowsScanner, InMemoryRowsStore, InMemoryTableOptions, IndexPruneResult, IndexValue, InsertValidationRules, JoinKey, JoinType, JsonExpr, JsonOrderByTerm, JsonQueryV1, Lake, LakeConfig, LakeqlError, LakeqlErrorCode, LikeExpr, ListOptions, LiteralExpr, LoadIcebergEngineTableOptions, LoadIcebergTableFromObjectStoreOptions, LoadIcebergTableFromRestOptions, LoadIcebergTableOptions, LoadParquetEngineTableOptions, LoadTableOptions, LockAdapter, LogHook, LogicalExpr, LookupJoinFunction, LookupJoinOptions, Manifest, ManifestDeleteFile, ManifestFile, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, MemorySpillAdapterOptions, MetadataFile, MetricsHook, MinMaxColumnIndex, NotExpr, NullCheckExpr, ObjectHead, ObjectInfo, ObjectStoreCacheOptions, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, ObjectStoreJsonCacheOptions, ObjectStoreReadControls, ObjectStoreUriAuthority, OperatorSnapshotValue, OrderByTerm, OutputManifest, OutputManifestEntry, PACKAGE, ParquetColumnBatch, ParquetEnginePlan, ParquetEngineTable, ParquetLakeConfig, ParquetMetadata, ParquetRowBatch, ParquetRowGroupPlan, ParquetScanAdapter, PartitionedParquetOutputEntryOptions, PathQueryInit, PlanIcebergFilesOptions, PlanParquetRowGroupsOptions, PlanParquetTaskWorkUnitsOptions, PlannedIcebergFile, PlannedParquetRowGroup, PredicatePlan, PredicatePlanOptions, ProjectIcebergRowOptions, PutOptions, QueryBudget, QueryBuilder, QueryPolicy, QueryPolicyContext, QueryResult, QueryRunOptions, QueryStats, QueueAdapter, ReadParquetBatchOptions, ReadParquetOptions, ResumableBatchOptions, ResumedQuery, Row, RuntimeSubstrate, Scalar, ScanAdapter, ScanBatch, ScanColumnBatch, ScanEngineOptions, ScanOptions, ScanParquetTaskOptions, ScanPlannedIcebergRowsOptions, ScanTaskPlan, ScanTaskPlanOptions, ScanVectorBatch, Selection, SharedCacheEntry, SharedCacheSetOptions, SharedMemoryCache, SidecarFileIndex, SliceOptions, SliceResult, Snapshot, SortOperatorState, SortOptions, SortResult, SortRunState, SpillAdapter, SpillRef, SpillUsage, SqlBoolean, TaskCheckpoint, TaskInput, TaskManifest, TaskManifestTask, TaskState, TaskTransitionInput, TimestampUnit, TimestampValue, TopKOperatorState, TopKOptions, TopKResult, ValueInput, Vector, VectorAggregateOptions, VectorAggregateSnapshotValue, VectorAggregateState, VectorAggregateStateSnapshot, VectorAggregateStateSnapshots, VectorAggregateStates, VectorAggregateValue, VectorGroup, VectorGroupByGroupSnapshot, VectorGroupByOptions, VectorGroupBySnapshotValue, VectorGroupByState, VectorGroupByStateSnapshot, VectorHashJoinOptions, VectorProjectionSpec, VectorTopKOptions, WorkUnitFanInOptions, WriteParquetOptions, WriteParquetRowsOptions, WritePartitionedParquetFile, WritePartitionedParquetResult, WritePartitionedParquetTaskOptions, WritePartitionedParquetTaskResult, add, advanceTaskCheckpoint, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, applyIcebergDeletes, assertBookmarkMatches, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxIntersects, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, compareTimestampValues, concatBatches, createBookmark, createInMemoryLake, createLake, createOutputManifest, createOutputManifestFromCheckpoints, createLake as createParquetLake, createParquetTableAs, createTaskManifest, createVectorAggregateStates, createVectorGroupByState, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, div, encodeJsonLine, enforceVectorGroupByBudget, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, eq, evaluate, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fingerprint, fn, gatherBatch, getOrCreateVectorGroup, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, inMemoryRowsScanner, isIn, isLakeqlError, isNotNull, isNull, isTimestampValue, jsonSafeValue, jsonWorkUnitBoundary, like, lit, loadGeoBackend, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, objectStoreJsonCache, or, parquetScanner, parseGeometry, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planFiles, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, requireGeoBackend, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanBatches, scanParquetTaskBatches, scanParquetTaskColumnBatches, scanPlannedIcebergRows, scanRows, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, setGeoBackend, signPaginationToken, snapshotVectorAggregateStates, snapshotVectorGroupByState, stableStringify, sub, throwIfAborted, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry, transitionTaskCheckpoint, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorHashJoin, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask } from './index.js';
+export { AggregateExpr, AggregateGroupSnapshot, AggregateOp, AggregateOperatorState, AggregateOptions, AggregateParquetGroupTaskOptions, AggregateParquetGroupTasksOptions, AggregateParquetTaskOptions, AggregateParquetTasksOptions, AggregateResult, AggregateSnapshotValue, AggregateSpec, AggregateStateSnapshot, AggregationBuilder, ApplyIcebergDeletesOptions, ArithmeticExpr, BBox, BBoxIndex, Batch, BatchExprValues, BetweenExpr, Bookmark, BookmarkInit, BookmarkPosition, BookmarkQuery, BroadcastJoinOptions, CacheApiCache, CacheApiCacheOptions, CacheEntry, CachePolicy, CallExpr, CaseExpr, CaseWhenExpr, CheckpointAdapter, CheckpointStore, Clock, ColumnExpr, ColumnInput, CompareExpr, CompareOp, CompatibleWindowSortGroup, CompatibleWindowSortItem, ConditionalObjectStore, ConditionalPutOptions, CreateParquetTableAsOptions, CreateParquetTableAsQuery, CreateParquetTableAsResult, CsvStreamOptions, DecodedIcebergDeletes, DecodedIcebergParquetDeletes, ERROR_CODES, EngineFilePlan, EngineTable, ErrorDetails, ExplainJson, ExplainResult, Expr, GeoBackend, GeoJsonGeometry, IcebergAppendFile, IcebergAppendOptions, IcebergAppendOutputManifestOptions, IcebergAppendResult, IcebergCatalog, IcebergCommitCatalog, IcebergCommitInput, IcebergCommitResult, IcebergDeleteFile, IcebergDeletionVector, IcebergEnginePlan, IcebergEngineTable, IcebergEqualityDelete, IcebergField, IcebergGlueCatalogOptions, IcebergLoadTableOptions, IcebergNessieCatalogOptions, IcebergParquetDeleteFile, IcebergParquetDeleteFileContent, IcebergPartitionField, IcebergPartitionSpec, IcebergPlan, IcebergPositionDelete, IcebergReadMode, IcebergRestAccessDelegation, IcebergRestCatalog, IcebergRestCatalogConfig, IcebergRestCatalogOptions, IcebergRestLoadContext, IcebergRestLoadTableOptions, IcebergRestLoadTableResult, IcebergRestStorageCredential, IcebergRowBatch, IcebergSortOrder, IcebergTable, IcebergTableIdentifier, IcebergUnsupportedCatalog, IdGenerator, InExpr, InMemoryLakeOptions, InMemoryRowsScanner, InMemoryRowsStore, InMemoryTableOptions, IndexPruneResult, IndexValue, InsertValidationRules, IntervalValue, JoinKey, JoinType, JsonExpr, JsonOrderByTerm, JsonQueryV1, Lake, LakeConfig, LakeqlError, LakeqlErrorCode, LikeExpr, ListOptions, LiteralExpr, LoadIcebergEngineTableOptions, LoadIcebergTableFromObjectStoreOptions, LoadIcebergTableFromRestOptions, LoadIcebergTableOptions, LoadParquetEngineTableOptions, LoadTableOptions, LockAdapter, LogHook, LogicalExpr, LookupJoinFunction, LookupJoinOptions, Manifest, ManifestDeleteFile, ManifestFile, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, MemorySpillAdapterOptions, MetadataFile, MetricsHook, MinMaxColumnIndex, NotExpr, NullCheckExpr, ObjectHead, ObjectInfo, ObjectStoreCacheOptions, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, ObjectStoreJsonCacheOptions, ObjectStoreReadControls, ObjectStoreUriAuthority, OperatorSnapshotValue, OrderByTerm, OutputManifest, OutputManifestEntry, PACKAGE, ParquetColumnBatch, ParquetEnginePlan, ParquetEngineTable, ParquetLakeConfig, ParquetMetadata, ParquetRowBatch, ParquetRowGroupPlan, ParquetScanAdapter, PartitionedParquetOutputEntryOptions, PathQueryInit, PlanIcebergFilesOptions, PlanParquetRowGroupsOptions, PlanParquetTaskWorkUnitsOptions, PlannedIcebergFile, PlannedParquetRowGroup, PredicatePlan, PredicatePlanOptions, ProjectIcebergRowOptions, PutOptions, QueryBudget, QueryBuilder, QueryPolicy, QueryPolicyContext, QueryResult, QueryRunOptions, QueryStats, QueueAdapter, ReadParquetBatchOptions, ReadParquetOptions, ResumableBatchOptions, ResumedQuery, Row, RuntimeSubstrate, Scalar, ScanAdapter, ScanBatch, ScanColumnBatch, ScanEngineOptions, ScanObjectPlanOptions, ScanOptions, ScanParquetTaskOptions, ScanPlannedIcebergRowsOptions, ScanTaskPlan, ScanTaskPlanOptions, ScanVectorBatch, Selection, SharedCacheEntry, SharedCacheSetOptions, SharedMemoryCache, SidecarFileIndex, SliceOptions, SliceResult, Snapshot, SortOperatorState, SortOptions, SortResult, SortRunState, SpillAdapter, SpillRef, SpillUsage, SqlBoolean, SqlCsvOptions, SqlLake, SqlQueryOptions, SqlQueryResult, TaskCheckpoint, TaskInput, TaskManifest, TaskManifestTask, TaskState, TaskTransitionInput, TimestampUnit, TimestampValue, TopKOperatorState, TopKOptions, TopKResult, ValueInput, Vector, VectorAggregateOptions, VectorAggregateSnapshotValue, VectorAggregateState, VectorAggregateStateSnapshot, VectorAggregateStateSnapshots, VectorAggregateStates, VectorAggregateValue, VectorGroup, VectorGroupByGroupSnapshot, VectorGroupByOptions, VectorGroupBySnapshotValue, VectorGroupByState, VectorGroupByStateSnapshot, VectorHashJoinOptions, VectorProjectionSpec, VectorTopKOptions, WindowExecutionMode, WindowExplainPlan, WindowExpr, WindowFn, WindowFrame, WindowFrameBound, WindowOperatorState, WindowOptions, WindowOrderTerm, WindowParquetTasksOptions, WindowRankingFn, WindowReadColumnInput, WindowResult, WindowRunState, WindowSnapshotValue, WindowSpec, WindowTaskExecutionOptions, WindowTaskPlan, WindowValueFn, WindowWorkUnitBucket, WindowWorkUnitEvaluationOptions, WindowWorkUnitOrdinal, WindowWorkUnitPartial, WindowWorkUnitRow, WorkUnitFanInOptions, WriteParquetOptions, WriteParquetRowsOptions, WritePartitionedParquetFile, WritePartitionedParquetResult, WritePartitionedParquetTaskOptions, WritePartitionedParquetTaskResult, add, advanceTaskCheckpoint, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, applyIcebergDeletes, applyIntervalToTimestamp, assertBookmarkMatches, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxDistance, bboxIntersects, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, collectExprColumns, collectWindowColumns, compareTimestampValues, compatibleWindowSortGroups, concatBatches, createBookmark, createInMemoryLake, createLake, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, createVectorAggregateStates, createVectorGroupByState, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, deserializeWindowOperatorState, div, encodeJsonLine, enforceVectorGroupByBudget, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, eq, evaluate, evaluateWindowWorkUnitPartials, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fingerprint, fn, gatherBatch, geometryDistance, getOrCreateVectorGroup, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, inMemoryRowsScanner, intervalToString, intervalValue, isIn, isIntervalValue, isLakeqlError, isNonNegativeInterval, isNotNull, isNull, isPrototypeMutationKey, isTimestampValue, jsonSafeValue, jsonWorkUnitBoundary, like, lit, loadGeoBackend, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, materializeBatchRow, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, objectStoreJsonCache, or, parquetScanner, parseGeometry, parseHivePartitions, parseJsonQuery, partitionWindowWorkUnitRows, partitionedParquetOutputEntries, planFiles, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, querySql, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, requireGeoBackend, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanBatches, scanParquetTaskBatches, scanParquetTaskColumnBatches, scanPlannedIcebergRows, scanRows, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, serializeWindowOperatorState, setGeoBackend, signPaginationToken, snapshotVectorAggregateStates, snapshotVectorGroupByState, stableStringify, sub, throwIfAborted, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry, transitionTaskCheckpoint, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorHashJoin, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, verifyPaginationToken, windowExpressions, windowOperatorState, windowOperatorStateFromRuns, windowParquetTask, windowParquetTasks, windowPartitionBucket, windowReadColumns, windowRowsFromState, windowSortGroupCount, windowSortSpecsCompatible, windowTaskPlanForWindows, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask } from './index.js';
 import 'hyparquet-writer';
 import 'hyparquet';
 

package/dist/cloudflare.js

@@ -1,7 +1,8 @@
-export { IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, InMemoryRowsScanner, InMemoryRowsStore, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, PACKAGE, applyIcebergDeletes, createInMemoryLake, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, inMemoryRowsScanner, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, objectStoreJsonCache, planFiles, scanBatches, scanPlannedIcebergRows, scanRows, vectorHashJoin } from './chunk-5K5JMJ2M.js';
-export { AggregationBuilder, CacheApiCache, Lake, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, SharedMemoryCache, add, advanceTaskCheckpoint, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, assertBookmarkMatches, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, concatBatches, createBookmark, createParquetLake as createLake, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, createVectorAggregateStates, createVectorGroupByState, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, div, enforceVectorGroupByBudget, eq, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fingerprint, fn, gatherBatch, getOrCreateVectorGroup, gt, gte, ilike, isIn, isNotNull, isNull, jsonWorkUnitBoundary, like, lit, lookupJoin, lt, lte, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanParquetTaskBatches, scanParquetTaskColumnBatches, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, signPaginationToken, snapshotVectorAggregateStates, snapshotVectorGroupByState, stableStringify, sub, throwIfAborted, transitionTaskCheckpoint, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask } from './chunk-MXGEAVHL.js';
-import { LakeqlError } from './chunk-TFD5RFKB.js';
-export { ERROR_CODES, LakeqlError, TimestampValue, bboxIntersects, compareTimestampValues, encodeJsonLine, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, evaluate, isLakeqlError, isTimestampValue, jsonSafeValue, loadGeoBackend, matches, parseGeometry, requireGeoBackend, setGeoBackend, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry } from './chunk-TFD5RFKB.js';
+export { IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, InMemoryRowsScanner, InMemoryRowsStore, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, PACKAGE, SqlQueryResult, applyIcebergDeletes, createInMemoryLake, createLake, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, inMemoryRowsScanner, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, objectStoreJsonCache, planFiles, querySql, scanBatches, scanPlannedIcebergRows, scanRows, vectorHashJoin } from './chunk-3WUY56UD.js';
+export { AggregationBuilder, CacheApiCache, Lake, MemoryCache, MemoryObjectStore, MemorySpillAdapter, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, SharedMemoryCache, add, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, concatBatches, createParquetLake, createParquetTableAs, createVectorAggregateStates, createVectorGroupByState, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, deserializeWindowOperatorState, div, enforceVectorGroupByBudget, eq, evaluateWindowWorkUnitPartials, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fn, gatherBatch, getOrCreateVectorGroup, gt, gte, ilike, isIn, isNotNull, isNull, jsonWorkUnitBoundary, like, lit, lookupJoin, lt, lte, materializeBatchRow, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, partitionWindowWorkUnitRows, partitionedParquetOutputEntries, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanParquetTaskBatches, scanParquetTaskColumnBatches, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, serializeWindowOperatorState, snapshotVectorAggregateStates, snapshotVectorGroupByState, sub, throwIfAborted, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, windowOperatorState, windowOperatorStateFromRuns, windowParquetTask, windowParquetTasks, windowPartitionBucket, windowRowsFromState, withObjectStoreReadControls, writeParquet, writePartitionedParquet, writePartitionedParquetTask } from './chunk-32PE6IK4.js';
+export { MemoryCheckpointAdapter, advanceTaskCheckpoint, assertBookmarkMatches, collectExprColumns, collectWindowColumns, compatibleWindowSortGroups, createBookmark, createOutputManifest, createOutputManifestFromCheckpoints, createTaskManifest, fingerprint, isPrototypeMutationKey, memoryCheckpointAdapter, readOutputManifest, signPaginationToken, stableStringify, transitionTaskCheckpoint, verifyPaginationToken, windowExpressions, windowReadColumns, windowSortGroupCount, windowSortSpecsCompatible, windowTaskPlanForWindows, writeOutputManifest } from './chunk-LWF5FKHB.js';
+import { LakeqlError } from './chunk-WGHR35QU.js';
+export { ERROR_CODES, LakeqlError, TimestampValue, applyIntervalToTimestamp, bboxDistance, bboxIntersects, compareTimestampValues, encodeJsonLine, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, evaluate, geometryDistance, intervalToString, intervalValue, isIntervalValue, isLakeqlError, isNonNegativeInterval, isTimestampValue, jsonSafeValue, loadGeoBackend, matches, parseGeometry, requireGeoBackend, setGeoBackend, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry } from './chunk-WGHR35QU.js';
 
 // ../r2/dist/index.js
 function r2Store(bucket) {

package/dist/{geo-backend-TSQJWAAB.js → geo-backend-WYCTLPNS.js}

@@ -1,4 +1,4 @@
-import { setGeoBackend } from './chunk-TFD5RFKB.js';
+import { setGeoBackend } from './chunk-WGHR35QU.js';
 import { booleanContains } from '@turf/boolean-contains';
 import { booleanIntersects } from '@turf/boolean-intersects';
 import { latLngToCell, isValidCell, gridDisk, cellToParent } from 'h3-js';