lakeql 0.1.0 → 0.1.2

package/dist/{chunk-VRJ72DGA.js → chunk-D3A4VN3U.js}

@@ -4,9 +4,36 @@ import { gridDisk, latLngToCell, cellToParent, isValidCell } from 'h3-js';
 import { parquetMetadataAsync, parquetReadObjects } from 'hyparquet';
 import { parquetWriteBuffer } from 'hyparquet-writer';
 
+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, mod2) => function __require() {
+  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.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 = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __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 || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
+
 // ../core/dist/errors.js
 var ERROR_CODES = [
   "LAQL_PARSE_ERROR",
+  "LAQL_SQL_UNSUPPORTED",
   "LAQL_TYPE_ERROR",
   "LAQL_UNKNOWN_TABLE",
   "LAQL_UNKNOWN_COLUMN",
@@ -71,6 +98,14 @@ function evaluate(expr, row) {
       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) {
@@ -144,6 +179,28 @@ function compare(op, left, right) {
       return order >= 0;
   }
 }
+function arithmetic(op, left, right) {
+  if (left === null || right === null)
+    return null;
+  if (typeof left !== "number" || typeof right !== "number") {
+    throw new LaQLError("LAQL_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";
 }
@@ -865,6 +922,21 @@ function ilike(column, pattern) {
 function fn(name, ...args) {
   return { kind: "call", fn: name, args: args.map(toValue) };
 }
+function add(left, right) {
+  return { kind: "arithmetic", op: "add", left: toValue(left), right: toValue(right) };
+}
+function sub(left, right) {
+  return { kind: "arithmetic", op: "sub", left: toValue(left), right: toValue(right) };
+}
+function mul(left, right) {
+  return { kind: "arithmetic", op: "mul", left: toValue(left), right: toValue(right) };
+}
+function div(left, right) {
+  return { kind: "arithmetic", op: "div", left: toValue(left), right: toValue(right) };
+}
+function mod(left, right) {
+  return { kind: "arithmetic", op: "mod", left: toValue(left), right: toValue(right) };
+}
 
 // ../core/dist/manifest.js
 function createTaskManifest(input) {
@@ -1661,7 +1733,15 @@ async function collectRightRows(rows, maxRightRows) {
   return out;
 }
 function validateJoinOptions(options, strategy) {
-  if (!options.leftKey || !options.rightKey) {
+  const leftKeys = normalizeJoinKeys(options.leftKey, "leftKey", strategy);
+  const rightKeys = normalizeJoinKeys(options.rightKey, "rightKey", strategy);
+  if (leftKeys.length !== rightKeys.length) {
+    throw new LaQLError("LAQL_TYPE_ERROR", `${strategy} join key counts must match`, {
+      leftKey: options.leftKey,
+      rightKey: options.rightKey
+    });
+  }
+  if (leftKeys.length === 0) {
     throw new LaQLError("LAQL_TYPE_ERROR", `${strategy} join requires leftKey and rightKey`);
   }
   if (!Number.isInteger(options.maxRightRows) || options.maxRightRows < 1) {
@@ -1673,10 +1753,24 @@ function validateJoinOptions(options, strategy) {
     });
   }
 }
+function normalizeJoinKeys(key, label, strategy) {
+  const keys = Array.isArray(key) ? key : [key];
+  if (keys.some((column) => typeof column !== "string" || column.length === 0)) {
+    throw new LaQLError("LAQL_TYPE_ERROR", `${strategy} join ${label} must contain column names`, {
+      [label]: key
+    });
+  }
+  return keys;
+}
 function joinKey(row, column) {
   return stableStringify(joinValue(row, column));
 }
 function joinValue(row, column) {
+  if (Array.isArray(column))
+    return column.map((key) => scalarJoinValue(row, key));
+  return scalarJoinValue(row, column);
+}
+function scalarJoinValue(row, column) {
   if (!(column in row)) {
     throw new LaQLError("LAQL_UNKNOWN_COLUMN", `Unknown join key ${column}`, { column });
   }
@@ -1691,8 +1785,10 @@ function joinValue(row, column) {
 function mergeRows(left, right, options) {
   const out = { ...left };
   const prefix = options.rightPrefix ?? "right.";
+  const leftKeys = normalizeJoinKeys(options.leftKey, "leftKey", "Merge");
+  const rightKeys = normalizeJoinKeys(options.rightKey, "rightKey", "Merge");
   for (const [key, value] of Object.entries(right)) {
-    if (key === options.rightKey && options.leftKey === options.rightKey)
+    if (rightKeys.includes(key) && leftKeys.includes(key))
       continue;
     const outKey = key in out ? `${prefix}${key}` : key;
     out[outKey] = value;
@@ -1907,6 +2003,18 @@ function collectColumns(expr, columns) {
       for (const arg of expr.args)
         collectColumns(arg, columns);
       return;
+    case "arithmetic":
+      collectColumns(expr.left, columns);
+      collectColumns(expr.right, columns);
+      return;
+    case "case":
+      for (const branch of expr.whens) {
+        collectColumns(branch.when, columns);
+        collectColumns(branch.value, columns);
+      }
+      if (expr.else !== void 0)
+        collectColumns(expr.else, columns);
+      return;
   }
 }
 
@@ -1982,6 +2090,8 @@ function fileMayMatch(file, expr) {
     case "column":
     case "null-check":
     case "like":
+    case "arithmetic":
+    case "case":
     case "call":
       return callMayMatch(file, expr);
     case "not":
@@ -2239,9 +2349,15 @@ var QueryBuilder = class _QueryBuilder {
   select(columns) {
     return new _QueryBuilder(this.lake, { ...this.init, select: columns });
   }
+  project(projections) {
+    return new _QueryBuilder(this.lake, { ...this.init, projections });
+  }
   where(expr) {
     return new _QueryBuilder(this.lake, { ...this.init, where: expr });
   }
+  distinct(enabled = true) {
+    return new _QueryBuilder(this.lake, { ...this.init, distinct: enabled });
+  }
   orderBy(terms) {
     return new _QueryBuilder(this.lake, { ...this.init, orderBy: normalizeOrderBy(terms) });
   }
@@ -2385,9 +2501,10 @@ var QueryResult = class {
     const startedAt = config.now();
     let offsetSkipped = 0;
     let returned = 0;
+    const distinct = config.distinct === true ? /* @__PURE__ */ new Set() : void 0;
     const { planned: paths, skipped: skippedFiles } = await this.planObjects();
     stats.filesSkipped = skippedFiles;
-    const columns = projectedReadColumns(config.select, config.where);
+    const columns = projectedReadColumns(config.select, config.where, void 0, config.projections);
     for (const object of paths) {
       stats.filesPlanned += 1;
       stats.filesRead += 1;
@@ -2416,13 +2533,17 @@ var QueryResult = class {
           if (!matches(config.where, row))
             continue;
           stats.rowsMatched += 1;
+          const projected = project(row, config.select, config.projections);
+          if (distinct !== void 0 && !addDistinctRow(distinct, projected, config.budget)) {
+            continue;
+          }
           if (offsetSkipped < (config.offset ?? 0)) {
             offsetSkipped += 1;
             continue;
           }
           if (config.limit !== void 0 && returned >= config.limit)
             break;
-          out.push(project(row, config.select));
+          out.push(projected);
           returned += 1;
           stats.rowsReturned += 1;
           enforceBudget(config.budget, stats, config.now, startedAt);
@@ -2451,6 +2572,9 @@ var QueryResult = class {
     if (config.limit === void 0) {
       throw new LaQLError("LAQL_TYPE_ERROR", "topKWithState requires limit");
     }
+    if (config.distinct === true) {
+      throw new LaQLError("LAQL_TYPE_ERROR", "topKWithState does not support distinct queries");
+    }
     const orderBy = normalizeOrderBy(config.orderBy);
     const topK = (config.offset ?? 0) + config.limit;
     const matched = await topKRowsFromState(orderBy, config.offset ?? 0, config.limit, options);
@@ -2461,7 +2585,7 @@ var QueryResult = class {
     matched.sort((left, right) => compareRows(left, right, orderBy));
     const start = config.offset ?? 0;
     const end = start + config.limit;
-    const rows = matched.slice(start, end).map((row) => project(row, config.select));
+    const rows = matched.slice(start, end).map((row) => project(row, config.select, config.projections));
     for (const _row of rows) {
       this.stats.rowsReturned += 1;
       enforceBudget(config.budget, this.stats, config.now, startedAt);
@@ -2480,6 +2604,9 @@ var QueryResult = class {
     if (config.orderBy === void 0) {
       throw new LaQLError("LAQL_TYPE_ERROR", "sortWithState requires orderBy");
     }
+    if (config.distinct === true) {
+      throw new LaQLError("LAQL_TYPE_ERROR", "sortWithState does not support distinct queries");
+    }
     const orderBy = normalizeOrderBy(config.orderBy);
     const runs = await sortRunsFromState(orderBy, options);
     const startedAt = config.now();
@@ -2487,7 +2614,7 @@ var QueryResult = class {
     const matched = mergeSortRuns(runs, orderBy);
     const start = config.offset ?? 0;
     const end = config.limit === void 0 ? matched.length : start + config.limit;
-    const rows = matched.slice(start, end).map((row) => project(row, config.select));
+    const rows = matched.slice(start, end).map((row) => project(row, config.select, config.projections));
     for (const _row of rows) {
       this.stats.rowsReturned += 1;
       enforceBudget(config.budget, this.stats, config.now, startedAt);
@@ -2599,7 +2726,7 @@ var QueryResult = class {
       group.add(row);
       enforceOperatorMemoryBudget(this.config.budget, estimateAggregateOperatorMemoryBytes(groupColumns, spec, groups));
     }
-    const rows = [...groups.values()].map((group) => group.finish());
+    const rows = applyAggregateResultOptions([...groups.values()].map((group) => group.finish()), options);
     for (const _row of rows) {
       this.stats.rowsReturned += 1;
       enforceBudget(this.config.budget, this.stats, this.config.now, startedAt);
@@ -2621,16 +2748,27 @@ var QueryResult = class {
     const config = this.config;
     const { stats } = this;
     const matched = [];
-    const topK = config.limit === void 0 ? void 0 : (config.offset ?? 0) + config.limit;
+    const topK = config.distinct === true || config.limit === void 0 ? void 0 : (config.offset ?? 0) + config.limit;
     const startedAt = config.now();
     await this.collectOrderedMatches(matched, topK, startedAt);
     matched.sort((left, right) => compareRows(left, right, config.orderBy ?? []));
-    const start = config.offset ?? 0;
-    const end = config.limit === void 0 ? matched.length : start + config.limit;
     const batchSize = config.batchSize ?? 4096;
     let batch = [];
-    for (const row of matched.slice(start, end)) {
-      batch.push(project(row, config.select));
+    let offsetSkipped = 0;
+    let returned = 0;
+    const distinct = config.distinct === true ? /* @__PURE__ */ new Set() : void 0;
+    for (const row of matched) {
+      const projected = project(row, config.select, config.projections);
+      if (distinct !== void 0 && !addDistinctRow(distinct, projected, config.budget))
+        continue;
+      if (offsetSkipped < (config.offset ?? 0)) {
+        offsetSkipped += 1;
+        continue;
+      }
+      if (config.limit !== void 0 && returned >= config.limit)
+        break;
+      batch.push(projected);
+      returned += 1;
       stats.rowsReturned += 1;
       enforceBudget(config.budget, stats, config.now, startedAt);
       if (batch.length >= batchSize) {
@@ -2649,7 +2787,7 @@ var QueryResult = class {
     const { planned: paths, skipped: skippedFiles } = await this.planObjects();
     stats.filesSkipped = skippedFiles;
     const orderBy = config.orderBy ?? [];
-    const columns = projectedReadColumns(config.select, config.where, orderBy);
+    const columns = projectedReadColumns(config.select, config.where, orderBy, config.projections);
     for (const object of paths) {
       stats.filesPlanned += 1;
       stats.filesRead += 1;
@@ -2691,7 +2829,7 @@ var QueryResult = class {
     const { stats } = this;
     const { planned: paths, skipped: skippedFiles } = await this.planObjects();
     stats.filesSkipped = skippedFiles;
-    const columns = projectedReadColumns(config.select, config.where, orderBy);
+    const columns = projectedReadColumns(config.select, config.where, orderBy, config.projections);
     const runCapacity = config.budget.maxBufferedRows ?? Number.POSITIVE_INFINITY;
     const currentRun = [];
     for (const object of paths) {
@@ -2736,7 +2874,7 @@ var QueryResult = class {
   async explain() {
     const { planned, skipped } = await this.planObjects();
     const tasks = await this.tasksFromObjects(planned);
-    const projectedColumns = projectedReadColumns(this.config.select, this.config.where) ?? [];
+    const projectedColumns = projectedReadColumns(this.config.select, this.config.where, void 0, this.config.projections) ?? [];
     const json = {
       queryId: this.stats.queryId,
       filesPlanned: tasks.length,
@@ -2759,7 +2897,7 @@ var QueryResult = class {
   }
   async tasksFromObjects(objects) {
     const config = this.config;
-    const projectedColumns = projectedReadColumns(config.select, config.where, config.orderBy);
+    const projectedColumns = projectedReadColumns(config.select, config.where, config.orderBy, config.projections);
     const tasks = [];
     for (const object of objects) {
       const partitionValues = config.hive ? parseHivePartitions(object.path) : {};
@@ -2973,7 +3111,9 @@ var CountState = class {
   constructor(count = 0) {
     this.count = count;
   }
-  add(_value) {
+  add(value) {
+    if (value === null || value === void 0)
+      return;
     this.count += 1;
   }
   finish() {
@@ -3409,8 +3549,11 @@ function snapshotValue(value) {
 function aggregateValue(row, alias, aggregate) {
   if (!aggregate)
     throw new LaQLError("LAQL_VALIDATION_ERROR", `Missing aggregate ${alias}`);
-  if (aggregate.op === "count" && aggregate.column === void 0)
+  if (aggregate.op === "count" && aggregate.column === void 0 && aggregate.expr === void 0) {
     return true;
+  }
+  if (aggregate.expr !== void 0)
+    return evaluate(aggregate.expr, row);
   if (aggregate.column === void 0) {
     throw new LaQLError("LAQL_TYPE_ERROR", `${aggregate.op} requires a column`, { aggregate });
   }
@@ -3432,9 +3575,32 @@ function validateAggregateRequest(groupColumns, spec, options) {
   if (options.maxGroups !== void 0 && (!Number.isInteger(options.maxGroups) || options.maxGroups < 1)) {
     throw new LaQLError("LAQL_TYPE_ERROR", "maxGroups must be a positive integer");
   }
+  if (options.orderBy !== void 0)
+    normalizeOrderBy(options.orderBy);
+  if (options.limit !== void 0 && (!Number.isInteger(options.limit) || options.limit < 0)) {
+    throw new LaQLError("LAQL_TYPE_ERROR", "aggregate limit must be a non-negative integer");
+  }
+  if (options.offset !== void 0 && (!Number.isInteger(options.offset) || options.offset < 0)) {
+    throw new LaQLError("LAQL_TYPE_ERROR", "aggregate offset must be a non-negative integer");
+  }
   for (const aggregate of Object.values(spec))
     validateAggregateExpr(aggregate);
 }
+function applyAggregateResultOptions(rows, options) {
+  let out = rows;
+  if (options.having !== void 0)
+    out = out.filter((row) => matches(options.having, row));
+  if (options.orderBy !== void 0) {
+    const orderBy = normalizeOrderBy(options.orderBy);
+    out = [...out].sort((left, right) => compareRows(left, right, orderBy));
+  }
+  const offset = options.offset ?? 0;
+  if (options.limit !== void 0)
+    return out.slice(offset, offset + options.limit);
+  if (offset > 0)
+    return out.slice(offset);
+  return out;
+}
 function validateAggregateExpr(aggregate) {
   const ops = [
     "count",
@@ -3451,8 +3617,15 @@ function validateAggregateExpr(aggregate) {
   if (!ops.includes(aggregate.op)) {
     throw new LaQLError("LAQL_TYPE_ERROR", `Unsupported aggregate ${aggregate.op}`, { aggregate });
   }
-  if (aggregate.op !== "count" && aggregate.column === void 0) {
-    throw new LaQLError("LAQL_TYPE_ERROR", `${aggregate.op} requires a column`, { aggregate });
+  if (aggregate.column !== void 0 && aggregate.expr !== void 0) {
+    throw new LaQLError("LAQL_TYPE_ERROR", "aggregate cannot specify both column and expr", {
+      aggregate
+    });
+  }
+  if (aggregate.op !== "count" && aggregate.column === void 0 && aggregate.expr === void 0) {
+    throw new LaQLError("LAQL_TYPE_ERROR", `${aggregate.op} requires a column or expression`, {
+      aggregate
+    });
   }
 }
 function throwAggregateType(op) {
@@ -3474,6 +3647,11 @@ function parseJsonQuery(input) {
   }
   if (input.where !== void 0)
     init.where = parseJsonExpr(input.where);
+  if (input.distinct !== void 0) {
+    if (typeof input.distinct !== "boolean")
+      throwParse("JSON query distinct must be a boolean");
+    init.distinct = input.distinct;
+  }
   if (input.orderBy !== void 0) {
     if (!Array.isArray(input.orderBy))
       throwParse("JSON query orderBy must be an array");
@@ -3615,6 +3793,9 @@ function validateQueryInit(init) {
   }
   if (init.orderBy !== void 0)
     normalizeOrderBy(init.orderBy);
+  if (init.distinct !== void 0 && typeof init.distinct !== "boolean") {
+    throw new LaQLError("LAQL_TYPE_ERROR", "distinct must be a boolean");
+  }
 }
 function applyQueryPolicy(init, policy) {
   const allowedColumns = policy.allowedColumns === void 0 ? void 0 : normalizeAllowedColumns(policy.allowedColumns);
@@ -3641,8 +3822,12 @@ function cloneBookmarkQuery(init) {
   const query = { source: init.source };
   if (init.select !== void 0)
     query.select = [...init.select];
+  if (init.projections !== void 0)
+    query.projections = init.projections;
   if (init.where !== void 0)
     query.where = init.where;
+  if (init.distinct !== void 0)
+    query.distinct = init.distinct;
   if (init.orderBy !== void 0) {
     query.orderBy = init.orderBy.map((term) => {
       const queryTerm = { column: term.column };
@@ -3700,6 +3885,8 @@ function validatePolicyColumns(init, effectiveWhere, allowedColumns) {
     requested.add(column);
   for (const term of init.orderBy ?? [])
     requested.add(term.column);
+  for (const expr of Object.values(init.projections ?? {}))
+    collectExprColumns(expr, requested);
   collectExprColumns(effectiveWhere, requested);
   for (const column of requested) {
     if (!allowed.has(column)) {
@@ -3760,12 +3947,14 @@ function globRegex(pattern) {
   }
   return new RegExp(`${source}$`, "u");
 }
-function projectedReadColumns(select, where, orderBy = void 0) {
+function projectedReadColumns(select, where, orderBy = void 0, projections = void 0) {
   const columns = /* @__PURE__ */ new Set();
   for (const column of select ?? [])
     columns.add(column);
   for (const term of orderBy ?? [])
     columns.add(term.column);
+  for (const expr of Object.values(projections ?? {}))
+    collectExprColumns(expr, columns);
   collectExprColumns(where, columns);
   return columns.size === 0 ? void 0 : [...columns].sort();
 }
@@ -3776,6 +3965,8 @@ function aggregateReadColumns(groupColumns, spec, where) {
   for (const aggregate of Object.values(spec)) {
     if (aggregate.column !== void 0)
       columns.add(aggregate.column);
+    if (aggregate.expr !== void 0)
+      collectExprColumns(aggregate.expr, columns);
   }
   collectExprColumns(where, columns);
   return columns.size === 0 ? void 0 : [...columns].sort();
@@ -3820,20 +4011,42 @@ function collectExprColumns(expr, columns) {
       for (const arg of expr.args)
         collectExprColumns(arg, columns);
       return;
+    case "arithmetic":
+      collectExprColumns(expr.left, columns);
+      collectExprColumns(expr.right, columns);
+      return;
+    case "case":
+      for (const branch of expr.whens) {
+        collectExprColumns(branch.when, columns);
+        collectExprColumns(branch.value, columns);
+      }
+      collectExprColumns(expr.else, columns);
+      return;
   }
 }
-function project(row, select) {
-  if (!select)
+function project(row, select, projections) {
+  if (!select && !projections)
     return row;
   const out = {};
-  for (const column of select) {
+  for (const column of select ?? []) {
     if (!(column in row)) {
       throw new LaQLError("LAQL_UNKNOWN_COLUMN", `Unknown column ${column}`, { column });
     }
     out[column] = row[column];
   }
+  for (const [alias, expr] of Object.entries(projections ?? {}))
+    out[alias] = evaluate(expr, row);
   return out;
 }
+function addDistinctRow(seen, row, budget) {
+  const key = stableStringify(jsonSafeValue(row));
+  if (seen.has(key))
+    return false;
+  seen.add(key);
+  enforceBufferedRowsBudget(budget, seen.size);
+  enforceOperatorMemoryBudget(budget, estimateOperatorMemoryBytes([...seen]));
+  return true;
+}
 function normalizeOrderBy(terms) {
   if (!Array.isArray(terms) || terms.length === 0) {
     throw new LaQLError("LAQL_TYPE_ERROR", "orderBy must contain at least one term");
@@ -3983,6 +4196,8 @@ function partitionEval(expr, partitions) {
     case "null-check":
     case "like":
     case "call":
+    case "arithmetic":
+    case "case":
       return expressionIsPartitionOnly(expr, partitions) ? matches(expr, partitions) : "unknown";
     case "not": {
       const value = partitionEval(expr.operand, partitions);
@@ -4323,1296 +4538,6 @@ var ReadSemaphore = class {
     this.queue.shift()?.();
   }
 };
-
-// ../iceberg/dist/index.js
-var PACKAGE = "@laql/iceberg";
-var IcebergTable = class {
-  store;
-  metadataPath;
-  metadata;
-  constructor(store, metadataPath, metadata) {
-    this.store = store;
-    this.metadataPath = metadataPath;
-    this.metadata = metadata;
-  }
-  snapshot(options = {}) {
-    if (options.snapshotId !== void 0)
-      return this.snapshotById(options.snapshotId);
-    if (options.ref !== void 0) {
-      const ref = this.metadata.refs?.[options.ref];
-      if (!ref) {
-        throw new LaQLError("LAQL_CATALOG_ERROR", `Unknown Iceberg ref ${options.ref}`, {
-          ref: options.ref
-        });
-      }
-      return this.snapshotById(ref["snapshot-id"]);
-    }
-    if (options.asOfTimestampMs !== void 0) {
-      const snapshot = [...this.metadata.snapshots].filter((candidate) => candidate["timestamp-ms"] <= options.asOfTimestampMs).sort((a, b) => b["timestamp-ms"] - a["timestamp-ms"])[0];
-      if (!snapshot) {
-        throw new LaQLError("LAQL_CATALOG_ERROR", "No Iceberg snapshot at requested timestamp", {
-          asOfTimestampMs: options.asOfTimestampMs
-        });
-      }
-      return snapshot;
-    }
-    return this.snapshotById(this.metadata["current-snapshot-id"]);
-  }
-  schema(schemaId) {
-    const schema = this.metadata.schemas.find((candidate) => candidate["schema-id"] === schemaId);
-    if (!schema) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", `Unknown Iceberg schema ${schemaId}`, { schemaId });
-    }
-    return schema.fields;
-  }
-  projectRow(row, options = {}) {
-    const snapshot = this.snapshot(options);
-    const fields = this.schema(snapshot["schema-id"]);
-    projectedIds(fields, options.select);
-    const selected = options.select === void 0 ? void 0 : new Set(options.select);
-    const out = {};
-    for (const field of fields) {
-      if (selected !== void 0 && !selected.has(field.name))
-        continue;
-      const sourceName = field.name in row ? field.name : field.sourceId !== void 0 ? this.fieldNameById(field.sourceId) : field.name;
-      out[field.name] = sourceName !== void 0 && sourceName in row ? row[sourceName] : null;
-    }
-    return out;
-  }
-  planFiles(options = {}) {
-    const snapshot = this.snapshot(options);
-    const fields = this.schema(snapshot["schema-id"]);
-    const projectedFieldIds = projectedIds(fields, options.select);
-    const readMode = options.readMode ?? "strict";
-    const files = [];
-    let manifestsSkipped = 0;
-    let filesSkipped = 0;
-    let deleteFilesPlanned = 0;
-    let deleteFilesIgnored = 0;
-    const manifests = snapshotManifests(snapshot);
-    for (const manifest of manifests) {
-      const manifestMayMatch = manifest.files.some((file) => partitionMayMatch2(options.where, file.partition ?? {}));
-      if (!manifestMayMatch) {
-        manifestsSkipped += 1;
-        filesSkipped += manifest.files.length;
-        continue;
-      }
-      for (const file of manifest.files) {
-        if (!partitionMayMatch2(options.where, file.partition ?? {})) {
-          filesSkipped += 1;
-          continue;
-        }
-        const supportedDeleteFiles = supportedIcebergDeleteFiles(file.deleteFiles);
-        const unsupportedDeleteFiles = unsupportedIcebergDeleteFiles(file.deleteFiles);
-        if (unsupportedDeleteFiles.length > 0 && readMode === "strict") {
-          throw new LaQLError("LAQL_UNSUPPORTED_DELETE_FILES", "Snapshot contains delete files unsupported by strict Iceberg planning", {
-            path: file.path,
-            deleteFiles: file.deleteFiles,
-            supportedDeleteFiles,
-            unsupportedDeleteFiles
-          });
-        }
-        const planned = {
-          path: file.path,
-          sequenceNumber: file.sequenceNumber,
-          partition: file.partition ?? {},
-          recordCount: file.recordCount,
-          projectedFieldIds,
-          snapshotId: snapshot["snapshot-id"]
-        };
-        if (file.fileSizeInBytes !== void 0)
-          planned.fileSizeInBytes = file.fileSizeInBytes;
-        if ((readMode === "strict" || readMode === "ignore-unsupported-deletes") && supportedDeleteFiles.length > 0) {
-          planned.deleteFiles = supportedDeleteFiles;
-          deleteFilesPlanned += supportedDeleteFiles.length;
-        }
-        if (readMode === "ignore-unsupported-deletes") {
-          deleteFilesIgnored += unsupportedDeleteFiles.length;
-        } else if (readMode === "ignore-deletes") {
-          deleteFilesIgnored += (file.deleteFiles ?? []).length;
-        }
-        files.push(planned);
-      }
-    }
-    files.sort((a, b) => a.sequenceNumber - b.sequenceNumber || a.path.localeCompare(b.path));
-    return {
-      snapshotId: snapshot["snapshot-id"],
-      schemaId: snapshot["schema-id"],
-      manifestsRead: manifests.length - manifestsSkipped,
-      manifestsSkipped,
-      filesPlanned: files.length,
-      filesSkipped,
-      deleteFilesPlanned,
-      deleteFilesIgnored,
-      files
-    };
-  }
-  async appendFiles(options) {
-    if (options.files.length === 0) {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg append requires at least one file");
-    }
-    if (this.metadata["format-version"] !== 2) {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg append requires format-version 2 metadata", { formatVersion: this.metadata["format-version"] });
-    }
-    const currentSnapshot = this.snapshot();
-    const nextSnapshotId = options.nextSnapshotId ?? randomSnapshotId(this.metadata.snapshots.map(snapshotIdOf));
-    validateNewSnapshotId(nextSnapshotId, this.metadata.snapshots);
-    const nextSequenceNumber = maxSequenceNumber(this.metadata) + 1;
-    const manifestPath = appendManifestPath(this.metadataPath, options.jobId, nextSnapshotId);
-    const manifest = {
-      path: manifestPath,
-      files: options.files.map((file, index) => ({
-        path: file.path,
-        sequenceNumber: nextSequenceNumber + index,
-        partition: sortStringRecord(file.partition ?? {}),
-        recordCount: file.recordCount,
-        fileSizeInBytes: file.fileSizeInBytes
-      }))
-    };
-    const nextSnapshot = {
-      "snapshot-id": nextSnapshotId,
-      "timestamp-ms": options.nowMs ?? Date.now(),
-      "schema-id": currentSnapshot["schema-id"],
-      manifests: [...snapshotManifests(currentSnapshot).map(cloneManifest), manifest]
-    };
-    const metadata = cloneMetadata(this.metadata);
-    metadata["current-snapshot-id"] = nextSnapshotId;
-    metadata.snapshots.push(nextSnapshot);
-    metadata.refs = {
-      ...metadata.refs ?? {},
-      main: { type: "branch", "snapshot-id": nextSnapshotId }
-    };
-    const nextMetadataPath = nextMetadataPathFor(this.metadataPath, nextSnapshotId);
-    const catalog = options.catalog ?? new ObjectStoreIcebergCommitCatalog();
-    const commit = await catalog.commitAppend({
-      store: this.store,
-      currentMetadataPath: this.metadataPath,
-      nextMetadataPath,
-      expectedSnapshotId: currentSnapshot["snapshot-id"],
-      nextSnapshotId,
-      manifestPath,
-      manifest,
-      metadata
-    });
-    const committed = typeof commit === "boolean" ? commit : commit.committed;
-    if (!committed) {
-      throw new LaQLError("LAQL_ICEBERG_COMMIT_CONFLICT", "Iceberg append commit conflict", {
-        metadataPath: this.metadataPath,
-        expectedSnapshotId: currentSnapshot["snapshot-id"],
-        nextSnapshotId
-      });
-    }
-    const committedMetadataPath = typeof commit === "boolean" ? nextMetadataPath : commit.metadataPath ?? nextMetadataPath;
-    return {
-      snapshotId: nextSnapshotId,
-      previousSnapshotId: currentSnapshot["snapshot-id"],
-      metadataPath: committedMetadataPath,
-      manifestPath,
-      files: manifest.files.map((file) => ({
-        path: file.path,
-        sequenceNumber: file.sequenceNumber,
-        partition: file.partition ?? {},
-        recordCount: file.recordCount,
-        projectedFieldIds: [],
-        snapshotId: nextSnapshotId
-      }))
-    };
-  }
-  async appendOutputManifest(options) {
-    const files = options.manifest.entries.map((entry) => {
-      if (entry.iceberg === void 0) {
-        throw new LaQLError("LAQL_VALIDATION_ERROR", "Output manifest entry is missing Iceberg file metadata", {
-          taskId: entry.taskId,
-          outputPath: entry.outputPath
-        });
-      }
-      return {
-        path: entry.outputPath,
-        partition: entry.iceberg.partitionValues,
-        recordCount: entry.iceberg.recordCount,
-        fileSizeInBytes: entry.iceberg.fileSizeInBytes
-      };
-    });
-    return await this.appendFiles({
-      files,
-      jobId: options.manifest.jobId,
-      ...options.nowMs !== void 0 ? { nowMs: options.nowMs } : {},
-      ...options.nextSnapshotId !== void 0 ? { nextSnapshotId: options.nextSnapshotId } : {},
-      ...options.catalog !== void 0 ? { catalog: options.catalog } : {}
-    });
-  }
-  snapshotById(snapshotId) {
-    const snapshot = this.metadata.snapshots.find((candidate) => candidate["snapshot-id"] === snapshotId);
-    if (!snapshot) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", `Unknown Iceberg snapshot ${snapshotId}`, {
-        snapshotId
-      });
-    }
-    return snapshot;
-  }
-  fieldNameById(fieldId) {
-    for (const schema of this.metadata.schemas) {
-      const field = schema.fields.find((candidate) => candidate.id === fieldId);
-      if (field)
-        return field.name;
-    }
-    return void 0;
-  }
-};
-function planFiles(table, options = {}) {
-  return table.planFiles(options);
-}
-var ObjectStoreIcebergCommitCatalog = class {
-  async commitAppend(input) {
-    if (!supportsConditionalPut(input.store)) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Object-store Iceberg append requires conditional put support", { metadataPath: input.currentMetadataPath });
-    }
-    const currentBytes = await input.store.get(input.currentMetadataPath);
-    if (!currentBytes) {
-      throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `No object at ${input.currentMetadataPath}`, {
-        path: input.currentMetadataPath
-      });
-    }
-    const current = validateMetadata(JSON.parse(new TextDecoder().decode(currentBytes)));
-    if (current["current-snapshot-id"] !== input.expectedSnapshotId) {
-      return { committed: false };
-    }
-    const versionHintPath = metadataVersionHintPath(input.nextMetadataPath);
-    const versionHintHead = await input.store.head(versionHintPath);
-    await input.store.put(input.manifestPath, new TextEncoder().encode(`${stableStringify(input.manifest)}
-`), { contentType: "application/json" });
-    await input.store.put(input.nextMetadataPath, new TextEncoder().encode(`${JSON.stringify(input.metadata, null, 2)}
-`), { contentType: "application/json" });
-    const updated = await input.store.conditionalPut(versionHintPath, new TextEncoder().encode(`${input.nextSnapshotId}
-`), { contentType: "text/plain", expectedEtag: versionHintHead?.etag ?? null });
-    if (!updated)
-      return { committed: false };
-    return { committed: true, metadataPath: input.nextMetadataPath };
-  }
-};
-var IcebergRestCatalog = class {
-  url;
-  namespace;
-  table;
-  prefix;
-  token;
-  fetchFn;
-  constructor(options) {
-    this.url = options.url;
-    this.namespace = namespaceParts(options.namespace);
-    this.table = requiredNonEmptyString(options.table, "table");
-    this.prefix = catalogPrefixParts(options.prefix);
-    this.token = options.token;
-    this.fetchFn = options.fetch ?? fetch;
-  }
-  async loadTable(store) {
-    const response = await this.requestJson(this.tableUrl(), { method: "GET" });
-    if (!isRecord4(response) || typeof response["metadata-location"] !== "string") {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg REST load table response", {
-        url: this.tableUrl()
-      });
-    }
-    return new IcebergTable(store, response["metadata-location"], await hydrateMetadataManifests(store, validateMetadata(response.metadata)));
-  }
-  async listTables() {
-    return validateListTablesResponse(await this.requestJson(this.namespaceTablesUrl(), {
-      method: "GET"
-    }));
-  }
-  async commitAppend(input) {
-    await input.store.put(input.manifestPath, new TextEncoder().encode(`${stableStringify(input.manifest)}
-`), { contentType: "application/json" });
-    await input.store.put(input.nextMetadataPath, new TextEncoder().encode(`${JSON.stringify(input.metadata, null, 2)}
-`), { contentType: "application/json" });
-    const response = await this.fetchFn(this.tableUrl(), {
-      method: "POST",
-      headers: this.headers(true),
-      body: JSON.stringify({
-        identifier: { namespace: this.namespace, name: this.table },
-        requirements: [
-          {
-            type: "assert-ref-snapshot-id",
-            ref: "main",
-            "snapshot-id": input.expectedSnapshotId
-          }
-        ],
-        updates: [
-          {
-            action: "add-snapshot",
-            snapshot: restAppendSnapshot(input)
-          },
-          {
-            action: "set-snapshot-ref",
-            "ref-name": "main",
-            type: "branch",
-            "snapshot-id": input.nextSnapshotId
-          }
-        ]
-      })
-    });
-    if (response.status === 409)
-      return { committed: false };
-    if (!response.ok) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg REST table commit failed", {
-        url: this.tableUrl(),
-        status: response.status,
-        statusText: response.statusText
-      });
-    }
-    const metadataPath = await commitResponseMetadataPath(response);
-    return {
-      committed: true,
-      ...metadataPath !== void 0 ? { metadataPath } : {}
-    };
-  }
-  async requestJson(url, init) {
-    const response = await this.fetchFn(url, {
-      ...init,
-      headers: this.headers(init.body !== void 0)
-    });
-    if (!response.ok) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg REST catalog request failed", {
-        url,
-        status: response.status,
-        statusText: response.statusText
-      });
-    }
-    try {
-      return await response.json();
-    } catch (cause) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg REST catalog response is not JSON", {
-        url,
-        cause
-      });
-    }
-  }
-  headers(hasBody) {
-    const headers = new Headers({ accept: "application/json" });
-    if (hasBody)
-      headers.set("content-type", "application/json");
-    if (this.token !== void 0)
-      headers.set("authorization", `Bearer ${this.token}`);
-    return headers;
-  }
-  tableUrl() {
-    return restCatalogUrl(this.url, [...this.namespaceTableSegments(), this.table]);
-  }
-  namespaceTablesUrl() {
-    return restCatalogUrl(this.url, this.namespaceTableSegments());
-  }
-  namespaceTableSegments() {
-    return ["v1", ...this.prefix, "namespaces", this.namespace.join(""), "tables"];
-  }
-};
-function icebergRestCatalog(options) {
-  return new IcebergRestCatalog(options);
-}
-var IcebergUnsupportedCatalog = class {
-  catalog;
-  namespace;
-  table;
-  constructor(catalog, namespace, table) {
-    this.catalog = requiredNonEmptyString(catalog, "catalog");
-    this.namespace = namespaceParts(namespace);
-    this.table = requiredNonEmptyString(table, "table");
-  }
-  async loadTable(_store) {
-    throw this.unsupported("loadTable");
-  }
-  async listTables() {
-    throw this.unsupported("listTables");
-  }
-  async commitAppend(_input) {
-    throw this.unsupported("commitAppend");
-  }
-  unsupported(operation) {
-    return new LaQLError("LAQL_CATALOG_ERROR", `${this.catalog} Iceberg catalog is not implemented`, {
-      catalog: this.catalog,
-      namespace: this.namespace,
-      table: this.table,
-      operation
-    });
-  }
-};
-function icebergGlueCatalog(options) {
-  requiredNonEmptyString(options.region, "region");
-  return new IcebergUnsupportedCatalog("Glue", options.namespace, options.table);
-}
-function icebergNessieCatalog(options) {
-  requiredNonEmptyString(options.url, "url");
-  if (options.ref !== void 0)
-    requiredNonEmptyString(options.ref, "ref");
-  return new IcebergUnsupportedCatalog("Nessie", options.namespace, options.table);
-}
-async function loadIcebergTable(options) {
-  const readControls = loadReadControls(options);
-  const store = withObjectStoreReadControls(options.store, readControls);
-  const bytes = await store.get(options.metadataPath);
-  if (!bytes) {
-    throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `No object at ${options.metadataPath}`, {
-      path: options.metadataPath
-    });
-  }
-  throwIfAborted(readControls.signal);
-  const text = new TextDecoder().decode(bytes);
-  try {
-    return new IcebergTable(store, options.metadataPath, await hydrateMetadataManifests(store, validateMetadata(JSON.parse(text)), readControls));
-  } catch (cause) {
-    if (cause instanceof LaQLError)
-      throw cause;
-    throw new LaQLError("LAQL_CATALOG_ERROR", `Invalid Iceberg metadata at ${options.metadataPath}`, {
-      path: options.metadataPath,
-      cause
-    });
-  }
-}
-async function loadIcebergTableFromObjectStore(options) {
-  const readControls = loadReadControls(options);
-  const store = withObjectStoreReadControls(options.store, readControls);
-  const tableLocation = trimTrailingSlash(options.tableLocation);
-  const metadataPrefix = `${tableLocation}/metadata/`;
-  const versionHintPath = `${metadataPrefix}version-hint.text`;
-  const hintedVersion = await readVersionHint(store, versionHintPath, readControls);
-  const metadataPath = hintedVersion === void 0 ? await latestMetadataPathFromList(store, metadataPrefix, readControls) : `${metadataPrefix}v${hintedVersion}.metadata.json`;
-  return await loadIcebergTable({ store, metadataPath, ...readControls });
-}
-async function loadIcebergTableFromRest(options) {
-  return await icebergRestCatalog(options).loadTable(withObjectStoreReadControls(options.store, loadReadControls(options)));
-}
-function loadReadControls(options) {
-  const controls = {};
-  if (options.maxConcurrentReads !== void 0)
-    controls.maxConcurrentReads = options.maxConcurrentReads;
-  const signal = readControlSignal(options);
-  if (signal !== void 0)
-    controls.signal = signal;
-  return controls;
-}
-function applyIcebergDeletes(options) {
-  const rowOffset = options.rowOffset ?? 0;
-  const positionDeletes = /* @__PURE__ */ new Set();
-  for (const deletion of options.positionDeletes ?? []) {
-    if (deletion.path !== options.dataFilePath)
-      continue;
-    positionDeletes.add(validateDeletePosition(deletion.position, deletion.path));
-  }
-  for (const deletionVector of options.deletionVectors ?? []) {
-    if (deletionVector.path !== options.dataFilePath)
-      continue;
-    for (const position of deletionVector.positions) {
-      positionDeletes.add(validateDeletePosition(position, deletionVector.path));
-    }
-  }
-  const equalityDeleteKeys = /* @__PURE__ */ new Map();
-  for (const deletion of options.equalityDeletes ?? []) {
-    if (deletion.columns.length === 0) {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg equality delete requires columns");
-    }
-    const columnsKey = stableStringify(deletion.columns);
-    let keys = equalityDeleteKeys.get(columnsKey);
-    if (!keys) {
-      keys = /* @__PURE__ */ new Set();
-      equalityDeleteKeys.set(columnsKey, keys);
-    }
-    keys.add(equalityKey(deletion.row, deletion.columns));
-  }
-  return options.rows.filter((row, index) => {
-    if (positionDeletes.has(rowOffset + index))
-      return false;
-    for (const [columnsKey, keys] of equalityDeleteKeys) {
-      const columns = JSON.parse(columnsKey);
-      if (keys.has(equalityKey(row, columns)))
-        return false;
-    }
-    return true;
-  });
-}
-async function* scanPlannedIcebergRows(options) {
-  const files = Array.isArray(options.plan) ? options.plan : options.plan.files;
-  const signal = readControlSignal(options);
-  for (const file of files) {
-    throwIfAborted(signal);
-    const deletes = await decodedDeletesForFile(file, options, signal);
-    throwIfAborted(signal);
-    const data = await options.readDataFile(file);
-    throwIfAborted(signal);
-    let rowOffset = 0;
-    for await (const batch of rowBatches(data)) {
-      throwIfAborted(signal);
-      const rows = Array.isArray(batch) ? batch : batch.rows;
-      const absoluteRowOffset = Array.isArray(batch) ? rowOffset : batch.rowOffset;
-      const visibleRows = hasDeletes(deletes) ? applyIcebergDeletes({
-        dataFilePath: file.path,
-        rows,
-        rowOffset: absoluteRowOffset,
-        ...deletes
-      }) : rows;
-      rowOffset = absoluteRowOffset + rows.length;
-      if (visibleRows.length > 0)
-        yield visibleRows;
-      throwIfAborted(signal);
-    }
-  }
-}
-async function decodedDeletesForFile(file, options, signal) {
-  const out = {};
-  for (const deleteFile of file.deleteFiles ?? []) {
-    throwIfAborted(signal);
-    const decoded = await options.readDeleteFile(deleteFile, file);
-    throwIfAborted(signal);
-    pushDeletes(out, decoded);
-  }
-  return out;
-}
-function pushDeletes(target, source) {
-  if (source.positionDeletes !== void 0) {
-    target.positionDeletes = [...target.positionDeletes ?? [], ...source.positionDeletes];
-  }
-  if (source.equalityDeletes !== void 0) {
-    target.equalityDeletes = [...target.equalityDeletes ?? [], ...source.equalityDeletes];
-  }
-  if (source.deletionVectors !== void 0) {
-    target.deletionVectors = [...target.deletionVectors ?? [], ...source.deletionVectors];
-  }
-}
-function hasDeletes(deletes) {
-  return (deletes.positionDeletes?.length ?? 0) > 0 || (deletes.equalityDeletes?.length ?? 0) > 0 || (deletes.deletionVectors?.length ?? 0) > 0;
-}
-async function* rowBatches(rows) {
-  if (isAsyncIterable(rows)) {
-    yield* rows;
-  } else {
-    yield rows;
-  }
-}
-function isAsyncIterable(value) {
-  return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
-}
-function validateDeletePosition(position, path) {
-  if (!Number.isInteger(position) || position < 0) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg delete position must be non-negative", {
-      path,
-      position
-    });
-  }
-  return position;
-}
-function nextMetadataPathFor(metadataPath, snapshotId) {
-  const slash = metadataPath.lastIndexOf("/");
-  const prefix = slash === -1 ? "" : `${metadataPath.slice(0, slash + 1)}`;
-  return `${prefix}v${snapshotId}.metadata.json`;
-}
-function randomSnapshotId(existingIds) {
-  const existing = new Set(existingIds);
-  for (let attempt = 0; attempt < 100; attempt += 1) {
-    const id = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER) + 1;
-    if (!existing.has(id))
-      return id;
-  }
-  throw new LaQLError("LAQL_CATALOG_ERROR", "Unable to allocate unique Iceberg snapshot id");
-}
-function validateNewSnapshotId(snapshotId, snapshots) {
-  if (!Number.isSafeInteger(snapshotId) || snapshotId <= 0) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg snapshot id must be a positive safe integer", { snapshotId });
-  }
-  if (snapshots.some((snapshot) => snapshotIdOf(snapshot) === snapshotId)) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg snapshot id already exists", {
-      snapshotId
-    });
-  }
-}
-function snapshotIdOf(snapshot) {
-  return snapshot["snapshot-id"];
-}
-function metadataVersionHintPath(metadataPath) {
-  const slash = metadataPath.lastIndexOf("/");
-  const prefix = slash === -1 ? "" : `${metadataPath.slice(0, slash + 1)}`;
-  return `${prefix}version-hint.text`;
-}
-function supportsConditionalPut(store) {
-  return typeof store.conditionalPut === "function";
-}
-async function hydrateMetadataManifests(store, metadata, controls = {}) {
-  const hydrated = cloneMetadata(metadata);
-  const tablePrefix = tableLocationObjectPrefix(hydrated.location);
-  for (const snapshot of hydrated.snapshots) {
-    throwIfAborted(controls.signal);
-    const manifestReferences = snapshot.manifests ?? (snapshot["manifest-list"] !== void 0 ? await readManifestList(store, validateManifestSourcedPath(snapshot["manifest-list"], tablePrefix)) : []);
-    const manifests = await Promise.all(manifestReferences.map(async (manifest) => {
-      const manifestPath = validateManifestSourcedPath(manifest.path, tablePrefix);
-      if (Array.isArray(manifest.files))
-        return validateManifestPaths(manifest, manifestPath, tablePrefix);
-      return await readManifest(store, manifestPath, tablePrefix);
-    }));
-    throwIfAborted(controls.signal);
-    snapshot.manifests = mergeDeleteManifests(manifests);
-  }
-  return hydrated;
-}
-function mergeDeleteManifests(manifests) {
-  const deleteFiles = manifests.flatMap((manifest) => manifest.deleteFiles ?? []);
-  const dataManifests = manifests.filter((manifest) => manifest.files.length > 0);
-  if (deleteFiles.length === 0)
-    return dataManifests;
-  return dataManifests.map((manifest) => ({
-    ...manifest,
-    files: manifest.files.map((file) => {
-      const applicable = deleteFiles.filter((deleteFile) => deleteFileMayApply(deleteFile, file));
-      if (applicable.length === 0)
-        return file;
-      return {
-        ...file,
-        deleteFiles: [...file.deleteFiles ?? [], ...applicable.map(publicDeleteFile)]
-      };
-    })
-  }));
-}
-function deleteFileMayApply(deleteFile, file) {
-  if (deleteFile.partition === void 0 || Object.keys(deleteFile.partition).length === 0) {
-    return true;
-  }
-  const filePartition = file.partition ?? {};
-  return Object.entries(deleteFile.partition).every(([key, value]) => filePartition[key] === value);
-}
-function publicDeleteFile(deleteFile) {
-  return { content: deleteFile.content, path: deleteFile.path };
-}
-async function readManifestList(store, path) {
-  const bytes = await store.get(path);
-  if (!bytes) {
-    throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `No Iceberg manifest list at ${path}`, { path });
-  }
-  try {
-    return avroObjectContainer(bytes) ? validateAvroManifestList(await decodeAvroObjectContainer(bytes), path) : validateManifestList(JSON.parse(new TextDecoder().decode(bytes)), path);
-  } catch (cause) {
-    if (cause instanceof LaQLError)
-      throw cause;
-    throw new LaQLError("LAQL_CATALOG_ERROR", `Invalid Iceberg manifest list at ${path}`, {
-      path,
-      cause
-    });
-  }
-}
-async function readManifest(store, path, tablePrefix = "") {
-  const bytes = await store.get(path);
-  if (!bytes) {
-    throw new LaQLError("LAQL_OBJECT_NOT_FOUND", `No Iceberg manifest at ${path}`, { path });
-  }
-  try {
-    const manifest = avroObjectContainer(bytes) ? validateAvroManifest(await decodeAvroObjectContainer(bytes), path) : validateManifest(JSON.parse(new TextDecoder().decode(bytes)), path);
-    return validateManifestPaths(manifest, path, tablePrefix);
-  } catch (cause) {
-    if (cause instanceof LaQLError)
-      throw cause;
-    throw new LaQLError("LAQL_CATALOG_ERROR", `Invalid Iceberg manifest at ${path}`, {
-      path,
-      cause
-    });
-  }
-}
-function validateAvroManifestList(records, path) {
-  return records.map((record) => {
-    if (!isRecord4(record) || typeof record.manifest_path !== "string") {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro manifest list entry is invalid", {
-        path
-      });
-    }
-    validateManifestContent(record.content, path);
-    return { path: record.manifest_path };
-  });
-}
-function validateAvroManifest(records, path) {
-  const files = [];
-  const deleteFiles = [];
-  for (const record of records) {
-    if (!isRecord4(record)) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro manifest entry is invalid", {
-        path
-      });
-    }
-    if (typeof record.status === "number" && record.status === 2)
-      continue;
-    const dataFile = record.data_file;
-    if (!isRecord4(dataFile)) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro manifest entry is missing data_file", {
-        path
-      });
-    }
-    const content = typeof dataFile.content === "number" ? dataFile.content : 0;
-    const recordCount = safeAvroNumber(dataFile.record_count);
-    if (typeof dataFile.file_path !== "string" || recordCount === void 0) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro data file has invalid fields", {
-        path
-      });
-    }
-    if (content !== 0) {
-      deleteFiles.push({
-        content: avroDeleteContent(content, dataFile),
-        path: dataFile.file_path,
-        partition: avroPartitionValues(dataFile.partition)
-      });
-      continue;
-    }
-    const sequenceNumber = safeAvroNumber(record.sequence_number) ?? safeAvroNumber(record.file_sequence_number) ?? 0;
-    const file = {
-      path: dataFile.file_path,
-      sequenceNumber,
-      partition: avroPartitionValues(dataFile.partition),
-      recordCount
-    };
-    const fileSizeInBytes = safeAvroNumber(dataFile.file_size_in_bytes);
-    if (fileSizeInBytes !== void 0) {
-      file.fileSizeInBytes = fileSizeInBytes;
-    }
-    files.push(file);
-  }
-  const manifest = { path, files };
-  if (deleteFiles.length > 0)
-    manifest.deleteFiles = deleteFiles;
-  return validateManifestPaths(manifest, path);
-}
-function avroDeleteContent(content, dataFile) {
-  if (content === 1 && (String(dataFile.file_format).toLowerCase() === "puffin" || dataFile.content_offset !== void 0 || dataFile.content_size_in_bytes !== void 0)) {
-    return "deletion-vector";
-  }
-  if (content === 1)
-    return "position-delete";
-  if (content === 2)
-    return "equality-delete";
-  return `unsupported-delete-${content}`;
-}
-function avroPartitionValues(value) {
-  if (!isRecord4(value))
-    return {};
-  const out = {};
-  for (const [key, inner] of Object.entries(value)) {
-    if (inner === null || inner === void 0)
-      continue;
-    out[key] = String(jsonSafeValue(inner));
-  }
-  return sortStringRecord(out);
-}
-function safeAvroNumber(value) {
-  if (typeof value === "number" && Number.isSafeInteger(value))
-    return value;
-  if (typeof value === "bigint") {
-    const numberValue = Number(value);
-    if (Number.isSafeInteger(numberValue) && BigInt(numberValue) === value)
-      return numberValue;
-  }
-  return void 0;
-}
-function avroObjectContainer(bytes) {
-  return bytes.length >= 4 && bytes[0] === 79 && bytes[1] === 98 && bytes[2] === 106 && bytes[3] === 1;
-}
-async function decodeAvroObjectContainer(bytes) {
-  const avro = await loadAvro();
-  const avroBigIntLongType = avro.types.LongType.__with({
-    fromBuffer: (buffer) => buffer.readBigInt64LE(),
-    toBuffer: (value) => {
-      const buffer = Buffer.alloc(8);
-      buffer.writeBigInt64LE(BigInt(value));
-      return buffer;
-    },
-    fromJSON: (value) => BigInt(value),
-    toJSON: (value) => value.toString(),
-    isValid: (value) => typeof value === "bigint" || typeof value === "number" && Number.isSafeInteger(value),
-    compare: (left, right) => {
-      const leftBigInt = BigInt(left);
-      const rightBigInt = BigInt(right);
-      return leftBigInt === rightBigInt ? 0 : leftBigInt < rightBigInt ? -1 : 1;
-    }
-  });
-  const avroLongTypeHook = (schema) => schema === "long" || isRecord4(schema) && schema.type === "long" ? avroBigIntLongType : void 0;
-  const decoder = new avro.streams.BlockDecoder({
-    parseHook: (schema) => avro.Type.forSchema(schema, { typeHook: avroLongTypeHook })
-  });
-  const records = [];
-  const done = new Promise((resolve, reject) => {
-    decoder.on("data", (record) => records.push(record));
-    decoder.on("end", () => resolve(records));
-    decoder.on("error", reject);
-  });
-  decoder.end(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
-  return done;
-}
-async function loadAvro() {
-  const module = await import('avsc');
-  return module.default ?? module;
-}
-function validateManifestList(value, path) {
-  const manifests = Array.isArray(value) ? value : isRecord4(value) && Array.isArray(value.manifests) ? value.manifests : void 0;
-  if (manifests === void 0) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg manifest list has invalid required fields", {
-      path
-    });
-  }
-  return manifests.map((manifest) => validateManifestReference(manifest, path));
-}
-function validateManifest(value, path) {
-  if (!isRecord4(value) || typeof value.path !== "string" || !Array.isArray(value.files)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg manifest has invalid required fields", {
-      path
-    });
-  }
-  return value;
-}
-function validateManifestReference(value, path) {
-  if (!isRecord4(value) || typeof value.path !== "string") {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg manifest list entry is invalid", { path });
-  }
-  validateManifestContent(value.content, path);
-  if (Array.isArray(value.files))
-    return value;
-  return { path: value.path };
-}
-function validateManifestContent(content, path) {
-  if (content === void 0 || content === null)
-    return;
-  if (content === 0 || content === 1 || content === "data" || content === "deletes")
-    return;
-  throw new LaQLError("LAQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg manifest list contains an unsupported manifest content type", {
-    path,
-    content
-  });
-}
-function validateManifestPaths(manifest, path, tablePrefix = "") {
-  validateManifestSourcedPath(manifest.path, tablePrefix);
-  for (const file of manifest.files) {
-    validateManifestSourcedPath(file.path, tablePrefix);
-    for (const deleteFile of file.deleteFiles ?? []) {
-      validateManifestSourcedPath(deleteFile.path, tablePrefix);
-    }
-  }
-  for (const deleteFile of manifest.deleteFiles ?? []) {
-    validateManifestSourcedPath(deleteFile.path, tablePrefix);
-  }
-  return { ...manifest, path };
-}
-function validateManifestSourcedPath(path, tablePrefix = "") {
-  if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//iu.test(path) || path.startsWith("/")) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path must be relative: ${path}`, {
-      path
-    });
-  }
-  for (const segment of path.split("/")) {
-    let decoded;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path is invalid: ${path}`, {
-        path
-      });
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path contains traversal: ${path}`, {
-        path
-      });
-    }
-  }
-  if (tablePrefix !== "" && path !== tablePrefix && !path.startsWith(`${tablePrefix}/`)) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path escapes table location: ${path}`, {
-      path,
-      tableLocation: tablePrefix
-    });
-  }
-  return path;
-}
-function tableLocationObjectPrefix(location) {
-  const trimmed = trimTrailingSlash(location.trim());
-  if (trimmed === "" || !trimmed.includes("/"))
-    return "";
-  if (/^[a-z][a-z0-9+.-]*:\/\//iu.test(trimmed)) {
-    const url = new URL(trimmed);
-    return trimSlashes(decodeURIComponent(url.pathname));
-  }
-  return trimSlashes(trimmed);
-}
-function trimSlashes(value) {
-  return value.replace(/^\/+|\/+$/gu, "");
-}
-async function readVersionHint(store, path, controls = {}) {
-  const bytes = await store.get(path);
-  if (!bytes)
-    return void 0;
-  throwIfAborted(controls.signal);
-  const text = new TextDecoder().decode(bytes).trim();
-  const version = Number(text);
-  if (!Number.isInteger(version) || version < 0) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg version hint", {
-      path,
-      versionHint: text
-    });
-  }
-  return version;
-}
-async function latestMetadataPathFromList(store, metadataPrefix, controls = {}) {
-  let latest;
-  for await (const object of store.list(metadataPrefix)) {
-    throwIfAborted(controls.signal);
-    const name = object.path.slice(metadataPrefix.length);
-    const match = /^v(\d+)\.metadata\.json$/u.exec(name);
-    if (!match)
-      continue;
-    const version = Number(match[1]);
-    if (!Number.isSafeInteger(version))
-      continue;
-    if (latest === void 0 || version > latest.version)
-      latest = { path: object.path, version };
-  }
-  if (latest === void 0) {
-    throw new LaQLError("LAQL_OBJECT_NOT_FOUND", "No Iceberg metadata files found", {
-      prefix: metadataPrefix
-    });
-  }
-  return latest.path;
-}
-function trimTrailingSlash(value) {
-  return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function restCatalogUrl(baseUrl, segments) {
-  const url = new URL(baseUrl);
-  const basePath = url.pathname.replace(/\/+$/u, "");
-  const encodedSegments = segments.map((segment) => encodeURIComponent(segment));
-  url.pathname = [basePath, ...encodedSegments].filter((segment) => segment.length > 0).join("/");
-  return url.toString();
-}
-function namespaceParts(namespace) {
-  const parts = Array.isArray(namespace) ? namespace : namespace.split(".");
-  const out = parts.map((part) => requiredNonEmptyString(part, "namespace"));
-  if (out.length === 0) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg REST namespace is required");
-  }
-  return out;
-}
-function catalogPrefixParts(prefix) {
-  if (prefix === void 0 || prefix.trim() === "")
-    return [];
-  return prefix.split("/").filter((part) => part.length > 0).map((part) => requiredNonEmptyString(part, "prefix"));
-}
-function requiredNonEmptyString(value, field) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg REST ${field} is required`);
-  }
-  return trimmed;
-}
-async function commitResponseMetadataPath(response) {
-  if (response.status === 204)
-    return void 0;
-  try {
-    const body = await response.json();
-    if (isRecord4(body) && typeof body["metadata-location"] === "string") {
-      return body["metadata-location"];
-    }
-  } catch {
-    return void 0;
-  }
-  return void 0;
-}
-function restAppendSnapshot(input) {
-  const snapshot = input.metadata.snapshots.at(-1);
-  if (snapshot === void 0) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg append metadata is missing next snapshot");
-  }
-  return {
-    "snapshot-id": snapshot["snapshot-id"],
-    "parent-snapshot-id": input.expectedSnapshotId,
-    "timestamp-ms": snapshot["timestamp-ms"],
-    "schema-id": snapshot["schema-id"],
-    "manifest-list": input.manifestPath,
-    summary: {
-      operation: "append",
-      "added-data-files": String(input.manifest.files.length),
-      "added-records": String(input.manifest.files.reduce((sum, file) => sum + file.recordCount, 0))
-    }
-  };
-}
-function equalityKey(row, columns) {
-  return stableStringify(columns.map((column) => {
-    if (!(column in row)) {
-      throw new LaQLError("LAQL_UNKNOWN_COLUMN", `Unknown Iceberg equality delete column ${column}`, {
-        column
-      });
-    }
-    return jsonSafeValue(row[column]);
-  }));
-}
-function appendManifestPath(metadataPath, jobId, snapshotId) {
-  const slash = metadataPath.lastIndexOf("/");
-  const prefix = slash === -1 ? "" : `${metadataPath.slice(0, slash + 1)}`;
-  return `${prefix}${jobId ?? "append"}-${snapshotId}.manifest.json`;
-}
-function maxSequenceNumber(metadata) {
-  let max = 0;
-  for (const snapshot of metadata.snapshots) {
-    for (const manifest of snapshotManifests(snapshot)) {
-      for (const file of manifest.files)
-        max = Math.max(max, file.sequenceNumber);
-    }
-  }
-  return max;
-}
-function supportedIcebergDeleteFiles(deleteFiles) {
-  const supported = [];
-  for (const deleteFile of deleteFiles ?? []) {
-    if (deleteFile.content === "position-delete" || deleteFile.content === "equality-delete") {
-      supported.push({ content: deleteFile.content, path: deleteFile.path });
-    }
-  }
-  return supported;
-}
-function unsupportedIcebergDeleteFiles(deleteFiles) {
-  const supported = /* @__PURE__ */ new Set(["position-delete", "equality-delete"]);
-  return (deleteFiles ?? []).filter((deleteFile) => !supported.has(deleteFile.content));
-}
-function cloneMetadata(metadata) {
-  const cloned = {
-    "format-version": metadata["format-version"],
-    "table-uuid": metadata["table-uuid"],
-    location: metadata.location,
-    "current-snapshot-id": metadata["current-snapshot-id"],
-    schemas: metadata.schemas.map((schema) => ({
-      "schema-id": schema["schema-id"],
-      fields: schema.fields.map((field) => ({ ...field }))
-    })),
-    snapshots: metadata.snapshots.map((snapshot) => {
-      const cloned2 = {
-        "snapshot-id": snapshot["snapshot-id"],
-        "timestamp-ms": snapshot["timestamp-ms"],
-        "schema-id": snapshot["schema-id"]
-      };
-      if (snapshot["manifest-list"] !== void 0)
-        cloned2["manifest-list"] = snapshot["manifest-list"];
-      if (snapshot.manifests !== void 0) {
-        cloned2.manifests = snapshot.manifests.map(cloneManifestOrReference);
-      }
-      return cloned2;
-    })
-  };
-  if (metadata.refs)
-    cloned.refs = cloneRefs(metadata.refs);
-  if (metadata["partition-specs"]) {
-    cloned["partition-specs"] = metadata["partition-specs"].map((spec) => ({
-      "spec-id": spec["spec-id"],
-      fields: spec.fields.map((field) => ({ ...field }))
-    }));
-  }
-  if (metadata["sort-orders"]) {
-    cloned["sort-orders"] = metadata["sort-orders"].map((order) => ({
-      "order-id": order["order-id"],
-      fields: order.fields.map((field) => field)
-    }));
-  }
-  return cloned;
-}
-function cloneRefs(refs) {
-  const out = {};
-  for (const [name, ref] of Object.entries(refs)) {
-    out[name] = { type: ref.type, "snapshot-id": ref["snapshot-id"] };
-  }
-  return out;
-}
-function cloneManifest(manifest) {
-  const cloned = {
-    path: manifest.path,
-    files: manifest.files.map((file) => {
-      const cloned2 = {
-        path: file.path,
-        sequenceNumber: file.sequenceNumber,
-        partition: sortStringRecord(file.partition ?? {}),
-        recordCount: file.recordCount
-      };
-      if (file.fileSizeInBytes !== void 0)
-        cloned2.fileSizeInBytes = file.fileSizeInBytes;
-      if (file.deleteFiles !== void 0) {
-        cloned2.deleteFiles = file.deleteFiles.map((deleteFile) => ({ ...deleteFile }));
-      }
-      return cloned2;
-    })
-  };
-  if (manifest.deleteFiles !== void 0) {
-    cloned.deleteFiles = manifest.deleteFiles.map((deleteFile) => ({ ...deleteFile }));
-  }
-  return cloned;
-}
-function cloneManifestOrReference(manifest) {
-  if (!Array.isArray(manifest.files)) {
-    return { path: manifest.path };
-  }
-  return cloneManifest(manifest);
-}
-function snapshotManifests(snapshot) {
-  return snapshot.manifests ?? [];
-}
-function sortStringRecord(record) {
-  const out = {};
-  for (const key of Object.keys(record).sort())
-    out[key] = record[key] ?? "";
-  return out;
-}
-function validateListTablesResponse(value) {
-  if (!isRecord4(value) || !Array.isArray(value.identifiers)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg REST list tables response");
-  }
-  return value.identifiers.map((identifier) => {
-    if (!isRecord4(identifier) || !Array.isArray(identifier.namespace) || !identifier.namespace.every((part) => typeof part === "string") || typeof identifier.name !== "string") {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg REST table identifier");
-    }
-    return { namespace: identifier.namespace, name: identifier.name };
-  });
-}
-function validateMetadata(value) {
-  if (!isRecord4(value))
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg metadata must be an object");
-  if (value["format-version"] !== 1 && value["format-version"] !== 2) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Only Iceberg format-version 1 and 2 metadata is supported for reads", {
-      formatVersion: value["format-version"]
-    });
-  }
-  if (!Array.isArray(value.snapshots) || !Array.isArray(value.schemas)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg metadata is missing snapshots or schemas");
-  }
-  if (!isMetadataFile(value)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg metadata has invalid required fields");
-  }
-  rejectUnsupportedMetadataFeatures(value);
-  return value;
-}
-function rejectUnsupportedMetadataFeatures(metadata) {
-  rejectAdvertisedFeatureFlags(metadata);
-  rejectUnsupportedPartitionTransforms(metadata["partition-specs"]);
-  rejectUnsupportedSortOrders(metadata["sort-orders"]);
-}
-function rejectAdvertisedFeatureFlags(metadata) {
-  for (const key of ["features", "table-features", "format-version-features"]) {
-    const features = metadata[key];
-    if (features === void 0 || Array.isArray(features) && features.length === 0)
-      continue;
-    throw new LaQLError("LAQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg metadata advertises unsupported table-format features", {
-      featureProperty: key,
-      features
-    });
-  }
-}
-function rejectUnsupportedPartitionTransforms(partitionSpecs) {
-  if (partitionSpecs === void 0)
-    return;
-  if (!Array.isArray(partitionSpecs)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg partition-specs must be an array");
-  }
-  for (const spec of partitionSpecs) {
-    if (!isRecord4(spec) || !Array.isArray(spec.fields)) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg partition spec is invalid");
-    }
-    for (const field of spec.fields) {
-      if (!isRecord4(field) || typeof field.transform !== "string") {
-        throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg partition field is invalid");
-      }
-      if (field.transform !== "identity" && field.transform !== "void") {
-        throw new LaQLError("LAQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg partition transform is not supported for strict planning", {
-          specId: spec["spec-id"],
-          fieldName: field.name,
-          transform: field.transform
-        });
-      }
-    }
-  }
-}
-function rejectUnsupportedSortOrders(sortOrders) {
-  if (sortOrders === void 0)
-    return;
-  if (!Array.isArray(sortOrders)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg sort-orders must be an array");
-  }
-  for (const order of sortOrders) {
-    if (!isRecord4(order) || !Array.isArray(order.fields)) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg sort order is invalid");
-    }
-    if (order.fields.length > 0) {
-      throw new LaQLError("LAQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg sorted table metadata is not supported for strict planning", {
-        orderId: order["order-id"],
-        fields: order.fields
-      });
-    }
-  }
-}
-function isMetadataFile(value) {
-  if (!isRecord4(value))
-    return false;
-  return (value["format-version"] === 1 || value["format-version"] === 2) && typeof value["table-uuid"] === "string" && typeof value.location === "string" && typeof value["current-snapshot-id"] === "number" && Array.isArray(value.refs) === false && Array.isArray(value.schemas) && Array.isArray(value.snapshots);
-}
-function projectedIds(fields, select) {
-  if (!select)
-    return fields.map((field) => field.id).sort((a, b) => a - b);
-  return select.map((name) => {
-    const field = fields.find((candidate) => candidate.name === name);
-    if (!field) {
-      throw new LaQLError("LAQL_UNKNOWN_COLUMN", `Unknown Iceberg column ${name}`, {
-        column: name
-      });
-    }
-    return field.sourceId ?? field.id;
-  }).sort((a, b) => a - b);
-}
-function partitionMayMatch2(expr, partition) {
-  if (!expr)
-    return true;
-  const columns = /* @__PURE__ */ new Set();
-  collectColumns2(expr, columns);
-  if (columns.size === 0 || [...columns].some((column) => !(column in partition)))
-    return true;
-  try {
-    return matches(expr, partition);
-  } catch (cause) {
-    if (cause instanceof LaQLError && cause.code === "LAQL_TYPE_ERROR")
-      return true;
-    throw cause;
-  }
-}
-function collectColumns2(expr, columns) {
-  switch (expr.kind) {
-    case "column":
-      columns.add(expr.name);
-      return;
-    case "literal":
-      return;
-    case "compare":
-      collectColumns2(expr.left, columns);
-      collectColumns2(expr.right, columns);
-      return;
-    case "in":
-      collectColumns2(expr.target, columns);
-      for (const value of expr.values)
-        collectColumns2(value, columns);
-      return;
-    case "between":
-      collectColumns2(expr.target, columns);
-      collectColumns2(expr.low, columns);
-      collectColumns2(expr.high, columns);
-      return;
-    case "null-check":
-      collectColumns2(expr.target, columns);
-      return;
-    case "logical":
-      for (const operand of expr.operands)
-        collectColumns2(operand, columns);
-      return;
-    case "not":
-      collectColumns2(expr.operand, columns);
-      return;
-    case "like":
-      collectColumns2(expr.target, columns);
-      return;
-    case "call":
-      for (const arg of expr.args)
-        collectColumns2(arg, columns);
-      return;
-  }
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 async function asyncBufferFromStore(store, path, options = void 0) {
   const controlledStore = options === void 0 ? store : withObjectStoreReadControls(store, options.budget);
   throwIfAborted(options?.budget.signal);
@@ -5847,7 +4772,7 @@ function partitionedParquetOutputEntries(result, options) {
     const entry = {
       taskId: typeof options.taskId === "function" ? options.taskId(file, index) : options.taskId,
       outputPath: file.path,
-      partitionValues: sortStringRecord2(file.partitionValues),
+      partitionValues: sortStringRecord(file.partitionValues),
       rowCount: file.rowCount,
       byteSize: file.byteSize,
       contentHash: file.contentHash
@@ -5858,7 +4783,7 @@ function partitionedParquetOutputEntries(result, options) {
       entry.iceberg = {
         recordCount: file.rowCount,
         fileSizeInBytes: file.byteSize,
-        partitionValues: sortStringRecord2(file.partitionValues)
+        partitionValues: sortStringRecord(file.partitionValues)
       };
     }
     return entry;
@@ -5872,7 +4797,7 @@ function outputEntriesToPartitionedResult(entries) {
         byteSize: entry.byteSize,
         contentHash: entry.contentHash ?? "",
         rowCount: entry.rowCount,
-        partitionValues: sortStringRecord2(entry.partitionValues)
+        partitionValues: sortStringRecord(entry.partitionValues)
       };
       if (entry.etag !== void 0)
         file.etag = entry.etag;
@@ -6288,7 +5213,7 @@ function compareInsertValues(left, right, column, rowIndex) {
     return 1;
   return 0;
 }
-function sortStringRecord2(record) {
+function sortStringRecord(record) {
   const out = {};
   for (const key of Object.keys(record).sort())
     out[key] = record[key] ?? "";
@@ -6472,6 +5397,8 @@ function rowGroupMayMatch(rowGroup, expr) {
     case "column":
     case "null-check":
     case "like":
+    case "arithmetic":
+    case "case":
       return true;
     case "call":
       return callMayMatch2(rowGroup, expr);
@@ -6747,78 +5674,4 @@ function createParquetLake(config) {
   });
 }
 
-// src/engine.ts
-async function loadTable(options) {
-  if (options.format === "parquet") {
-    return { format: "parquet", store: options.store, path: options.path };
-  }
-  const { format: _format, ...icebergOptions } = options;
-  return {
-    format: "iceberg",
-    store: options.store,
-    table: await loadIcebergTable(icebergOptions)
-  };
-}
-function planFiles2(table, options = {}) {
-  if (table.format === "parquet") {
-    return { format: "parquet", store: table.store, files: [{ path: table.path }] };
-  }
-  return {
-    format: "iceberg",
-    store: table.store,
-    table: table.table,
-    plan: planFiles(table.table, options),
-    options
-  };
-}
-async function* scanBatches(plan, options = {}) {
-  if (plan.format === "parquet") {
-    for (const file of plan.files) {
-      const readOptions = {};
-      if (options.batchSize !== void 0) readOptions.batchSize = options.batchSize;
-      for await (const batch of readParquetObjectBatches(plan.store, file.path, readOptions)) {
-        yield batch.rows;
-      }
-    }
-    return;
-  }
-  for await (const batch of scanPlannedIcebergRows({
-    plan: plan.plan,
-    ...options,
-    readDataFile: async (file) => projectIcebergParquetBatches(
-      plan.store,
-      plan.table,
-      file.path,
-      file.partition,
-      file.snapshotId,
-      plan.options,
-      options
-    ),
-    readDeleteFile: async (deleteFile) => readIcebergParquetDeletes(plan.store, deleteFile)
-  })) {
-    yield batch;
-  }
-}
-async function* scanRows(plan, options = {}) {
-  for await (const batch of scanBatches(plan, options)) {
-    for (const row of batch) {
-      yield row;
-    }
-  }
-}
-async function* projectIcebergParquetBatches(store, table, path, partition, snapshotId, planOptions, scanOptions) {
-  const readOptions = {};
-  if (scanOptions.batchSize !== void 0) readOptions.batchSize = scanOptions.batchSize;
-  for await (const batch of readParquetObjectBatches(store, path, readOptions)) {
-    yield {
-      rowOffset: batch.rowOffset,
-      rows: batch.rows.map((row) => {
-        const projectOptions = { snapshotId };
-        if (planOptions.select !== void 0) projectOptions.select = planOptions.select;
-        return table.projectRow({ ...partition, ...row }, projectOptions);
-      })
-    };
-  }
-}
-
-export { AggregationBuilder, CacheApiCache, ERROR_CODES, IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, LaQLError, Lake, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, ObjectStoreIcebergCommitCatalog, PACKAGE, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, advanceTaskCheckpoint, and, applyIcebergDeletes, assertBookmarkMatches, asyncBufferFromStore, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, classifyPredicate, col, createBookmark, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, encodeJsonLine, eq, evaluate, fingerprint, fn, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, isIn, isLaQLError, isNotNull, isNull, jsonSafeValue, like, lit, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planFiles2 as planFiles, planRowGroups, planRowGroupsFromMetadata, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, rowGroupMayMatch, scanBatches, scanPlannedIcebergRows, scanRows, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, signPaginationToken, stableStringify, throwIfAborted, transitionTaskCheckpoint, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask };
+export { AggregationBuilder, CacheApiCache, ERROR_CODES, LaQLError, Lake, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, __commonJS, __toESM, add, advanceTaskCheckpoint, and, assertBookmarkMatches, asyncBufferFromStore, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, classifyPredicate, col, createBookmark, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, div, encodeJsonLine, eq, evaluate, fingerprint, fn, gt, gte, ilike, isIn, isLaQLError, isNotNull, isNull, jsonSafeValue, like, lit, lookupJoin, lt, lte, matches, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, mod, mul, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planRowGroups, planRowGroupsFromMetadata, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, rowGroupMayMatch, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, signPaginationToken, stableStringify, sub, throwIfAborted, transitionTaskCheckpoint, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask };