9 files changed, 512 insertions, 319 deletions

diff --git a/t/unit-tests/t-reftable-block.c b/t/unit-tests/t-reftable-block.c
index 22040aeefa..52f1dae1c9 100644
--- a/t/unit-tests/t-reftable-block.c
+++ b/t/unit-tests/t-reftable-block.c
@@ -19,24 +19,25 @@ static void t_ref_block_read_write(void)
 	struct reftable_record recs[30];
 	const size_t N = ARRAY_SIZE(recs);
 	const size_t block_size = 1024;
-	struct reftable_block block = { 0 };
+	struct reftable_block_source source = { 0 };
 	struct block_writer bw = {
 		.last_key = REFTABLE_BUF_INIT,
 	};
 	struct reftable_record rec = {
-		.type = BLOCK_TYPE_REF,
+		.type = REFTABLE_BLOCK_TYPE_REF,
 	};
 	size_t i = 0;
 	int ret;
-	struct block_reader br = { 0 };
+	struct reftable_block block = { 0 };
 	struct block_iter it = BLOCK_ITER_INIT;
-	struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
+	struct reftable_buf want = REFTABLE_BUF_INIT;
+	struct reftable_buf block_data = REFTABLE_BUF_INIT;
 
-	REFTABLE_CALLOC_ARRAY(block.data, block_size);
-	check(block.data != NULL);
-	block.len = block_size;
-	block_source_from_buf(&block.source ,&buf);
-	ret = block_writer_init(&bw, BLOCK_TYPE_REF, block.data, block_size,
+	REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+	check(block_data.buf != NULL);
+	block_data.len = block_size;
+
+	ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) block_data.buf, block_size,
 				header_off, hash_size(REFTABLE_HASH_SHA1));
 	check(!ret);
 
@@ -62,9 +63,11 @@ static void t_ref_block_read_write(void)
 
 	block_writer_release(&bw);
 
-	block_reader_init(&br, &block, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+	block_source_from_buf(&source ,&block_data);
+	reftable_block_init(&block, &source, 0, header_off, block_size,
+			    REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);
 
-	block_iter_seek_start(&it, &br);
+	block_iter_init(&it, &block);
 
 	for (i = 0; ; i++) {
 		ret = block_iter_next(&it, &rec);
@@ -77,10 +80,9 @@ static void t_ref_block_read_write(void)
 	}
 
 	for (i = 0; i < N; i++) {
-		block_iter_reset(&it);
 		reftable_record_key(&recs[i], &want);
 
-		ret = block_iter_seek_key(&it, &br, &want);
+		ret = block_iter_seek_key(&it, &want);
 		check_int(ret, ==, 0);
 
 		ret = block_iter_next(&it, &rec);
@@ -89,7 +91,7 @@ static void t_ref_block_read_write(void)
 		check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
 
 		want.len--;
-		ret = block_iter_seek_key(&it, &br, &want);
+		ret = block_iter_seek_key(&it, &want);
 		check_int(ret, ==, 0);
 
 		ret = block_iter_next(&it, &rec);
@@ -97,12 +99,11 @@ static void t_ref_block_read_write(void)
 		check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
 	}
 
-	block_reader_release(&br);
+	reftable_block_release(&block);
 	block_iter_close(&it);
 	reftable_record_release(&rec);
-	reftable_block_done(&br.block);
 	reftable_buf_release(&want);
-	reftable_buf_release(&buf);
+	reftable_buf_release(&block_data);
 	for (i = 0; i < N; i++)
 		reftable_record_release(&recs[i]);
 }
@@ -113,24 +114,25 @@ static void t_log_block_read_write(void)
 	struct reftable_record recs[30];
 	const size_t N = ARRAY_SIZE(recs);
 	const size_t block_size = 2048;
-	struct reftable_block block = { 0 };
+	struct reftable_block_source source = { 0 };
 	struct block_writer bw = {
 		.last_key = REFTABLE_BUF_INIT,
 	};
 	struct reftable_record rec = {
-		.type = BLOCK_TYPE_LOG,
+		.type = REFTABLE_BLOCK_TYPE_LOG,
 	};
 	size_t i = 0;
 	int ret;
-	struct block_reader br = { 0 };
+	struct reftable_block block = { 0 };
 	struct block_iter it = BLOCK_ITER_INIT;
-	struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
+	struct reftable_buf want = REFTABLE_BUF_INIT;
+	struct reftable_buf block_data = REFTABLE_BUF_INIT;
+
+	REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+	check(block_data.buf != NULL);
+	block_data.len = block_size;
 
-	REFTABLE_CALLOC_ARRAY(block.data, block_size);
-	check(block.data != NULL);
-	block.len = block_size;
-	block_source_from_buf(&block.source ,&buf);
-	ret = block_writer_init(&bw, BLOCK_TYPE_LOG, block.data, block_size,
+	ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_LOG, (uint8_t *) block_data.buf, block_size,
 				header_off, hash_size(REFTABLE_HASH_SHA1));
 	check(!ret);
 
@@ -151,9 +153,11 @@ static void t_log_block_read_write(void)
 
 	block_writer_release(&bw);
 
-	block_reader_init(&br, &block, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+	block_source_from_buf(&source, &block_data);
+	reftable_block_init(&block, &source, 0, header_off, block_size,
+			    REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_LOG);
 
-	block_iter_seek_start(&it, &br);
+	block_iter_init(&it, &block);
 
 	for (i = 0; ; i++) {
 		ret = block_iter_next(&it, &rec);
@@ -166,11 +170,10 @@ static void t_log_block_read_write(void)
 	}
 
 	for (i = 0; i < N; i++) {
-		block_iter_reset(&it);
 		reftable_buf_reset(&want);
 		check(!reftable_buf_addstr(&want, recs[i].u.log.refname));
 
-		ret = block_iter_seek_key(&it, &br, &want);
+		ret = block_iter_seek_key(&it, &want);
 		check_int(ret, ==, 0);
 
 		ret = block_iter_next(&it, &rec);
@@ -179,7 +182,7 @@ static void t_log_block_read_write(void)
 		check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
 
 		want.len--;
-		ret = block_iter_seek_key(&it, &br, &want);
+		ret = block_iter_seek_key(&it, &want);
 		check_int(ret, ==, 0);
 
 		ret = block_iter_next(&it, &rec);
@@ -187,12 +190,11 @@ static void t_log_block_read_write(void)
 		check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
 	}
 
-	block_reader_release(&br);
+	reftable_block_release(&block);
 	block_iter_close(&it);
 	reftable_record_release(&rec);
-	reftable_block_done(&br.block);
 	reftable_buf_release(&want);
-	reftable_buf_release(&buf);
+	reftable_buf_release(&block_data);
 	for (i = 0; i < N; i++)
 		reftable_record_release(&recs[i]);
 }
@@ -203,24 +205,25 @@ static void t_obj_block_read_write(void)
 	struct reftable_record recs[30];
 	const size_t N = ARRAY_SIZE(recs);
 	const size_t block_size = 1024;
-	struct reftable_block block = { 0 };
+	struct reftable_block_source source = { 0 };
 	struct block_writer bw = {
 		.last_key = REFTABLE_BUF_INIT,
 	};
 	struct reftable_record rec = {
-		.type = BLOCK_TYPE_OBJ,
+		.type = REFTABLE_BLOCK_TYPE_OBJ,
 	};
 	size_t i = 0;
 	int ret;
-	struct block_reader br = { 0 };
+	struct reftable_block block = { 0 };
 	struct block_iter it = BLOCK_ITER_INIT;
-	struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
+	struct reftable_buf want = REFTABLE_BUF_INIT;
+	struct reftable_buf block_data = REFTABLE_BUF_INIT;
+
+	REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+	check(block_data.buf != NULL);
+	block_data.len = block_size;
 
-	REFTABLE_CALLOC_ARRAY(block.data, block_size);
-	check(block.data != NULL);
-	block.len = block_size;
-	block_source_from_buf(&block.source, &buf);
-	ret = block_writer_init(&bw, BLOCK_TYPE_OBJ, block.data, block_size,
+	ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_OBJ, (uint8_t *) block_data.buf, block_size,
 				header_off, hash_size(REFTABLE_HASH_SHA1));
 	check(!ret);
 
@@ -243,9 +246,11 @@ static void t_obj_block_read_write(void)
 
 	block_writer_release(&bw);
 
-	block_reader_init(&br, &block, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+	block_source_from_buf(&source, &block_data);
+	reftable_block_init(&block, &source, 0, header_off, block_size,
+			    REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_OBJ);
 
-	block_iter_seek_start(&it, &br);
+	block_iter_init(&it, &block);
 
 	for (i = 0; ; i++) {
 		ret = block_iter_next(&it, &rec);
@@ -258,10 +263,9 @@ static void t_obj_block_read_write(void)
 	}
 
 	for (i = 0; i < N; i++) {
-		block_iter_reset(&it);
 		reftable_record_key(&recs[i], &want);
 
-		ret = block_iter_seek_key(&it, &br, &want);
+		ret = block_iter_seek_key(&it, &want);
 		check_int(ret, ==, 0);
 
 		ret = block_iter_next(&it, &rec);
@@ -270,12 +274,11 @@ static void t_obj_block_read_write(void)
 		check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
 	}
 
-	block_reader_release(&br);
+	reftable_block_release(&block);
 	block_iter_close(&it);
 	reftable_record_release(&rec);
-	reftable_block_done(&br.block);
 	reftable_buf_release(&want);
-	reftable_buf_release(&buf);
+	reftable_buf_release(&block_data);
 	for (i = 0; i < N; i++)
 		reftable_record_release(&recs[i]);
 }
