lakeql 0.1.2 → 0.1.8

package/dist/{chunk-MUTXXFOW.js → chunk-5K5JMJ2M.js}

@@ -1,7 +1,402 @@
-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-MXGEAVHL.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/object-store-json-cache.js
+var ObjectStoreJsonCache = class {
+  store;
+  prefix;
+  ttlMs;
+  now;
+  constructor(options) {
+    this.store = options.store;
+    this.prefix = normalizeCachePrefix(options.prefix);
+    this.ttlMs = options.ttlMs;
+    this.now = options.now ?? Date.now;
+  }
+  async get(key) {
+    const path = this.pathFor(key);
+    const bytes = await this.store.get(path);
+    if (bytes === null)
+      return void 0;
+    let parsed;
+    try {
+      parsed = JSON.parse(new TextDecoder().decode(bytes));
+    } catch (cause) {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Invalid JSON cache entry at ${path}`, {
+        path,
+        cause
+      });
+    }
+    if (!isStoredJsonCacheEntry(parsed)) {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", `Invalid JSON cache entry at ${path}`, {
+        path
+      });
+    }
+    if (parsed.expiresAt !== void 0 && parsed.expiresAt <= this.now()) {
+      await this.store.delete(path);
+      return void 0;
+    }
+    const entry = { value: parsed.value };
+    if (parsed.expiresAt !== void 0)
+      entry.expiresAt = parsed.expiresAt;
+    return entry;
+  }
+  async set(key, entry) {
+    if (entry.value === void 0) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", "JSON cache value is not JSON serializable", {
+        key
+      });
+    }
+    const stored = { value: entry.value };
+    if (entry.expiresAt !== void 0) {
+      stored.expiresAt = entry.expiresAt;
+    } else if (this.ttlMs !== void 0) {
+      stored.expiresAt = this.now() + this.ttlMs;
+    }
+    let json;
+    try {
+      json = JSON.stringify(stored);
+    } catch (cause) {
+      throw new LakeqlError("LAKEQL_TYPE_ERROR", "JSON cache value is not JSON serializable", {
+        key,
+        cause
+      });
+    }
+    await this.store.put(this.pathFor(key), new TextEncoder().encode(json), {
+      contentType: "application/json"
+    });
+  }
+  async delete(key) {
+    await this.store.delete(this.pathFor(key));
+  }
+  pathFor(key) {
+    return `${this.prefix}/${encodeURIComponent(key)}.json`;
+  }
+};
+function objectStoreJsonCache(options) {
+  return new ObjectStoreJsonCache(options);
+}
+function normalizeCachePrefix(prefix) {
+  const trimmed = prefix.replace(/^\/+|\/+$/g, "");
+  if (trimmed === "") {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "JSON cache prefix must be non-empty");
+  }
+  return trimmed;
+}
+function isStoredJsonCacheEntry(value) {
+  return typeof value === "object" && value !== null && "value" in value;
+}
+
+// ../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 +412,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 +421,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 +432,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 +478,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 +522,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 +569,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 +594,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 +617,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 +638,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
       });
     }
@@ -270,37 +667,61 @@ var IcebergRestCatalog = class {
   url;
   namespace;
   table;
-  prefix;
+  explicitPrefix;
+  warehouse;
+  accessDelegation;
   token;
   fetchFn;
+  configPromise;
+  prefixPromise;
   constructor(options) {
     this.url = options.url;
     this.namespace = namespaceParts(options.namespace);
     this.table = requiredNonEmptyString(options.table, "table");
-    this.prefix = catalogPrefixParts(options.prefix);
+    this.explicitPrefix = options.prefix === void 0 ? void 0 : catalogPrefixParts(options.prefix);
+    this.warehouse = options.warehouse === void 0 ? void 0 : requiredNonEmptyString(options.warehouse, "warehouse");
+    this.accessDelegation = options.accessDelegation?.join(",");
     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 LaQLError("LAQL_CATALOG_ERROR", "Invalid Iceberg REST load table response", {
-        url: this.tableUrl()
+  async loadTable(store, options = {}) {
+    const response = await this.loadTableResult();
+    const readControls = loadReadControls(options);
+    const controlledStore = withObjectStoreReadControls(store, readControls);
+    return new IcebergTable(controlledStore, response["metadata-location"], await hydrateMetadataManifests(controlledStore, response.metadata, readControls, options.cache));
+  }
+  async loadTableResult(options = {}) {
+    const url = await this.tableUrl(options.snapshots);
+    const headers = this.headers(false);
+    if (this.accessDelegation !== void 0)
+      headers.set("X-Iceberg-Access-Delegation", this.accessDelegation);
+    if (options.ifNoneMatch !== void 0)
+      headers.set("If-None-Match", options.ifNoneMatch);
+    const response = await this.requestJsonResponse(url, { method: "GET", headers });
+    return validateRestLoadTableResult(response.body, url, response.headers.get("etag"));
+  }
+  async loadConfig() {
+    if (this.configPromise === void 0) {
+      const url = this.configUrl();
+      this.configPromise = this.requestJson(url, { method: "GET" }).then((body) => validateRestCatalogConfig(body, url)).catch((cause) => {
+        this.configPromise = void 0;
+        throw cause;
       });
     }
-    return new IcebergTable(store, response["metadata-location"], await hydrateMetadataManifests(store, validateMetadata(response.metadata)));
+    return await this.configPromise;
   }
   async listTables() {
-    return validateListTablesResponse(await this.requestJson(this.namespaceTablesUrl(), {
+    return validateListTablesResponse(await this.requestJson(await this.namespaceTablesUrl(), {
       method: "GET"
     }));
   }
   async commitAppend(input) {
+    const tableUrl = await this.tableUrl();
     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(), {
+    const response = await this.fetchFn(tableUrl, {
       method: "POST",
       headers: this.headers(true),
       body: JSON.stringify({
@@ -329,8 +750,8 @@ var IcebergRestCatalog = class {
     if (response.status === 409)
       return { committed: false };
     if (!response.ok) {
-      throw new LaQLError("LAQL_CATALOG_ERROR", "Iceberg REST table commit failed", {
-        url: this.tableUrl(),
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST table commit failed", {
+        url: tableUrl,
         status: response.status,
         statusText: response.statusText
       });
@@ -342,21 +763,24 @@ var IcebergRestCatalog = class {
     };
   }
   async requestJson(url, init) {
+    return (await this.requestJsonResponse(url, init)).body;
+  }
+  async requestJsonResponse(url, init) {
     const response = await this.fetchFn(url, {
       ...init,
-      headers: this.headers(init.body !== void 0)
+      headers: init.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
       });
     }
     try {
-      return await response.json();
+      return { body: await response.json(), headers: response.headers };
     } 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
       });
@@ -370,14 +794,50 @@ var IcebergRestCatalog = class {
       headers.set("authorization", `Bearer ${this.token}`);
     return headers;
   }
-  tableUrl() {
-    return restCatalogUrl(this.url, [...this.namespaceTableSegments(), this.table]);
-  }
-  namespaceTablesUrl() {
-    return restCatalogUrl(this.url, this.namespaceTableSegments());
+  async tableUrl(snapshots) {
+    const url = new URL(restCatalogUrl(this.url, [...await this.namespaceTableSegments(), this.table]));
+    if (snapshots !== void 0)
+      url.searchParams.set("snapshots", snapshots);
+    return url.toString();
+  }
+  async namespaceTablesUrl() {
+    return restCatalogUrl(this.url, await this.namespaceTableSegments());
+  }
+  async namespaceTableSegments() {
+    return [
+      "v1",
+      ...await this.prefixParts(),
+      "namespaces",
+      this.namespace.join(""),
+      "tables"
+    ];
+  }
+  async prefixParts() {
+    if (this.explicitPrefix !== void 0)
+      return this.explicitPrefix;
+    if (this.warehouse === void 0)
+      return [];
+    if (this.prefixPromise === void 0)
+      this.prefixPromise = this.computePrefixParts();
+    return await this.prefixPromise;
+  }
+  async computePrefixParts() {
+    try {
+      const config = await this.loadConfig();
+      const serverPrefix = config.overrides.prefix ?? config.defaults.prefix;
+      if (serverPrefix !== void 0 && serverPrefix.trim() !== "") {
+        return catalogPrefixParts(serverPrefix);
+      }
+    } catch {
+      return [this.warehouse];
+    }
+    return [this.warehouse];
   }
-  namespaceTableSegments() {
-    return ["v1", ...this.prefix, "namespaces", this.namespace.join(""), "tables"];
+  configUrl() {
+    const url = new URL(restCatalogUrl(this.url, ["v1", "config"]));
+    if (this.warehouse !== void 0)
+      url.searchParams.set("warehouse", this.warehouse);
+    return url.toString();
   }
 };
 function icebergRestCatalog(options) {
@@ -392,7 +852,7 @@ var IcebergUnsupportedCatalog = class {
     this.namespace = namespaceParts(namespace);
     this.table = requiredNonEmptyString(table, "table");
   }
-  async loadTable(_store) {
+  async loadTable(_store, _options = {}) {
     throw this.unsupported("loadTable");
   }
   async listTables() {
@@ -402,7 +862,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,18 +885,18 @@ 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
     });
   }
   throwIfAborted(readControls.signal);
   const text = new TextDecoder().decode(bytes);
   try {
-    return new IcebergTable(store, options.metadataPath, await hydrateMetadataManifests(store, validateMetadata(JSON.parse(text)), readControls));
+    return new IcebergTable(store, options.metadataPath, await hydrateMetadataManifests(store, validateMetadata(JSON.parse(text)), readControls, options.cache));
   } 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
     });
@@ -450,10 +910,23 @@ async function loadIcebergTableFromObjectStore(options) {
   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 });
+  return await loadIcebergTable({
+    store,
+    metadataPath,
+    ...readControls,
+    ...options.cache !== void 0 ? { cache: options.cache } : {}
+  });
 }
 async function loadIcebergTableFromRest(options) {
-  return await icebergRestCatalog(options).loadTable(withObjectStoreReadControls(options.store, loadReadControls(options)));
+  const catalog = icebergRestCatalog(options);
+  const response = await catalog.loadTableResult();
+  const baseStore = options.store ?? (options.storeFactory === void 0 ? void 0 : await options.storeFactory({ ...response, catalog }));
+  if (baseStore === void 0) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Iceberg REST table loading requires a store or storeFactory");
+  }
+  const readControls = loadReadControls(options);
+  const store = withObjectStoreReadControls(baseStore, readControls);
+  return new IcebergTable(store, response["metadata-location"], await hydrateMetadataManifests(store, response.metadata, readControls, options.cache));
 }
 function loadReadControls(options) {
   const controls = {};
@@ -482,7 +955,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 +1039,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 +1058,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
     });
   }
@@ -608,23 +1081,81 @@ function metadataVersionHintPath(metadataPath) {
 function supportsConditionalPut(store) {
   return typeof store.conditionalPut === "function";
 }
-async function hydrateMetadataManifests(store, metadata, controls = {}) {
+async function hydrateMetadataManifests(store, metadata, controls = {}, persistentCache) {
   const hydrated = cloneMetadata(metadata);
-  const tablePrefix = tableLocationObjectPrefix(hydrated.location);
-  for (const snapshot of hydrated.snapshots) {
+  const tableLocation = tableLocationRef(hydrated.location);
+  const cache = {
+    lists: /* @__PURE__ */ new Map(),
+    manifests: /* @__PURE__ */ new Map(),
+    tableCacheKey: icebergTableCacheKey(hydrated)
+  };
+  if (persistentCache !== void 0)
+    cache.persistent = persistentCache;
+  await Promise.all(hydrated.snapshots.map(async (snapshot) => {
     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);
-    }));
+    snapshot.manifests = mergeDeleteManifests(await hydrateSnapshotManifests(store, snapshot, tableLocation, cache, controls));
     throwIfAborted(controls.signal);
-    snapshot.manifests = mergeDeleteManifests(manifests);
-  }
+  }));
   return hydrated;
 }
+async function hydrateSnapshotManifests(store, snapshot, tableLocation, cache, controls) {
+  const manifestReferences = snapshot.manifests ?? (snapshot["manifest-list"] !== void 0 ? await cachedManifestList(store, validateManifestSourcedPath(snapshot["manifest-list"], tableLocation), cache) : []);
+  return await Promise.all(manifestReferences.map(async (manifest) => {
+    throwIfAborted(controls.signal);
+    const manifestPath = validateManifestSourcedPath(manifest.path, tableLocation);
+    if (Array.isArray(manifest.files))
+      return validateManifestPaths(manifest, manifestPath, tableLocation);
+    return await cachedManifest(store, manifestPath, tableLocation, cache);
+  }));
+}
+function cachedManifestList(store, path, cache) {
+  const cached = cache.lists.get(path);
+  if (cached !== void 0)
+    return cached;
+  const key = icebergMetadataCacheKey(cache, "manifest-list", path);
+  const promise = readPersistentCache(cache.persistent, key, cloneManifestReferences).then(async (persistent) => {
+    if (persistent !== void 0)
+      return persistent;
+    const manifests = await readManifestList(store, path);
+    await cache.persistent?.set(key, { value: manifests.map(cloneManifestOrReference) });
+    return manifests;
+  }).catch((cause) => {
+    cache.lists.delete(path);
+    throw cause;
+  });
+  cache.lists.set(path, promise);
+  return promise;
+}
+function cachedManifest(store, path, tableLocation, cache) {
+  const cached = cache.manifests.get(path);
+  if (cached !== void 0)
+    return cached;
+  const key = icebergMetadataCacheKey(cache, "manifest", path);
+  const promise = readPersistentCache(cache.persistent, key, cloneManifest).then(async (persistent) => {
+    if (persistent !== void 0)
+      return validateManifestPaths(persistent, path, tableLocation);
+    const manifest = await readManifest(store, path, tableLocation);
+    await cache.persistent?.set(key, { value: cloneManifest(manifest) });
+    return manifest;
+  }).catch((cause) => {
+    cache.manifests.delete(path);
+    throw cause;
+  });
+  cache.manifests.set(path, promise);
+  return promise;
+}
+async function readPersistentCache(cache, key, clone) {
+  const entry = await cache?.get(key);
+  if (entry === void 0)
+    return void 0;
+  return clone(entry.value);
+}
+function icebergTableCacheKey(metadata) {
+  return `${metadata["table-uuid"]}:${metadata.location}`;
+}
+function icebergMetadataCacheKey(cache, kind, path) {
+  return `iceberg:${cache.tableCacheKey}:${kind}:${path}`;
+}
 function mergeDeleteManifests(manifests) {
   const deleteFiles = manifests.flatMap((manifest) => manifest.deleteFiles ?? []);
   const dataManifests = manifests.filter((manifest) => manifest.files.length > 0);
@@ -656,31 +1187,33 @@ 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
     });
   }
 }
-async function readManifest(store, path, tablePrefix = "") {
+async function readManifest(store, path, tableLocation = tableLocationRef("")) {
   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);
+    return validateManifestPaths(manifest, path, tableLocation);
   } 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 +1222,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 +1235,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 +1243,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
       });
     }
@@ -745,7 +1278,7 @@ function validateAvroManifest(records, path) {
   const manifest = { path, files };
   if (deleteFiles.length > 0)
     manifest.deleteFiles = deleteFiles;
-  return validateManifestPaths(manifest, path);
+  return manifest;
 }
 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)) {
@@ -819,7 +1352,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 +1360,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 +1368,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,62 +1382,100 @@ 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
   });
 }
-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);
+function validateManifestPaths(manifest, path, tableLocation = tableLocationRef("")) {
+  validateManifestSourcedPath(manifest.path, tableLocation);
+  return {
+    ...manifest,
+    path,
+    files: manifest.files.map((file) => ({
+      ...file,
+      path: validateManifestSourcedPath(file.path, tableLocation),
+      ...file.deleteFiles !== void 0 ? {
+        deleteFiles: file.deleteFiles.map((deleteFile) => ({
+          ...deleteFile,
+          path: validateManifestSourcedPath(deleteFile.path, tableLocation)
+        }))
+      } : {}
+    })),
+    ...manifest.deleteFiles !== void 0 ? {
+      deleteFiles: manifest.deleteFiles.map((deleteFile) => ({
+        ...deleteFile,
+        path: validateManifestSourcedPath(deleteFile.path, tableLocation)
+      }))
+    } : {}
+  };
+}
+function validateManifestSourcedPath(path, tableLocation = tableLocationRef("")) {
+  const normalized = normalizeManifestSourcedPath(path, tableLocation);
+  validateRelativeObjectPath(normalized, path);
+  if (tableLocation.prefix !== "" && normalized !== tableLocation.prefix && !normalized.startsWith(`${tableLocation.prefix}/`)) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path escapes table location: ${path}`, {
+      path,
+      tableLocation: tableLocation.prefix
+    });
   }
-  return { ...manifest, path };
+  return normalized;
 }
