lakeql 0.1.0 → 0.1.7

package/dist/chunk-BFLGC6Y5.js

@@ -0,0 +1,1694 @@
+import { Lake, stableStringify, vectorValue, scalarVectorValue, batchFromColumns, withObjectStoreReadControls, throwIfAborted, readControlSignal, readParquetObjectBatches, readIcebergParquetDeletes } from './chunk-RZL45ZSN.js';
+import { LakeqlError, jsonSafeValue, matches } from './chunk-TFD5RFKB.js';
+
+// ../core/dist/in-memory.js
+var InMemoryRowsScanner = class {
+  tables;
+  constructor(tables, options = {}) {
+    this.tables = normalizeInMemoryTables(tables, options);
+  }
+  async *scan(path, options) {
+    const table = this.table(path);
+    const batchSize = options.batchSize;
+    for (let start = 0; start < table.rows.length; start += batchSize) {
+      const out = [];
+      for (const row of table.rows.slice(start, start + batchSize)) {
+        out.push(projectPhysicalColumns(row, options.columns));
+      }
+      yield out;
+    }
+  }
+  async planTask(path) {
+    return { rowGroupRanges: [{ start: 0, end: this.table(path).rows.length }] };
+  }
+  tableInfo(path) {
+    const table = this.table(path);
+    return {
+      path: table.path,
+      size: table.size,
+      etag: table.etag,
+      lastModified: table.lastModified
+    };
+  }
+  listTables(prefix, options = {}) {
+    const out = [];
+    for (const table of [...this.tables.values()].sort((left, right) => left.path.localeCompare(right.path))) {
+      if (!table.path.startsWith(prefix))
+        continue;
+      out.push({
+        path: table.path,
+        size: table.size,
+        etag: table.etag,
+        lastModified: table.lastModified
+      });
+      if (options.limit !== void 0 && out.length >= options.limit)
+        break;
+    }
+    return out;
+  }
+  table(path) {
+    const table = this.tables.get(path);
+    if (table === void 0) {
+      throw new LakeqlError("LAKEQL_UNKNOWN_TABLE", `No in-memory table named ${path}`, { path });
+    }
+    return table;
+  }
+};
+var InMemoryRowsStore = class {
+  scanner;
+  constructor(scanner) {
+    this.scanner = scanner;
+  }
+  async get(path) {
+    this.scanner.tableInfo(path);
+    return null;
+  }
+  async getRange(path) {
+    this.scanner.tableInfo(path);
+    return new Uint8Array();
+  }
+  async put() {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "In-memory row stores are read-only");
+  }
+  async delete() {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "In-memory row stores are read-only");
+  }
+  async *list(prefix, options) {
+    yield* this.scanner.listTables(prefix, options);
+  }
+  async head(path) {
+    try {
+      const table = this.scanner.tableInfo(path);
+      const head = {
+        size: table.size,
+        contentType: "application/vnd.lakeql.rows+json"
+      };
+      if (table.etag !== void 0)
+        head.etag = table.etag;
+      if (table.lastModified !== void 0)
+        head.lastModified = table.lastModified;
+      return head;
+    } catch (cause) {
+      if (cause instanceof LakeqlError && cause.code === "LAKEQL_UNKNOWN_TABLE")
+        return null;
+      throw cause;
+    }
+  }
+};
+function inMemoryRowsScanner(tables, options = {}) {
+  return new InMemoryRowsScanner(tables, options);
+}
+function createInMemoryLake(tables, options = {}) {
+  const { maxRows, maxBytes, ...lakeOptions } = options;
+  const tableOptions = {};
+  if (maxRows !== void 0)
+    tableOptions.maxRows = maxRows;
+  if (maxBytes !== void 0)
+    tableOptions.maxBytes = maxBytes;
+  const scanner = inMemoryRowsScanner(tables, tableOptions);
+  return new Lake({
+    ...lakeOptions,
+    store: new InMemoryRowsStore(scanner),
+    scanner
+  });
+}
+function normalizeInMemoryTables(tables, options) {
+  const normalized = /* @__PURE__ */ new Map();
+  let totalRows = 0;
+  let totalBytes = 0;
+  for (const [path, rows] of Object.entries(tables)) {
+    if (path.trim() === "") {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", "In-memory table names must be non-empty");
+    }
+    const copiedRows = rows.map((row) => ({ ...row }));
+    const size = estimateRowsBytes(copiedRows);
+    totalRows += copiedRows.length;
+    totalBytes += size;
+    enforceInMemoryTableBudget(options, totalRows, totalBytes);
+    normalized.set(path, {
+      path,
+      rows: copiedRows,
+      size,
+      etag: `memory-${stableStringify([path, copiedRows.length, size])}`,
+      lastModified: /* @__PURE__ */ new Date(0)
+    });
+  }
+  return normalized;
+}
+function enforceInMemoryTableBudget(options, rows, bytes) {
+  if (options.maxRows !== void 0 && rows > options.maxRows) {
+    throw new LakeqlError("LAKEQL_BUDGET_EXCEEDED", `In-memory ingest exceeded row budget (${rows} > ${options.maxRows})`, { metric: "ingest rows", limit: options.maxRows, actual: rows });
+  }
+  if (options.maxBytes !== void 0 && bytes > options.maxBytes) {
+    throw new LakeqlError("LAKEQL_BUDGET_EXCEEDED", `In-memory ingest exceeded byte budget (${bytes} > ${options.maxBytes})`, { metric: "ingest bytes", limit: options.maxBytes, actual: bytes });
+  }
+}
+function estimateRowsBytes(rows) {
+  return new TextEncoder().encode(stableStringify(jsonSafeValue(rows))).byteLength;
+}
+function projectPhysicalColumns(row, columns) {
+  if (columns === void 0)
+    return { ...row };
+  const out = {};
+  for (const column of columns) {
+    if (column in row)
+      out[column] = row[column];
+  }
+  return out;
+}
+
+// ../core/dist/vector-join.js
+function vectorHashJoin(left, right, options) {
+  const normalized = validateVectorJoinOptions(left, right, options);
+  const rightIndices = selectedIndices(right.rowCount, options.rightSelection);
+  enforceMaxRightRows(rightIndices.length, options.maxRightRows);
+  const index = buildRightIndex(right, rightIndices, normalized.rightKeys);
+  const output = createOutputColumns(left, right, normalized);
+  for (const leftIndex of selectedIndices(left.rowCount, options.leftSelection)) {
+    const matches2 = index.get(joinKey(left, leftIndex, normalized.leftKeys));
+    if (normalized.type === "semi") {
+      if (matches2 !== void 0 && matches2.length > 0)
+        appendLeftOnly(output, left, leftIndex);
+      continue;
+    }
+    if (normalized.type === "anti") {
+      if (matches2 === void 0 || matches2.length === 0)
+        appendLeftOnly(output, left, leftIndex);
+      continue;
+    }
+    if (matches2 === void 0 || matches2.length === 0) {
+      if (normalized.type === "left")
+        appendLeftWithNullRight(output, left, right, leftIndex, normalized);
+      continue;
+    }
+    for (const rightIndex of matches2)
+      appendJoined(output, left, right, leftIndex, rightIndex, normalized);
+  }
+  return batchFromOutput(output);
+}
+function validateVectorJoinOptions(left, right, options) {
+  const leftKeys = normalizeJoinKeys(options.leftKey, "leftKey");
+  const rightKeys = normalizeJoinKeys(options.rightKey, "rightKey");
+  if (leftKeys.length !== rightKeys.length) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Vector join key counts must match", {
+      leftKey: options.leftKey,
+      rightKey: options.rightKey
+    });
+  }
+  if (!Number.isInteger(options.maxRightRows) || options.maxRightRows < 1) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Vector join maxRightRows must be a positive integer");
+  }
+  const type = options.type ?? "inner";
+  if (type !== "inner" && type !== "left" && type !== "semi" && type !== "anti") {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Vector join type is not supported", { type });
+  }
+  for (const key of leftKeys)
+    assertColumn(left, key);
+  for (const key of rightKeys)
+    assertColumn(right, key);
+  const rightPrefix = options.rightPrefix ?? "right.";
+  return {
+    leftKeys,
+    rightKeys,
+    type,
+    rightPrefix,
+    outputRightColumns: type === "semi" || type === "anti" ? [] : outputRightColumns(left, right, leftKeys, rightKeys, rightPrefix)
+  };
+}
+function buildRightIndex(right, rightIndices, rightKeys) {
+  const index = /* @__PURE__ */ new Map();
+  for (const rightIndex of rightIndices) {
+    const key = joinKey(right, rightIndex, rightKeys);
+    const bucket = index.get(key);
+    if (bucket === void 0)
+      index.set(key, [rightIndex]);
+    else
+      bucket.push(rightIndex);
+  }
+  return index;
+}
+function createOutputColumns(left, _right, options) {
+  const output = {};
+  for (const column of Object.keys(left.columns))
+    output[column] = [];
+  for (const { output: column } of options.outputRightColumns)
+    output[column] = [];
+  return output;
+}
+function appendJoined(output, left, right, leftIndex, rightIndex, options) {
+  appendLeft(output, left, leftIndex);
+  appendRight(output, right, rightIndex, options);
+}
+function appendLeftOnly(output, left, leftIndex) {
+  appendLeft(output, left, leftIndex);
+}
+function appendLeftWithNullRight(output, left, right, leftIndex, options) {
+  appendLeft(output, left, leftIndex);
+  for (const { output: column } of options.outputRightColumns)
+    output[column]?.push(null);
+}
+function appendLeft(output, left, leftIndex) {
+  for (const [column, vector] of Object.entries(left.columns)) {
+    output[column]?.push(vectorValue(vector, leftIndex));
+  }
+}
+function appendRight(output, right, rightIndex, options) {
+  for (const { input, output: column } of options.outputRightColumns) {
+    const vector = right.columns[input];
+    if (vector === void 0)
+      throw new LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown column ${input}`, { column: input });
+    output[column]?.push(vectorValue(vector, rightIndex));
+  }
+}
+function outputRightColumns(left, right, leftKeys, rightKeys, rightPrefix) {
+  return Object.keys(right.columns).flatMap((column) => {
+    if (rightKeys.includes(column) && leftKeys.includes(column))
+      return [];
+    return [{ input: column, output: column in left.columns ? `${rightPrefix}${column}` : column }];
+  });
+}
+function joinKey(batch, index, keys) {
+  const values = keys.map((key) => scalarJoinValue(batch, index, key));
+  return stableStringify(values.length === 1 ? values[0] : values);
+}
+function scalarJoinValue(batch, index, column) {
+  const vector = batch.columns[column];
+  if (vector === void 0)
+    throw new LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown join key ${column}`, { column });
+  return scalarVectorValue(vector, index);
+}
+function normalizeJoinKeys(key, label) {
+  const keys = Array.isArray(key) ? key : [key];
+  if (keys.length === 0 || keys.some((column) => typeof column !== "string" || column.length === 0)) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", `Vector join ${label} must contain column names`, {
+      [label]: key
+    });
+  }
+  return keys;
+}
+function assertColumn(batch, column) {
+  if (batch.columns[column] === void 0) {
+    throw new LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown join key ${column}`, { column });
+  }
+}
+function selectedIndices(rowCount, selection) {
+  const indices = [];
+  for (let index = 0; index < rowCount; index += 1) {
+    if (selection !== void 0 && selection[index] !== 1)
+      continue;
+    indices.push(index);
+  }
+  return indices;
+}
+function enforceMaxRightRows(actual, limit) {
+  if (actual <= limit)
+    return;
+  throw new LakeqlError("LAKEQL_BUDGET_EXCEEDED", `Vector join exceeded maxRightRows (${actual} > ${limit})`, { metric: "maxRightRows", limit, actual });
+}
+function batchFromOutput(output) {
+  return batchFromColumns(output);
+}
+
+// ../iceberg/dist/index.js
+var PACKAGE = "lakeql-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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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) => partitionMayMatch(options.where, file.partition ?? {}));
+      if (!manifestMayMatch) {
+        manifestsSkipped += 1;
+        filesSkipped += manifest.files.length;
+        continue;
+      }
+      for (const file of manifest.files) {
+        if (!partitionMayMatch(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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_VALIDATION_ERROR", "Iceberg append requires at least one file");
+    }
+    if (this.metadata["format-version"] !== 2) {
+      throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 (!isRecord(response) || typeof response["metadata-location"] !== "string") {
+      throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST catalog request failed", {
+        url,
+        status: response.status,
+        statusText: response.statusText
+      });
+    }
+    try {
+      return await response.json();
+    } catch (cause) {
+      throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError)
+      throw cause;
+    throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_CATALOG_ERROR", "Unable to allocate unique Iceberg snapshot id");
+}
+function validateNewSnapshotId(snapshotId, snapshots) {
+  if (!Number.isSafeInteger(snapshotId) || snapshotId <= 0) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Iceberg snapshot id must be a positive safe integer", { snapshotId });
+  }
+  if (snapshots.some((snapshot) => snapshotIdOf(snapshot) === snapshotId)) {
+    throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError)
+      throw cause;
+    throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError)
+      throw cause;
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Invalid Iceberg manifest at ${path}`, {
+      path,
+      cause
+    });
+  }
+}
+function validateAvroManifestList(records, path) {
+  return records.map((record) => {
+    if (!isRecord(record) || typeof record.manifest_path !== "string") {
+      throw new LakeqlError("LAKEQL_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 (!isRecord(record)) {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg Avro manifest entry is invalid", {
+        path
+      });
+    }
+    if (typeof record.status === "number" && record.status === 2)
+      continue;
+    const dataFile = record.data_file;
+    if (!isRecord(dataFile)) {
+      throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 (!isRecord(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" || isRecord(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 : isRecord(value) && Array.isArray(value.manifests) ? value.manifests : void 0;
+  if (manifests === void 0) {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg manifest list has invalid required fields", {
+      path
+    });
+  }
+  return manifests.map((manifest) => validateManifestReference(manifest, path));
+}
+function validateManifest(value, path) {
+  if (!isRecord(value) || typeof value.path !== "string" || !Array.isArray(value.files)) {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg manifest has invalid required fields", {
+      path
+    });
+  }
+  return value;
+}
+function validateManifestReference(value, path) {
+  if (!isRecord(value) || typeof value.path !== "string") {
+    throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path is invalid: ${path}`, {
+        path
+      });
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path contains traversal: ${path}`, {
+        path
+      });
+    }
+  }
+  if (tablePrefix !== "" && path !== tablePrefix && !path.startsWith(`${tablePrefix}/`)) {
+    throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 (isRecord(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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 (!isRecord(value) || !Array.isArray(value.identifiers)) {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg REST list tables response");
+  }
+  return value.identifiers.map((identifier) => {
+    if (!isRecord(identifier) || !Array.isArray(identifier.namespace) || !identifier.namespace.every((part) => typeof part === "string") || typeof identifier.name !== "string") {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg REST table identifier");
+    }
+    return { namespace: identifier.namespace, name: identifier.name };
+  });
+}
+function validateMetadata(value) {
+  if (!isRecord(value))
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg metadata must be an object");
+  if (value["format-version"] !== 1 && value["format-version"] !== 2) {
+    throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg metadata is missing snapshots or schemas");
+  }
+  if (!isMetadataFile(value)) {
+    throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg partition-specs must be an array");
+  }
+  for (const spec of partitionSpecs) {
+    if (!isRecord(spec) || !Array.isArray(spec.fields)) {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg partition spec is invalid");
+    }
+    for (const field of spec.fields) {
+      if (!isRecord(field) || typeof field.transform !== "string") {
+        throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg partition field is invalid");
+      }
+      if (field.transform !== "identity" && field.transform !== "void") {
+        throw new LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg sort-orders must be an array");
+  }
+  for (const order of sortOrders) {
+    if (!isRecord(order) || !Array.isArray(order.fields)) {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg sort order is invalid");
+    }
+    if (order.fields.length > 0) {
+      throw new LakeqlError("LAKEQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg sorted table metadata is not supported for strict planning", {
+        orderId: order["order-id"],
+        fields: order.fields
+      });
+    }
+  }
+}
+function isMetadataFile(value) {
+  if (!isRecord(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 LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown Iceberg column ${name}`, {
+        column: name
+      });
+    }
+    return field.sourceId ?? field.id;
+  }).sort((a, b) => a - b);
+}
+function partitionMayMatch(expr, partition) {
+  if (!expr)
+    return true;
+  const columns = /* @__PURE__ */ new Set();
+  collectColumns(expr, columns);
+  if (columns.size === 0 || [...columns].some((column) => !(column in partition)))
+    return true;
+  try {
+    return matches(expr, partition);
+  } catch (cause) {
+    if (cause instanceof LakeqlError && cause.code === "LAKEQL_TYPE_ERROR")
+      return true;
+    throw cause;
+  }
+}
+function collectColumns(expr, columns) {
+  switch (expr.kind) {
+    case "column":
+      columns.add(expr.name);
+      return;
+    case "literal":
+      return;
+    case "compare":
+      collectColumns(expr.left, columns);
+      collectColumns(expr.right, columns);
+      return;
+    case "in":
+      collectColumns(expr.target, columns);
+      for (const value of expr.values)
+        collectColumns(value, columns);
+      return;
+    case "between":
+      collectColumns(expr.target, columns);
+      collectColumns(expr.low, columns);
+      collectColumns(expr.high, columns);
+      return;
+    case "null-check":
+      collectColumns(expr.target, columns);
+      return;
+    case "logical":
+      for (const operand of expr.operands)
+        collectColumns(operand, columns);
+      return;
+    case "not":
+      collectColumns(expr.operand, columns);
+      return;
+    case "like":
+      collectColumns(expr.target, columns);
+      return;
+    case "call":
+      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;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// 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 { IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, InMemoryRowsScanner, InMemoryRowsStore, ObjectStoreIcebergCommitCatalog, PACKAGE, applyIcebergDeletes, createInMemoryLake, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, inMemoryRowsScanner, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, planFiles2 as planFiles, scanBatches, scanPlannedIcebergRows, scanRows, vectorHashJoin };