@@ -286,25 +289,26 @@ static void t_index_block_read_write(void)
 	struct reftable_record recs[30];
 	const size_t N = ARRAY_SIZE(recs);
 	const size_t block_size = 1024;
-	struct reftable_block block = { 0 };
+	struct reftable_block_source source = { 0 };
 	struct block_writer bw = {
 		.last_key = REFTABLE_BUF_INIT,
 	};
 	struct reftable_record rec = {
-		.type = BLOCK_TYPE_INDEX,
+		.type = REFTABLE_BLOCK_TYPE_INDEX,
 		.u.idx.last_key = REFTABLE_BUF_INIT,
 	};
 	size_t i = 0;
 	int ret;
-	struct block_reader br = { 0 };
+	struct reftable_block block = { 0 };
 	struct block_iter it = BLOCK_ITER_INIT;
-	struct reftable_buf want = REFTABLE_BUF_INIT, buf = REFTABLE_BUF_INIT;
+	struct reftable_buf want = REFTABLE_BUF_INIT;
+	struct reftable_buf block_data = REFTABLE_BUF_INIT;
 
-	REFTABLE_CALLOC_ARRAY(block.data, block_size);
-	check(block.data != NULL);
-	block.len = block_size;
-	block_source_from_buf(&block.source, &buf);
-	ret = block_writer_init(&bw, BLOCK_TYPE_INDEX, block.data, block_size,
+	REFTABLE_CALLOC_ARRAY(block_data.buf, block_size);
+	check(block_data.buf != NULL);
+	block_data.len = block_size;
+
+	ret = block_writer_init(&bw, REFTABLE_BLOCK_TYPE_INDEX, (uint8_t *) block_data.buf, block_size,
 				header_off, hash_size(REFTABLE_HASH_SHA1));
 	check(!ret);
 
@@ -314,7 +318,7 @@ static void t_index_block_read_write(void)
 		snprintf(buf, sizeof(buf), "branch%02"PRIuMAX, (uintmax_t)i);
 
 		reftable_buf_init(&recs[i].u.idx.last_key);
-		recs[i].type = BLOCK_TYPE_INDEX;
+		recs[i].type = REFTABLE_BLOCK_TYPE_INDEX;
 		check(!reftable_buf_addstr(&recs[i].u.idx.last_key, buf));
 		recs[i].u.idx.offset = i;
 
@@ -327,9 +331,11 @@ static void t_index_block_read_write(void)
 
 	block_writer_release(&bw);
 
-	block_reader_init(&br, &block, header_off, block_size, REFTABLE_HASH_SIZE_SHA1);
+	block_source_from_buf(&source, &block_data);
+	reftable_block_init(&block, &source, 0, header_off, block_size,
+			    REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_INDEX);
 
-	block_iter_seek_start(&it, &br);
+	block_iter_init(&it, &block);
 
 	for (i = 0; ; i++) {
 		ret = block_iter_next(&it, &rec);
@@ -342,10 +348,9 @@ static void t_index_block_read_write(void)
 	}
 
 	for (i = 0; i < N; i++) {
-		block_iter_reset(&it);
 		reftable_record_key(&recs[i], &want);
 
-		ret = block_iter_seek_key(&it, &br, &want);
+		ret = block_iter_seek_key(&it, &want);
 		check_int(ret, ==, 0);
 
 		ret = block_iter_next(&it, &rec);
@@ -354,7 +359,7 @@ static void t_index_block_read_write(void)
 		check(reftable_record_equal(&recs[i], &rec, REFTABLE_HASH_SIZE_SHA1));
 
 		want.len--;
-		ret = block_iter_seek_key(&it, &br, &want);
+		ret = block_iter_seek_key(&it, &want);
 		check_int(ret, ==, 0);
 
 		ret = block_iter_next(&it, &rec);
@@ -362,22 +367,100 @@ static void t_index_block_read_write(void)
 		check(reftable_record_equal(&recs[10 * (i / 10)], &rec, REFTABLE_HASH_SIZE_SHA1));
 	}
 
-	block_reader_release(&br);
+	reftable_block_release(&block);
 	block_iter_close(&it);
 	reftable_record_release(&rec);
-	reftable_block_done(&br.block);
 	reftable_buf_release(&want);
-	reftable_buf_release(&buf);
+	reftable_buf_release(&block_data);
 	for (i = 0; i < N; i++)
 		reftable_record_release(&recs[i]);
 }
 
+static void t_block_iterator(void)
+{
+	struct reftable_block_source source = { 0 };
+	struct block_writer writer = {
+		.last_key = REFTABLE_BUF_INIT,
+	};
+	struct reftable_record expected_refs[20];
+	struct reftable_ref_record ref = { 0 };
+	struct reftable_iterator it = { 0 };
+	struct reftable_block block = { 0 };
+	struct reftable_buf data;
+	int err;
+
+	data.len = 1024;
+	REFTABLE_CALLOC_ARRAY(data.buf, data.len);
+	check(data.buf != NULL);
+
+	err = block_writer_init(&writer, REFTABLE_BLOCK_TYPE_REF, (uint8_t *) data.buf, data.len,
+				0, hash_size(REFTABLE_HASH_SHA1));
+	check(!err);
+
+	for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++) {
+		expected_refs[i] = (struct reftable_record) {
+			.type = REFTABLE_BLOCK_TYPE_REF,
+			.u.ref = {
+				.value_type = REFTABLE_REF_VAL1,
+				.refname = xstrfmt("refs/heads/branch-%02"PRIuMAX, (uintmax_t)i),
+			},
+		};
+		memset(expected_refs[i].u.ref.value.val1, i, REFTABLE_HASH_SIZE_SHA1);
+
+		err = block_writer_add(&writer, &expected_refs[i]);
+		check_int(err, ==, 0);
+	}
+
+	err = block_writer_finish(&writer);
+	check_int(err, >, 0);
+
+	block_source_from_buf(&source, &data);
+	reftable_block_init(&block, &source, 0, 0, data.len,
+			    REFTABLE_HASH_SIZE_SHA1, REFTABLE_BLOCK_TYPE_REF);
+
+	err = reftable_block_init_iterator(&block, &it);
+	check_int(err, ==, 0);
+
+	for (size_t i = 0; ; i++) {
+		err = reftable_iterator_next_ref(&it, &ref);
+		if (err > 0) {
+			check_int(i, ==, ARRAY_SIZE(expected_refs));
+			break;
+		}
+		check_int(err, ==, 0);
+
+		check(reftable_ref_record_equal(&ref, &expected_refs[i].u.ref,
+						REFTABLE_HASH_SIZE_SHA1));
+	}
+
+	err = reftable_iterator_seek_ref(&it, "refs/heads/does-not-exist");
+	check_int(err, ==, 0);
+	err = reftable_iterator_next_ref(&it, &ref);
+	check_int(err, ==, 1);
+
+	err = reftable_iterator_seek_ref(&it, "refs/heads/branch-13");
+	check_int(err, ==, 0);
+	err = reftable_iterator_next_ref(&it, &ref);
+	check_int(err, ==, 0);
+	check(reftable_ref_record_equal(&ref, &expected_refs[13].u.ref,
+					REFTABLE_HASH_SIZE_SHA1));
+
+	for (size_t i = 0; i < ARRAY_SIZE(expected_refs); i++)
+		reftable_free(expected_refs[i].u.ref.refname);
+	reftable_ref_record_release(&ref);
+	reftable_iterator_destroy(&it);
+	reftable_block_release(&block);
+	block_writer_release(&writer);
+	reftable_buf_release(&data);
+}
+
 int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
 {
 	TEST(t_index_block_read_write(), "read-write operations on index blocks work");
 	TEST(t_log_block_read_write(), "read-write operations on log blocks work");
 	TEST(t_obj_block_read_write(), "read-write operations on obj blocks work");
 	TEST(t_ref_block_read_write(), "read-write operations on ref blocks work");
+	TEST(t_block_iterator(), "block iterator works");
 
 	return test_done();
 }
diff --git a/t/unit-tests/t-reftable-merged.c b/t/unit-tests/t-reftable-merged.c
index 60836f80d6..18c3251a56 100644
--- a/t/unit-tests/t-reftable-merged.c
+++ b/t/unit-tests/t-reftable-merged.c
@@ -11,7 +11,7 @@ https://developers.google.com/open-source/licenses/bsd
 #include "reftable/blocksource.h"
 #include "reftable/constants.h"
 #include "reftable/merged.h"
-#include "reftable/reader.h"
+#include "reftable/table.h"
 #include "reftable/reftable-error.h"
 #include "reftable/reftable-merged.h"
 #include "reftable/reftable-writer.h"
