lakeql 0.1.2 → 0.1.7

package/dist/{chunk-MUTXXFOW.js → chunk-BFLGC6Y5.js}

@@ -1,7 +1,316 @@
-import { LaQLError, stableStringify, withObjectStoreReadControls, throwIfAborted, readControlSignal, jsonSafeValue, matches, readParquetObjectBatches, readIcebergParquetDeletes } from './chunk-D3A4VN3U.js';
+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 = "@laql/iceberg";
+var PACKAGE = "lakeql-iceberg";
 var IcebergTable = class {
   store;
   metadataPath;
@@ -17,7 +326,7 @@ var IcebergTable = class {
     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}`, {
+        throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Unknown Iceberg ref ${options.ref}`, {
           ref: options.ref
         });
       }
@@ -26,7 +335,7 @@ var IcebergTable = class {
     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", {
+        throw new LakeqlError("LAKEQL_CATALOG_ERROR", "No Iceberg snapshot at requested timestamp", {
           asOfTimestampMs: options.asOfTimestampMs
         });
       }
@@ -37,7 +346,9 @@ var IcebergTable = class {
   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 });
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Unknown Iceberg schema ${schemaId}`, {
+        schemaId
+      });
     }
     return schema.fields;
   }
@@ -81,7 +392,7 @@ var IcebergTable = class {
         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", {
+          throw new LakeqlError("LAKEQL_UNSUPPORTED_DELETE_FILES", "Snapshot contains delete files unsupported by strict Iceberg planning", {
             path: file.path,
             deleteFiles: file.deleteFiles,
             supportedDeleteFiles,
@@ -125,10 +436,10 @@ var IcebergTable = class {
   }
   async appendFiles(options) {
     if (options.files.length === 0) {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg append requires at least one file");
+      throw new LakeqlError("LAKEQL_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"] });
+      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));
@@ -172,7 +483,7 @@ var IcebergTable = class {
     });
     const committed = typeof commit === "boolean" ? commit : commit.committed;
     if (!committed) {
-      throw new LaQLError("LAQL_ICEBERG_COMMIT_CONFLICT", "Iceberg append commit conflict", {
+      throw new LakeqlError("LAKEQL_ICEBERG_COMMIT_CONFLICT", "Iceberg append commit conflict", {
         metadataPath: this.metadataPath,
         expectedSnapshotId: currentSnapshot["snapshot-id"],
         nextSnapshotId
@@ -197,7 +508,7 @@ var IcebergTable = class {
   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", {
+        throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Output manifest entry is missing Iceberg file metadata", {
           taskId: entry.taskId,
           outputPath: entry.outputPath
         });
@@ -220,7 +531,7 @@ var IcebergTable = class {
   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}`, {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Unknown Iceberg snapshot ${snapshotId}`, {
         snapshotId
       });
     }
@@ -241,11 +552,11 @@ function planFiles(table, 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 });
+      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 LaQLError("LAQL_OBJECT_NOT_FOUND", `No object at ${input.currentMetadataPath}`, {
+      throw new LakeqlError("LAKEQL_OBJECT_NOT_FOUND", `No object at ${input.currentMetadataPath}`, {
         path: input.currentMetadataPath
       });
     }
@@ -284,7 +595,7 @@ var IcebergRestCatalog = class {
   async loadTable(store) {
     const response = await this.requestJson(this.tableUrl(), { method: "GET" });
     if (!isRecord(response) || typeof response["metadata-location"] !== "string") {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg REST load table response", {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg REST load table response", {
         url: this.tableUrl()
       });
     }
@@ -329,7 +640,7 @@ var IcebergRestCatalog = class {
     if (response.status === 409)
       return { committed: false };
     if (!response.ok) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg REST table commit failed", {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST table commit failed", {
         url: this.tableUrl(),
         status: response.status,
         statusText: response.statusText
@@ -347,7 +658,7 @@ var IcebergRestCatalog = class {
       headers: this.headers(init.body !== void 0)
     });
     if (!response.ok) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg REST catalog request failed", {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST catalog request failed", {
         url,
         status: response.status,
         statusText: response.statusText
@@ -356,7 +667,7 @@ var IcebergRestCatalog = class {
     try {
       return await response.json();
     } catch (cause) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg REST catalog response is not JSON", {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST catalog response is not JSON", {
         url,
         cause
       });
@@ -402,7 +713,7 @@ var IcebergUnsupportedCatalog = class {
     throw this.unsupported("commitAppend");
   }
   unsupported(operation) {
-    return new LaQLError("LAQL_CATALOG_ERROR", `${this.catalog} Iceberg catalog is not implemented`, {
+    return new LakeqlError("LAKEQL_CATALOG_ERROR", `${this.catalog} Iceberg catalog is not implemented`, {
       catalog: this.catalog,
       namespace: this.namespace,
       table: this.table,
@@ -425,7 +736,7 @@ async function loadIcebergTable(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}`, {
+    throw new LakeqlError("LAKEQL_OBJECT_NOT_FOUND", `No object at ${options.metadataPath}`, {
       path: options.metadataPath
     });
   }
@@ -434,9 +745,9 @@ async function loadIcebergTable(options) {
   try {
     return new IcebergTable(store, options.metadataPath, await hydrateMetadataManifests(store, validateMetadata(JSON.parse(text)), readControls));
   } catch (cause) {
-    if (cause instanceof LaQLError)
+    if (cause instanceof LakeqlError)
       throw cause;
-    throw new LaQLError("LAQL_CATALOG_ERROR", `Invalid Iceberg metadata at ${options.metadataPath}`, {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Invalid Iceberg metadata at ${options.metadataPath}`, {
       path: options.metadataPath,
       cause
     });
@@ -482,7 +793,7 @@ function applyIcebergDeletes(options) {
   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");
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Iceberg equality delete requires columns");
     }
     const columnsKey = stableStringify(deletion.columns);
     let keys = equalityDeleteKeys.get(columnsKey);
@@ -566,7 +877,7 @@ function isAsyncIterable(value) {
 }
 function validateDeletePosition(position, path) {
   if (!Number.isInteger(position) || position < 0) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", "Iceberg delete position must be non-negative", {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Iceberg delete position must be non-negative", {
       path,
       position
     });
@@ -585,14 +896,14 @@ function randomSnapshotId(existingIds) {
     if (!existing.has(id))
       return id;
   }
-  throw new LaQLError("LAQL_CATALOG_ERROR", "Unable to allocate unique Iceberg snapshot 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 LaQLError("LAQL_VALIDATION_ERROR", "Iceberg snapshot id must be a positive safe integer", { snapshotId });
+    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 LaQLError("LAQL_VALIDATION_ERROR", "Iceberg snapshot id already exists", {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Iceberg snapshot id already exists", {
       snapshotId
     });
   }
@@ -656,14 +967,16 @@ function publicDeleteFile(deleteFile) {
 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 });
+    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 LaQLError)
+    if (cause instanceof LakeqlError)
       throw cause;
-    throw new LaQLError("LAQL_CATALOG_ERROR", `Invalid Iceberg manifest list at ${path}`, {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Invalid Iceberg manifest list at ${path}`, {
       path,
       cause
     });
@@ -672,15 +985,15 @@ async function readManifestList(store, path) {
 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 });
+    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 LaQLError)
+    if (cause instanceof LakeqlError)
       throw cause;
-    throw new LaQLError("LAQL_CATALOG_ERROR", `Invalid Iceberg manifest at ${path}`, {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Invalid Iceberg manifest at ${path}`, {
       path,
       cause
     });
@@ -689,7 +1002,7 @@ async function readManifest(store, path, tablePrefix = "") {
 function validateAvroManifestList(records, path) {
   return records.map((record) => {
     if (!isRecord(record) || typeof record.manifest_path !== "string") {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro manifest list entry is invalid", {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg Avro manifest list entry is invalid", {
         path
       });
     }
@@ -702,7 +1015,7 @@ function validateAvroManifest(records, path) {
   const deleteFiles = [];
   for (const record of records) {
     if (!isRecord(record)) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro manifest entry is invalid", {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg Avro manifest entry is invalid", {
         path
       });
     }
@@ -710,14 +1023,14 @@ function validateAvroManifest(records, path) {
       continue;
     const dataFile = record.data_file;
     if (!isRecord(dataFile)) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro manifest entry is missing data_file", {
+      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 LaQLError("LAQL_CATALOG_ERROR", "Iceberg Avro data file has invalid fields", {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg Avro data file has invalid fields", {
         path
       });
     }
@@ -819,7 +1132,7 @@ async function loadAvro() {
 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 LaQLError("LAQL_CATALOG_ERROR", "Iceberg manifest list has invalid required fields", {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg manifest list has invalid required fields", {
       path
     });
   }
@@ -827,7 +1140,7 @@ function validateManifestList(value, path) {
 }
 function validateManifest(value, path) {
   if (!isRecord(value) || typeof value.path !== "string" || !Array.isArray(value.files)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg manifest has invalid required fields", {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg manifest has invalid required fields", {
       path
     });
   }
@@ -835,7 +1148,9 @@ function validateManifest(value, path) {
 }
 function validateManifestReference(value, path) {
   if (!isRecord(value) || typeof value.path !== "string") {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg manifest list entry is invalid", { path });
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg manifest list entry is invalid", {
+      path
+    });
   }
   validateManifestContent(value.content, path);
   if (Array.isArray(value.files))
@@ -847,7 +1162,7 @@ function validateManifestContent(content, path) {
     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", {
+  throw new LakeqlError("LAKEQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg manifest list contains an unsupported manifest content type", {
     path,
     content
   });
@@ -867,7 +1182,7 @@ function validateManifestPaths(manifest, path, tablePrefix = "") {
 }
 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}`, {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path must be relative: ${path}`, {
       path
     });
   }
@@ -876,18 +1191,18 @@ function validateManifestSourcedPath(path, tablePrefix = "") {
     try {
       decoded = decodeURIComponent(segment);
     } catch {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path is invalid: ${path}`, {
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path is invalid: ${path}`, {
         path
       });
     }
     if (decoded === "." || decoded === "..") {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path contains traversal: ${path}`, {
+      throw new LakeqlError("LAKEQL_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}`, {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path escapes table location: ${path}`, {
       path,
       tableLocation: tablePrefix
     });
@@ -915,7 +1230,7 @@ async function readVersionHint(store, path, controls = {}) {
   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", {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg version hint", {
       path,
       versionHint: text
     });
@@ -937,7 +1252,7 @@ async function latestMetadataPathFromList(store, metadataPrefix, controls = {})
       latest = { path: object.path, version };
   }
   if (latest === void 0) {
-    throw new LaQLError("LAQL_OBJECT_NOT_FOUND", "No Iceberg metadata files found", {
+    throw new LakeqlError("LAKEQL_OBJECT_NOT_FOUND", "No Iceberg metadata files found", {
       prefix: metadataPrefix
     });
   }
@@ -957,7 +1272,7 @@ 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");
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Iceberg REST namespace is required");
   }
   return out;
 }
@@ -969,7 +1284,7 @@ function catalogPrefixParts(prefix) {
 function requiredNonEmptyString(value, field) {
   const trimmed = value.trim();
   if (trimmed.length === 0) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg REST ${field} is required`);
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg REST ${field} is required`);
   }
   return trimmed;
 }
@@ -989,7 +1304,7 @@ async function commitResponseMetadataPath(response) {
 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");
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg append metadata is missing next snapshot");
   }
   return {
     "snapshot-id": snapshot["snapshot-id"],
@@ -1007,7 +1322,7 @@ function restAppendSnapshot(input) {
 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}`, {
+      throw new LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown Iceberg equality delete column ${column}`, {
         column
       });
     }
@@ -1129,28 +1444,28 @@ function sortStringRecord(record) {
 }
 function validateListTablesResponse(value) {
   if (!isRecord(value) || !Array.isArray(value.identifiers)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg REST list tables response");
+    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 LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg REST table identifier");
+      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 LaQLError("LAQL_CATALOG_ERROR", "Iceberg metadata must be an object");
+    throw new LakeqlError("LAKEQL_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", {
+    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 LaQLError("LAQL_CATALOG_ERROR", "Iceberg metadata is missing snapshots or schemas");
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg metadata is missing snapshots or schemas");
   }
   if (!isMetadataFile(value)) {
-    throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg metadata has invalid required fields");
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg metadata has invalid required fields");
   }
   rejectUnsupportedMetadataFeatures(value);
   return value;
@@ -1165,7 +1480,7 @@ function rejectAdvertisedFeatureFlags(metadata) {
     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", {
+    throw new LakeqlError("LAKEQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg metadata advertises unsupported table-format features", {
       featureProperty: key,
       features
     });
@@ -1175,18 +1490,18 @@ 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");
+    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 LaQLError("LAQL_CATALOG_ERROR", "Iceberg partition spec is invalid");
+      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 LaQLError("LAQL_CATALOG_ERROR", "Iceberg partition field is invalid");
+        throw new LakeqlError("LAKEQL_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", {
+        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
@@ -1199,14 +1514,14 @@ 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");
+    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 LaQLError("LAQL_CATALOG_ERROR", "Iceberg sort order is invalid");
+      throw new LakeqlError("LAKEQL_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", {
+      throw new LakeqlError("LAKEQL_UNSUPPORTED_ICEBERG_FEATURE", "Iceberg sorted table metadata is not supported for strict planning", {
         orderId: order["order-id"],
         fields: order.fields
       });
@@ -1224,7 +1539,7 @@ function projectedIds(fields, select) {
   return select.map((name) => {
     const field = fields.find((candidate) => candidate.name === name);
     if (!field) {
-      throw new LaQLError("LAQL_UNKNOWN_COLUMN", `Unknown Iceberg column ${name}`, {
+      throw new LakeqlError("LAKEQL_UNKNOWN_COLUMN", `Unknown Iceberg column ${name}`, {
         column: name
       });
     }
@@ -1241,7 +1556,7 @@ function partitionMayMatch(expr, partition) {
   try {
     return matches(expr, partition);
   } catch (cause) {
-    if (cause instanceof LaQLError && cause.code === "LAQL_TYPE_ERROR")
+    if (cause instanceof LakeqlError && cause.code === "LAKEQL_TYPE_ERROR")
       return true;
     throw cause;
   }
@@ -1376,4 +1691,4 @@ async function* projectIcebergParquetBatches(store, table, path, partition, snap
   }
 }
 
-export { IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, ObjectStoreIcebergCommitCatalog, PACKAGE, applyIcebergDeletes, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, planFiles2 as planFiles, scanBatches, scanPlannedIcebergRows, scanRows };
+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 };