-function validateManifestSourcedPath(path, tablePrefix = "") {
+function normalizeManifestSourcedPath(path, tableLocation) {
   if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//iu.test(path) || path.startsWith("/")) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path must be relative: ${path}`, {
-      path
-    });
+    if (tableLocation.uriAuthority === void 0) {
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path must be relative: ${path}`, {
+        path
+      });
+    }
+    let url;
+    try {
+      url = new URL(path);
+    } catch {
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path is invalid: ${path}`, {
+        path
+      });
+    }
+    const authority = `${url.protocol}//${url.host}`;
+    if (authority !== tableLocation.uriAuthority) {
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path escapes table location: ${path}`, {
+        path,
+        tableLocation: tableLocation.uriAuthority
+      });
+    }
+    return trimSlashes(decodeURIComponent(url.pathname));
   }
+  return path;
+}
+function validateRelativeObjectPath(path, originalPath) {
   for (const segment of path.split("/")) {
     let decoded;
     try {
       decoded = decodeURIComponent(segment);
     } catch {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path is invalid: ${path}`, {
-        path
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path is invalid: ${originalPath}`, {
+        path: originalPath
       });
     }
     if (decoded === "." || decoded === "..") {
-      throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path contains traversal: ${path}`, {
-        path
+      throw new LakeqlError("LAKEQL_VALIDATION_ERROR", `Iceberg manifest path contains traversal: ${originalPath}`, {
+        path: originalPath
       });
     }
   }
-  if (tablePrefix !== "" && path !== tablePrefix && !path.startsWith(`${tablePrefix}/`)) {
-    throw new LaQLError("LAQL_VALIDATION_ERROR", `Iceberg manifest path escapes table location: ${path}`, {
-      path,
-      tableLocation: tablePrefix
-    });
-  }
-  return path;
 }
