diff --git a/zircon/system/ulib/blobfs/blobfs.cc b/zircon/system/ulib/blobfs/blobfs.cc
index 21e69c0..3900cd8 100644
--- a/zircon/system/ulib/blobfs/blobfs.cc
+++ b/zircon/system/ulib/blobfs/blobfs.cc
@@ -870,7 +870,7 @@
   // Only supported paged compression format is ZSTD Seekable.
   ZX_DEBUG_ASSERT(info && info->compression_algorithm == CompressionAlgorithm::ZSTD_SEEKABLE);
 
-  // Assume |ExtendReadRange| already called on |offset| and |length|.
+  // Assume |ExtendReadRange()| already called on |offset| and |length|.
   ZX_DEBUG_ASSERT(offset % kBlobfsBlockSize == 0);
   ZX_DEBUG_ASSERT(length % kBlobfsBlockSize == 0 || offset + length == info->data_length_bytes);
 
@@ -886,14 +886,21 @@
     return status;
   }
 
-  status = compressed_blobs_for_paging_->Read(
-      info->identifier, static_cast<uint8_t*>(mapping.start()), offset, length);
+  uint64_t read_offset = offset;
+  uint64_t read_length = length;
+  status =
+      compressed_blobs_for_paging_->Read(info->identifier, static_cast<uint8_t*>(mapping.start()),
+                                         mapping.size(), &read_offset, &read_length);
   if (status != ZX_OK) {
     FS_TRACE_ERROR("blobfs: Failed to read from ZSTD Seekable archive to service page fault: %s\n",
                    zx_status_get_string(status));
     return status;
   }
 
+  // Assume |ExtendReadRange()| already calibrated to line up with frame boundaries.
+  ZX_DEBUG_ASSERT(read_offset == offset);
+  ZX_DEBUG_ASSERT(read_length == length);
+
   return ZX_OK;
 }
 
diff --git a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.cc b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.cc
index da4a5d2..5cd1ef0 100644
--- a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.cc
+++ b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.cc
@@ -31,6 +31,13 @@
   std::unique_ptr<ZSTDSeekableBlobCollection> cbc(new ZSTDSeekableBlobCollection(
       vmoid_registry, space_manager, txn_handler, node_finder, kZSTDSeekableBlobCacheSize));
 
+  // Initialize shared decompression stream.
+  cbc->d_stream_ = ZSTD_createDStream();
+  if (cbc->d_stream_ == nullptr) {
+    FS_TRACE_ERROR("[blobfs][compressed] Failed to create shared decompression stream\n");
+    return ZX_ERR_INTERNAL;
+  }
+
   // Initialize shared transfer buffer.
   zx_status_t status = zx::vmo::create(kCompressedTransferBufferBytes, 0, &cbc->transfer_vmo_);
   if (status != ZX_OK) {
@@ -60,7 +67,10 @@
   return ZX_OK;
 }
 