@@ -19,7 +19,7 @@ https://developers.google.com/open-source/licenses/bsd
 static struct reftable_merged_table *
 merged_table_from_records(struct reftable_ref_record **refs,
 			  struct reftable_block_source **source,
-			  struct reftable_reader ***readers, const size_t *sizes,
+			  struct reftable_table ***tables, const size_t *sizes,
 			  struct reftable_buf *buf, const size_t n)
 {
 	struct reftable_merged_table *mt = NULL;
@@ -28,8 +28,8 @@ merged_table_from_records(struct reftable_ref_record **refs,
 	};
 	int err;
 
-	REFTABLE_CALLOC_ARRAY(*readers, n);
-	check(*readers != NULL);
+	REFTABLE_CALLOC_ARRAY(*tables, n);
+	check(*tables != NULL);
 	REFTABLE_CALLOC_ARRAY(*source, n);
 	check(*source != NULL);
 
@@ -37,21 +37,21 @@ merged_table_from_records(struct reftable_ref_record **refs,
 		t_reftable_write_to_buf(&buf[i], refs[i], sizes[i], NULL, 0, &opts);
 		block_source_from_buf(&(*source)[i], &buf[i]);
 
-		err = reftable_reader_new(&(*readers)[i], &(*source)[i],
-					  "name");
+		err = reftable_table_new(&(*tables)[i], &(*source)[i],
+					 "name");
 		check(!err);
 	}
 
-	err = reftable_merged_table_new(&mt, *readers, n, REFTABLE_HASH_SHA1);
+	err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
 	check(!err);
 	return mt;
 }
 
-static void readers_destroy(struct reftable_reader **readers, const size_t n)
+static void tables_destroy(struct reftable_table **tables, const size_t n)
 {
 	for (size_t i = 0; i < n; i++)
-		reftable_reader_decref(readers[i]);
-	reftable_free(readers);
+		reftable_table_decref(tables[i]);
+	reftable_free(tables);
 }
 
 static void t_merged_single_record(void)
@@ -77,14 +77,14 @@ static void t_merged_single_record(void)
 	size_t sizes[] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
 	struct reftable_buf bufs[3] = { REFTABLE_BUF_INIT, REFTABLE_BUF_INIT, REFTABLE_BUF_INIT };
 	struct reftable_block_source *bs = NULL;
-	struct reftable_reader **readers = NULL;
+	struct reftable_table **tables = NULL;
 	struct reftable_merged_table *mt =
-		merged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);
+		merged_table_from_records(refs, &bs, &tables, sizes, bufs, 3);
 	struct reftable_ref_record ref = { 0 };
 	struct reftable_iterator it = { 0 };
 	int err;
 
-	err = merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+	err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, "a");
 	check(!err);
@@ -94,7 +94,7 @@ static void t_merged_single_record(void)
 	check(reftable_ref_record_equal(&r2[0], &ref, REFTABLE_HASH_SIZE_SHA1));
 	reftable_ref_record_release(&ref);
 	reftable_iterator_destroy(&it);
-	readers_destroy(readers, 3);
+	tables_destroy(tables, 3);
 	reftable_merged_table_free(mt);
 	for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
 		reftable_buf_release(&bufs[i]);
@@ -154,9 +154,9 @@ static void t_merged_refs(void)
 	size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
 	struct reftable_buf bufs[3] = { REFTABLE_BUF_INIT, REFTABLE_BUF_INIT, REFTABLE_BUF_INIT };
 	struct reftable_block_source *bs = NULL;
-	struct reftable_reader **readers = NULL;
+	struct reftable_table **tables = NULL;
 	struct reftable_merged_table *mt =
-		merged_table_from_records(refs, &bs, &readers, sizes, bufs, 3);
+		merged_table_from_records(refs, &bs, &tables, sizes, bufs, 3);
 	struct reftable_iterator it = { 0 };
 	int err;
 	struct reftable_ref_record *out = NULL;
@@ -164,7 +164,7 @@ static void t_merged_refs(void)
 	size_t cap = 0;
 	size_t i;
 
-	err = merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+	err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, "a");
 	check(!err);
@@ -193,7 +193,7 @@ static void t_merged_refs(void)
 
 	for (i = 0; i < 3; i++)
 		reftable_buf_release(&bufs[i]);
-	readers_destroy(readers, 3);
+	tables_destroy(tables, 3);
 	reftable_merged_table_free(mt);
 	reftable_free(bs);
 }
@@ -238,13 +238,13 @@ static void t_merged_seek_multiple_times(void)
 		REFTABLE_BUF_INIT, REFTABLE_BUF_INIT,
 	};
 	struct reftable_block_source *sources = NULL;
-	struct reftable_reader **readers = NULL;
+	struct reftable_table **tables = NULL;
 	struct reftable_ref_record rec = { 0 };
 	struct reftable_iterator it = { 0 };
 	struct reftable_merged_table *mt;
 
-	mt = merged_table_from_records(refs, &sources, &readers, sizes, bufs, 2);
-	merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+	mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);
+	merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
 
 	for (size_t i = 0; i < 5; i++) {
 		int err = reftable_iterator_seek_ref(&it, "c");
@@ -266,7 +266,7 @@ static void t_merged_seek_multiple_times(void)
 
 	for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
 		reftable_buf_release(&bufs[i]);
-	readers_destroy(readers, ARRAY_SIZE(refs));
+	tables_destroy(tables, ARRAY_SIZE(refs));
 	reftable_ref_record_release(&rec);
 	reftable_iterator_destroy(&it);
 	reftable_merged_table_free(mt);
@@ -313,14 +313,14 @@ static void t_merged_seek_multiple_times_without_draining(void)
 		REFTABLE_BUF_INIT, REFTABLE_BUF_INIT,
 	};
 	struct reftable_block_source *sources = NULL;
-	struct reftable_reader **readers = NULL;
+	struct reftable_table **tables = NULL;
 	struct reftable_ref_record rec = { 0 };
 	struct reftable_iterator it = { 0 };
 	struct reftable_merged_table *mt;
 	int err;
 
-	mt = merged_table_from_records(refs, &sources, &readers, sizes, bufs, 2);
-	merged_table_init_iter(mt, &it, BLOCK_TYPE_REF);
+	mt = merged_table_from_records(refs, &sources, &tables, sizes, bufs, 2);
+	merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_REF);
 
 	err = reftable_iterator_seek_ref(&it, "b");
 	check(!err);
@@ -338,7 +338,7 @@ static void t_merged_seek_multiple_times_without_draining(void)
 
 	for (size_t i = 0; i < ARRAY_SIZE(bufs); i++)
 		reftable_buf_release(&bufs[i]);
-	readers_destroy(readers, ARRAY_SIZE(refs));
+	tables_destroy(tables, ARRAY_SIZE(refs));
 	reftable_ref_record_release(&rec);
 	reftable_iterator_destroy(&it);
 	reftable_merged_table_free(mt);
@@ -348,7 +348,7 @@ static void t_merged_seek_multiple_times_without_draining(void)
 static struct reftable_merged_table *
 merged_table_from_log_records(struct reftable_log_record **logs,
 			      struct reftable_block_source **source,
-			      struct reftable_reader ***readers, const size_t *sizes,
+			      struct reftable_table ***tables, const size_t *sizes,
 			      struct reftable_buf *buf, const size_t n)
 {
 	struct reftable_merged_table *mt = NULL;
@@ -358,8 +358,8 @@ merged_table_from_log_records(struct reftable_log_record **logs,
 	};
 	int err;
 
-	REFTABLE_CALLOC_ARRAY(*readers, n);
-	check(*readers != NULL);
+	REFTABLE_CALLOC_ARRAY(*tables, n);
+	check(*tables != NULL);
 	REFTABLE_CALLOC_ARRAY(*source, n);
 	check(*source != NULL);
 
@@ -367,12 +367,12 @@ merged_table_from_log_records(struct reftable_log_record **logs,
 		t_reftable_write_to_buf(&buf[i], NULL, 0, logs[i], sizes[i], &opts);
 		block_source_from_buf(&(*source)[i], &buf[i]);
 
-		err = reftable_reader_new(&(*readers)[i], &(*source)[i],
-					  "name");
+		err = reftable_table_new(&(*tables)[i], &(*source)[i],
+					 "name");
 		check(!err);
 	}
 
-	err = reftable_merged_table_new(&mt, *readers, n, REFTABLE_HASH_SHA1);
+	err = reftable_merged_table_new(&mt, *tables, n, REFTABLE_HASH_SHA1);
 	check(!err);
 	return mt;
 }
@@ -435,9 +435,9 @@ static void t_merged_logs(void)
 	size_t sizes[3] = { ARRAY_SIZE(r1), ARRAY_SIZE(r2), ARRAY_SIZE(r3) };
 	struct reftable_buf bufs[3] = { REFTABLE_BUF_INIT, REFTABLE_BUF_INIT, REFTABLE_BUF_INIT };
 	struct reftable_block_source *bs = NULL;
-	struct reftable_reader **readers = NULL;
+	struct reftable_table **tables = NULL;
 	struct reftable_merged_table *mt = merged_table_from_log_records(
-		logs, &bs, &readers, sizes, bufs, 3);
+		logs, &bs, &tables, sizes, bufs, 3);
 	struct reftable_iterator it = { 0 };
 	int err;
 	struct reftable_log_record *out = NULL;
@@ -445,7 +445,7 @@ static void t_merged_logs(void)
 	size_t cap = 0;
 	size_t i;
 
-	err = merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);
+	err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
 	check(!err);
 	err = reftable_iterator_seek_log(&it, "a");
 	check(!err);
@@ -469,7 +469,7 @@ static void t_merged_logs(void)
 		check(reftable_log_record_equal(want[i], &out[i],
 						 REFTABLE_HASH_SIZE_SHA1));
 
-	err = merged_table_init_iter(mt, &it, BLOCK_TYPE_LOG);
+	err = merged_table_init_iter(mt, &it, REFTABLE_BLOCK_TYPE_LOG);
 	check(!err);
 	err = reftable_iterator_seek_log_at(&it, "a", 2);
 	check(!err);
@@ -485,7 +485,7 @@ static void t_merged_logs(void)
 
 	for (i = 0; i < 3; i++)
 		reftable_buf_release(&bufs[i]);
-	readers_destroy(readers, 3);
+	tables_destroy(tables, 3);
 	reftable_merged_table_free(mt);
 	reftable_free(bs);
 }
@@ -502,7 +502,7 @@ static void t_default_write_opts(void)
 	int err;
 	struct reftable_block_source source = { 0 };
 	uint32_t hash_id;
-	struct reftable_reader *rd = NULL;
+	struct reftable_table *table = NULL;
 	struct reftable_merged_table *merged = NULL;
 
 	reftable_writer_set_limits(w, 1, 1);
@@ -516,18 +516,18 @@ static void t_default_write_opts(void)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&rd, &source, "filename");
+	err = reftable_table_new(&table, &source, "filename");
 	check(!err);
 
-	hash_id = reftable_reader_hash_id(rd);
+	hash_id = reftable_table_hash_id(table);
 	check_int(hash_id, ==, REFTABLE_HASH_SHA1);
 
-	err = reftable_merged_table_new(&merged, &rd, 1, REFTABLE_HASH_SHA256);
+	err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA256);
 	check_int(err, ==, REFTABLE_FORMAT_ERROR);
-	err = reftable_merged_table_new(&merged, &rd, 1, REFTABLE_HASH_SHA1);
+	err = reftable_merged_table_new(&merged, &table, 1, REFTABLE_HASH_SHA1);
 	check(!err);
 
-	reftable_reader_decref(rd);
+	reftable_table_decref(table);
 	reftable_merged_table_free(merged);
 	reftable_buf_release(&buf);
 }
diff --git a/t/unit-tests/t-reftable-pq.c b/t/unit-tests/t-reftable-pq.c
index c128fe8616..fb5a4eb187 100644
--- a/t/unit-tests/t-reftable-pq.c
+++ b/t/unit-tests/t-reftable-pq.c
@@ -34,7 +34,7 @@ static void t_pq_record(void)
 	char *last = NULL;
 
 	for (i = 0; i < N; i++) {
-		check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
+		check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
 		recs[i].u.ref.refname = xstrfmt("%02"PRIuMAX, (uintmax_t)i);
 	}
 
@@ -57,7 +57,7 @@ static void t_pq_record(void)
 		merged_iter_pqueue_check(&pq);
 
 		check(pq_entry_equal(&top, &e));
-		check(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
+		check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
 		if (last)
 			check_int(strcmp(last, e.rec->u.ref.refname), <, 0);
 		last = e.rec->u.ref.refname;
@@ -76,7 +76,7 @@ static void t_pq_index(void)
 	size_t N = ARRAY_SIZE(recs), i;
 
 	for (i = 0; i < N; i++) {
-		check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
+		check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
 		recs[i].u.ref.refname = (char *) "refs/heads/master";
 	}
 
@@ -100,7 +100,7 @@ static void t_pq_index(void)
 		merged_iter_pqueue_check(&pq);
 
 		check(pq_entry_equal(&top, &e));
-		check(reftable_record_type(e.rec) == BLOCK_TYPE_REF);
+		check(reftable_record_type(e.rec) == REFTABLE_BLOCK_TYPE_REF);
 		check_int(e.index, ==, i);
 		if (last)
 			check_str(last, e.rec->u.ref.refname);
@@ -117,7 +117,7 @@ static void t_merged_iter_pqueue_top(void)
 	size_t N = ARRAY_SIZE(recs), i;
 
 	for (i = 0; i < N; i++) {
-		check(!reftable_record_init(&recs[i], BLOCK_TYPE_REF));
+		check(!reftable_record_init(&recs[i], REFTABLE_BLOCK_TYPE_REF));
 		recs[i].u.ref.refname = (char *) "refs/heads/master";
 	}
 
diff --git a/t/unit-tests/t-reftable-reader.c b/t/unit-tests/t-reftable-reader.c
deleted file mode 100644
index 546df6005e..0000000000
--- a/t/unit-tests/t-reftable-reader.c
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "test-lib.h"
-#include "lib-reftable.h"
-#include "reftable/blocksource.h"
-#include "reftable/reader.h"
-
-static int t_reader_seek_once(void)
-{
-	struct reftable_ref_record records[] = {
-		{
-			.refname = (char *) "refs/heads/main",
-			.value_type = REFTABLE_REF_VAL1,
-			.value.val1 = { 42 },
-		},
-	};
-	struct reftable_block_source source = { 0 };
-	struct reftable_ref_record ref = { 0 };
-	struct reftable_iterator it = { 0 };
-	struct reftable_reader *reader;
-	struct reftable_buf buf = REFTABLE_BUF_INIT;
-	int ret;
-
-	t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
-	block_source_from_buf(&source, &buf);
-
-	ret = reftable_reader_new(&reader, &source, "name");
-	check(!ret);
-
-	reftable_reader_init_ref_iterator(reader, &it);
-	ret = reftable_iterator_seek_ref(&it, "");
-	check(!ret);
-	ret = reftable_iterator_next_ref(&it, &ref);
-	check(!ret);
-
-	ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
-	check_int(ret, ==, 1);
-
-	ret = reftable_iterator_next_ref(&it, &ref);
-	check_int(ret, ==, 1);
-
-	reftable_ref_record_release(&ref);
-	reftable_iterator_destroy(&it);
-	reftable_reader_decref(reader);
-	reftable_buf_release(&buf);
-	return 0;
-}
-
-static int t_reader_reseek(void)
-{
-	struct reftable_ref_record records[] = {
-		{
-			.refname = (char *) "refs/heads/main",
-			.value_type = REFTABLE_REF_VAL1,
-			.value.val1 = { 42 },
-		},
-	};
-	struct reftable_block_source source = { 0 };
-	struct reftable_ref_record ref = { 0 };
-	struct reftable_iterator it = { 0 };
-	struct reftable_reader *reader;
-	struct reftable_buf buf = REFTABLE_BUF_INIT;
-	int ret;
-
-	t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
-	block_source_from_buf(&source, &buf);
-
-	ret = reftable_reader_new(&reader, &source, "name");
-	check(!ret);
-
-	reftable_reader_init_ref_iterator(reader, &it);
-
-	for (size_t i = 0; i < 5; i++) {
-		ret = reftable_iterator_seek_ref(&it, "");
-		check(!ret);
-		ret = reftable_iterator_next_ref(&it, &ref);
-		check(!ret);
-
-		ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
-		check_int(ret, ==, 1);
-
-		ret = reftable_iterator_next_ref(&it, &ref);
-		check_int(ret, ==, 1);
-	}
-
-	reftable_ref_record_release(&ref);
-	reftable_iterator_destroy(&it);
-	reftable_reader_decref(reader);
-	reftable_buf_release(&buf);
-	return 0;
-}
-
-int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
-{
-	TEST(t_reader_seek_once(), "reader can seek once");
-	TEST(t_reader_reseek(), "reader can reseek multiple times");
-	return test_done();
-}
diff --git a/t/unit-tests/t-reftable-readwrite.c b/t/unit-tests/t-reftable-readwrite.c
index c9626831da..4c49129439 100644
--- a/t/unit-tests/t-reftable-readwrite.c
+++ b/t/unit-tests/t-reftable-readwrite.c
@@ -12,9 +12,9 @@ https://developers.google.com/open-source/licenses/bsd
 #include "lib-reftable.h"
 #include "reftable/basics.h"
 #include "reftable/blocksource.h"
-#include "reftable/reader.h"
 #include "reftable/reftable-error.h"
 #include "reftable/reftable-writer.h"
+#include "reftable/table.h"
 #include "strbuf.h"
 
 static const int update_index = 5;
@@ -23,22 +23,22 @@ static void t_buffer(void)
 {
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	struct reftable_block_source source = { 0 };
-	struct reftable_block out = { 0 };
+	struct reftable_block_data out = { 0 };
 	int n;
 	uint8_t in[] = "hello";
 	check(!reftable_buf_add(&buf, in, sizeof(in)));
 	block_source_from_buf(&source, &buf);
 	check_int(block_source_size(&source), ==, 6);
-	n = block_source_read_block(&source, &out, 0, sizeof(in));
+	n = block_source_read_data(&source, &out, 0, sizeof(in));
 	check_int(n, ==, sizeof(in));
 	check(!memcmp(in, out.data, n));
-	reftable_block_done(&out);
+	block_source_release_data(&out);
 
-	n = block_source_read_block(&source, &out, 1, 2);
+	n = block_source_read_data(&source, &out, 1, 2);
 	check_int(n, ==, 2);
 	check(!memcmp(out.data, "el", 2));
 
-	reftable_block_done(&out);
+	block_source_release_data(&out);
 	block_source_close(&source);
 	reftable_buf_release(&buf);
 }
@@ -204,7 +204,7 @@ static void t_log_write_read(void)
 	struct reftable_ref_record ref = { 0 };
 	struct reftable_log_record log = { 0 };
 	struct reftable_iterator it = { 0 };
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	struct reftable_block_source source = { 0 };
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ -254,10 +254,10 @@ static void t_log_write_read(void)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&reader, &source, "file.log");
+	err = reftable_table_new(&table, &source, "file.log");
 	check(!err);
 
-	err = reftable_reader_init_ref_iterator(reader, &it);
+	err = reftable_table_init_ref_iterator(table, &it);
 	check(!err);
 
 	err = reftable_iterator_seek_ref(&it, names[N - 1]);
@@ -273,7 +273,7 @@ static void t_log_write_read(void)
 	reftable_iterator_destroy(&it);
 	reftable_ref_record_release(&ref);
 
-	err = reftable_reader_init_log_iterator(reader, &it);
+	err = reftable_table_init_log_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_log(&it, "");
 	check(!err);
@@ -294,7 +294,7 @@ static void t_log_write_read(void)
 	/* cleanup. */
 	reftable_buf_release(&buf);
 	free_names(names);
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 }
 
 static void t_log_zlib_corruption(void)
@@ -303,7 +303,7 @@ static void t_log_zlib_corruption(void)
 		.block_size = 256,
 	};
 	struct reftable_iterator it = { 0 };
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	struct reftable_block_source source = { 0 };
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ -345,10 +345,10 @@ static void t_log_zlib_corruption(void)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&reader, &source, "file.log");
+	err = reftable_table_new(&table, &source, "file.log");
 	check(!err);
 
-	err = reftable_reader_init_log_iterator(reader, &it);
+	err = reftable_table_init_log_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_log(&it, "refname");
 	check_int(err, ==, REFTABLE_ZLIB_ERROR);
@@ -356,7 +356,7 @@ static void t_log_zlib_corruption(void)
 	reftable_iterator_destroy(&it);
 
 	/* cleanup. */
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 	reftable_buf_release(&buf);
 }
 
@@ -367,7 +367,7 @@ static void t_table_read_write_sequential(void)
 	int N = 50;
 	struct reftable_iterator it = { 0 };
 	struct reftable_block_source source = { 0 };
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	int err = 0;
 	int j = 0;
 
@@ -375,10 +375,10 @@ static void t_table_read_write_sequential(void)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&reader, &source, "file.ref");
+	err = reftable_table_new(&table, &source, "file.ref");
 	check(!err);
 
-	err = reftable_reader_init_ref_iterator(reader, &it);
+	err = reftable_table_init_ref_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, "");
 	check(!err);
@@ -396,7 +396,7 @@ static void t_table_read_write_sequential(void)
 	check_int(j, ==, N);
 
 	reftable_iterator_destroy(&it);
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 	reftable_buf_release(&buf);
 	free_names(names);
 }
@@ -417,7 +417,7 @@ static void t_table_read_api(void)
 	char **names;
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	int N = 50;
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	struct reftable_block_source source = { 0 };
 	int err;
 	struct reftable_log_record log = { 0 };
@@ -427,10 +427,10 @@ static void t_table_read_api(void)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&reader, &source, "file.ref");
+	err = reftable_table_new(&table, &source, "file.ref");
 	check(!err);
 
-	err = reftable_reader_init_ref_iterator(reader, &it);
+	err = reftable_table_init_ref_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, names[0]);
 	check(!err);
@@ -441,7 +441,7 @@ static void t_table_read_api(void)
 	reftable_buf_release(&buf);
 	free_names(names);
 	reftable_iterator_destroy(&it);
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 	reftable_buf_release(&buf);
 }
 
@@ -450,7 +450,7 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
 	char **names;
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	int N = 50;
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	struct reftable_block_source source = { 0 };
 	int err;
 	int i = 0;
@@ -463,18 +463,18 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&reader, &source, "file.ref");
+	err = reftable_table_new(&table, &source, "file.ref");
 	check(!err);
-	check_int(hash_id, ==, reftable_reader_hash_id(reader));
+	check_int(hash_id, ==, reftable_table_hash_id(table));
 
 	if (!index) {
-		reader->ref_offsets.index_offset = 0;
+		table->ref_offsets.index_offset = 0;
 	} else {
-		check_int(reader->ref_offsets.index_offset, >, 0);
+		check_int(table->ref_offsets.index_offset, >, 0);
 	}
 
 	for (i = 1; i < N; i++) {
-		err = reftable_reader_init_ref_iterator(reader, &it);
+		err = reftable_table_init_ref_iterator(table, &it);
 		check(!err);
 		err = reftable_iterator_seek_ref(&it, names[i]);
 		check(!err);
@@ -491,7 +491,7 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
 	check(!reftable_buf_addstr(&pastLast, names[N - 1]));
 	check(!reftable_buf_addstr(&pastLast, "/"));
 
-	err = reftable_reader_init_ref_iterator(reader, &it);
+	err = reftable_table_init_ref_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, pastLast.buf);
 	if (err == 0) {
@@ -507,7 +507,7 @@ static void t_table_read_write_seek(int index, enum reftable_hash hash_id)
 
 	reftable_buf_release(&buf);
 	free_names(names);
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 }
 
 static void t_table_read_write_seek_linear(void)
@@ -535,7 +535,7 @@ static void t_table_refs_for(int indexed)
 		.block_size = 256,
 	};
 	struct reftable_ref_record ref = { 0 };
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	struct reftable_block_source source = { 0 };
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
@@ -585,18 +585,18 @@ static void t_table_refs_for(int indexed)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&reader, &source, "file.ref");
+	err = reftable_table_new(&table, &source, "file.ref");
 	check(!err);
 	if (!indexed)
-		reader->obj_offsets.is_present = 0;
+		table->obj_offsets.is_present = 0;
 
-	err = reftable_reader_init_ref_iterator(reader, &it);
+	err = reftable_table_init_ref_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, "");
 	check(!err);
 	reftable_iterator_destroy(&it);
 
-	err = reftable_reader_refs_for(reader, &it, want_hash);
+	err = reftable_table_refs_for(table, &it, want_hash);
 	check(!err);
 
 	for (j = 0; ; j++) {
@@ -613,7 +613,7 @@ static void t_table_refs_for(int indexed)
 	reftable_buf_release(&buf);
 	free_names(want_names);
 	reftable_iterator_destroy(&it);
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 }
 
 static void t_table_refs_for_no_index(void)
@@ -632,7 +632,7 @@ static void t_write_empty_table(void)
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	struct reftable_writer *w = t_reftable_strbuf_writer(&buf, &opts);
 	struct reftable_block_source source = { 0 };
-	struct reftable_reader *rd = NULL;
+	struct reftable_table *table = NULL;
 	struct reftable_ref_record rec = { 0 };
 	struct reftable_iterator it = { 0 };
 	int err;
@@ -647,10 +647,10 @@ static void t_write_empty_table(void)
 
 	block_source_from_buf(&source, &buf);
 
-	err = reftable_reader_new(&rd, &source, "filename");
+	err = reftable_table_new(&table, &source, "filename");
 	check(!err);
 
-	err = reftable_reader_init_ref_iterator(rd, &it);
+	err = reftable_table_init_ref_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, "");
 	check(!err);
@@ -659,7 +659,7 @@ static void t_write_empty_table(void)
 	check_int(err, >, 0);
 
 	reftable_iterator_destroy(&it);
-	reftable_reader_decref(rd);
+	reftable_table_decref(table);
 	reftable_buf_release(&buf);
 }
 
@@ -803,7 +803,7 @@ static void t_write_multiple_indices(void)
 	struct reftable_iterator it = { 0 };
 	const struct reftable_stats *stats;
 	struct reftable_writer *writer;
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	char buf[128];
 	int err, i;
 
@@ -852,21 +852,21 @@ static void t_write_multiple_indices(void)
 	check_int(stats->log_stats.index_offset, >, 0);
 
 	block_source_from_buf(&source, &writer_buf);
-	err = reftable_reader_new(&reader, &source, "filename");
+	err = reftable_table_new(&table, &source, "filename");
 	check(!err);
 
 	/*
 	 * Seeking the log uses the log index now. In case there is any
 	 * confusion regarding indices we would notice here.
 	 */
-	err = reftable_reader_init_log_iterator(reader, &it);
+	err = reftable_table_init_log_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_log(&it, "");
 	check(!err);
 
 	reftable_iterator_destroy(&it);
 	reftable_writer_free(writer);
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 	reftable_buf_release(&writer_buf);
 }
 
@@ -880,7 +880,7 @@ static void t_write_multi_level_index(void)
 	struct reftable_iterator it = { 0 };
 	const struct reftable_stats *stats;
 	struct reftable_writer *writer;
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	int err;
 
 	writer = t_reftable_strbuf_writer(&writer_buf, &opts);
@@ -909,20 +909,20 @@ static void t_write_multi_level_index(void)
 	check_int(stats->ref_stats.max_index_level, ==, 2);
 
 	block_source_from_buf(&source, &writer_buf);
-	err = reftable_reader_new(&reader, &source, "filename");
+	err = reftable_table_new(&table, &source, "filename");
 	check(!err);
 
 	/*
 	 * Seeking the last ref should work as expected.
 	 */
-	err = reftable_reader_init_ref_iterator(reader, &it);
+	err = reftable_table_init_ref_iterator(table, &it);
 	check(!err);
 	err = reftable_iterator_seek_ref(&it, "refs/heads/199");
 	check(!err);
 
 	reftable_iterator_destroy(&it);
 	reftable_writer_free(writer);
-	reftable_reader_decref(reader);
+	reftable_table_decref(table);
 	reftable_buf_release(&writer_buf);
 	reftable_buf_release(&buf);
 }
@@ -931,11 +931,11 @@ static void t_corrupt_table_empty(void)
 {
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	struct reftable_block_source source = { 0 };
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	int err;
 
 	block_source_from_buf(&source, &buf);
-	err = reftable_reader_new(&reader, &source, "file.log");
+	err = reftable_table_new(&table, &source, "file.log");
 	check_int(err, ==, REFTABLE_FORMAT_ERROR);
 }
 
@@ -944,12 +944,12 @@ static void t_corrupt_table(void)
 	uint8_t zeros[1024] = { 0 };
 	struct reftable_buf buf = REFTABLE_BUF_INIT;
 	struct reftable_block_source source = { 0 };
-	struct reftable_reader *reader;
+	struct reftable_table *table;
 	int err;
 	check(!reftable_buf_add(&buf, zeros, sizeof(zeros)));
 
 	block_source_from_buf(&source, &buf);
-	err = reftable_reader_new(&reader, &source, "file.log");
+	err = reftable_table_new(&table, &source, "file.log");
 	check_int(err, ==, REFTABLE_FORMAT_ERROR);
 
 	reftable_buf_release(&buf);
diff --git a/t/unit-tests/t-reftable-record.c b/t/unit-tests/t-reftable-record.c
index 5954966373..553a007664 100644
--- a/t/unit-tests/t-reftable-record.c
+++ b/t/unit-tests/t-reftable-record.c
@@ -84,17 +84,17 @@ static void t_reftable_ref_record_comparison(void)
 {
 	struct reftable_record in[3] = {
 		{
-			.type = BLOCK_TYPE_REF,
+			.type = REFTABLE_BLOCK_TYPE_REF,
 			.u.ref.refname = (char *) "refs/heads/master",
 			.u.ref.value_type = REFTABLE_REF_VAL1,
 		},
 		{
-			.type = BLOCK_TYPE_REF,
+			.type = REFTABLE_BLOCK_TYPE_REF,
 			.u.ref.refname = (char *) "refs/heads/master",
 			.u.ref.value_type = REFTABLE_REF_DELETION,
 		},
 		{
-			.type = BLOCK_TYPE_REF,
+			.type = REFTABLE_BLOCK_TYPE_REF,
 			.u.ref.refname = (char *) "HEAD",
 			.u.ref.value_type = REFTABLE_REF_SYMREF,
 			.u.ref.value.symref = (char *) "refs/heads/master",
@@ -141,10 +141,10 @@ static void t_reftable_ref_record_roundtrip(void)
 
 	for (int i = REFTABLE_REF_DELETION; i < REFTABLE_NR_REF_VALUETYPES; i++) {
 		struct reftable_record in = {
-			.type = BLOCK_TYPE_REF,
+			.type = REFTABLE_BLOCK_TYPE_REF,
 			.u.ref.value_type = i,
 		};
-		struct reftable_record out = { .type = BLOCK_TYPE_REF };
+		struct reftable_record out = { .type = REFTABLE_BLOCK_TYPE_REF };
 		struct reftable_buf key = REFTABLE_BUF_INIT;
 		uint8_t buffer[1024] = { 0 };
 		struct string_view dest = {
@@ -198,17 +198,17 @@ static void t_reftable_log_record_comparison(void)
 {
 	struct reftable_record in[3] = {
 		{
-			.type = BLOCK_TYPE_LOG,
+			.type = REFTABLE_BLOCK_TYPE_LOG,
 			.u.log.refname = (char *) "refs/heads/master",
 			.u.log.update_index = 42,
 		},
 		{
-			.type = BLOCK_TYPE_LOG,
+			.type = REFTABLE_BLOCK_TYPE_LOG,
 			.u.log.refname = (char *) "refs/heads/master",
 			.u.log.update_index = 22,
 		},
 		{
-			.type = BLOCK_TYPE_LOG,
+			.type = REFTABLE_BLOCK_TYPE_LOG,
 			.u.log.refname = (char *) "refs/heads/main",
 			.u.log.update_index = 22,
 		},
@@ -297,7 +297,7 @@ static void t_reftable_log_record_roundtrip(void)
 	check(!reftable_log_record_is_deletion(&in[2]));
 
 	for (size_t i = 0; i < ARRAY_SIZE(in); i++) {
-		struct reftable_record rec = { .type = BLOCK_TYPE_LOG };
+		struct reftable_record rec = { .type = REFTABLE_BLOCK_TYPE_LOG };
 		struct reftable_buf key = REFTABLE_BUF_INIT;
 		uint8_t buffer[1024] = { 0 };
 		struct string_view dest = {
@@ -306,7 +306,7 @@ static void t_reftable_log_record_roundtrip(void)
 		};
 		/* populate out, to check for leaks. */
 		struct reftable_record out = {
-			.type = BLOCK_TYPE_LOG,
+			.type = REFTABLE_BLOCK_TYPE_LOG,
 			.u.log = {
 				.refname = xstrdup("old name"),
 				.value_type = REFTABLE_LOG_UPDATE,
@@ -384,21 +384,21 @@ static void t_reftable_obj_record_comparison(void)
 	uint64_t offsets[] = { 0, 16, 32, 48, 64, 80, 96, 112};
 	struct reftable_record in[3] = {
 		{
-			.type = BLOCK_TYPE_OBJ,
+			.type = REFTABLE_BLOCK_TYPE_OBJ,
 			.u.obj.hash_prefix = id_bytes,
 			.u.obj.hash_prefix_len = 7,
 			.u.obj.offsets = offsets,
 			.u.obj.offset_len = 8,
 		},
 		{
-			.type = BLOCK_TYPE_OBJ,
+			.type = REFTABLE_BLOCK_TYPE_OBJ,
 			.u.obj.hash_prefix = id_bytes,
 			.u.obj.hash_prefix_len = 7,
 			.u.obj.offsets = offsets,
 			.u.obj.offset_len = 5,
 		},
 		{
-			.type = BLOCK_TYPE_OBJ,
+			.type = REFTABLE_BLOCK_TYPE_OBJ,
 			.u.obj.hash_prefix = id_bytes,
 			.u.obj.hash_prefix_len = 5,
 		},
@@ -450,13 +450,13 @@ static void t_reftable_obj_record_roundtrip(void)
 			.len = sizeof(buffer),
 		};
 		struct reftable_record in = {
-			.type = BLOCK_TYPE_OBJ,
+			.type = REFTABLE_BLOCK_TYPE_OBJ,
 			.u = {
 				.obj = recs[i],
 			},
 		};
 		struct reftable_buf key = REFTABLE_BUF_INIT;
-		struct reftable_record out = { .type = BLOCK_TYPE_OBJ };
+		struct reftable_record out = { .type = REFTABLE_BLOCK_TYPE_OBJ };
 		int n, m;
 		uint8_t extra;
 
@@ -482,17 +482,17 @@ static void t_reftable_index_record_comparison(void)
 {
 	struct reftable_record in[3] = {
 		{
-			.type = BLOCK_TYPE_INDEX,
+			.type = REFTABLE_BLOCK_TYPE_INDEX,
 			.u.idx.offset = 22,
 			.u.idx.last_key = REFTABLE_BUF_INIT,
 		},
 		{
-			.type = BLOCK_TYPE_INDEX,
+			.type = REFTABLE_BLOCK_TYPE_INDEX,
 			.u.idx.offset = 32,
 			.u.idx.last_key = REFTABLE_BUF_INIT,
 		},
 		{
-			.type = BLOCK_TYPE_INDEX,
+			.type = REFTABLE_BLOCK_TYPE_INDEX,
 			.u.idx.offset = 32,
 			.u.idx.last_key = REFTABLE_BUF_INIT,
 		},
@@ -523,7 +523,7 @@ static void t_reftable_index_record_comparison(void)
 static void t_reftable_index_record_roundtrip(void)
 {
 	struct reftable_record in = {
-		.type = BLOCK_TYPE_INDEX,
+		.type = REFTABLE_BLOCK_TYPE_INDEX,
 		.u.idx = {
 			.offset = 42,
 			.last_key = REFTABLE_BUF_INIT,
@@ -537,7 +537,7 @@ static void t_reftable_index_record_roundtrip(void)
 	struct reftable_buf scratch = REFTABLE_BUF_INIT;
 	struct reftable_buf key = REFTABLE_BUF_INIT;
 	struct reftable_record out = {
-		.type = BLOCK_TYPE_INDEX,
+		.type = REFTABLE_BLOCK_TYPE_INDEX,
 		.u.idx = { .last_key = REFTABLE_BUF_INIT },
 	};
 	int n, m;
diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/t-reftable-stack.c
index c3f0059c34..2f49c97519 100644
--- a/t/unit-tests/t-reftable-stack.c
+++ b/t/unit-tests/t-reftable-stack.c
@@ -12,9 +12,9 @@ https://developers.google.com/open-source/licenses/bsd
 #include "lib-reftable.h"
 #include "dir.h"
 #include "reftable/merged.h"
-#include "reftable/reader.h"
 #include "reftable/reftable-error.h"
 #include "reftable/stack.h"
+#include "reftable/table.h"
 #include "strbuf.h"
 #include "tempfile.h"
 #include <dirent.h>
@@ -176,7 +176,7 @@ static void t_reftable_stack_add_one(void)
 	err = reftable_stack_read_ref(st, ref.refname, &dest);
 	check(!err);
 	check(reftable_ref_record_equal(&ref, &dest, REFTABLE_HASH_SIZE_SHA1));
-	check_int(st->readers_len, >, 0);
+	check_int(st->tables_len, >, 0);
 
 #ifndef GIT_WINDOWS_NATIVE
 	check(!reftable_buf_addstr(&scratch, dir));
@@ -189,7 +189,7 @@ static void t_reftable_stack_add_one(void)
 	check(!reftable_buf_addstr(&scratch, dir));
 	check(!reftable_buf_addstr(&scratch, "/"));
 	/* do not try at home; not an external API for reftable. */
-	check(!reftable_buf_addstr(&scratch, st->readers[0]->name));
+	check(!reftable_buf_addstr(&scratch, st->tables[0]->name));
 	err = stat(scratch.buf, &stat_result);
 	check(!err);
 	check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
@@ -402,9 +402,9 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void)
 		 * all tables in the stack.
 		 */
 		if (i != n)
-			check_int(st->merged->readers_len, ==, i + 1);
+			check_int(st->merged->tables_len, ==, i + 1);
 		else
-			check_int(st->merged->readers_len, ==, 1);
+			check_int(st->merged->tables_len, ==, 1);
 	}
 
 	reftable_stack_destroy(st);
@@ -430,7 +430,7 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
 
 	err = reftable_stack_add(st, write_test_ref, &ref);
 	check(!err);
-	check_int(st->merged->readers_len, ==, 1);
+	check_int(st->merged->tables_len, ==, 1);
 	check_int(st->stats.attempts, ==, 0);
 	check_int(st->stats.failures, ==, 0);
 
@@ -441,14 +441,14 @@ static void t_reftable_stack_auto_compaction_fails_gracefully(void)
 	 */
 	check(!reftable_buf_addstr(&table_path, dir));
 	check(!reftable_buf_addstr(&table_path, "/"));
-	check(!reftable_buf_addstr(&table_path, st->readers[0]->name));
+	check(!reftable_buf_addstr(&table_path, st->tables[0]->name));
 	check(!reftable_buf_addstr(&table_path, ".lock"));
 	write_file_buf(table_path.buf, "", 0);
 
 	ref.update_index = 2;
 	err = reftable_stack_add(st, write_test_ref, &ref);
 	check(!err);
-	check_int(st->merged->readers_len, ==, 2);
+	check_int(st->merged->tables_len, ==, 2);
 	check_int(st->stats.attempts, ==, 1);
 	check_int(st->stats.failures, ==, 1);
 
@@ -592,7 +592,7 @@ static void t_reftable_stack_add(void)
 	check(!reftable_buf_addstr(&path, dir));
 	check(!reftable_buf_addstr(&path, "/"));
 	/* do not try at home; not an external API for reftable. */
-	check(!reftable_buf_addstr(&path, st->readers[0]->name));
+	check(!reftable_buf_addstr(&path, st->tables[0]->name));
 	err = stat(path.buf, &stat_result);
 	check(!err);
 	check_int((stat_result.st_mode & 0777), ==, opts.default_permissions);
@@ -1026,7 +1026,7 @@ static void t_reftable_stack_auto_compaction(void)
 
 		err = reftable_stack_auto_compact(st);
 		check(!err);
-		check(i < 2 || st->merged->readers_len < 2 * fastlogN(i, 2));
+		check(i < 2 || st->merged->tables_len < 2 * fastlogN(i, 2));
 	}
 
 	check_int(reftable_stack_compaction_stats(st)->entries_written, <,
@@ -1061,7 +1061,7 @@ static void t_reftable_stack_auto_compaction_factor(void)
 		err = reftable_stack_add(st, &write_test_ref, &ref);
 		check(!err);
 
-		check(i < 5 || st->merged->readers_len < 5 * fastlogN(i, 5));
+		check(i < 5 || st->merged->tables_len < 5 * fastlogN(i, 5));
 	}
 
 	reftable_stack_destroy(st);
@@ -1082,7 +1082,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
 	check(!err);
 
 	write_n_ref_tables(st, 5);
-	check_int(st->merged->readers_len, ==, 5);
+	check_int(st->merged->tables_len, ==, 5);
 
 	/*
 	 * Given that all tables we have written should be roughly the same
@@ -1091,7 +1091,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
 	 */
 	check(!reftable_buf_addstr(&buf, dir));
 	check(!reftable_buf_addstr(&buf, "/"));
-	check(!reftable_buf_addstr(&buf, st->readers[2]->name));
+	check(!reftable_buf_addstr(&buf, st->tables[2]->name));
 	check(!reftable_buf_addstr(&buf, ".lock"));
 	write_file_buf(buf.buf, "", 0);
 
@@ -1104,7 +1104,7 @@ static void t_reftable_stack_auto_compaction_with_locked_tables(void)
 	err = reftable_stack_auto_compact(st);
 	check(!err);
 	check_int(st->stats.failures, ==, 0);
-	check_int(st->merged->readers_len, ==, 4);
+	check_int(st->merged->tables_len, ==, 4);
 
 	reftable_stack_destroy(st);
 	reftable_buf_release(&buf);
@@ -1149,9 +1149,9 @@ static void t_reftable_stack_add_performs_auto_compaction(void)
 		 * all tables in the stack.
 		 */
 		if (i != n)
-			check_int(st->merged->readers_len, ==, i + 1);
+			check_int(st->merged->tables_len, ==, i + 1);
 		else
-			check_int(st->merged->readers_len, ==, 1);
+			check_int(st->merged->tables_len, ==, 1);
 	}
 
 	reftable_stack_destroy(st);
@@ -1172,12 +1172,12 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
 	check(!err);
 
 	write_n_ref_tables(st, 3);
-	check_int(st->merged->readers_len, ==, 3);
+	check_int(st->merged->tables_len, ==, 3);
 
 	/* Lock one of the tables that we're about to compact. */
 	check(!reftable_buf_addstr(&buf, dir));
 	check(!reftable_buf_addstr(&buf, "/"));
-	check(!reftable_buf_addstr(&buf, st->readers[1]->name));
+	check(!reftable_buf_addstr(&buf, st->tables[1]->name));
 	check(!reftable_buf_addstr(&buf, ".lock"));
 	write_file_buf(buf.buf, "", 0);
 
@@ -1188,7 +1188,7 @@ static void t_reftable_stack_compaction_with_locked_tables(void)
 	err = reftable_stack_compact_all(st, NULL);
 	check_int(err, ==, REFTABLE_LOCK_ERROR);
 	check_int(st->stats.failures, ==, 1);
-	check_int(st->merged->readers_len, ==, 3);
+	check_int(st->merged->tables_len, ==, 3);
 
 	reftable_stack_destroy(st);
 	reftable_buf_release(&buf);
@@ -1222,10 +1222,10 @@ static void t_reftable_stack_compaction_concurrent(void)
 static void unclean_stack_close(struct reftable_stack *st)
 {
 	/* break abstraction boundary to simulate unclean shutdown. */
-	for (size_t i = 0; i < st->readers_len; i++)
-		reftable_reader_decref(st->readers[i]);
-	st->readers_len = 0;
-	REFTABLE_FREE_AND_NULL(st->readers);
+	for (size_t i = 0; i < st->tables_len; i++)
+		reftable_table_decref(st->tables[i]);
+	st->tables_len = 0;
+	REFTABLE_FREE_AND_NULL(st->tables);
 }
 
 static void t_reftable_stack_compaction_concurrent_clean(void)
@@ -1275,7 +1275,7 @@ static void t_reftable_stack_read_across_reload(void)
 	err = reftable_new_stack(&st1, dir, &opts);
 	check(!err);
 	write_n_ref_tables(st1, 2);
-	check_int(st1->merged->readers_len, ==, 2);
+	check_int(st1->merged->tables_len, ==, 2);
 	reftable_stack_init_ref_iterator(st1, &it);
 	err = reftable_iterator_seek_ref(&it, "");
 	check(!err);
@@ -1283,10 +1283,10 @@ static void t_reftable_stack_read_across_reload(void)
 	/* Set up a second stack for the same directory and compact it. */
 	err = reftable_new_stack(&st2, dir, &opts);
 	check(!err);
-	check_int(st2->merged->readers_len, ==, 2);
+	check_int(st2->merged->tables_len, ==, 2);
 	err = reftable_stack_compact_all(st2, NULL);
 	check(!err);
-	check_int(st2->merged->readers_len, ==, 1);
+	check_int(st2->merged->tables_len, ==, 1);
 
 	/*
 	 * Verify that we can continue to use the old iterator even after we
@@ -1294,7 +1294,7 @@ static void t_reftable_stack_read_across_reload(void)
 	 */
 	err = reftable_stack_reload(st1);
 	check(!err);
-	check_int(st1->merged->readers_len, ==, 1);
+	check_int(st1->merged->tables_len, ==, 1);
 	err = reftable_iterator_next_ref(&it, &rec);
 	check(!err);
 	check_str(rec.refname, "refs/heads/branch-0000");
@@ -1325,19 +1325,19 @@ static void t_reftable_stack_reload_with_missing_table(void)
 	err = reftable_new_stack(&st, dir, &opts);
 	check(!err);
 	write_n_ref_tables(st, 2);
-	check_int(st->merged->readers_len, ==, 2);
+	check_int(st->merged->tables_len, ==, 2);
 	reftable_stack_init_ref_iterator(st, &it);
 	err = reftable_iterator_seek_ref(&it, "");
 	check(!err);
 
 	/*
 	 * Update the tables.list file with some garbage data, while reusing
-	 * our old readers. This should trigger a partial reload of the stack,
-	 * where we try to reuse our old readers.
+	 * our old tables. This should trigger a partial reload of the stack,
+	 * where we try to reuse our old tables.
 	*/
-	check(!reftable_buf_addstr(&content, st->readers[0]->name));
+	check(!reftable_buf_addstr(&content, st->tables[0]->name));
 	check(!reftable_buf_addstr(&content, "\n"));
-	check(!reftable_buf_addstr(&content, st->readers[1]->name));
+	check(!reftable_buf_addstr(&content, st->tables[1]->name));
 	check(!reftable_buf_addstr(&content, "\n"));
 	check(!reftable_buf_addstr(&content, "garbage\n"));
 	check(!reftable_buf_addstr(&table_path, st->list_file));
@@ -1348,7 +1348,7 @@ static void t_reftable_stack_reload_with_missing_table(void)
 
 	err = reftable_stack_reload(st);
 	check_int(err, ==, -4);
-	check_int(st->merged->readers_len, ==, 2);
+	check_int(st->merged->tables_len, ==, 2);
 
 	/*
 	 * Even though the reload has failed, we should be able to continue
diff --git a/t/unit-tests/t-reftable-table.c b/t/unit-tests/t-reftable-table.c
new file mode 100644
index 0000000000..7e1eb533d0
--- /dev/null
+++ b/t/unit-tests/t-reftable-table.c
@@ -0,0 +1,206 @@
+#include "test-lib.h"
+#include "lib-reftable.h"
+#include "reftable/blocksource.h"
+#include "reftable/constants.h"
+#include "reftable/iter.h"
+#include "reftable/table.h"
+#include "strbuf.h"
+
+static int t_table_seek_once(void)
+{
+	struct reftable_ref_record records[] = {
+		{
+			.refname = (char *) "refs/heads/main",
+			.value_type = REFTABLE_REF_VAL1,
+			.value.val1 = { 42 },
+		},
+	};
+	struct reftable_block_source source = { 0 };
+	struct reftable_ref_record ref = { 0 };
+	struct reftable_iterator it = { 0 };
+	struct reftable_table *table;
+	struct reftable_buf buf = REFTABLE_BUF_INIT;
+	int ret;
+
+	t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
+	block_source_from_buf(&source, &buf);
+
+	ret = reftable_table_new(&table, &source, "name");
+	check(!ret);
+
+	reftable_table_init_ref_iterator(table, &it);
+	ret = reftable_iterator_seek_ref(&it, "");
+	check(!ret);
+	ret = reftable_iterator_next_ref(&it, &ref);
+	check(!ret);
+
+	ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
+	check_int(ret, ==, 1);
+
+	ret = reftable_iterator_next_ref(&it, &ref);
+	check_int(ret, ==, 1);
+
+	reftable_ref_record_release(&ref);
+	reftable_iterator_destroy(&it);
+	reftable_table_decref(table);
+	reftable_buf_release(&buf);
+	return 0;
+}
+
+static int t_table_reseek(void)
+{
+	struct reftable_ref_record records[] = {
+		{
+			.refname = (char *) "refs/heads/main",
+			.value_type = REFTABLE_REF_VAL1,
+			.value.val1 = { 42 },
+		},
+	};
+	struct reftable_block_source source = { 0 };
+	struct reftable_ref_record ref = { 0 };
+	struct reftable_iterator it = { 0 };
+	struct reftable_table *table;
+	struct reftable_buf buf = REFTABLE_BUF_INIT;
+	int ret;
+
+	t_reftable_write_to_buf(&buf, records, ARRAY_SIZE(records), NULL, 0, NULL);
+	block_source_from_buf(&source, &buf);
+
+	ret = reftable_table_new(&table, &source, "name");
+	check(!ret);
+
+	reftable_table_init_ref_iterator(table, &it);
+
+	for (size_t i = 0; i < 5; i++) {
+		ret = reftable_iterator_seek_ref(&it, "");
+		check(!ret);
+		ret = reftable_iterator_next_ref(&it, &ref);
+		check(!ret);
+
+		ret = reftable_ref_record_equal(&ref, &records[0], REFTABLE_HASH_SIZE_SHA1);
+		check_int(ret, ==, 1);
+
+		ret = reftable_iterator_next_ref(&it, &ref);
+		check_int(ret, ==, 1);
+	}
+
+	reftable_ref_record_release(&ref);
+	reftable_iterator_destroy(&it);
+	reftable_table_decref(table);
+	reftable_buf_release(&buf);
+	return 0;
+}
+
+static int t_table_block_iterator(void)
+{
+	struct reftable_block_source source = { 0 };
+	struct reftable_table_iterator it = { 0 };
+	struct reftable_ref_record *records;
+	const struct reftable_block *block;
+	struct reftable_table *table;
+	struct reftable_buf buf = REFTABLE_BUF_INIT;
+	struct {
+		uint8_t block_type;
+		uint16_t header_off;
+		uint16_t restart_count;
+		uint16_t record_count;
+	} expected_blocks[] = {
+		{
+			.block_type = REFTABLE_BLOCK_TYPE_REF,
+			.header_off = 24,
+			.restart_count = 10,
+			.record_count = 158,
+		},
+		{
+			.block_type = REFTABLE_BLOCK_TYPE_REF,
+			.restart_count = 10,
+			.record_count = 159,
+		},
+		{
+			.block_type = REFTABLE_BLOCK_TYPE_REF,
+			.restart_count = 10,
+			.record_count = 159,
+		},
+		{
+			.block_type = REFTABLE_BLOCK_TYPE_REF,
+			.restart_count = 2,
+			.record_count = 24,
+		},
+		{
+			.block_type = REFTABLE_BLOCK_TYPE_INDEX,
+			.restart_count = 1,
+			.record_count = 4,
+		},
+		{
+			.block_type = REFTABLE_BLOCK_TYPE_OBJ,
+			.restart_count = 1,
+			.record_count = 1,
+		},
+	};
+	const size_t nrecords = 500;
+	int ret;
+
+	REFTABLE_CALLOC_ARRAY(records, nrecords);
+	for (size_t i = 0; i < nrecords; i++) {
+		records[i].value_type = REFTABLE_REF_VAL1;
+		records[i].refname = xstrfmt("refs/heads/branch-%03"PRIuMAX,
+					     (uintmax_t) i);
+	}
+
+	t_reftable_write_to_buf(&buf, records, nrecords, NULL, 0, NULL);
+	block_source_from_buf(&source, &buf);
+
+	ret = reftable_table_new(&table, &source, "name");
+	check(!ret);
+
+	ret = reftable_table_iterator_init(&it, table);
+	check(!ret);
+
+	for (size_t i = 0; i < ARRAY_SIZE(expected_blocks); i++) {
+		struct reftable_iterator record_it = { 0 };
+		struct reftable_record record = {
+			.type = expected_blocks[i].block_type,
+		};
+
+		ret = reftable_table_iterator_next(&it, &block);
+		check(!ret);
+
+		check_int(block->block_type, ==, expected_blocks[i].block_type);
+		check_int(block->header_off, ==, expected_blocks[i].header_off);
+		check_int(block->restart_count, ==, expected_blocks[i].restart_count);
+
+		ret = reftable_block_init_iterator(block, &record_it);
+		check(!ret);
+
+		for (size_t j = 0; ; j++) {
+			ret = iterator_next(&record_it, &record);
+			if (ret > 0) {
+				check_int(j, ==, expected_blocks[i].record_count);
+				break;
+			}
+			check(!ret);
+		}
+
+		reftable_iterator_destroy(&record_it);
+		reftable_record_release(&record);
+	}
+
+	ret = reftable_table_iterator_next(&it, &block);
+	check_int(ret, ==, 1);
+
+	for (size_t i = 0; i < nrecords; i++)
+		reftable_free(records[i].refname);
+	reftable_table_iterator_release(&it);
+	reftable_table_decref(table);
+	reftable_buf_release(&buf);
+	reftable_free(records);
+	return 0;
+}
+
+int cmd_main(int argc UNUSED, const char *argv[] UNUSED)
+{
+	TEST(t_table_seek_once(), "table can seek once");
+	TEST(t_table_reseek(), "table can reseek multiple times");
+	TEST(t_table_block_iterator(), "table can iterate through blocks");
+	return test_done();
+}
diff --git a/t/unit-tests/u-oidmap.c b/t/unit-tests/u-oidmap.c
index dc805b7e3c..b23af449f6 100644
--- a/t/unit-tests/u-oidmap.c
+++ b/t/unit-tests/u-oidmap.c
@@ -35,7 +35,7 @@ void test_oidmap__initialize(void)
 
 void test_oidmap__cleanup(void)
 {
-	oidmap_free(&map, 1);
+	oidmap_clear(&map, 1);
 }
 
 void test_oidmap__replace(void)