-function tableLocationObjectPrefix(location) {
+function tableLocationRef(location) {
   const trimmed = trimTrailingSlash(location.trim());
   if (trimmed === "" || !trimmed.includes("/"))
-    return "";
+    return { prefix: "" };
   if (/^[a-z][a-z0-9+.-]*:\/\//iu.test(trimmed)) {
     const url = new URL(trimmed);
-    return trimSlashes(decodeURIComponent(url.pathname));
+    return {
+      prefix: trimSlashes(decodeURIComponent(url.pathname)),
+      uriAuthority: `${url.protocol}//${url.host}`
+    };
   }
-  return trimSlashes(trimmed);
+  return { prefix: trimSlashes(trimmed) };
 }
 function trimSlashes(value) {
   return value.replace(/^\/+|\/+$/gu, "");
@@ -915,7 +1488,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 +1510,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 +1530,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 +1542,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 +1562,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 +1580,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
       });
     }
@@ -1118,6 +1691,9 @@ function cloneManifestOrReference(manifest) {
   }
   return cloneManifest(manifest);
 }
+function cloneManifestReferences(manifests) {
+  return manifests.map(cloneManifestOrReference);
+}
 function snapshotManifests(snapshot) {
   return snapshot.manifests ?? [];
 }
@@ -1129,28 +1705,93 @@ 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 validateRestLoadTableResult(value, url, etag) {
+  if (!isRecord(value) || typeof value["metadata-location"] !== "string") {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg REST load table response", {
+      url
+    });
+  }
+  return {
+    "metadata-location": value["metadata-location"],
+    metadata: validateMetadata(value.metadata),
+    config: validateStringRecord(value.config, "Iceberg REST load table config"),
+    "storage-credentials": validateStorageCredentials(value["storage-credentials"]),
+    etag
+  };
+}
+function validateRestCatalogConfig(value, url) {
+  if (!isRecord(value)) {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg REST catalog config response", {
+      url
+    });
+  }
+  const config = {
+    defaults: validateStringRecord(value.defaults, "Iceberg REST catalog defaults"),
+    overrides: validateStringRecord(value.overrides, "Iceberg REST catalog overrides")
+  };
+  if (Array.isArray(value.endpoints) && value.endpoints.every((endpoint) => typeof endpoint === "string")) {
+    config.endpoints = value.endpoints;
+  }
+  if (typeof value["idempotency-key-lifetime"] === "string") {
+    config["idempotency-key-lifetime"] = value["idempotency-key-lifetime"];
+  }
+  return config;
+}
+function validateStorageCredentials(value) {
+  if (value === void 0)
+    return [];
+  if (!Array.isArray(value)) {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg REST storage credentials");
+  }
+  return value.map((credential) => {
+    if (!isRecord(credential) || typeof credential.prefix !== "string") {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Invalid Iceberg REST storage credential");
+    }
+    return {
+      prefix: credential.prefix,
+      config: validateStringRecord(credential.config, "Iceberg REST storage credential config")
+    };
+  });
+}
+function validateStringRecord(value, label) {
+  if (value === void 0)
+    return {};
+  if (!isRecord(value)) {
+    throw new LakeqlError("LAKEQL_CATALOG_ERROR", `${label} must be an object`);
+  }
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry !== "string") {
+      throw new LakeqlError("LAKEQL_CATALOG_ERROR", `${label} values must be strings`, {
+        key
+      });
+    }
+    out[key] = entry;
+  }
+  return out;
+}
 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 +1806,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 +1816,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 +1840,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 +1865,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 +1882,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 +2017,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, ObjectStoreJsonCache, PACKAGE, applyIcebergDeletes, createInMemoryLake, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, inMemoryRowsScanner, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, objectStoreJsonCache, planFiles2 as planFiles, scanBatches, scanPlannedIcebergRows, scanRows, vectorHashJoin };