-ZSTDSeekableBlobCollection::~ZSTDSeekableBlobCollection() { mapped_vmo_.Unmap(); }
+ZSTDSeekableBlobCollection::~ZSTDSeekableBlobCollection() {
+  mapped_vmo_.Unmap();
+  ZSTD_freeDStream(d_stream_);
+}
 
 ZSTDSeekableBlobCollection::ZSTDSeekableBlobCollection(storage::VmoidRegistry* vmoid_registry,
                                                        SpaceManager* space_manager,
@@ -70,12 +80,13 @@
       txn_handler_(txn_handler),
       node_finder_(node_finder),
       vmoid_(vmoid_registry),
-      cache_(cache_size) {}
+      cache_(cache_size),
+      d_stream_(nullptr) {}
 
-zx_status_t ZSTDSeekableBlobCollection::Read(uint32_t node_index, uint8_t* buf,
-                                             uint64_t data_byte_offset, uint64_t num_bytes) {
+zx_status_t ZSTDSeekableBlobCollection::Read(uint32_t node_index, uint8_t* buf, uint64_t buf_size,
+                                             uint64_t* data_byte_offset, uint64_t* num_bytes) {
   InodePtr node = node_finder_->GetNode(node_index);
-  if (!node) {
+  if (node == nullptr) {
     FS_TRACE_ERROR("[blobfs][compressed] Invalid node index: %u\n", node_index);
     return ZX_ERR_INVALID_ARGS;
   }
@@ -97,8 +108,8 @@
           &mapped_vmo_, &vmoid_, kCompressedTransferBufferBlocks, space_manager_, txn_handler_,
           node_finder_, node_index, num_merkle_blocks);
       std::unique_ptr<ZSTDSeekableBlob> new_blob;
-      zx_status_t status =
-          ZSTDSeekableBlob::Create(node_index, &mapped_vmo_, std::move(blocks), &new_blob);
+      zx_status_t status = ZSTDSeekableBlob::Create(node_index, d_stream_, &mapped_vmo_,
+                                                    std::move(blocks), &new_blob);
       if (status != ZX_OK) {
         FS_TRACE_ERROR("[blobfs][compressed] Failed to construct ZSTDSeekableBlob: %s\n",
                        zx_status_get_string(status));
@@ -109,12 +120,12 @@
       ZX_ASSERT(blob != nullptr);
     }
 
-    zx_status_t status = blob->Read(buf, data_byte_offset, num_bytes);
+    zx_status_t status = blob->Read(buf, buf_size, data_byte_offset, num_bytes);
     if (status != ZX_OK) {
       FS_TRACE_ERROR(
           "[blobfs][compressed] Failed to Read from blob: node_index=%u, data_byte_offset=%lu, "
           "num_bytes=%lu: %s\n",
-          node_index, data_byte_offset, num_bytes, zx_status_get_string(status));
+          node_index, *data_byte_offset, *num_bytes, zx_status_get_string(status));
       return status;
     }
   }
diff --git a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.h b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.h
index 58cbd96..e37f261 100644
--- a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.h
+++ b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob-collection.h
@@ -63,8 +63,8 @@
   // Load exactly |num_bytes| bytes starting at _uncompressed_ file contents byte offset
   // |data_byte_offset| from blob identified by inode index |node_index| into |buf|. The value of
   // data in |buf| is expected to be valid if and only if the return value is |ZX_OK|.
-  zx_status_t Read(uint32_t node_index, uint8_t* buf, uint64_t data_byte_offset,
-                   uint64_t num_bytes);
+  zx_status_t Read(uint32_t node_index, uint8_t* buf, uint64_t buf_size, uint64_t* data_byte_offset,
+                   uint64_t* num_bytes);
 
  private:
   ZSTDSeekableBlobCollection(storage::VmoidRegistry* vmoid_registry, SpaceManager* space_manager,
@@ -90,6 +90,7 @@
   storage::OwnedVmoid vmoid_;
   fzl::VmoMapper mapped_vmo_;
   ZSTDSeekableLRUBlobCache cache_;
+  ZSTD_DStream* d_stream_;
 };
 
 }  // namespace blobfs
diff --git a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.cc b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.cc
index d5ce0f5..8e200bb 100644
--- a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.cc
+++ b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.cc
@@ -218,23 +218,154 @@
 }
 
 zx_status_t ZSTDSeekableBlob::Create(
-    uint32_t node_index, fzl::VmoMapper* mapped_vmo,
+    uint32_t node_index, ZSTD_DStream* d_stream, fzl::VmoMapper* mapped_vmo,
     std::unique_ptr<ZSTDCompressedBlockCollection> compressed_block_collection,
     std::unique_ptr<ZSTDSeekableBlob>* out) {
-  std::unique_ptr<ZSTDSeekableBlob> blob(
-      new ZSTDSeekableBlob(node_index, mapped_vmo, std::move(compressed_block_collection)));
+  std::unique_ptr<ZSTDSeekableBlob> blob(new ZSTDSeekableBlob(
+      node_index, d_stream, mapped_vmo, std::move(compressed_block_collection)));
   zx_status_t status = blob->ReadHeader();
   if (status != ZX_OK) {
     return status;
   }
+  status = blob->LoadSeekTable();
 
   *out = std::move(blob);
   return ZX_OK;
 }
 
