lakeql 0.1.7 → 0.1.8

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createParquetLake, readParquetMetadata, memoryStore, writePartitionedParquet, broadcastJoin, createOutputManifest, partitionedParquetOutputEntries, fingerprint, writeOutputManifest } from './chunk-RZL45ZSN.js';
+import { createParquetLake, readParquetMetadata, memoryStore, writePartitionedParquet, broadcastJoin, createOutputManifest, partitionedParquetOutputEntries, fingerprint, writeOutputManifest } from './chunk-MXGEAVHL.js';
 import { __commonJS, __toESM, LakeqlError, matches, evaluate, isTimestampValue } from './chunk-TFD5RFKB.js';
 import { readFile, mkdir, writeFile } from 'fs/promises';
 import { dirname } from 'path';

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

@@ -1,4 +1,4 @@
-import { Lake, stableStringify, vectorValue, scalarVectorValue, batchFromColumns, withObjectStoreReadControls, throwIfAborted, readControlSignal, readParquetObjectBatches, readIcebergParquetDeletes } from './chunk-RZL45ZSN.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
@@ -157,6 +157,92 @@ function projectPhysicalColumns(row, columns) {
   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);
@@ -581,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 LakeqlError("LAKEQL_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({
@@ -641,7 +751,7 @@ var IcebergRestCatalog = class {
       return { committed: false };
     if (!response.ok) {
       throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST table commit failed", {
-        url: this.tableUrl(),
+        url: tableUrl,
         status: response.status,
         statusText: response.statusText
       });
@@ -653,9 +763,12 @@ 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 LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST catalog request failed", {
@@ -665,7 +778,7 @@ var IcebergRestCatalog = class {
       });
     }
     try {
-      return await response.json();
+      return { body: await response.json(), headers: response.headers };
     } catch (cause) {
       throw new LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg REST catalog response is not JSON", {
         url,
@@ -681,14 +794,50 @@ var IcebergRestCatalog = class {
       headers.set("authorization", `Bearer ${this.token}`);
     return headers;
   }
-  tableUrl() {
-    return restCatalogUrl(this.url, [...this.namespaceTableSegments(), this.table]);
+  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;
   }
-  namespaceTablesUrl() {
-    return restCatalogUrl(this.url, this.namespaceTableSegments());
+  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) {
@@ -703,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() {
@@ -743,7 +892,7 @@ async function loadIcebergTable(options) {
   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 LakeqlError)
       throw cause;
@@ -761,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 = {};
@@ -919,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);
@@ -982,14 +1202,14 @@ async function readManifestList(store, path) {
     });
   }
 }
-async function readManifest(store, path, tablePrefix = "") {
+async function readManifest(store, path, tableLocation = tableLocationRef("")) {
   const bytes = await store.get(path);
   if (!bytes) {
     throw new LakeqlError("LAKEQL_OBJECT_NOT_FOUND", `No Iceberg manifest at ${path}`, { path });
   }
   try {
     const manifest = avroObjectContainer(bytes) ? validateAvroManifest(await decodeAvroObjectContainer(bytes), path) : validateManifest(JSON.parse(new TextDecoder().decode(bytes)), path);
-    return validateManifestPaths(manifest, path, tablePrefix);
+    return validateManifestPaths(manifest, path, tableLocation);
   } catch (cause) {
     if (cause instanceof LakeqlError)
       throw cause;
@@ -1058,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)) {
@@ -1167,57 +1387,95 @@ function validateManifestContent(content, 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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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 LakeqlError("LAKEQL_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, "");
@@ -1433,6 +1691,9 @@ function cloneManifestOrReference(manifest) {
   }
   return cloneManifest(manifest);
 }
+function cloneManifestReferences(manifests) {
+  return manifests.map(cloneManifestOrReference);
+}
 function snapshotManifests(snapshot) {
   return snapshot.manifests ?? [];
 }
@@ -1453,6 +1714,71 @@ function validateListTablesResponse(value) {
     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 LakeqlError("LAKEQL_CATALOG_ERROR", "Iceberg metadata must be an object");
@@ -1691,4 +2017,4 @@ async function* projectIcebergParquetBatches(store, table, path, partition, snap
   }
 }
 
-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 };
+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 };