lakeql 0.1.2 → 0.1.8

package/dist/chunk-TFD5RFKB.js

@@ -0,0 +1,1152 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../core/dist/errors.js
+var ERROR_CODES = [
+  "LAKEQL_PARSE_ERROR",
+  "LAKEQL_SQL_UNSUPPORTED",
+  "LAKEQL_TYPE_ERROR",
+  "LAKEQL_UNKNOWN_TABLE",
+  "LAKEQL_UNKNOWN_COLUMN",
+  "LAKEQL_UNSUPPORTED_PUSHDOWN",
+  "LAKEQL_BUDGET_EXCEEDED",
+  "LAKEQL_GROUP_LIMIT_EXCEEDED",
+  "LAKEQL_OBJECT_NOT_FOUND",
+  "LAKEQL_CATALOG_ERROR",
+  "LAKEQL_UNSUPPORTED_ICEBERG_FEATURE",
+  "LAKEQL_UNSUPPORTED_PARQUET_FEATURE",
+  "LAKEQL_ICEBERG_COMMIT_CONFLICT",
+  "LAKEQL_UNSUPPORTED_DELETE_FILES",
+  "LAKEQL_PARQUET_READ_ERROR",
+  "LAKEQL_PARQUET_WRITE_ERROR",
+  "LAKEQL_VALIDATION_ERROR",
+  "LAKEQL_BOOKMARK_STALE",
+  "LAKEQL_BOOKMARK_INVALID",
+  "LAKEQL_ABORTED",
+  "LAKEQL_GEO_BACKEND_MISSING"
+];
+var LakeqlError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "LakeqlError";
+    this.code = code;
+    this.details = details;
+  }
+};
+function isLakeqlError(value) {
+  return value instanceof LakeqlError;
+}
+
+// ../core/dist/timestamp.js
+var NANOS_PER_MILLI = 1000000n;
+var NANOS_PER_MICRO = 1000n;
+var TimestampValue = class {
+  epochNanoseconds;
+  unit;
+  isAdjustedToUTC;
+  constructor(epochNanoseconds2, unit, isAdjustedToUTC = true) {
+    this.epochNanoseconds = epochNanoseconds2;
+    this.unit = unit;
+    this.isAdjustedToUTC = isAdjustedToUTC;
+  }
+  toJSON() {
+    return timestampToIsoString(this);
+  }
+  toString() {
+    return timestampToIsoString(this);
+  }
+};
+function timestampFromEpoch(value, unit, isAdjustedToUTC = true) {
+  return new TimestampValue(epochNanoseconds(value, unit), unit, isAdjustedToUTC);
+}
+function timestampValueFromIso(value) {
+  const match = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?Z$/u.exec(value);
+  if (!match)
+    return void 0;
+  const millis = Date.parse(`${match[1]}.000Z`);
+  if (!Number.isFinite(millis))
+    return void 0;
+  const fraction = (match[2] ?? "").padEnd(9, "0");
+  const fractionNanos = fraction.length === 0 ? 0n : BigInt(fraction);
+  return new TimestampValue(BigInt(millis) * NANOS_PER_MILLI + fractionNanos, unitForFraction(match[2] ?? ""));
+}
+function isTimestampValue(value) {
+  return typeof value === "object" && value !== null && "epochNanoseconds" in value && typeof value.epochNanoseconds === "bigint" && "unit" in value && (value.unit === "millis" || value.unit === "micros" || value.unit === "nanos") && "isAdjustedToUTC" in value && typeof value.isAdjustedToUTC === "boolean";
+}
+function timestampToIsoString(value) {
+  const wholeMillis = value.epochNanoseconds / NANOS_PER_MILLI;
+  const nanosWithinMillis = value.epochNanoseconds % NANOS_PER_MILLI;
+  const millisWithinSecond = wholeMillis % 1000n;
+  const secondMillis = wholeMillis - millisWithinSecond;
+  const base = new Date(Number(secondMillis)).toISOString().replace(/\.\d{3}Z$/u, "");
+  const nanosWithinSecond = millisWithinSecond * NANOS_PER_MILLI + nanosWithinMillis;
+  const fraction = fractionForUnit(nanosWithinSecond, value.unit);
+  return `${base}${fraction}Z`;
+}
+function timestampEpochForUnit(value, unit) {
+  switch (unit) {
+    case "millis":
+      return value.epochNanoseconds / NANOS_PER_MILLI;
+    case "micros":
+      return value.epochNanoseconds / NANOS_PER_MICRO;
+    case "nanos":
+      return value.epochNanoseconds;
+  }
+}
+function compareTimestampValues(left, right) {
+  if (left.epochNanoseconds < right.epochNanoseconds)
+    return -1;
+  if (left.epochNanoseconds > right.epochNanoseconds)
+    return 1;
+  return 0;
+}
+function epochNanoseconds(value, unit) {
+  switch (unit) {
+    case "millis":
+      return value * NANOS_PER_MILLI;
+    case "micros":
+      return value * NANOS_PER_MICRO;
+    case "nanos":
+      return value;
+  }
+}
+function unitForFraction(fraction) {
+  if (fraction.length <= 3)
+    return "millis";
+  if (fraction.length <= 6)
+    return "micros";
+  return "nanos";
+}
+function fractionForUnit(nanos, unit) {
+  switch (unit) {
+    case "millis": {
+      const millis = nanos / NANOS_PER_MILLI;
+      return `.${millis.toString().padStart(3, "0")}`;
+    }
+    case "micros": {
+      const micros = nanos / NANOS_PER_MICRO;
+      return `.${micros.toString().padStart(6, "0")}`;
+    }
+    case "nanos":
+      return `.${nanos.toString().padStart(9, "0")}`;
+  }
+}
+
+// ../core/dist/regex-functions.js
+function regexpMatchesValue(value, pattern, options = "") {
+  const regexOptions = parseRegexOptions("regexp_matches", options, { allowGlobal: false });
+  return compileRegex("regexp_matches", pattern, regexOptions).test(value);
+}
+function regexpReplaceValue(value, pattern, replacement, options = "") {
+  const regexOptions = parseRegexOptions("regexp_replace", options, { allowGlobal: true });
+  const regex = compileRegex("regexp_replace", pattern, regexOptions);
+  return value.replace(regex, duckdbReplacementToJs(replacement));
+}
+function compileRegex(name, pattern, options) {
+  const source = options.literal ? escapeRegexPattern(pattern) : pattern;
+  try {
+    return new RegExp(source, options.flags);
+  } catch (cause) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() received an invalid regular expression`, {
+      pattern,
+      cause
+    });
+  }
+}
+function parseRegexOptions(name, options, input) {
+  let caseInsensitive = false;
+  let multiline = false;
+  let dotAll = false;
+  let literal = false;
+  let global = false;
+  for (const option of options) {
+    switch (option) {
+      case "c":
+        caseInsensitive = false;
+        break;
+      case "i":
+        caseInsensitive = true;
+        break;
+      case "g":
+        if (!input.allowGlobal) {
+          throw new LakeqlError("LAKEQL_TYPE_ERROR", "g regex option is only valid for regexp_replace()");
+        }
+        global = true;
+        break;
+      case "l":
+        literal = true;
+        break;
+      case "m":
+      case "n":
+      case "p":
+        multiline = true;
+        break;
+      case "s":
+        dotAll = true;
+        break;
+      default:
+        throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() received an unsupported regex option`, {
+          option
+        });
+    }
+  }
+  return {
+    global,
+    literal,
+    flags: `${caseInsensitive ? "i" : ""}${multiline ? "m" : ""}${dotAll ? "s" : ""}${global ? "g" : ""}`
+  };
+}
+function duckdbReplacementToJs(replacement) {
+  return replacement.replace(/\\([1-9])/g, "$$$1");
+}
+function escapeRegexPattern(pattern) {
+  return pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ../core/dist/evaluator.js
+var GEO_BACKEND_FUNCTIONS = /* @__PURE__ */ new Set([
+  "st_intersects",
+  "st_disjoint",
+  "st_contains",
+  "st_within",
+  "h3_within",
+  "h3_cell",
+  "h3_parent"
+]);
+var geoBackend = null;
+function setGeoBackend(backend) {
+  geoBackend = backend;
+}
+function requireGeoBackend() {
+  if (geoBackend === null) {
+    throw new LakeqlError("LAKEQL_GEO_BACKEND_MISSING", "Spatial function requires the geo backend. Query execution loads it automatically; when calling evaluate() directly, await loadGeoBackend() first.");
+  }
+  return geoBackend;
+}
+async function loadGeoBackend() {
+  if (geoBackend !== null)
+    return;
+  const module = await import('./geo-backend-TSQJWAAB.js');
+  module.installGeoBackend();
+}
+async function ensureGeoBackendForExprs(exprs) {
+  if (geoBackend !== null)
+    return;
+  for (const expr of exprs) {
+    if (exprNeedsGeoBackend(expr)) {
+      await loadGeoBackend();
+      return;
+    }
+  }
+}
+function exprNeedsGeoBackend(expr) {
+  if (!expr)
+    return false;
+  switch (expr.kind) {
+    case "literal":
+    case "column":
+      return false;
+    case "compare":
+    case "arithmetic":
+      return exprNeedsGeoBackend(expr.left) || exprNeedsGeoBackend(expr.right);
+    case "in":
+      return exprNeedsGeoBackend(expr.target) || expr.values.some(exprNeedsGeoBackend);
+    case "between":
+      return exprNeedsGeoBackend(expr.target) || exprNeedsGeoBackend(expr.low) || exprNeedsGeoBackend(expr.high);
+    case "null-check":
+    case "like":
+      return exprNeedsGeoBackend(expr.target);
+    case "logical":
+      return expr.operands.some(exprNeedsGeoBackend);
+    case "not":
+      return exprNeedsGeoBackend(expr.operand);
+    case "call":
+      return GEO_BACKEND_FUNCTIONS.has(expr.fn.toLowerCase()) || expr.args.some(exprNeedsGeoBackend);
+    case "case":
+      return expr.whens.some((branch) => exprNeedsGeoBackend(branch.when) || exprNeedsGeoBackend(branch.value)) || exprNeedsGeoBackend(expr.else);
+  }
+}
+var textEncoder = new TextEncoder();
+function evaluate(expr, row) {
+  switch (expr.kind) {
+    case "literal":
+      return expr.value;
+    case "column":
+      return rowValue(row, expr.name);
+    case "compare":
+      return compare(expr.op, evaluate(expr.left, row), evaluate(expr.right, row));
+    case "in": {
+      const target = evaluate(expr.target, row);
+      const result = inList(target, expr.values.map((value) => evaluate(value, row)));
+      return expr.negated ? sqlNot(result) : result;
+    }
+    case "between": {
+      const target = evaluate(expr.target, row);
+      const low = evaluate(expr.low, row);
+      const high = evaluate(expr.high, row);
+      return sqlAnd(compare("gte", target, low), compare("lte", target, high));
+    }
+    case "null-check": {
+      const result = evaluate(expr.target, row) === null;
+      return expr.negated ? !result : result;
+    }
+    case "logical":
+      return expr.op === "and" ? expr.operands.reduce((acc, operand) => sqlAnd(acc, toSqlBoolean(evaluate(operand, row))), true) : expr.operands.reduce((acc, operand) => sqlOr(acc, toSqlBoolean(evaluate(operand, row))), false);
+    case "not":
+      return sqlNot(toSqlBoolean(evaluate(expr.operand, row)));
+    case "like":
+      return likeMatch(evaluate(expr.target, row), expr.pattern, expr.caseInsensitive);
+    case "call":
+      return callFunction(expr.fn, expr.args.map((arg) => evaluate(arg, row)));
+    case "arithmetic":
+      return arithmetic(expr.op, evaluate(expr.left, row), evaluate(expr.right, row));
+    case "case":
+      for (const branch of expr.whens) {
+        if (toSqlBoolean(evaluate(branch.when, row)) === true)
+          return evaluate(branch.value, row);
+      }
+      return expr.else === void 0 ? null : evaluate(expr.else, row);
+  }
+}
+function matches(expr, row) {
+  if (!expr)
+    return true;
+  return toSqlBoolean(evaluate(expr, row)) === true;
+}
+function jsonSafeValue(value) {
+  if (isTimestampValue(value))
+    return value.toJSON();
+  if (typeof value === "bigint") {
+    const asNumber = Number(value);
+    return Number.isSafeInteger(asNumber) ? asNumber : value.toString();
+  }
+  if (Array.isArray(value))
+    return value.map(jsonSafeValue);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, inner] of Object.entries(value))
+      out[key] = jsonSafeValue(inner);
+    return out;
+  }
+  return value;
+}
+function encodeJsonLine(row) {
+  return textEncoder.encode(`${JSON.stringify(jsonSafeValue(row))}
+`);
+}
+function rowValue(row, name) {
+  if (!(name in row)) {
+    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)) {
+    return value;
+  }
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `Column ${name} is not a scalar value`, {
+    column: name,
+    valueType: typeof value
+  });
+}
+function toSqlBoolean(value) {
+  if (value === null)
+    return null;
+  if (typeof value === "boolean")
+    return value;
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", "Predicate expression must evaluate to boolean", {
+    value
+  });
+}
+function compare(op, left, right) {
+  if (left === null || right === null)
+    return null;
+  if (isTimestampValue(left) || isTimestampValue(right)) {
+    const leftTimestamp = timestampEvalValue(left);
+    const rightTimestamp = timestampEvalValue(right);
+    if (leftTimestamp === void 0 || rightTimestamp === void 0) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare timestamp with non-timestamp", {
+        leftType: evalValueType(left),
+        rightType: evalValueType(right)
+      });
+    }
+    return compareOrder(op, compareTimestampValues(leftTimestamp, rightTimestamp));
+  }
+  if (typeof left !== typeof right && !(isNumberLike(left) && isNumberLike(right))) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cannot compare values of different types", {
+      leftType: typeof left,
+      rightType: typeof right
+    });
+  }
+  const order = left < right ? -1 : left > right ? 1 : 0;
+  return compareOrder(op, order);
+}
+function compareOrder(op, order) {
+  switch (op) {
+    case "eq":
+      return order === 0;
+    case "ne":
+      return order !== 0;
+    case "lt":
+      return order < 0;
+    case "lte":
+      return order <= 0;
+    case "gt":
+      return order > 0;
+    case "gte":
+      return order >= 0;
+  }
+}
+function timestampEvalValue(value) {
+  if (isTimestampValue(value))
+    return value;
+  if (typeof value === "string")
+    return timestampValueFromIso(value);
+  return void 0;
+}
+function evalValueType(value) {
+  return isTimestampValue(value) ? "timestamp" : typeof value;
+}
+function arithmetic(op, left, right) {
+  if (left === null || right === null)
+    return null;
+  if (typeof left !== "number" || typeof right !== "number") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Arithmetic expressions require numeric values", {
+      leftType: typeof left,
+      rightType: typeof right
+    });
+  }
+  switch (op) {
+    case "add":
+      return left + right;
+    case "sub":
+      return left - right;
+    case "mul":
+      return left * right;
+    case "div":
+      return left / right;
+    case "mod":
+      return left % right;
+  }
+}
+function isNumberLike(value) {
+  return typeof value === "number" || typeof value === "bigint";
+}
+function inList(target, values) {
+  if (target === null)
+    return null;
+  let sawNull = false;
+  for (const value of values) {
+    const result = compare("eq", target, value);
+    if (result === true)
+      return true;
+    if (result === null)
+      sawNull = true;
+  }
+  return sawNull ? null : false;
+}
+function sqlAnd(left, right) {
+  if (left === false || right === false)
+    return false;
+  if (left === null || right === null)
+    return null;
+  return true;
+}
+function sqlOr(left, right) {
+  if (left === true || right === true)
+    return true;
+  if (left === null || right === null)
+    return null;
+  return false;
+}
+function sqlNot(value) {
+  if (value === null)
+    return null;
+  return !value;
+}
+function likeMatch(value, pattern, caseInsensitive) {
+  if (value === null)
+    return null;
+  if (typeof value !== "string") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "LIKE expects a string value", {
+      valueType: typeof value
+    });
+  }
+  const regex = new RegExp(`^${escapeLikePattern(pattern)}$`, caseInsensitive ? "iu" : "u");
+  return regex.test(value);
+}
+function escapeLikePattern(pattern) {
+  let out = "";
+  for (const char of pattern) {
+    if (char === "%")
+      out += ".*";
+    else if (char === "_")
+      out += ".";
+    else
+      out += char.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  }
+  return out;
+}
+function callFunction(name, args) {
+  const fn = name.toLowerCase();
+  switch (fn) {
+    case "lower":
+      return unaryString(fn, args, (value) => value.toLowerCase());
+    case "upper":
+      return unaryString(fn, args, (value) => value.toUpperCase());
+    case "trim":
+      return unaryString(fn, args, (value) => value.trim());
+    case "substr":
+      return substr(args);
+    case "replace":
+      return replace(args);
+    case "regexp_matches":
+      return regexpMatches(args);
+    case "regexp_replace":
+      return regexpReplace(args);
+    case "coalesce":
+      return args.find((value) => value !== null) ?? null;
+    case "nullif":
+      requireArgCount(fn, args, 2);
+      return compare("eq", args[0] ?? null, args[1] ?? null) === true ? null : args[0] ?? null;
+    case "cast":
+      return cast(args);
+    case "year":
+      return datePart(fn, args, (date) => date.getUTCFullYear());
+    case "month":
+      return datePart(fn, args, (date) => date.getUTCMonth() + 1);
+    case "day":
+      return datePart(fn, args, (date) => date.getUTCDate());
+    case "hour":
+      return datePart(fn, args, (date) => date.getUTCHours());
+    case "date_trunc":
+      return dateTrunc(args);
+    case "round":
+      return round(args);
+    case "floor":
+      return unaryNumber(fn, args, Math.floor);
+    case "ceil":
+      return unaryNumber(fn, args, Math.ceil);
+    case "abs":
+      return unaryNumber(fn, args, Math.abs);
+    case "least":
+      return leastGreatest(fn, args, "least");
+    case "greatest":
+      return leastGreatest(fn, args, "greatest");
+    case "st_point":
+      return stPoint(args);
+    case "st_x":
+      return pointCoordinate(fn, args, 0);
+    case "st_y":
+      return pointCoordinate(fn, args, 1);
+    case "st_bbox":
+      return stBBox(args);
+    case "st_intersects":
+      return spatialPredicate(fn, args, "intersects");
+    case "st_contains":
+      return spatialPredicate(fn, args, "contains");
+    case "st_within":
+      return spatialPredicate(fn, args, "within");
+    case "st_disjoint":
+      return spatialPredicate(fn, args, "disjoint");
+    case "st_distance":
+      return spatialMeasurement(fn, args, bboxDistance);
+    case "st_area":
+      return geometryMeasurement(fn, args, geometryArea);
+    case "st_length":
+      return geometryMeasurement(fn, args, geometryLength);
+    case "st_centroid":
+      return geometryTransform(fn, args, geometryCentroid);
+    case "st_envelope":
+      return geometryTransform(fn, args, (geometry) => JSON.stringify(envelopeFromGeometry(geometry, fn)));
+    case "h3_in":
+      return h3In(args);
+    case "h3_within":
+      return h3Within(args);
+    case "h3_cell":
+      return h3Cell(args);
+    case "h3_parent":
+      return h3Parent(args);
+    default:
+      throw new LakeqlError("LAKEQL_UNSUPPORTED_PUSHDOWN", `Unsupported scalar function ${name}`, {
+        function: name
+      });
+  }
+}
+function requireArgCount(name, args, expected) {
+  if (args.length !== expected) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() expects ${expected} arguments`, {
+      expected,
+      received: args.length
+    });
+  }
+}
+function unaryString(name, args, cb) {
+  requireArgCount(name, args, 1);
+  const value = args[0] ?? null;
+  if (value === null)
+    return null;
+  if (typeof value !== "string")
+    throwType(name, "string", value);
+  return cb(value);
+}
+function unaryNumber(name, args, cb) {
+  requireArgCount(name, args, 1);
+  const value = args[0] ?? null;
+  if (value === null)
+    return null;
+  if (typeof value !== "number")
+    throwType(name, "number", value);
+  return cb(value);
+}
+function substr(args) {
+  requireArgCount("substr", args, 3);
+  const value = args[0] ?? null;
+  const start = args[1] ?? null;
+  const length = args[2] ?? null;
+  if (value === null || start === null || length === null)
+    return null;
+  if (typeof value !== "string")
+    throwType("substr", "string", value);
+  if (typeof start !== "number" || typeof length !== "number") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "substr() start and length must be numbers");
+  }
+  return value.slice(start, start + length);
+}
+function replace(args) {
+  requireArgCount("replace", args, 3);
+  const value = args[0] ?? null;
+  const search = args[1] ?? null;
+  const replacement = args[2] ?? null;
+  if (value === null || search === null || replacement === null)
+    return null;
+  if (typeof value !== "string")
+    throwType("replace", "string", value);
+  if (typeof search !== "string" || typeof replacement !== "string") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "replace() search and replacement must be strings");
+  }
+  return value.replaceAll(search, replacement);
+}
+function regexpMatches(args) {
+  if (args.length < 2 || args.length > 3) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "regexp_matches() expects 2 or 3 arguments", {
+      received: args.length
+    });
+  }
+  const value = args[0] ?? null;
+  const pattern = args[1] ?? null;
+  const options = args[2] ?? "";
+  if (value === null || pattern === null || options === null)
+    return null;
+  if (typeof value !== "string" || typeof pattern !== "string" || typeof options !== "string") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "regexp_matches() value, pattern, and options must be strings");
+  }
+  return regexpMatchesValue(value, pattern, options);
+}
+function regexpReplace(args) {
+  if (args.length < 3 || args.length > 4) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "regexp_replace() expects 3 or 4 arguments", {
+      received: args.length
+    });
+  }
+  const value = args[0] ?? null;
+  const pattern = args[1] ?? null;
+  const replacement = args[2] ?? null;
+  const options = args[3] ?? "";
+  if (value === null || pattern === null || replacement === null || options === null)
+    return null;
+  if (typeof value !== "string" || typeof pattern !== "string" || typeof replacement !== "string" || typeof options !== "string") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "regexp_replace() value, pattern, replacement, and options must be strings");
+  }
+  return regexpReplaceValue(value, pattern, replacement, options);
+}
+function stPoint(args) {
+  requireArgCount("st_point", args, 2);
+  const [lon, lat] = args;
+  if (!finiteNumber(lon) || !finiteNumber(lat)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "st_point() expects finite lon/lat numbers");
+  }
+  return JSON.stringify({ type: "Point", coordinates: [lon, lat] });
+}
+function pointCoordinate(name, args, index) {
+  requireArgCount(name, args, 1);
+  const value = args[0] ?? null;
+  if (value === null)
+    return null;
+  return pointFromGeometry(parseGeometry(value, name), name)[index];
+}
+function stBBox(args) {
+  requireArgCount("st_bbox", args, 4);
+  const [minx, miny, maxx, maxy] = args;
+  if (!finiteNumber(minx) || !finiteNumber(miny) || !finiteNumber(maxx) || !finiteNumber(maxy)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "st_bbox() expects finite number bounds");
+  }
+  if (minx > maxx || miny > maxy) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "st_bbox() bounds must be ordered min <= max");
+  }
+  return JSON.stringify({ type: "BBox", minx, miny, maxx, maxy });
+}
+function spatialPredicate(name, args, op) {
+  requireArgCount(name, args, 2);
+  const left = args[0] ?? null;
+  const right = args[1] ?? null;
+  if (left === null || right === null)
+    return null;
+  const a = toGeometry(parseGeometry(left, name), name);
+  const b = toGeometry(parseGeometry(right, name), name);
+  const ea = envelopeOf(a);
+  const eb = envelopeOf(b);
+  const geo = requireGeoBackend();
+  switch (op) {
+    case "intersects":
+      return bboxIntersects(ea, eb) && geo.booleanIntersects(a, b);
+    case "disjoint":
+      return !bboxIntersects(ea, eb) || !geo.booleanIntersects(a, b);
+    case "contains":
+      return bboxContains(ea, eb) && geo.booleanContains(a, b);
+    case "within":
+      return bboxContains(eb, ea) && geo.booleanContains(b, a);
+  }
+}
+function envelopeOf(geometry) {
+  switch (geometry.type) {
+    case "Point":
+      return pointsEnvelope([geometry.coordinates]);
+    case "LineString":
+      return pointsEnvelope(geometry.coordinates);
+    case "Polygon":
+      return pointsEnvelope(geometry.coordinates.flat());
+  }
+}
+function toGeometry(parsed, name) {
+  switch (parsed.type) {
+    case "Point":
+      return { type: "Point", coordinates: pointFromGeometry(parsed, name) };
+    case "LineString":
+      return { type: "LineString", coordinates: lineStringPoints(parsed, name) };
+    case "Polygon":
+      return { type: "Polygon", coordinates: polygonRings(parsed, name) };
+    case "BBox":
+      return { type: "Polygon", coordinates: [bboxRing(bboxFromRecord(parsed, name))] };
+    default:
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() supports Point, LineString, Polygon, or BBox geometry`);
+  }
+}
+function bboxRing(box) {
+  return [
+    [box.minx, box.miny],
+    [box.maxx, box.miny],
+    [box.maxx, box.maxy],
+    [box.minx, box.maxy],
+    [box.minx, box.miny]
+  ];
+}
+function polygonRings(record, name) {
+  const rings = record.coordinates;
+  if (!Array.isArray(rings) || rings.length === 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() Polygon coordinates are invalid`);
+  }
+  return rings.map((ring) => {
+    if (!Array.isArray(ring) || ring.length === 0 || !ring.every(isPosition)) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() Polygon coordinates are invalid`);
+    }
+    return closeRing(ring);
+  });
+}
+function closeRing(ring) {
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first && last && (first[0] !== last[0] || first[1] !== last[1])) {
+    return [...ring, first];
+  }
+  return ring;
+}
+function spatialMeasurement(name, args, measure) {
+  requireArgCount(name, args, 2);
+  const left = args[0] ?? null;
+  const right = args[1] ?? null;
+  if (left === null || right === null)
+    return null;
+  return measure(envelope(left, name), envelope(right, name));
+}
+function geometryMeasurement(name, args, measure) {
+  requireArgCount(name, args, 1);
+  const value = args[0] ?? null;
+  if (value === null)
+    return null;
+  return measure(parseGeometry(value, name), name);
+}
+function geometryTransform(name, args, transform) {
+  requireArgCount(name, args, 1);
+  const value = args[0] ?? null;
+  if (value === null)
+    return null;
+  return transform(parseGeometry(value, name));
+}
+function h3In(args) {
+  requireArgCount("h3_in", args, 2);
+  const cell = args[0] ?? null;
+  const cells = args[1] ?? null;
+  if (cell === null || cells === null)
+    return null;
+  if (typeof cell !== "string" || typeof cells !== "string") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "h3_in() expects a string cell and JSON cell list");
+  }
+  const parsed = JSON.parse(cells);
+  if (!Array.isArray(parsed) || !parsed.every((value) => typeof value === "string")) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "h3_in() cell list must be a JSON string array");
+  }
+  return parsed.includes(cell);
+}
+function h3Within(args) {
+  requireArgCount("h3_within", args, 3);
+  const cell = args[0] ?? null;
+  const origin = args[1] ?? null;
+  const k = args[2] ?? null;
+  if (cell === null || origin === null || k === null)
+    return null;
+  if (typeof cell !== "string" || typeof origin !== "string") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "h3_within() expects string cells");
+  }
+  validateH3Cell(cell, "cell");
+  validateH3Cell(origin, "origin");
+  if (typeof k !== "number" || !Number.isInteger(k) || k < 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "h3_within() expects a non-negative integer radius");
+  }
+  return requireGeoBackend().gridDisk(origin, k).includes(cell);
+}
+function h3Cell(args) {
+  requireArgCount("h3_cell", args, 3);
+  const lat = args[0] ?? null;
+  const lon = args[1] ?? null;
+  const res = args[2] ?? null;
+  if (!finiteNumber(lat) || !finiteNumber(lon)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "h3_cell() expects finite lat/lon numbers");
+  }
+  if (typeof res !== "number" || !Number.isInteger(res) || res < 0 || res > 15) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "h3_cell() expects an integer resolution 0..15");
+  }
+  return requireGeoBackend().latLngToCell(lat, lon, res);
+}
+function h3Parent(args) {
+  requireArgCount("h3_parent", args, 2);
+  const cell = args[0] ?? null;
+  const res = args[1] ?? null;
+  if (cell === null || res === null)
+    return null;
+  if (typeof cell !== "string")
+    throwType("h3_parent", "string", cell);
+  validateH3Cell(cell, "cell");
+  if (typeof res !== "number" || !Number.isInteger(res) || res < 0 || res > 15) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "h3_parent() expects an integer resolution 0..15");
+  }
+  return requireGeoBackend().cellToParent(cell, res);
+}
+function validateH3Cell(cell, label) {
+  if (!requireGeoBackend().isValidCell(cell)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `h3 cell ${label} is invalid`, { cell });
+  }
+}
+function envelope(value, name) {
+  return envelopeFromGeometry(parseGeometry(value, name), name);
+}
+function parseGeometry(value, name) {
+  if (typeof value !== "string")
+    throwType(name, "GeoJSON or BBox JSON string", value);
+  const wkt = parseWktGeometry(value);
+  if (wkt !== void 0)
+    return wkt;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (cause) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() received invalid geometry JSON`, {
+      cause
+    });
+  }
+  if (!isRecord(parsed) || typeof parsed.type !== "string") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() expects GeoJSON or BBox JSON`);
+  }
+  return parsed;
+}
+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) {
+    const lon = Number(point[1]);
+    const lat = Number(point[2]);
+    if (Number.isFinite(lon) && Number.isFinite(lat)) {
+      return { type: "Point", coordinates: [lon, lat] };
+    }
+  }
+  return void 0;
+}
+function envelopeFromGeometry(parsed, name) {
+  if (parsed.type === "BBox")
+    return bboxFromRecord(parsed, name);
+  if (parsed.type === "Point")
+    return pointEnvelope(parsed, name);
+  if (parsed.type === "LineString")
+    return lineStringEnvelope(parsed, name);
+  if (parsed.type === "Polygon")
+    return polygonEnvelope(parsed, name);
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() supports Point, LineString, Polygon, or BBox geometry`);
+}
+function bboxFromRecord(record, name) {
+  const { minx, miny, maxx, maxy } = record;
+  if (!finiteNumber(minx) || !finiteNumber(miny) || !finiteNumber(maxx) || !finiteNumber(maxy)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() BBox values must be finite numbers`);
+  }
+  return { minx, miny, maxx, maxy };
+}
+function pointEnvelope(record, name) {
+  const [x, y] = pointFromGeometry(record, name);
+  return { minx: x, miny: y, maxx: x, maxy: y };
+}
+function lineStringEnvelope(record, name) {
+  return pointsEnvelope(lineStringPoints(record, name));
+}
+function polygonEnvelope(record, name) {
+  const points = polygonPoints(record, name);
+  return pointsEnvelope(points);
+}
+function pointsEnvelope(points) {
+  let minx = Number.POSITIVE_INFINITY;
+  let miny = Number.POSITIVE_INFINITY;
+  let maxx = Number.NEGATIVE_INFINITY;
+  let maxy = Number.NEGATIVE_INFINITY;
+  for (const [x, y] of points) {
+    minx = Math.min(minx, x);
+    miny = Math.min(miny, y);
+    maxx = Math.max(maxx, x);
+    maxy = Math.max(maxy, y);
+  }
+  return { minx, miny, maxx, maxy };
+}
+function bboxIntersects(left, right) {
+  return left.maxx >= right.minx && left.minx <= right.maxx && left.maxy >= right.miny && left.miny <= right.maxy;
+}
+function bboxContains(left, right) {
+  return left.minx <= right.minx && left.miny <= right.miny && left.maxx >= right.maxx && left.maxy >= right.maxy;
+}
+function bboxDistance(left, right) {
+  const dx = left.maxx < right.minx ? right.minx - left.maxx : right.maxx < left.minx ? left.minx - right.maxx : 0;
+  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 geometryArea(geometry, name) {
+  if (geometry.type === "BBox") {
+    const box = bboxFromRecord(geometry, name);
+    return (box.maxx - box.minx) * (box.maxy - box.miny);
+  }
+  if (geometry.type === "Polygon")
+    return Math.abs(ringArea(polygonPoints(geometry, name)));
+  if (geometry.type === "Point" || geometry.type === "LineString")
+    return 0;
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() unsupported geometry type`, {
+    type: geometry.type
+  });
+}
+function geometryLength(geometry, name) {
+  if (geometry.type === "BBox") {
+    const box = bboxFromRecord(geometry, name);
+    return 2 * (box.maxx - box.minx + (box.maxy - box.miny));
+  }
+  if (geometry.type === "LineString")
+    return pathLength(lineStringPoints(geometry, name));
+  if (geometry.type === "Polygon")
+    return pathLength(polygonPoints(geometry, name));
+  if (geometry.type === "Point")
+    return 0;
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() unsupported geometry type`, {
+    type: geometry.type
+  });
+}
+function geometryCentroid(geometry) {
+  const box = envelopeFromGeometry(geometry, "st_centroid");
+  return JSON.stringify({
+    type: "Point",
+    coordinates: [(box.minx + box.maxx) / 2, (box.miny + box.maxy) / 2]
+  });
+}
+function pointFromGeometry(record, name) {
+  if (record.type !== "Point" || !isPosition(record.coordinates)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() Point coordinates are invalid`);
+  }
+  return record.coordinates;
+}
+function lineStringPoints(record, name) {
+  const points = record.coordinates;
+  if (!Array.isArray(points) || points.length === 0 || !points.every(isPosition)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() LineString coordinates are invalid`);
+  }
+  return points;
+}
+function polygonPoints(record, name) {
+  const rings = record.coordinates;
+  if (!Array.isArray(rings)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() Polygon coordinates are invalid`);
+  }
+  const points = rings.flat();
+  if (points.length === 0 || !points.every(isPosition)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() Polygon coordinates are invalid`);
+  }
+  return points;
+}
+function ringArea(points) {
+  let area = 0;
+  for (let index = 0; index < points.length; index += 1) {
+    const current = points[index];
+    const next = points[(index + 1) % points.length];
+    if (current === void 0 || next === void 0)
+      continue;
+    area += current[0] * next[1] - next[0] * current[1];
+  }
+  return area / 2;
+}
+function pathLength(points) {
+  let length = 0;
+  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)
+      continue;
+    length += Math.hypot(current[0] - previous[0], current[1] - previous[1]);
+  }
+  return length;
+}
+function isPosition(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number" && Number.isFinite(value[0]) && Number.isFinite(value[1]);
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cast(args) {
+  requireArgCount("cast", args, 2);
+  const value = args[0] ?? null;
+  const target = args[1] ?? null;
+  if (value === null)
+    return null;
+  if (typeof target !== "string")
+    throwType("cast", "string type name", target ?? null);
+  switch (target) {
+    case "string":
+      return String(value);
+    case "float64":
+    case "number": {
+      const number = Number(value);
+      return Number.isNaN(number) ? null : number;
+    }
+    case "boolean":
+      return Boolean(value);
+    default:
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", `Unsupported cast target ${target}`, { target });
+  }
+}
+function datePart(name, args, cb) {
+  requireArgCount(name, args, 1);
+  const date = parseDateArg(name, args[0] ?? null);
+  return date ? cb(date) : null;
+}
+function dateTrunc(args) {
+  requireArgCount("date_trunc", args, 2);
+  const part = args[0] ?? null;
+  const value = args[1] ?? null;
+  if (part === null || value === null)
+    return null;
+  if (typeof part !== "string")
+    throwType("date_trunc", "string part", part);
+  const date = parseDateArg("date_trunc", value);
+  if (!date)
+    return null;
+  if (part === "year")
+    return `${date.getUTCFullYear()}-01-01T00:00:00.000Z`;
+  if (part === "month") {
+    return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-01T00:00:00.000Z`;
+  }
+  if (part === "day") {
+    return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}T00:00:00.000Z`;
+  }
+  if (part === "hour") {
+    return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}T${pad(date.getUTCHours())}:00:00.000Z`;
+  }
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `Unsupported date_trunc part ${part}`, { part });
+}
+function round(args) {
+  if (args.length < 1 || args.length > 2) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "round() expects 1 or 2 arguments", {
+      received: args.length
+    });
+  }
+  const value = args[0] ?? null;
+  const places = args[1] ?? 0;
+  if (value === null || places === null)
+    return null;
+  if (typeof value !== "number" || typeof places !== "number") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "round() arguments must be numbers");
+  }
+  const scale = 10 ** places;
+  return Math.round(value * scale) / scale;
+}
+function leastGreatest(name, args, mode) {
+  if (args.length === 0) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() expects at least 1 argument`);
+  }
+  if (args.some((value) => value === null))
+    return null;
+  let best = args[0] ?? null;
+  for (const value of args.slice(1)) {
+    if (compare(mode === "least" ? "lt" : "gt", value, best) === true)
+      best = value;
+  }
+  return best;
+}
+function parseDateArg(name, value) {
+  if (value === null)
+    return null;
+  if (isTimestampValue(value))
+    return new Date(Number(value.epochNanoseconds / 1000000n));
+  if (typeof value !== "string" && typeof value !== "number")
+    throwType(name, "date string", value);
+  const date = new Date(value);
+  if (Number.isNaN(date.valueOf())) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() received an invalid date`, { value });
+  }
+  return date;
+}
+function throwType(name, expected, value) {
+  throw new LakeqlError("LAKEQL_TYPE_ERROR", `${name}() expects ${expected}`, {
+    expected,
+    received: typeof value
+  });
+}
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+
+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 };