-zx_status_t ZSTDSeekableBlob::Read(uint8_t* buf, uint64_t data_byte_offset, uint64_t num_bytes) {
-  TRACE_DURATION("blobfs", "ZSTDSeekableBlob::Read", "data byte offset", data_byte_offset,
-                 "num bytes", num_bytes);
+zx_status_t ZSTDSeekableBlob::Read(uint8_t* buf, uint64_t buf_size, uint64_t* data_byte_offset,
+                                   uint64_t* num_bytes) {
+  ZX_DEBUG_ASSERT(buf != nullptr);
+  ZX_DEBUG_ASSERT(data_byte_offset != nullptr);
+  ZX_DEBUG_ASSERT(num_bytes != nullptr);
+
+  TRACE_DURATION("blobfs", "ZSTDSeekableBlob::Read", "data byte offset", *data_byte_offset,
+                 "num bytes", *num_bytes);
+
+  if (*num_bytes == 0) {
+    return ZX_OK;
+  }
+
+  size_t zstd_return = ZSTD_DCtx_reset(d_stream_, ZSTD_reset_session_only);
+  if (ZSTD_isError(zstd_return)) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] Failed to reset decompression stream: %s\n",
+                   ZSTD_getErrorName(zstd_return));
+    return ZX_ERR_INTERNAL;
+  }
+  zstd_return = ZSTD_DCtx_refDDict(d_stream_, nullptr);
+  if (ZSTD_isError(zstd_return)) {
+    FS_TRACE_ERROR(
+        "[blobfs][zstd-seekable] Failed to reset dictionary for decompression stream: %s\n",
+        ZSTD_getErrorName(zstd_return));
+    return ZX_ERR_INTERNAL;
+  }
+
+  unsigned first_frame = ZSTD_seekTable_offsetToFrameIndex(seek_table_, *data_byte_offset);
+  unsigned uncompressed_frame_byte_start =
+      ZSTD_seekTable_getFrameDecompressedOffset(seek_table_, first_frame);
+  unsigned compressed_frame_byte_start =
+      ZSTD_seekTable_getFrameCompressedOffset(seek_table_, first_frame);
+
+  unsigned last_frame =
+      ZSTD_seekTable_offsetToFrameIndex(seek_table_, (*data_byte_offset) + +(*num_bytes) - 1);
+  unsigned uncompressed_frame_byte_end =
+      ZSTD_seekTable_getFrameDecompressedOffset(seek_table_, last_frame) +
+      ZSTD_seekTable_getFrameDecompressedSize(seek_table_, last_frame);
+  unsigned compressed_frame_byte_end =
+      ZSTD_seekTable_getFrameCompressedOffset(seek_table_, last_frame) +
+      ZSTD_seekTable_getFrameCompressedSize(seek_table_, last_frame);
+
+  if (uncompressed_frame_byte_end <= uncompressed_frame_byte_start) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] End block overflow\n");
+    return ZX_ERR_OUT_OF_RANGE;
+  }
+
+  unsigned uncompressed_frame_byte_size =
+      uncompressed_frame_byte_end - uncompressed_frame_byte_start;
+  if (buf_size < uncompressed_frame_byte_size) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] Uncompressed output buffer too small: %lu < %u\n",
+                   buf_size, uncompressed_frame_byte_size);
+    return ZX_ERR_BUFFER_TOO_SMALL;
+  }
+
+  // ZSTD Seekable blob data contains: [header][zstd-seekable-archive].
+  unsigned blob_byte_start = kZSTDSeekableHeaderSize + compressed_frame_byte_start;
+  unsigned blob_byte_end = kZSTDSeekableHeaderSize + compressed_frame_byte_end;
+  unsigned blob_block_byte_offset = fbl::round_down(blob_byte_start, kBlobfsBlockSize);
+  unsigned blob_block_offset_unsigned = blob_block_byte_offset / kBlobfsBlockSize;
+  if (blob_block_offset_unsigned > std::numeric_limits<uint32_t>::max()) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] Start block overflow\n");
+    return ZX_ERR_OUT_OF_RANGE;
+  }
+  uint32_t blob_block_offset = static_cast<uint32_t>(blob_block_offset_unsigned);
+
+  unsigned blob_block_end = fbl::round_up(blob_byte_end, kBlobfsBlockSize) / kBlobfsBlockSize;
+  if (blob_block_end <= blob_block_offset_unsigned) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] End block overflow\n");
+    return ZX_ERR_OUT_OF_RANGE;
+  }
+
+  unsigned num_blocks_unsigned = blob_block_end - blob_block_offset_unsigned;
+  if (num_blocks_unsigned > std::numeric_limits<uint32_t>::max()) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] Number of block overflow\n");
+    return ZX_ERR_OUT_OF_RANGE;
+  }
+  uint32_t num_blocks = static_cast<uint32_t>(num_blocks_unsigned);
+
+  zx_status_t status = compressed_block_collection_->Read(blob_block_offset, num_blocks);
+  if (status != ZX_OK) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] Failed to read from compressed block collection: %s\n",
+                   zx_status_get_string(status));
+    return status;
+  }
+
+  ZSTD_inBuffer compressed_buf = ZSTD_inBuffer{
+      .src = mapped_vmo_->start(),
+      .size = mapped_vmo_->size(),
+      .pos = blob_byte_start - blob_block_byte_offset,
+  };
+  ZSTD_outBuffer uncompressed_buf = ZSTD_outBuffer{
+      .dst = buf,
+      .size = uncompressed_frame_byte_size,
+      .pos = 0,
+  };
+
+  size_t prev_output_pos = 0;
+  do {
+    prev_output_pos = uncompressed_buf.pos;
+    zstd_return = ZSTD_decompressStream(d_stream_, &uncompressed_buf, &compressed_buf);
+    if (ZSTD_isError(zstd_return)) {
+      FS_TRACE_ERROR("[blobfs][zstd-seekable] Failed to decompress: %s\n",
+                     ZSTD_getErrorName(zstd_return));
+      return ZX_ERR_INTERNAL;
+    }
+  } while (uncompressed_buf.pos < uncompressed_buf.size && prev_output_pos != uncompressed_buf.pos);
+  if (uncompressed_buf.pos < uncompressed_buf.size) {
+    FS_TRACE_ERROR(
+        "[blobfs][zstd-seekable] Decompression stopped making progress before decompressing all "
+        "bytes\n");
+    return ZX_ERR_INTERNAL;
+  }
+
+  *data_byte_offset = uncompressed_frame_byte_start;
+  *num_bytes = uncompressed_frame_byte_size;
+  return ZX_OK;
+}
+
+ZSTDSeekableBlob::ZSTDSeekableBlob(
+    uint32_t node_index, ZSTD_DStream* d_stream, fzl::VmoMapper* mapped_vmo,
+    std::unique_ptr<ZSTDCompressedBlockCollection> compressed_block_collection)
+    : node_index_(node_index),
+      mapped_vmo_(mapped_vmo),
+      compressed_block_collection_(std::move(compressed_block_collection)),
+      seek_table_(nullptr),
+      d_stream_(d_stream) {}
+
+zx_status_t ZSTDSeekableBlob::LoadSeekTable() {
+  zx_status_t status = ReadHeader();
+  if (status != ZX_OK) {
+    return status;
+  }
 
   ZSTD_seekable* d_stream = ZSTD_seekable_create();
   if (d_stream == nullptr) {
@@ -262,42 +393,16 @@
     return ZX_ERR_INTERNAL;
   }
 
-  size_t decompressed = 0;
-  do {
-    zstd_return =
-        ZSTD_seekable_decompress(d_stream, buf, num_bytes, data_byte_offset + decompressed);
-    if (ZSTD_isError(zstd_return)) {
-      FS_TRACE_ERROR("[blobfs][zstd-seekable] Failed to decompress: %s\n",
-                     ZSTD_getErrorName(zstd_return));
-      if (zstd_seekable_file.status != ZX_OK) {
-        return zstd_seekable_file.status;
-      }
-
-      return ZX_ERR_IO_DATA_INTEGRITY;
-    }
-
-    // Non-error case: |ZSTD_seekable_decompress| returns number of bytes decompressed.
-    decompressed += zstd_return;
-
-    // From the ZSTD_seekable_decompress Documentation:
-    //   The return value is the number of bytes decompressed, or an error code checkable with
-    //   ZSTD_isError().
-    // Assume that a return value of 0 indicates, not only that 0 bytes were decompressed, but also
-    // that there are no more bytes to decompress.
-  } while (zstd_return > 0 && decompressed < num_bytes);
-
-  // TODO(markdittmer): Perform verification over block-aligned data that was read.
+  zstd_return = ZSTD_seekable_copySeekTable(d_stream, &seek_table_);
+  if (ZSTD_isError(zstd_return)) {
+    FS_TRACE_ERROR("[blobfs][zstd-seekable] Failed to initialize seek table: %s\n",
+                   ZSTD_getErrorName(zstd_return));
+    return ZX_ERR_INTERNAL;
+  }
 
   return ZX_OK;
 }
 
