@slatedb/uniffi 0.12.0 → 0.13.0

package/slatedb.js

@@ -486,6 +486,34 @@ export const LogLevel = Object.freeze({
   "Trace": "Trace",
 });
 
+/**
+ * Compaction lifecycle state.
+ */
+export const CompactionStatus = Object.freeze({
+  "Submitted": "Submitted",
+  "Running": "Running",
+  "Completed": "Completed",
+  "Failed": "Failed",
+});
+
+/**
+ * Compression codec used for an SSTable.
+ */
+export const CompressionCodec = Object.freeze({
+  "Snappy": "Snappy",
+  "Zlib": "Zlib",
+  "Lz4": "Lz4",
+  "Zstd": "Zstd",
+});
+
+/**
+ * Filter block format stored in SST metadata.
+ */
+export const FilterFormat = Object.freeze({
+  "Legacy": "Legacy",
+  "Composite": "Composite",
+});
+
 /**
  * Kind of row entry stored in WAL iteration results.
  */
@@ -504,6 +532,14 @@ export const RowEntryKind = Object.freeze({
   "Merge": "Merge",
 });
 
+/**
+ * Physical SSTable type.
+ */
+export const SstType = Object.freeze({
+  "Compacted": "Compacted",
+  "Wal": "Wal",
+});
+
 /**
  * Time-to-live policy applied to an inserted value or merge operand.
  */
@@ -586,6 +622,94 @@ export const MetricValue = Object.freeze({
   },
 });
 
+/**
+ * Cache content that [`crate::Db::warm_sst`] should populate.
+ */
+export const CacheTarget = Object.freeze({
+  /**
+   * Warm all filters on the SST, if any exist.
+   */
+  Filters() {
+    return Object.freeze({
+      tag: "Filters",
+    });
+  },
+  /**
+   * Warm the SST index.
+   */
+  Index() {
+    return Object.freeze({
+      tag: "Index",
+    });
+  },
+  /**
+   * Warm the SST stats block, if one exists.
+   */
+  Stats() {
+    return Object.freeze({
+      tag: "Stats",
+    });
+  },
+  /**
+   * Warm the SST data blocks that overlap `range`. Also warms the index,
+   * since block planning depends on it.
+   */
+  Data(range) {
+    return Object.freeze({
+      tag: "Data",
+      "range": range,
+    });
+  },
+});
+
+/**
+ * Compaction input source identifier.
+ */
+export const SourceId = Object.freeze({
+  /**
+   * Existing sorted run ID.
+   */
+  SortedRun(_) {
+    return Object.freeze({
+      tag: "SortedRun",
+      "": _,
+    });
+  },
+  /**
+   * L0 SST view ULID string.
+   */
+  SstView(_) {
+    return Object.freeze({
+      tag: "SstView",
+      "": _,
+    });
+  },
+});
+
+/**
+ * SSTable identifier.
+ */
+export const SsTableId = Object.freeze({
+  /**
+   * WAL SST identified by numeric WAL ID.
+   */
+  Wal(_) {
+    return Object.freeze({
+      tag: "Wal",
+      "": _,
+    });
+  },
+  /**
+   * Compacted SST identified by ULID string.
+   */
+  Compacted(_) {
+    return Object.freeze({
+      tag: "Compacted",
+      "": _,
+    });
+  },
+});
+
 /**
  * Error type returned by the UniFFI bindings.
  */
@@ -825,6 +949,46 @@ const FfiConverterWriteOptions = new (class extends AbstractFfiConverterByteArra
     };
   }
 })();
+const FfiConverterFoyerCacheOptions = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("FoyerCacheOptions", value);
+    return FfiConverterUInt64.allocationSize(recordValue["max_capacity"]) + FfiConverterUInt64.allocationSize(recordValue["shards"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("FoyerCacheOptions", value);
+    FfiConverterUInt64.write(recordValue["max_capacity"], writer);
+    FfiConverterUInt64.write(recordValue["shards"], writer);
+  }
+
+  read(reader) {
+    return {
+      "max_capacity": FfiConverterUInt64.read(reader),
+      "shards": FfiConverterUInt64.read(reader),
+    };
+  }
+})();
+const FfiConverterMokaCacheOptions = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("MokaCacheOptions", value);
+    return FfiConverterUInt64.allocationSize(recordValue["max_capacity"]) + uniffiOptionalConverter(FfiConverterUInt64).allocationSize(recordValue["time_to_live"]) + uniffiOptionalConverter(FfiConverterUInt64).allocationSize(recordValue["time_to_idle"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("MokaCacheOptions", value);
+    FfiConverterUInt64.write(recordValue["max_capacity"], writer);
+    uniffiOptionalConverter(FfiConverterUInt64).write(recordValue["time_to_live"], writer);
+    uniffiOptionalConverter(FfiConverterUInt64).write(recordValue["time_to_idle"], writer);
+  }
+
+  read(reader) {
+    return {
+      "max_capacity": FfiConverterUInt64.read(reader),
+      "time_to_live": uniffiOptionalConverter(FfiConverterUInt64).read(reader),
+      "time_to_idle": uniffiOptionalConverter(FfiConverterUInt64).read(reader),
+    };
+  }
+})();
 const FfiConverterLogRecord = new (class extends AbstractFfiConverterByteArray {
   allocationSize(value) {
     const recordValue = uniffiRequireRecordObject("LogRecord", value);
@@ -921,6 +1085,100 @@ const FfiConverterMetricLabel = new (class extends AbstractFfiConverterByteArray
     };
   }
 })();
+const FfiConverterCheckpoint = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("Checkpoint", value);
+    return FfiConverterString.allocationSize(recordValue["id"]) + FfiConverterUInt64.allocationSize(recordValue["manifest_id"]) + uniffiOptionalConverter(FfiConverterInt64).allocationSize(recordValue["expire_time_secs"]) + FfiConverterInt64.allocationSize(recordValue["create_time_secs"]) + uniffiOptionalConverter(FfiConverterString).allocationSize(recordValue["name"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("Checkpoint", value);
+    FfiConverterString.write(recordValue["id"], writer);
+    FfiConverterUInt64.write(recordValue["manifest_id"], writer);
+    uniffiOptionalConverter(FfiConverterInt64).write(recordValue["expire_time_secs"], writer);
+    FfiConverterInt64.write(recordValue["create_time_secs"], writer);
+    uniffiOptionalConverter(FfiConverterString).write(recordValue["name"], writer);
+  }
+
+  read(reader) {
+    return {
+      "id": FfiConverterString.read(reader),
+      "manifest_id": FfiConverterUInt64.read(reader),
+      "expire_time_secs": uniffiOptionalConverter(FfiConverterInt64).read(reader),
+      "create_time_secs": FfiConverterInt64.read(reader),
+      "name": uniffiOptionalConverter(FfiConverterString).read(reader),
+    };
+  }
+})();
+const FfiConverterCompaction = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("Compaction", value);
+    return FfiConverterString.allocationSize(recordValue["id"]) + FfiConverterCompactionSpec.allocationSize(recordValue["spec"]) + FfiConverterUInt64.allocationSize(recordValue["bytes_processed"]) + FfiConverterCompactionStatus.allocationSize(recordValue["status"]) + uniffiArrayConverter(FfiConverterSsTableHandle).allocationSize(recordValue["output_ssts"]) + FfiConverterBool.allocationSize(recordValue["active"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("Compaction", value);
+    FfiConverterString.write(recordValue["id"], writer);
+    FfiConverterCompactionSpec.write(recordValue["spec"], writer);
+    FfiConverterUInt64.write(recordValue["bytes_processed"], writer);
+    FfiConverterCompactionStatus.write(recordValue["status"], writer);
+    uniffiArrayConverter(FfiConverterSsTableHandle).write(recordValue["output_ssts"], writer);
+    FfiConverterBool.write(recordValue["active"], writer);
+  }
+
+  read(reader) {
+    return {
+      "id": FfiConverterString.read(reader),
+      "spec": FfiConverterCompactionSpec.read(reader),
+      "bytes_processed": FfiConverterUInt64.read(reader),
+      "status": FfiConverterCompactionStatus.read(reader),
+      "output_ssts": uniffiArrayConverter(FfiConverterSsTableHandle).read(reader),
+      "active": FfiConverterBool.read(reader),
+    };
+  }
+})();
+const FfiConverterCompactionSpec = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("CompactionSpec", value);
+    return uniffiArrayConverter(FfiConverterSourceId).allocationSize(recordValue["sources"]) + uniffiOptionalConverter(FfiConverterUInt32).allocationSize(recordValue["destination"]) + FfiConverterBool.allocationSize(recordValue["has_l0_sources"]) + FfiConverterBool.allocationSize(recordValue["has_sr_sources"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("CompactionSpec", value);
+    uniffiArrayConverter(FfiConverterSourceId).write(recordValue["sources"], writer);
+    uniffiOptionalConverter(FfiConverterUInt32).write(recordValue["destination"], writer);
+    FfiConverterBool.write(recordValue["has_l0_sources"], writer);
+    FfiConverterBool.write(recordValue["has_sr_sources"], writer);
+  }
+
+  read(reader) {
+    return {
+      "sources": uniffiArrayConverter(FfiConverterSourceId).read(reader),
+      "destination": uniffiOptionalConverter(FfiConverterUInt32).read(reader),
+      "has_l0_sources": FfiConverterBool.read(reader),
+      "has_sr_sources": FfiConverterBool.read(reader),
+    };
+  }
+})();
+const FfiConverterCompactorStateView = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("CompactorStateView", value);
+    return uniffiOptionalConverter(FfiConverterVersionedCompactions).allocationSize(recordValue["compactions"]) + FfiConverterVersionedManifest.allocationSize(recordValue["manifest"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("CompactorStateView", value);
+    uniffiOptionalConverter(FfiConverterVersionedCompactions).write(recordValue["compactions"], writer);
+    FfiConverterVersionedManifest.write(recordValue["manifest"], writer);
+  }
+
+  read(reader) {
+    return {
+      "compactions": uniffiOptionalConverter(FfiConverterVersionedCompactions).read(reader),
+      "manifest": FfiConverterVersionedManifest.read(reader),
+    };
+  }
+})();
 const FfiConverterDbStatus = new (class extends AbstractFfiConverterByteArray {
   allocationSize(value) {
     const recordValue = uniffiRequireRecordObject("DbStatus", value);
@@ -940,6 +1198,29 @@ const FfiConverterDbStatus = new (class extends AbstractFfiConverterByteArray {
     };
   }
 })();
+const FfiConverterExternalDb = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("ExternalDb", value);
+    return FfiConverterString.allocationSize(recordValue["path"]) + FfiConverterString.allocationSize(recordValue["source_checkpoint_id"]) + uniffiOptionalConverter(FfiConverterString).allocationSize(recordValue["final_checkpoint_id"]) + uniffiArrayConverter(FfiConverterSsTableId).allocationSize(recordValue["sst_ids"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("ExternalDb", value);
+    FfiConverterString.write(recordValue["path"], writer);
+    FfiConverterString.write(recordValue["source_checkpoint_id"], writer);
+    uniffiOptionalConverter(FfiConverterString).write(recordValue["final_checkpoint_id"], writer);
+    uniffiArrayConverter(FfiConverterSsTableId).write(recordValue["sst_ids"], writer);
+  }
+
+  read(reader) {
+    return {
+      "path": FfiConverterString.read(reader),
+      "source_checkpoint_id": FfiConverterString.read(reader),
+      "final_checkpoint_id": uniffiOptionalConverter(FfiConverterString).read(reader),
+      "sst_ids": uniffiArrayConverter(FfiConverterSsTableId).read(reader),
+    };
+  }
+})();
 const FfiConverterKeyRange = new (class extends AbstractFfiConverterByteArray {
   allocationSize(value) {
     const recordValue = uniffiRequireRecordObject("KeyRange", value);
@@ -1015,6 +1296,176 @@ const FfiConverterRowEntry = new (class extends AbstractFfiConverterByteArray {
     };
   }
 })();
+const FfiConverterSortedRun = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("SortedRun", value);
+    return FfiConverterUInt32.allocationSize(recordValue["id"]) + uniffiArrayConverter(FfiConverterSsTableView).allocationSize(recordValue["sst_views"]) + FfiConverterUInt64.allocationSize(recordValue["estimated_size_bytes"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("SortedRun", value);
+    FfiConverterUInt32.write(recordValue["id"], writer);
+    uniffiArrayConverter(FfiConverterSsTableView).write(recordValue["sst_views"], writer);
+    FfiConverterUInt64.write(recordValue["estimated_size_bytes"], writer);
+  }
+
+  read(reader) {
+    return {
+      "id": FfiConverterUInt32.read(reader),
+      "sst_views": uniffiArrayConverter(FfiConverterSsTableView).read(reader),
+      "estimated_size_bytes": FfiConverterUInt64.read(reader),
+    };
+  }
+})();
+const FfiConverterSsTableHandle = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("SsTableHandle", value);
+    return FfiConverterSsTableId.allocationSize(recordValue["id"]) + FfiConverterSsTableInfo.allocationSize(recordValue["info"]) + FfiConverterUInt64.allocationSize(recordValue["estimated_size_bytes"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("SsTableHandle", value);
+    FfiConverterSsTableId.write(recordValue["id"], writer);
+    FfiConverterSsTableInfo.write(recordValue["info"], writer);
+    FfiConverterUInt64.write(recordValue["estimated_size_bytes"], writer);
+  }
+
+  read(reader) {
+    return {
+      "id": FfiConverterSsTableId.read(reader),
+      "info": FfiConverterSsTableInfo.read(reader),
+      "estimated_size_bytes": FfiConverterUInt64.read(reader),
+    };
+  }
+})();
+const FfiConverterSsTableInfo = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("SsTableInfo", value);
+    return uniffiOptionalConverter(FfiConverterBytes).allocationSize(recordValue["first_entry"]) + uniffiOptionalConverter(FfiConverterBytes).allocationSize(recordValue["last_entry"]) + FfiConverterUInt64.allocationSize(recordValue["index_offset"]) + FfiConverterUInt64.allocationSize(recordValue["index_len"]) + FfiConverterUInt64.allocationSize(recordValue["filter_offset"]) + FfiConverterUInt64.allocationSize(recordValue["filter_len"]) + uniffiOptionalConverter(FfiConverterCompressionCodec).allocationSize(recordValue["compression_codec"]) + FfiConverterSstType.allocationSize(recordValue["sst_type"]) + FfiConverterUInt64.allocationSize(recordValue["stats_offset"]) + FfiConverterUInt64.allocationSize(recordValue["stats_len"]) + FfiConverterFilterFormat.allocationSize(recordValue["filter_format"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("SsTableInfo", value);
+    uniffiOptionalConverter(FfiConverterBytes).write(recordValue["first_entry"], writer);
+    uniffiOptionalConverter(FfiConverterBytes).write(recordValue["last_entry"], writer);
+    FfiConverterUInt64.write(recordValue["index_offset"], writer);
+    FfiConverterUInt64.write(recordValue["index_len"], writer);
+    FfiConverterUInt64.write(recordValue["filter_offset"], writer);
+    FfiConverterUInt64.write(recordValue["filter_len"], writer);
+    uniffiOptionalConverter(FfiConverterCompressionCodec).write(recordValue["compression_codec"], writer);
+    FfiConverterSstType.write(recordValue["sst_type"], writer);
+    FfiConverterUInt64.write(recordValue["stats_offset"], writer);
+    FfiConverterUInt64.write(recordValue["stats_len"], writer);
+    FfiConverterFilterFormat.write(recordValue["filter_format"], writer);
+  }
+
+  read(reader) {
+    return {
+      "first_entry": uniffiOptionalConverter(FfiConverterBytes).read(reader),
+      "last_entry": uniffiOptionalConverter(FfiConverterBytes).read(reader),
+      "index_offset": FfiConverterUInt64.read(reader),
+      "index_len": FfiConverterUInt64.read(reader),
+      "filter_offset": FfiConverterUInt64.read(reader),
+      "filter_len": FfiConverterUInt64.read(reader),
+      "compression_codec": uniffiOptionalConverter(FfiConverterCompressionCodec).read(reader),
+      "sst_type": FfiConverterSstType.read(reader),
+      "stats_offset": FfiConverterUInt64.read(reader),
+      "stats_len": FfiConverterUInt64.read(reader),
+      "filter_format": FfiConverterFilterFormat.read(reader),
+    };
+  }
+})();
+const FfiConverterSsTableView = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("SsTableView", value);
+    return FfiConverterString.allocationSize(recordValue["id"]) + FfiConverterSsTableHandle.allocationSize(recordValue["sst"]) + uniffiOptionalConverter(FfiConverterKeyRange).allocationSize(recordValue["visible_range"]) + FfiConverterUInt64.allocationSize(recordValue["estimated_size_bytes"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("SsTableView", value);
+    FfiConverterString.write(recordValue["id"], writer);
+    FfiConverterSsTableHandle.write(recordValue["sst"], writer);
+    uniffiOptionalConverter(FfiConverterKeyRange).write(recordValue["visible_range"], writer);
+    FfiConverterUInt64.write(recordValue["estimated_size_bytes"], writer);
+  }
+
+  read(reader) {
+    return {
+      "id": FfiConverterString.read(reader),
+      "sst": FfiConverterSsTableHandle.read(reader),
+      "visible_range": uniffiOptionalConverter(FfiConverterKeyRange).read(reader),
+      "estimated_size_bytes": FfiConverterUInt64.read(reader),
+    };
+  }
+})();
+const FfiConverterVersionedCompactions = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("VersionedCompactions", value);
+    return FfiConverterUInt64.allocationSize(recordValue["id"]) + FfiConverterUInt64.allocationSize(recordValue["compactor_epoch"]) + uniffiArrayConverter(FfiConverterCompaction).allocationSize(recordValue["recent_compactions"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("VersionedCompactions", value);
+    FfiConverterUInt64.write(recordValue["id"], writer);
+    FfiConverterUInt64.write(recordValue["compactor_epoch"], writer);
+    uniffiArrayConverter(FfiConverterCompaction).write(recordValue["recent_compactions"], writer);
+  }
+
+  read(reader) {
+    return {
+      "id": FfiConverterUInt64.read(reader),
+      "compactor_epoch": FfiConverterUInt64.read(reader),
+      "recent_compactions": uniffiArrayConverter(FfiConverterCompaction).read(reader),
+    };
+  }
+})();
+const FfiConverterVersionedManifest = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const recordValue = uniffiRequireRecordObject("VersionedManifest", value);
+    return FfiConverterUInt64.allocationSize(recordValue["id"]) + FfiConverterUInt64.allocationSize(recordValue["writer_epoch"]) + FfiConverterUInt64.allocationSize(recordValue["compactor_epoch"]) + uniffiArrayConverter(FfiConverterExternalDb).allocationSize(recordValue["external_dbs"]) + FfiConverterBool.allocationSize(recordValue["initialized"]) + uniffiOptionalConverter(FfiConverterString).allocationSize(recordValue["last_compacted_l0_sst_view_id"]) + uniffiOptionalConverter(FfiConverterString).allocationSize(recordValue["last_compacted_l0_sst_id"]) + uniffiArrayConverter(FfiConverterSsTableView).allocationSize(recordValue["l0"]) + uniffiArrayConverter(FfiConverterSortedRun).allocationSize(recordValue["compacted"]) + FfiConverterUInt64.allocationSize(recordValue["next_wal_sst_id"]) + FfiConverterUInt64.allocationSize(recordValue["replay_after_wal_id"]) + FfiConverterInt64.allocationSize(recordValue["last_l0_clock_tick"]) + FfiConverterUInt64.allocationSize(recordValue["last_l0_seq"]) + FfiConverterUInt64.allocationSize(recordValue["recent_snapshot_min_seq"]) + uniffiArrayConverter(FfiConverterCheckpoint).allocationSize(recordValue["checkpoints"]) + uniffiOptionalConverter(FfiConverterString).allocationSize(recordValue["wal_object_store_uri"]);
+  }
+
+  write(value, writer) {
+    const recordValue = uniffiRequireRecordObject("VersionedManifest", value);
+    FfiConverterUInt64.write(recordValue["id"], writer);
+    FfiConverterUInt64.write(recordValue["writer_epoch"], writer);
+    FfiConverterUInt64.write(recordValue["compactor_epoch"], writer);
+    uniffiArrayConverter(FfiConverterExternalDb).write(recordValue["external_dbs"], writer);
+    FfiConverterBool.write(recordValue["initialized"], writer);
+    uniffiOptionalConverter(FfiConverterString).write(recordValue["last_compacted_l0_sst_view_id"], writer);
+    uniffiOptionalConverter(FfiConverterString).write(recordValue["last_compacted_l0_sst_id"], writer);
+    uniffiArrayConverter(FfiConverterSsTableView).write(recordValue["l0"], writer);
+    uniffiArrayConverter(FfiConverterSortedRun).write(recordValue["compacted"], writer);
+    FfiConverterUInt64.write(recordValue["next_wal_sst_id"], writer);
+    FfiConverterUInt64.write(recordValue["replay_after_wal_id"], writer);
+    FfiConverterInt64.write(recordValue["last_l0_clock_tick"], writer);
+    FfiConverterUInt64.write(recordValue["last_l0_seq"], writer);
+    FfiConverterUInt64.write(recordValue["recent_snapshot_min_seq"], writer);
+    uniffiArrayConverter(FfiConverterCheckpoint).write(recordValue["checkpoints"], writer);
+    uniffiOptionalConverter(FfiConverterString).write(recordValue["wal_object_store_uri"], writer);
+  }
+
+  read(reader) {
+    return {
+      "id": FfiConverterUInt64.read(reader),
+      "writer_epoch": FfiConverterUInt64.read(reader),
+      "compactor_epoch": FfiConverterUInt64.read(reader),
+      "external_dbs": uniffiArrayConverter(FfiConverterExternalDb).read(reader),
+      "initialized": FfiConverterBool.read(reader),
+      "last_compacted_l0_sst_view_id": uniffiOptionalConverter(FfiConverterString).read(reader),
+      "last_compacted_l0_sst_id": uniffiOptionalConverter(FfiConverterString).read(reader),
+      "l0": uniffiArrayConverter(FfiConverterSsTableView).read(reader),
+      "compacted": uniffiArrayConverter(FfiConverterSortedRun).read(reader),
+      "next_wal_sst_id": FfiConverterUInt64.read(reader),
+      "replay_after_wal_id": FfiConverterUInt64.read(reader),
+      "last_l0_clock_tick": FfiConverterInt64.read(reader),
+      "last_l0_seq": FfiConverterUInt64.read(reader),
+      "recent_snapshot_min_seq": FfiConverterUInt64.read(reader),
+      "checkpoints": uniffiArrayConverter(FfiConverterCheckpoint).read(reader),
+      "wal_object_store_uri": uniffiOptionalConverter(FfiConverterString).read(reader),
+    };
+  }
+})();
 const FfiConverterWriteHandle = new (class extends AbstractFfiConverterByteArray {
   allocationSize(value) {
     const recordValue = uniffiRequireRecordObject("WriteHandle", value);
@@ -1336,6 +1787,122 @@ const FfiConverterLogLevel = new (class extends AbstractFfiConverterByteArray {
     }
   }
 })();
+const FfiConverterCompactionStatus = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    uniffiRequireFlatEnumValue(CompactionStatus, "CompactionStatus", value);
+    return 4;
+  }
+
+  write(value, writer) {
+    const enumValue = uniffiRequireFlatEnumValue(CompactionStatus, "CompactionStatus", value);
+    switch (enumValue) {
+      case CompactionStatus["Submitted"]:
+        writer.writeInt32(1);
+        return;
+      case CompactionStatus["Running"]:
+        writer.writeInt32(2);
+        return;
+      case CompactionStatus["Completed"]:
+        writer.writeInt32(3);
+        return;
+      case CompactionStatus["Failed"]:
+        writer.writeInt32(4);
+        return;
+      default:
+        throw new UnexpectedEnumCase(`Unexpected CompactionStatus case ${String(enumValue)}.`);
+    }
+  }
+
+  read(reader) {
+    const enumTag = reader.readInt32();
+    switch (enumTag) {
+      case 1:
+        return CompactionStatus["Submitted"];
+      case 2:
+        return CompactionStatus["Running"];
+      case 3:
+        return CompactionStatus["Completed"];
+      case 4:
+        return CompactionStatus["Failed"];
+      default:
+        throw new UnexpectedEnumCase(`Unexpected CompactionStatus case ${String(enumTag)}.`);
+    }
+  }
+})();
+const FfiConverterCompressionCodec = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    uniffiRequireFlatEnumValue(CompressionCodec, "CompressionCodec", value);
+    return 4;
+  }
+
+  write(value, writer) {
+    const enumValue = uniffiRequireFlatEnumValue(CompressionCodec, "CompressionCodec", value);
+    switch (enumValue) {
+      case CompressionCodec["Snappy"]:
+        writer.writeInt32(1);
+        return;
+      case CompressionCodec["Zlib"]:
+        writer.writeInt32(2);
+        return;
+      case CompressionCodec["Lz4"]:
+        writer.writeInt32(3);
+        return;
+      case CompressionCodec["Zstd"]:
+        writer.writeInt32(4);
+        return;
+      default:
+        throw new UnexpectedEnumCase(`Unexpected CompressionCodec case ${String(enumValue)}.`);
+    }
+  }
+
+  read(reader) {
+    const enumTag = reader.readInt32();
+    switch (enumTag) {
+      case 1:
+        return CompressionCodec["Snappy"];
+      case 2:
+        return CompressionCodec["Zlib"];
+      case 3:
+        return CompressionCodec["Lz4"];
+      case 4:
+        return CompressionCodec["Zstd"];
+      default:
+        throw new UnexpectedEnumCase(`Unexpected CompressionCodec case ${String(enumTag)}.`);
+    }
+  }
+})();
+const FfiConverterFilterFormat = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    uniffiRequireFlatEnumValue(FilterFormat, "FilterFormat", value);
+    return 4;
+  }
+
+  write(value, writer) {
+    const enumValue = uniffiRequireFlatEnumValue(FilterFormat, "FilterFormat", value);
+    switch (enumValue) {
+      case FilterFormat["Legacy"]:
+        writer.writeInt32(1);
+        return;
+      case FilterFormat["Composite"]:
+        writer.writeInt32(2);
+        return;
+      default:
+        throw new UnexpectedEnumCase(`Unexpected FilterFormat case ${String(enumValue)}.`);
+    }
+  }
+
+  read(reader) {
+    const enumTag = reader.readInt32();
+    switch (enumTag) {
+      case 1:
+        return FilterFormat["Legacy"];
+      case 2:
+        return FilterFormat["Composite"];
+      default:
+        throw new UnexpectedEnumCase(`Unexpected FilterFormat case ${String(enumTag)}.`);
+    }
+  }
+})();
 const FfiConverterRowEntryKind = new (class extends AbstractFfiConverterByteArray {
   allocationSize(value) {
     uniffiRequireFlatEnumValue(RowEntryKind, "RowEntryKind", value);
@@ -1373,6 +1940,38 @@ const FfiConverterRowEntryKind = new (class extends AbstractFfiConverterByteArra
     }
   }
 })();
+const FfiConverterSstType = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    uniffiRequireFlatEnumValue(SstType, "SstType", value);
+    return 4;
+  }
+
+  write(value, writer) {
+    const enumValue = uniffiRequireFlatEnumValue(SstType, "SstType", value);
+    switch (enumValue) {
+      case SstType["Compacted"]:
+        writer.writeInt32(1);
+        return;
+      case SstType["Wal"]:
+        writer.writeInt32(2);
+        return;
+      default:
+        throw new UnexpectedEnumCase(`Unexpected SstType case ${String(enumValue)}.`);
+    }
+  }
+
+  read(reader) {
+    const enumTag = reader.readInt32();
+    switch (enumTag) {
+      case 1:
+        return SstType["Compacted"];
+      case 2:
+        return SstType["Wal"];
+      default:
+        throw new UnexpectedEnumCase(`Unexpected SstType case ${String(enumTag)}.`);
+    }
+  }
+})();
 const FfiConverterTtl = new (class extends AbstractFfiConverterByteArray {
   allocationSize(value) {
     const enumValue = uniffiRequireTaggedEnumValue("Ttl", value);
@@ -1465,7 +2064,147 @@ const FfiConverterMetricValue = new (class extends AbstractFfiConverterByteArray
         FfiConverterHistogramMetricValue.write(enumValue[""], writer);
         return;
       default:
-        throw new UnexpectedEnumCase(`Unexpected MetricValue case ${String(enumValue.tag)}.`);
+        throw new UnexpectedEnumCase(`Unexpected MetricValue case ${String(enumValue.tag)}.`);
+    }
+  }
+
+  read(reader) {
+    const enumTag = reader.readInt32();
+    switch (enumTag) {
+      case 1:
+        return MetricValue.Counter(FfiConverterUInt64.read(reader));
+      case 2:
+        return MetricValue.Gauge(FfiConverterInt64.read(reader));
+      case 3:
+        return MetricValue.UpDownCounter(FfiConverterInt64.read(reader));
+      case 4:
+        return MetricValue.Histogram(FfiConverterHistogramMetricValue.read(reader));
+      default:
+        throw new UnexpectedEnumCase(`Unexpected MetricValue case ${String(enumTag)}.`);
+    }
+  }
+})();
+const FfiConverterCacheTarget = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const enumValue = uniffiRequireTaggedEnumValue("CacheTarget", value);
+    switch (enumValue.tag) {
+      case "Filters":
+        return 4;
+      case "Index":
+        return 4;
+      case "Stats":
+        return 4;
+      case "Data":
+        return 4 + FfiConverterKeyRange.allocationSize(enumValue["range"]);
+      default:
+        throw new UnexpectedEnumCase(`Unexpected CacheTarget case ${String(enumValue.tag)}.`);
+    }
+  }
+
+  write(value, writer) {
+    const enumValue = uniffiRequireTaggedEnumValue("CacheTarget", value);
+    switch (enumValue.tag) {
+      case "Filters":
+        writer.writeInt32(1);
+        return;
+      case "Index":
+        writer.writeInt32(2);
+        return;
+      case "Stats":
+        writer.writeInt32(3);
+        return;
+      case "Data":
+        writer.writeInt32(4);
+        FfiConverterKeyRange.write(enumValue["range"], writer);
+        return;
+      default:
+        throw new UnexpectedEnumCase(`Unexpected CacheTarget case ${String(enumValue.tag)}.`);
+    }
+  }
+
+  read(reader) {
+    const enumTag = reader.readInt32();
+    switch (enumTag) {
+      case 1:
+        return CacheTarget.Filters();
+      case 2:
+        return CacheTarget.Index();
+      case 3:
+        return CacheTarget.Stats();
+      case 4:
+        return CacheTarget.Data(FfiConverterKeyRange.read(reader));
+      default:
+        throw new UnexpectedEnumCase(`Unexpected CacheTarget case ${String(enumTag)}.`);
+    }
+  }
+})();
+const FfiConverterSourceId = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const enumValue = uniffiRequireTaggedEnumValue("SourceId", value);
+    switch (enumValue.tag) {
+      case "SortedRun":
+        return 4 + FfiConverterUInt32.allocationSize(enumValue[""]);
+      case "SstView":
+        return 4 + FfiConverterString.allocationSize(enumValue[""]);
+      default:
+        throw new UnexpectedEnumCase(`Unexpected SourceId case ${String(enumValue.tag)}.`);
+    }
+  }
+
+  write(value, writer) {
+    const enumValue = uniffiRequireTaggedEnumValue("SourceId", value);
+    switch (enumValue.tag) {
+      case "SortedRun":
+        writer.writeInt32(1);
+        FfiConverterUInt32.write(enumValue[""], writer);
+        return;
+      case "SstView":
+        writer.writeInt32(2);
+        FfiConverterString.write(enumValue[""], writer);
+        return;
+      default:
+        throw new UnexpectedEnumCase(`Unexpected SourceId case ${String(enumValue.tag)}.`);
+    }
+  }
+
+  read(reader) {
+    const enumTag = reader.readInt32();
+    switch (enumTag) {
+      case 1:
+        return SourceId.SortedRun(FfiConverterUInt32.read(reader));
+      case 2:
+        return SourceId.SstView(FfiConverterString.read(reader));
+      default:
+        throw new UnexpectedEnumCase(`Unexpected SourceId case ${String(enumTag)}.`);
+    }
+  }
+})();
+const FfiConverterSsTableId = new (class extends AbstractFfiConverterByteArray {
+  allocationSize(value) {
+    const enumValue = uniffiRequireTaggedEnumValue("SsTableId", value);
+    switch (enumValue.tag) {
+      case "Wal":
+        return 4 + FfiConverterUInt64.allocationSize(enumValue[""]);
+      case "Compacted":
+        return 4 + FfiConverterString.allocationSize(enumValue[""]);
+      default:
+        throw new UnexpectedEnumCase(`Unexpected SsTableId case ${String(enumValue.tag)}.`);
+    }
+  }
+
+  write(value, writer) {
+    const enumValue = uniffiRequireTaggedEnumValue("SsTableId", value);
+    switch (enumValue.tag) {
+      case "Wal":
+        writer.writeInt32(1);
+        FfiConverterUInt64.write(enumValue[""], writer);
+        return;
+      case "Compacted":
+        writer.writeInt32(2);
+        FfiConverterString.write(enumValue[""], writer);
+        return;
+      default:
+        throw new UnexpectedEnumCase(`Unexpected SsTableId case ${String(enumValue.tag)}.`);
     }
   }
 
@@ -1473,15 +2212,11 @@ const FfiConverterMetricValue = new (class extends AbstractFfiConverterByteArray
     const enumTag = reader.readInt32();
     switch (enumTag) {
       case 1:
-        return MetricValue.Counter(FfiConverterUInt64.read(reader));
+        return SsTableId.Wal(FfiConverterUInt64.read(reader));
       case 2:
-        return MetricValue.Gauge(FfiConverterInt64.read(reader));
-      case 3:
-        return MetricValue.UpDownCounter(FfiConverterInt64.read(reader));
-      case 4:
-        return MetricValue.Histogram(FfiConverterHistogramMetricValue.read(reader));
+        return SsTableId.Compacted(FfiConverterString.read(reader));
       default:
-        throw new UnexpectedEnumCase(`Unexpected MetricValue case ${String(enumTag)}.`);
+        throw new UnexpectedEnumCase(`Unexpected SsTableId case ${String(enumTag)}.`);
     }
   }
 })();
@@ -2592,29 +3327,428 @@ configureRuntimeHooks({
   onLoad(bindings) {
     uniffiRegisterCallbackVtables(bindings);
   },
-  onUnload() {
-    if (uniffiRustFutureContinuationPointer != null) {
-      koffi.unregister(uniffiRustFutureContinuationPointer);
-      uniffiRustFutureContinuationPointer = null;
-    }
-    uniffiUnregisterCallbackVtables();
+  onUnload() {
+    if (uniffiRustFutureContinuationPointer != null) {
+      koffi.unregister(uniffiRustFutureContinuationPointer);
+      uniffiRustFutureContinuationPointer = null;
+    }
+    uniffiUnregisterCallbackVtables();
+  },
+});
+
+/**
+ * Installs SlateDB logging exactly once for the current process.
+ *
+ * If `callback` is provided, log records are forwarded to it. Otherwise logs
+ * are written to standard error using the default tracing formatter.
+ */
+export function init_logging(level, callback) {
+    const loweredLevel = uniffiLowerIntoRustBuffer(FfiConverterLogLevel, level);
+    const loweredCallback = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterLogCallback), callback);
+  uniffiRustCaller.rustCall(
+    (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_func_init_logging(loweredLevel, loweredCallback, status),
+    uniffiRustCallOptions(FfiConverterError),
+  );
+}
+
+/**
+ * Administrative read/query handle for SlateDB.
+ */
+export class Admin extends UniffiObjectBase {
+  constructor() {
+    super();
+    return uniffiNotImplemented("Admin.constructor");
+  }
+
+  /**
+   * Looks up a sequence number for the provided Unix UTC timestamp seconds.
+   */
+  async get_sequence_for_timestamp(timestamp_secs, round_up) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_get_sequence_for_timestamp_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_get_sequence_for_timestamp;
+    const loweredTimestampSecs = FfiConverterInt64.lower(timestamp_secs);
+    const loweredRoundUp = FfiConverterBool.lower(round_up);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredTimestampSecs, loweredRoundUp),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Looks up a timestamp for the provided sequence number.
+   */
+  async get_timestamp_for_sequence(seq, round_up) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_get_timestamp_for_sequence_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_get_timestamp_for_sequence;
+    const loweredSeq = FfiConverterUInt64.lower(seq);
+    const loweredRoundUp = FfiConverterBool.lower(round_up);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredSeq, loweredRoundUp),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiOptionalConverter(FfiConverterInt64), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Lists checkpoints, optionally filtering by exact name.
+   */
+  async list_checkpoints(name_filter) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_list_checkpoints_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_list_checkpoints;
+    const loweredNameFilter = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterString), name_filter);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredNameFilter),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiArrayConverter(FfiConverterCheckpoint), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Lists compactions files inside the half-open ID range `[from, to)`.
+   */
+  async list_compactions(from, to) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_list_compactions_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_list_compactions;
+    const loweredFrom = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), from);
+    const loweredTo = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), to);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredFrom, loweredTo),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiArrayConverter(FfiConverterVersionedCompactions), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Lists manifests inside the half-open ID range `[from, to)`.
+   */
+  async list_manifests(from, to) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_list_manifests_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_list_manifests;
+    const loweredFrom = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), from);
+    const loweredTo = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), to);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredFrom, loweredTo),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiArrayConverter(FfiConverterVersionedManifest), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Reads a compaction by ULID string from a specific or latest compactions file.
+   */
+  async read_compaction(compaction_id, compactions_id) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_compaction_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_compaction;
+    const loweredCompactionId = uniffiLowerString(compaction_id);
+    const loweredCompactionsId = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), compactions_id);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredCompactionId, loweredCompactionsId),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiOptionalConverter(FfiConverterCompaction), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Reads a specific compactions file by ID, or the latest when `id` is `None`.
+   */
+  async read_compactions(id) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_compactions_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_compactions;
+    const loweredId = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), id);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredId),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiOptionalConverter(FfiConverterVersionedCompactions), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Reads the latest compactor state view.
+   */
+  async read_compactor_state_view() {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_compactor_state_view_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_compactor_state_view;
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(FfiConverterCompactorStateView, uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Reads a specific manifest by ID, or the latest when `id` is `None`.
+   */
+  async read_manifest(id) {
+    const loweredSelf = uniffiAdminObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_manifest_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_admin_read_manifest;
+    const loweredId = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterUInt64), id);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredId),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiOptionalConverter(FfiConverterVersionedManifest), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+}
+
+const uniffiAdminObjectFactory = createObjectFactory({
+  typeName: "Admin",
+  createInstance: () => Object.create(Admin.prototype),
+  cloneFreeUsesUniffiHandle: true,
+  cloneHandleGeneric(handle) {
+    return uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_clone_admin_generic_abi(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  cloneHandleRawExternal(handle) {
+    const rawExternalCloneHandle = uniffiGetCachedLibraryFunction(
+      "uniffi_slatedb_uniffi_fn_clone_admin:raw-external",
+      (bindings) => bindings.library.func(
+        "uniffi_slatedb_uniffi_fn_clone_admin",
+        bindings.ffiTypes.VoidPointer,
+        [bindings.ffiTypes.VoidPointer, koffi.pointer(bindings.ffiTypes.RustCallStatus)],
+      ),
+    );
+    return uniffiRustCaller.rustCall(
+      (status) => rawExternalCloneHandle(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  cloneHandle(handle) {
+    return uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_clone_admin(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandleGeneric(handle) {
+    uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_free_admin_generic_abi(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandleRawExternal(handle) {
+    const rawExternalFreeHandle = uniffiGetCachedLibraryFunction(
+      "uniffi_slatedb_uniffi_fn_free_admin:raw-external",
+      (bindings) => bindings.library.func(
+        "uniffi_slatedb_uniffi_fn_free_admin",
+        "void",
+        [bindings.ffiTypes.VoidPointer, koffi.pointer(bindings.ffiTypes.RustCallStatus)],
+      ),
+    );
+    uniffiRustCaller.rustCall(
+      (status) => rawExternalFreeHandle(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandle(handle) {
+    uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_free_admin(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+});
+const FfiConverterAdmin = createObjectConverter(uniffiAdminObjectFactory);
+
+/**
+ * Builder for opening an administrative [`crate::Admin`] handle.
+ *
+ * Builders are single-use: calling [`AdminBuilder::build`] consumes the builder.
+ */
+export class AdminBuilder extends UniffiObjectBase {
+  /**
+   * Creates a new admin builder for `path` in `object_store`.
+   */
+  constructor(path, object_store) {
+    super();
+    const loweredPath = uniffiLowerString(path);
+    const loweredObjectStore = uniffiObjectStoreObjectFactory.cloneHandle(object_store);
+    const pointer = uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_constructor_adminbuilder_new(loweredPath, loweredObjectStore, status),
+      uniffiRustCallOptions(),
+    );
+    return uniffiAdminBuilderObjectFactory.attach(this, pointer);
+  }
+
+  /**
+   * Builds the admin handle and consumes this builder.
+   */
+  build() {
+    const loweredSelf = uniffiAdminBuilderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminBuilderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_adminbuilder_build_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_adminbuilder_build;
+    const uniffiResult = uniffiRustCaller.rustCall(
+      (status) => ffiMethod(loweredSelf, status),
+      uniffiRustCallOptions(FfiConverterError),
+    );
+    return uniffiAdminObjectFactory.create(uniffiResult);
+  }
+
+  /**
+   * Sets the seed used for SlateDB's internal random number generation.
+   */
+  with_seed(seed) {
+    const loweredSelf = uniffiAdminBuilderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminBuilderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_adminbuilder_with_seed_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_adminbuilder_with_seed;
+    const loweredSeed = FfiConverterUInt64.lower(seed);
+    uniffiRustCaller.rustCall(
+      (status) => ffiMethod(loweredSelf, loweredSeed, status),
+      uniffiRustCallOptions(FfiConverterError),
+    );
+  }
+
+  /**
+   * Uses a separate object store for WAL-backed administrative operations.
+   */
+  with_wal_object_store(wal_object_store) {
+    const loweredSelf = uniffiAdminBuilderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiAdminBuilderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_adminbuilder_with_wal_object_store_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_adminbuilder_with_wal_object_store;
+    const loweredWalObjectStore = uniffiObjectStoreObjectFactory.cloneHandle(wal_object_store);
+    uniffiRustCaller.rustCall(
+      (status) => ffiMethod(loweredSelf, loweredWalObjectStore, status),
+      uniffiRustCallOptions(FfiConverterError),
+    );
+  }
+}
+
+const uniffiAdminBuilderObjectFactory = createObjectFactory({
+  typeName: "AdminBuilder",
+  createInstance: () => Object.create(AdminBuilder.prototype),
+  cloneFreeUsesUniffiHandle: true,
+  cloneHandleGeneric(handle) {
+    return uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_clone_adminbuilder_generic_abi(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  cloneHandleRawExternal(handle) {
+    const rawExternalCloneHandle = uniffiGetCachedLibraryFunction(
+      "uniffi_slatedb_uniffi_fn_clone_adminbuilder:raw-external",
+      (bindings) => bindings.library.func(
+        "uniffi_slatedb_uniffi_fn_clone_adminbuilder",
+        bindings.ffiTypes.VoidPointer,
+        [bindings.ffiTypes.VoidPointer, koffi.pointer(bindings.ffiTypes.RustCallStatus)],
+      ),
+    );
+    return uniffiRustCaller.rustCall(
+      (status) => rawExternalCloneHandle(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  cloneHandle(handle) {
+    return uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_clone_adminbuilder(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandleGeneric(handle) {
+    uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_free_adminbuilder_generic_abi(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandleRawExternal(handle) {
+    const rawExternalFreeHandle = uniffiGetCachedLibraryFunction(
+      "uniffi_slatedb_uniffi_fn_free_adminbuilder:raw-external",
+      (bindings) => bindings.library.func(
+        "uniffi_slatedb_uniffi_fn_free_adminbuilder",
+        "void",
+        [bindings.ffiTypes.VoidPointer, koffi.pointer(bindings.ffiTypes.RustCallStatus)],
+      ),
+    );
+    uniffiRustCaller.rustCall(
+      (status) => rawExternalFreeHandle(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandle(handle) {
+    uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_free_adminbuilder(handle, status),
+      uniffiRustCallOptions(),
+    );
   },
 });
-
-/**
- * Installs SlateDB logging exactly once for the current process.
- *
- * If `callback` is provided, log records are forwarded to it. Otherwise logs
- * are written to standard error using the default tracing formatter.
- */
-export function init_logging(level, callback) {
-    const loweredLevel = uniffiLowerIntoRustBuffer(FfiConverterLogLevel, level);
-    const loweredCallback = uniffiLowerIntoRustBuffer(uniffiOptionalConverter(FfiConverterLogCallback), callback);
-  uniffiRustCaller.rustCall(
-    (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_func_init_logging(loweredLevel, loweredCallback, status),
-    uniffiRustCallOptions(FfiConverterError),
-  );
-}
+const FfiConverterAdminBuilder = createObjectConverter(uniffiAdminBuilderObjectFactory);
 
 /**
  * Builder for opening a writable [`crate::Db`].
@@ -2665,6 +3799,22 @@ export class DbBuilder extends UniffiObjectBase {
     });
   }
 
+  /**
+   * Sets DB cache.
+   */
+  with_db_cache(db_cache) {
+    const loweredSelf = uniffiDbBuilderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiDbBuilderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbbuilder_with_db_cache_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbbuilder_with_db_cache;
+    const loweredDbCache = uniffiDbCacheObjectFactory.cloneHandle(db_cache);
+    uniffiRustCaller.rustCall(
+      (status) => ffiMethod(loweredSelf, loweredDbCache, status),
+      uniffiRustCallOptions(FfiConverterError),
+    );
+  }
+
   /**
    * Disables the SST block and metadata cache.
    */
@@ -3109,6 +4259,30 @@ export class Db extends UniffiObjectBase {
     });
   }
 
+  /**
+   * Best-effort eviction of block-cache entries for one SST.
+   *
+   * If no block cache is configured, returns `Ok(())`.
+   */
+  async evict_cached_sst(sst_id) {
+    const loweredSelf = uniffiDbObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiDbObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_db_evict_cached_sst_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_db_evict_cached_sst;
+    const loweredSstId = uniffiLowerIntoRustBuffer(FfiConverterSsTableId, sst_id);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_void(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredSstId),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_void(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_void(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_void(rustFuture),
+      liftFunc: (_uniffiResult) => undefined,
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
   /**
    * Flushes the default storage layer.
    */
@@ -3529,6 +4703,33 @@ export class Db extends UniffiObjectBase {
     return uniffiLiftFromRustBuffer(FfiConverterDbStatus, uniffiResult);
   }
 
+  /**
+   * Warms selected cache content for one SST.
+   *
+   * Returns `Err` on the first failing target. If no block cache is
+   * configured, or if the SST is not reachable from the current manifest,
+   * the call is a no-op that returns `Ok(())`.
+   */
+  async warm_sst(sst_id, targets) {
+    const loweredSelf = uniffiDbObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiDbObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_db_warm_sst_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_db_warm_sst;
+    const loweredSstId = uniffiLowerIntoRustBuffer(FfiConverterSsTableId, sst_id);
+    const loweredTargets = uniffiLowerIntoRustBuffer(uniffiArrayConverter(FfiConverterCacheTarget), targets);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_void(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredSstId, loweredTargets),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_void(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_void(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_void(rustFuture),
+      liftFunc: (_uniffiResult) => undefined,
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
   /**
    * Applies all operations in `batch` atomically.
    *
@@ -3638,6 +4839,112 @@ const uniffiDbObjectFactory = createObjectFactory({
 });
 const FfiConverterDb = createObjectConverter(uniffiDbObjectFactory);
 
+/**
+ * Database cache used to store blocks in memory.
+ */
+export class DbCache extends UniffiObjectBase {
+  constructor() {
+    super();
+    return uniffiNotImplemented("DbCache.constructor");
+  }
+
+  /**
+   * Creates a new Foyer based DB cache.
+   */
+  static new_foyer_cache(options) {
+    const loweredOptions = uniffiLowerIntoRustBuffer(FfiConverterFoyerCacheOptions, options);
+    const pointer = uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_constructor_dbcache_new_foyer_cache(loweredOptions, status),
+      uniffiRustCallOptions(FfiConverterError),
+    );
+    return uniffiDbCacheObjectFactory.create(pointer);
+  }
+
+  /**
+   * Creates a new Moka based DB cache.
+   */
+  static new_moka_cache(options) {
+    const loweredOptions = uniffiLowerIntoRustBuffer(FfiConverterMokaCacheOptions, options);
+    const pointer = uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_constructor_dbcache_new_moka_cache(loweredOptions, status),
+      uniffiRustCallOptions(FfiConverterError),
+    );
+    return uniffiDbCacheObjectFactory.create(pointer);
+  }
+
+  /**
+   * Creates a new split cache with separate block and metadata capacities.
+   */
+  static new_split_cache(block_cache, meta_cache) {
+    const loweredBlockCache = uniffiDbCacheObjectFactory.cloneHandle(block_cache);
+    const loweredMetaCache = uniffiDbCacheObjectFactory.cloneHandle(meta_cache);
+    const pointer = uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_constructor_dbcache_new_split_cache(loweredBlockCache, loweredMetaCache, status),
+      uniffiRustCallOptions(FfiConverterError),
+    );
+    return uniffiDbCacheObjectFactory.create(pointer);
+  }
+}
+
+const uniffiDbCacheObjectFactory = createObjectFactory({
+  typeName: "DbCache",
+  createInstance: () => Object.create(DbCache.prototype),
+  cloneFreeUsesUniffiHandle: true,
+  cloneHandleGeneric(handle) {
+    return uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_clone_dbcache_generic_abi(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  cloneHandleRawExternal(handle) {
+    const rawExternalCloneHandle = uniffiGetCachedLibraryFunction(
+      "uniffi_slatedb_uniffi_fn_clone_dbcache:raw-external",
+      (bindings) => bindings.library.func(
+        "uniffi_slatedb_uniffi_fn_clone_dbcache",
+        bindings.ffiTypes.VoidPointer,
+        [bindings.ffiTypes.VoidPointer, koffi.pointer(bindings.ffiTypes.RustCallStatus)],
+      ),
+    );
+    return uniffiRustCaller.rustCall(
+      (status) => rawExternalCloneHandle(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  cloneHandle(handle) {
+    return uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_clone_dbcache(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandleGeneric(handle) {
+    uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_free_dbcache_generic_abi(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandleRawExternal(handle) {
+    const rawExternalFreeHandle = uniffiGetCachedLibraryFunction(
+      "uniffi_slatedb_uniffi_fn_free_dbcache:raw-external",
+      (bindings) => bindings.library.func(
+        "uniffi_slatedb_uniffi_fn_free_dbcache",
+        "void",
+        [bindings.ffiTypes.VoidPointer, koffi.pointer(bindings.ffiTypes.RustCallStatus)],
+      ),
+    );
+    uniffiRustCaller.rustCall(
+      (status) => rawExternalFreeHandle(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+  freeHandle(handle) {
+    uniffiRustCaller.rustCall(
+      (status) => ffiFunctions.uniffi_slatedb_uniffi_fn_free_dbcache(handle, status),
+      uniffiRustCallOptions(),
+    );
+  },
+});
+const FfiConverterDbCache = createObjectConverter(uniffiDbCacheObjectFactory);
+
 /**
  * Read-only database handle opened by [`crate::DbReaderBuilder`].
  */
@@ -3647,6 +4954,30 @@ export class DbReader extends UniffiObjectBase {
     return uniffiNotImplemented("DbReader.constructor");
   }
 
+  /**
+   * Best-effort eviction of block-cache entries for one SST.
+   *
+   * If no block cache is configured, returns `Ok(())`.
+   */
+  async evict_cached_sst(sst_id) {
+    const loweredSelf = uniffiDbReaderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiDbReaderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_evict_cached_sst_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_evict_cached_sst;
+    const loweredSstId = uniffiLowerIntoRustBuffer(FfiConverterSsTableId, sst_id);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_void(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredSstId),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_void(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_void(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_void(rustFuture),
+      liftFunc: (_uniffiResult) => undefined,
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
   /**
    * Reads the current value for `key`.
    */
@@ -3669,6 +5000,51 @@ export class DbReader extends UniffiObjectBase {
     });
   }
 
+  /**
+   * Reads the current row version for `key`, including metadata.
+   */
+  async get_key_value(key) {
+    const loweredSelf = uniffiDbReaderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiDbReaderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_get_key_value_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_get_key_value;
+    const loweredKey = uniffiLowerIntoRustBuffer(FfiConverterBytes, key);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredKey),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiOptionalConverter(FfiConverterKeyValue), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
+  /**
+   * Reads the current row version for `key` using custom read options.
+   */
+  async get_key_value_with_options(key, options) {
+    const loweredSelf = uniffiDbReaderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiDbReaderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_get_key_value_with_options_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_get_key_value_with_options;
+    const loweredKey = uniffiLowerIntoRustBuffer(FfiConverterBytes, key);
+    const loweredOptions = uniffiLowerIntoRustBuffer(FfiConverterReadOptions, options);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_rust_buffer(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredKey, loweredOptions),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_rust_buffer(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_rust_buffer(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_rust_buffer(rustFuture),
+      liftFunc: (uniffiResult) => uniffiLiftFromRustBuffer(uniffiOptionalConverter(FfiConverterKeyValue), uniffiResult),
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
+
   /**
    * Reads the current value for `key` using custom read options.
    */
@@ -3850,6 +5226,33 @@ export class DbReader extends UniffiObjectBase {
     );
     return uniffiLiftFromRustBuffer(FfiConverterDbStatus, uniffiResult);
   }
+
+  /**
+   * Warms selected cache content for one SST.
+   *
+   * Returns `Err` on the first failing target. If no block cache is
+   * configured, or if the SST is not reachable from the current manifest,
+   * the call is a no-op that returns `Ok(())`.
+   */
+  async warm_sst(sst_id, targets) {
+    const loweredSelf = uniffiDbReaderObjectFactory.cloneHandle(this);
+    const ffiMethod =
+      uniffiDbReaderObjectFactory.usesGenericAbi(this)
+        ? ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_warm_sst_generic_abi
+        : ffiFunctions.uniffi_slatedb_uniffi_fn_method_dbreader_warm_sst;
+    const loweredSstId = uniffiLowerIntoRustBuffer(FfiConverterSsTableId, sst_id);
+    const loweredTargets = uniffiLowerIntoRustBuffer(uniffiArrayConverter(FfiConverterCacheTarget), targets);
+    const completeFunc = (rustFuture, status) => ffiFunctions.ffi_slatedb_uniffi_rust_future_complete_void(rustFuture, status);
+    return rustCallAsync({
+      rustFutureFunc: () => ffiMethod(loweredSelf, loweredSstId, loweredTargets),
+      pollFunc: (rustFuture, _continuationCallback, continuationHandle) => ffiFunctions.ffi_slatedb_uniffi_rust_future_poll_void(rustFuture, uniffiGetRustFutureContinuationPointer(), continuationHandle),
+      cancelFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_cancel_void(rustFuture),
+      completeFunc,
+      freeFunc: (rustFuture) => ffiFunctions.ffi_slatedb_uniffi_rust_future_free_void(rustFuture),
+      liftFunc: (_uniffiResult) => undefined,
+      ...uniffiRustCallOptions(FfiConverterError),
+    });
+  }
 }
 
 const uniffiDbReaderObjectFactory = createObjectFactory({