-ZSTDSeekableBlob::ZSTDSeekableBlob(
-    uint32_t node_index, fzl::VmoMapper* mapped_vmo,
-    std::unique_ptr<ZSTDCompressedBlockCollection> compressed_block_collection)
-    : node_index_(node_index),
-      mapped_vmo_(mapped_vmo),
-      compressed_block_collection_(std::move(compressed_block_collection)) {}
-
 zx_status_t ZSTDSeekableBlob::ReadHeader() {
   // The header is an internal BlobFS data structure that fits into one block.
   static_assert(kZSTDSeekableHeaderSize <= kBlobfsBlockSize);
diff --git a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.h b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.h
index b7f5f2d..b8dd9f5 100644
--- a/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.h
+++ b/zircon/system/ulib/blobfs/compression/zstd-seekable-blob.h
@@ -33,7 +33,8 @@
   // Load into |buf| exactly |num_bytes| bytes starting at _uncompressed_ file contents byte offset
   // |data_byte_offset|. The value of data in |buf| is expected to be valid if and only if the
   // return value is |ZX_OK|.
-  virtual zx_status_t Read(uint8_t* buf, uint64_t data_byte_offset, uint64_t num_bytes) = 0;
+  virtual zx_status_t Read(uint8_t* buf, uint64_t buf_size, uint64_t* data_byte_offset,
+                           uint64_t* num_bytes) = 0;
 };
 
 // ZSTDSeekableBlob as an implementation of |RandomAccessCompressedBlob| that uses the ZSTD Seekable
@@ -45,12 +46,13 @@
   // Create a |ZSTDSeekableBlob|. It is the invoker's responsibility to ensure that the VMO
   // populated on |compressed_block_collection.Read()| corresponds to |mapped_vmo|.
   static zx_status_t Create(
-      uint32_t node_index, fzl::VmoMapper* mapped_vmo,
+      uint32_t node_index, ZSTD_DStream* d_stream, fzl::VmoMapper* mapped_vmo,
       std::unique_ptr<ZSTDCompressedBlockCollection> compressed_block_collection,
       std::unique_ptr<ZSTDSeekableBlob>* out);
 
   // RandomAccessCompressedBlob implementation.
-  zx_status_t Read(uint8_t* buf, uint64_t data_byte_offset, uint64_t num_bytes) final;
+  zx_status_t Read(uint8_t* buf, uint64_t buf_size, uint64_t* data_byte_offset,
+                   uint64_t* num_bytes) final;
 
   const uint8_t* compressed_data_start() const {
     return static_cast<uint8_t*>(mapped_vmo_->start());
@@ -59,15 +61,18 @@
   uint32_t node_index() { return node_index_; }
 
  private:
-  ZSTDSeekableBlob(uint32_t node_index, fzl::VmoMapper* mapped_vmo,
+  ZSTDSeekableBlob(uint32_t node_index, ZSTD_DStream* d_stream, fzl::VmoMapper* mapped_vmo,
                    std::unique_ptr<ZSTDCompressedBlockCollection> compressed_block_collection);
 
+  zx_status_t LoadSeekTable();
   zx_status_t ReadHeader();
 
   uint32_t node_index_;
   ZSTDSeekableHeader header_;
   fzl::VmoMapper* mapped_vmo_;
   std::unique_ptr<ZSTDCompressedBlockCollection> compressed_block_collection_;
+  ZSTD_seekTable* seek_table_;
+  ZSTD_DStream* d_stream_;
 };
 
 // Type used for opaque pointer in ZSTD Seekable custom |ZSTD_seekable_seek| and
diff --git a/zircon/system/ulib/blobfs/test/unit/zstd-seekable-blob-test.cc b/zircon/system/ulib/blobfs/test/unit/zstd-seekable-blob-test.cc
index 8c094b5..979baf3 100644
--- a/zircon/system/ulib/blobfs/test/unit/zstd-seekable-blob-test.cc
+++ b/zircon/system/ulib/blobfs/test/unit/zstd-seekable-blob-test.cc
@@ -80,8 +80,10 @@
   void CheckRead(uint32_t node_index, std::vector<uint8_t>* buf, std::vector<uint8_t>* expected_buf,
                  uint64_t data_byte_offset, uint64_t num_bytes) {
     uint8_t* expected = expected_buf->data() + data_byte_offset;
+    uint64_t offset = data_byte_offset;
+    uint64_t length = num_bytes;
     ASSERT_OK(
-        compressed_blob_collection()->Read(node_index, buf->data(), data_byte_offset, num_bytes));
+        compressed_blob_collection()->Read(node_index, buf->data(), buf->size(), &offset, &length));
     ASSERT_BYTES_EQ(expected, buf->data(), num_bytes);
   }
 
@@ -246,7 +248,10 @@
   auto blocks_for_file = blocks.get();
 
   std::unique_ptr<ZSTDSeekableBlob> blob;
-  ASSERT_OK(ZSTDSeekableBlob::Create(node_index, &mapper, std::move(blocks), &blob));
+  ZSTD_DStream* d_stream = ZSTD_createDStream();
+  ASSERT_NOT_NULL(d_stream);
+  auto clean_up = fbl::MakeAutoCall([&]() { ZSTD_freeDStream(d_stream); });
+  ASSERT_OK(ZSTDSeekableBlob::Create(node_index, d_stream, &mapper, std::move(blocks), &blob));
 
   ZSTDSeekableFile file = ZSTDSeekableFile{
       .blob = blob.get(),
@@ -275,7 +280,10 @@
   std::vector<uint8_t> buf(blob_info->size_data);
   std::vector<uint8_t> expected(blob_info->size_data);
   ZeroToSevenBlobSrcFunction(reinterpret_cast<char*>(expected.data()), blob_info->size_data);
-  ASSERT_OK(compressed_blob_collection()->Read(node_index, buf.data(), 0, blob_info->size_data));
+  uint64_t offset = 0;
+  uint64_t length = blob_info->size_data;
+  ASSERT_OK(
+      compressed_blob_collection()->Read(node_index, buf.data(), buf.size(), &offset, &length));
   ASSERT_BYTES_EQ(expected.data(), buf.data(), blob_info->size_data);
 }
 
@@ -338,8 +346,10 @@
 
   // Attempt to read one byte passed the end of the blob.
   std::vector<uint8_t> buf(1);
-  ASSERT_EQ(ZX_ERR_IO_DATA_INTEGRITY,
-            compressed_blob_collection()->Read(node_index, buf.data(), blob_info->size_data, 1));
+  uint64_t offset = blob_info->size_data;
+  uint64_t length = 1;
+  ASSERT_EQ(ZX_ERR_IO_DATA_INTEGRITY, compressed_blob_collection()->Read(
+                                          node_index, buf.data(), buf.size(), &offset, &length));
 }
 
 TEST_F(ZSTDSeekableBlobTest, BadSize) {
@@ -349,15 +359,20 @@
 
   // Attempt to read two bytes: the last byte in the blob, and one byte passed the end.
   std::vector<uint8_t> buf(2);
+  uint64_t offset = blob_info->size_data - 1;
+  uint64_t length = 2;
   ASSERT_EQ(ZX_ERR_IO_DATA_INTEGRITY, compressed_blob_collection()->Read(
-                                          node_index, buf.data(), blob_info->size_data - 1, 2));
+                                          node_index, buf.data(), buf.size(), &offset, &length));
 }
 
 TEST_F(ZSTDSeekableBlobNullNodeFinderTest, BadNode) {
   std::vector<uint8_t> buf(1);
 
   // Attempt to read a byte from a node that doesn't exist.
-  ASSERT_EQ(ZX_ERR_INVALID_ARGS, compressed_blob_collection()->Read(42, buf.data(), 0, 1));
+  uint64_t offset = 0;
+  uint64_t length = 1;
+  ASSERT_EQ(ZX_ERR_INVALID_ARGS,
+            compressed_blob_collection()->Read(42, buf.data(), buf.size(), &offset, &length));
 }
 
 TEST_F(ZSTDSeekableBlobWrongAlgorithmTest, BadFlags) {
@@ -367,7 +382,10 @@
   std::vector<uint8_t> buf(1);
 
   // Attempt to read a byte from a blob that is not zstd-seekable.
-  ASSERT_EQ(ZX_ERR_NOT_SUPPORTED, compressed_blob_collection()->Read(node_index, buf.data(), 0, 1));
+  uint64_t offset = 0;
+  uint64_t length = 1;
+  ASSERT_EQ(ZX_ERR_NOT_SUPPORTED, compressed_blob_collection()->Read(node_index, buf.data(),
+                                                                     buf.size(), &offset, &length));
 }
 
 }  // namespace