diff --git a/doc/api/fs.md b/doc/api/fs.md
index b1fac10e45c6c0..5fd4cfeefb504d 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -202,15 +202,6 @@ When operating on file handles, the mode cannot be changed from what it was set
 to with [`fsPromises.open()`][]. Therefore, this is equivalent to
 [`filehandle.writeFile()`][].
 
-#### `filehandle.blob()`
-<!-- YAML
-added: REPLACEME
--->
-
-> Stability: 1 - Experimental
-
-Returns a {Blob} whose data is backed by this file.
-
 #### `filehandle.chmod(mode)`
 
 <!-- YAML
@@ -3333,6 +3324,45 @@ a colon, Node.js will open a file system stream, as described by
 Functions based on `fs.open()` exhibit this behavior as well:
 `fs.writeFile()`, `fs.readFile()`, etc.
 
+### `fs.openAsBlob(path[, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+* `path` {string|Buffer|URL}
+* `options` {Object}
+  * `type` {string} An optional mime type for the blob.
+* Return: {Promise} containing {Blob}
+
+Returns a {Blob} whose data is backed by the given file.
+
+The file must not be modified after the {Blob} is created. Any modifications
+will cause reading the {Blob} data to fail with a `DOMException`.
+error. Synchronous stat operations on the file when the `Blob` is created, and
+before each read in order to detect whether the file data has been modified
+on disk.
+
+```mjs
+import { openAsBlob } from 'node:fs';
+
+const blob = await openAsBlob('the.file.txt');
+const ab = await blob.arrayBuffer();
+blob.stream();
+```
+
+```cjs
+const { openAsBlob } = require('node:fs');
+
+(async () => {
+  const blob = await openAsBlob('the.file.txt');
+  const ab = await blob.arrayBuffer();
+  blob.stream();
+})();
+```
+
 ### `fs.opendir(path[, options], callback)`
 
 <!-- YAML
diff --git a/lib/fs.js b/lib/fs.js
index 300abd73fada23..847c43de7596dc 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -32,6 +32,7 @@ const {
   ObjectDefineProperties,
   ObjectDefineProperty,
   Promise,
+  PromiseResolve,
   ReflectApply,
   SafeMap,
   SafeSet,
@@ -62,6 +63,9 @@ const { isArrayBufferView } = require('internal/util/types');
 // it's re-initialized after deserialization.
 
 const binding = internalBinding('fs');
+
+const { createBlobFromFilePath } = require('internal/blob');
+
 const { Buffer } = require('buffer');
 const {
   aggregateTwoErrors,
@@ -586,6 +590,20 @@ function openSync(path, flags, mode) {
   return result;
 }
 
+/**
+ * @param {string | Buffer | URL } path
+ * @returns {Promise<Blob>}
+ */
+function openAsBlob(path, options = kEmptyObject) {
+  validateObject(options, 'options');
+  const type = options.type || '';
+  validateString(type, 'options.type');
+  // The underlying implementation here returns the Blob synchronously for now.
+  // To give ourselves flexibility to maybe return the Blob asynchronously,
+  // this API returns a Promise.
+  return PromiseResolve(createBlobFromFilePath(getValidatedPath(path), { type }));
+}
+
 /**
  * Reads file from the specified `fd` (file descriptor).
  * @param {number} fd
@@ -3022,6 +3040,7 @@ module.exports = fs = {
   mkdtempSync,
   open,
   openSync,
+  openAsBlob,
   readdir,
   readdirSync,
   read,
diff --git a/lib/internal/blob.js b/lib/internal/blob.js
index c864c309989c30..6761ccae230816 100644
--- a/lib/internal/blob.js
+++ b/lib/internal/blob.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayBuffer,
   ArrayFrom,
   MathMax,
   MathMin,
@@ -21,7 +22,7 @@ const {
 
 const {
   createBlob: _createBlob,
-  createBlobFromFileHandle: _createBlobFromFileHandle,
+  createBlobFromFilePath: _createBlobFromFilePath,
   concat,
   getDataObject,
 } = internalBinding('blob');
@@ -48,6 +49,7 @@ const {
   customInspectSymbol: kInspect,
   kEmptyObject,
   kEnumerableProperty,
+  lazyDOMException,
 } = require('internal/util');
 const { inspect } = require('internal/util/inspect');
 
@@ -58,7 +60,6 @@ const {
     ERR_INVALID_THIS,
     ERR_BUFFER_TOO_LARGE,
   },
-  errnoException,
 } = require('internal/errors');
 
 const {
@@ -66,6 +67,10 @@ const {
   validateDictionary,
 } = require('internal/validators');
 
+const {
+  CountQueuingStrategy,
+} = require('internal/webstreams/queuingstrategies');
+
 const kHandle = Symbol('kHandle');
 const kType = Symbol('kType');
 const kLength = Symbol('kLength');
@@ -265,16 +270,23 @@ class Blob {
       return PromiseResolve(new ArrayBuffer(0));
     }
 
-    const { promise, resolve } = createDeferredPromise();
+    const { promise, resolve, reject } = createDeferredPromise();
     const reader = this[kHandle].getReader();
     const buffers = [];
     const readNext = () => {
       reader.pull((status, buffer) => {
-        if (status === -1) {
+        if (status === 0) {
           // EOS, concat & resolve
           // buffer should be undefined here
           resolve(concat(buffers));
           return;
+        } else if (status < 0) {
+          // The read could fail for many different reasons when reading
+          // from a non-memory resident blob part (e.g. file-backed blob).
+          // The error details the system error code.
+          const error = lazyDOMException('The blob could not be read', 'NotReadableError');
+          reject(error);
+          return;
         }
         if (buffer !== undefined)
           buffers.push(buffer);
@@ -319,7 +331,7 @@ class Blob {
       },
       pull(c) {
         const { promise, resolve, reject } = createDeferredPromise();
-        this.pendingPulls.push({resolve, reject});
+        this.pendingPulls.push({ resolve, reject });
         reader.pull((status, buffer) => {
           // If pendingPulls is empty here, the stream had to have
           // been canceled, and we don't really care about the result.
@@ -328,18 +340,24 @@ class Blob {
             return;
           }
           const pending = this.pendingPulls.shift();
-          if (status === -1 || (status === 0 && buffer === undefined)) {
+          if (status === 0) {
             // EOS
             c.close();
             pending.resolve();
             return;
           } else if (status < 0) {
-            const error = errnoException(status, 'read');
+            // The read could fail for many different reasons when reading
+            // from a non-memory resident blob part (e.g. file-backed blob).
+            // The error details the system error code.
+            const error = lazyDOMException('The blob could not be read', 'NotReadableError');
+
             c.error(error);
             pending.reject(error);
             return;
           }
-          c.enqueue(new Uint8Array(buffer));
+          if (buffer !== undefined) {
+            c.enqueue(new Uint8Array(buffer));
+          }
           pending.resolve();
         });
         return promise;
@@ -422,16 +440,22 @@ function resolveObjectURL(url) {
   }
 }
 
-function createBlobFromFileHandle(handle) {
-  const [blob, length] = _createBlobFromFileHandle(handle);
-  return createBlob(blob, length);
+// TODO(@jasnell): Now that the File class exists, we might consider having
+// this return a `File` instead of a `Blob`.
+function createBlobFromFilePath(path, options) {
+  const maybeBlob = _createBlobFromFilePath(path);
+  if (maybeBlob === undefined) {
+    return lazyDOMException('The blob could not be read', 'NotReadableError');
+  }
+  const { 0: blob, 1: length } = maybeBlob;
+  return createBlob(blob, length, options?.type);
 }
 
 module.exports = {
   Blob,
   ClonedBlob,
   createBlob,
-  createBlobFromFileHandle,
+  createBlobFromFilePath,
   isBlob,
   kHandle,
   resolveObjectURL,
diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js
index 6d4b69b4b16db7..c61758d3bd3d5e 100644
--- a/lib/internal/fs/promises.js
+++ b/lib/internal/fs/promises.js
@@ -25,8 +25,6 @@ const {
   S_IFREG
 } = constants;
 
-const { createBlobFromFileHandle } = require('internal/blob');
-
 const binding = internalBinding('fs');
 const { Buffer } = require('buffer');
 
@@ -312,14 +310,6 @@ class FileHandle extends EventEmitterMixin(JSTransferable) {
     return new WriteStream(undefined, { ...options, fd: this });
   }
 
-  /**
-   * @typedef {import('../blob').Blob} Blob
-   * @returns {Blob}
-   */
-  blob() {
-    return createBlobFromFileHandle(this[kHandle]);
-  }
-
   [kTransfer]() {
     if (this[kClosePromise] || this[kRefs] > 1) {
       throw lazyDOMException('Cannot transfer FileHandle while in use',
diff --git a/src/async_wrap.h b/src/async_wrap.h
index 93af84aaa75def..121216579a8ad7 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -31,49 +31,49 @@
 
 namespace node {
 
-#define NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                               \
-  V(NONE)                                                                     \
-  V(DIRHANDLE)                                                                \
-  V(DNSCHANNEL)                                                               \
-  V(ELDHISTOGRAM)                                                             \
-  V(FILEHANDLE)                                                               \
-  V(FILEHANDLECLOSEREQ)                                                       \
-  V(BLOBREADER)                                                               \
-  V(FSEVENTWRAP)                                                              \
-  V(FSREQCALLBACK)                                                            \
-  V(FSREQPROMISE)                                                             \
-  V(GETADDRINFOREQWRAP)                                                       \
-  V(GETNAMEINFOREQWRAP)                                                       \
-  V(HEAPSNAPSHOT)                                                             \
-  V(HTTP2SESSION)                                                             \
-  V(HTTP2STREAM)                                                              \
-  V(HTTP2PING)                                                                \
-  V(HTTP2SETTINGS)                                                            \
-  V(HTTPINCOMINGMESSAGE)                                                      \
-  V(HTTPCLIENTREQUEST)                                                        \
-  V(JSSTREAM)                                                                 \
-  V(JSUDPWRAP)                                                                \
-  V(MESSAGEPORT)                                                              \
-  V(PIPECONNECTWRAP)                                                          \
-  V(PIPESERVERWRAP)                                                           \
-  V(PIPEWRAP)                                                                 \
-  V(PROCESSWRAP)                                                              \
-  V(PROMISE)                                                                  \
-  V(QUERYWRAP)                                                                \
-  V(SHUTDOWNWRAP)                                                             \
-  V(SIGNALWRAP)                                                               \
-  V(STATWATCHER)                                                              \
-  V(STREAMPIPE)                                                               \
-  V(TCPCONNECTWRAP)                                                           \
-  V(TCPSERVERWRAP)                                                            \
-  V(TCPWRAP)                                                                  \
-  V(TTYWRAP)                                                                  \
-  V(UDPSENDWRAP)                                                              \
-  V(UDPWRAP)                                                                  \
-  V(SIGINTWATCHDOG)                                                           \
-  V(WORKER)                                                                   \
-  V(WORKERHEAPSNAPSHOT)                                                       \
-  V(WRITEWRAP)                                                                \
+#define NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                                \
+  V(NONE)                                                                      \
+  V(DIRHANDLE)                                                                 \
+  V(DNSCHANNEL)                                                                \
+  V(ELDHISTOGRAM)                                                              \
+  V(FILEHANDLE)                                                                \
+  V(FILEHANDLECLOSEREQ)                                                        \
+  V(BLOBREADER)                                                                \
+  V(FSEVENTWRAP)                                                               \
+  V(FSREQCALLBACK)                                                             \
+  V(FSREQPROMISE)                                                              \
+  V(GETADDRINFOREQWRAP)                                                        \
+  V(GETNAMEINFOREQWRAP)                                                        \
+  V(HEAPSNAPSHOT)                                                              \
+  V(HTTP2SESSION)                                                              \
+  V(HTTP2STREAM)                                                               \
+  V(HTTP2PING)                                                                 \
+  V(HTTP2SETTINGS)                                                             \
+  V(HTTPINCOMINGMESSAGE)                                                       \
+  V(HTTPCLIENTREQUEST)                                                         \
+  V(JSSTREAM)                                                                  \
+  V(JSUDPWRAP)                                                                 \
+  V(MESSAGEPORT)                                                               \
+  V(PIPECONNECTWRAP)                                                           \
+  V(PIPESERVERWRAP)                                                            \
+  V(PIPEWRAP)                                                                  \
+  V(PROCESSWRAP)                                                               \
+  V(PROMISE)                                                                   \
+  V(QUERYWRAP)                                                                 \
+  V(SHUTDOWNWRAP)                                                              \
+  V(SIGNALWRAP)                                                                \
+  V(STATWATCHER)                                                               \
+  V(STREAMPIPE)                                                                \
+  V(TCPCONNECTWRAP)                                                            \
+  V(TCPSERVERWRAP)                                                             \
+  V(TCPWRAP)                                                                   \
+  V(TTYWRAP)                                                                   \
+  V(UDPSENDWRAP)                                                               \
+  V(UDPWRAP)                                                                   \
+  V(SIGINTWATCHDOG)                                                            \
+  V(WORKER)                                                                    \
+  V(WORKERHEAPSNAPSHOT)                                                        \
+  V(WRITEWRAP)                                                                 \
   V(ZLIB)
 
 #if HAVE_OPENSSL
diff --git a/src/dataqueue/queue.cc b/src/dataqueue/queue.cc
index 2ca87c0b59454a..a39314e23e13bf 100644
--- a/src/dataqueue/queue.cc
+++ b/src/dataqueue/queue.cc
@@ -6,73 +6,53 @@
 #include <node.h>
 #include <node_bob-inl.h>
 #include <node_errors.h>
+#include <node_external_reference.h>
 #include <node_file-inl.h>
 #include <stream_base-inl.h>
-#include <v8.h>
 #include <util-inl.h>
 #include <uv.h>
+#include <v8.h>
 #include <algorithm>
 #include <deque>
 #include <initializer_list>
 #include <memory>
 #include <vector>
-#include "base_object.h"
-#include "memory_tracker.h"
-#include "node_bob.h"
-#include "node_external_reference.h"
-#include "util.h"
-#include "v8-function-callback.h"
 
 namespace node {
 
 using v8::ArrayBufferView;
 using v8::BackingStore;
-using v8::Context;
-using v8::HandleScope;
-using v8::Just;
 using v8::Local;
 using v8::Object;
-using v8::Maybe;
-using v8::Nothing;
-using v8::FunctionTemplate;
-using v8::Isolate;
-using v8::FunctionCallbackInfo;
 using v8::Value;
-using v8::String;
-using v8::Global;
-using v8::Function;
-using v8::Int32;
-using v8::Uint32;
 
 namespace {
 // ============================================================================
 class IdempotentDataQueueReader;
 class NonIdempotentDataQueueReader;
 
-class EntryBase : public DataQueue::Entry {
+class EntryImpl : public DataQueue::Entry {
  public:
-   virtual std::unique_ptr<DataQueue::Reader> getReader() = 0;
+  virtual std::shared_ptr<DataQueue::Reader> get_reader() = 0;
 };
 
 class DataQueueImpl final : public DataQueue,
                             public std::enable_shared_from_this<DataQueueImpl> {
  public:
-  // Constructor for an imdempotent, fixed sized DataQueue.
-  DataQueueImpl(std::vector<std::unique_ptr<Entry>> list, size_t size)
+  // Constructor for an idempotent, fixed sized DataQueue.
+  DataQueueImpl(std::vector<std::unique_ptr<Entry>>&& list, uint64_t size)
       : entries_(std::move(list)),
         idempotent_(true),
-        size_(Just(size)),
-        capped_size_(Just<size_t>(0UL)) {}
+        size_(size),
+        capped_size_(0) {}
 
   // Constructor for a non-idempotent DataQueue. This kind of queue can have
   // entries added to it over time. The size is set to 0 initially. The queue
   // can be capped immediately on creation. Depending on the entries that are
   // added, the size can be cleared if any of the entries are not capable of
   // providing a size.
-  DataQueueImpl(Maybe<size_t> cap = Nothing<size_t>())
-      : idempotent_(false),
-        size_(Just<size_t>(0UL)),
-        capped_size_(cap) {}
+  DataQueueImpl(std::optional<uint64_t> cap = std::nullopt)
+      : idempotent_(false), size_(0), capped_size_(cap) {}
 
   // Disallow moving and copying.
   DataQueueImpl(const DataQueueImpl&) = delete;
@@ -81,42 +61,38 @@ class DataQueueImpl final : public DataQueue,
   DataQueueImpl& operator=(DataQueueImpl&&) = delete;
 
   std::shared_ptr<DataQueue> slice(
-      size_t start,
-      Maybe<size_t> maybeEnd = Nothing<size_t>()) override {
+      uint64_t start,
+      std::optional<uint64_t> maybeEnd = std::nullopt) override {
     // If the data queue is not idempotent, or the size cannot be determined,
     // we cannot reasonably create a slice. Therefore, return nothing.
-    if (!idempotent_ || size_.IsNothing()) return nullptr;
+    if (!idempotent_ || !size_.has_value()) return nullptr;
 
-    size_t size = size_.FromJust();
+    uint64_t size = size_.value();
 
     // start cannot be greater than the size.
     start = std::min(start, size);
 
-    size_t end;
-    if (maybeEnd.To(&end)) {
-      // end cannot be less than start, or greater than the size.
-      end = std::max(start, std::min(end, size));
-    } else {
-      end = size;
-    }
+    uint64_t end = std::max(start, std::min(maybeEnd.value_or(size), size));
 
     DCHECK_LE(start, end);
 
-    size_t len = end - start;
-    size_t remaining = end - start;
+    uint64_t len = end - start;
+    uint64_t remaining = end - start;
     std::vector<std::unique_ptr<Entry>> slices;
 
     if (remaining > 0) {
       for (const auto& entry : entries_) {
-        size_t entrySize = entry->size().FromJust();
+        // The size of every entry should be known since this is an
+        // idempotent queue.
+        uint64_t entrySize = entry->size().value();
         if (start > entrySize) {
           start -= entrySize;
           continue;
         }
 
-        size_t chunkStart = start;
-        size_t len = std::min(remaining, entrySize - chunkStart);
-        slices.emplace_back(entry->slice(chunkStart, Just(chunkStart + len)));
+        uint64_t chunkStart = start;
+        uint64_t len = std::min(remaining, entrySize - chunkStart);
+        slices.emplace_back(entry->slice(chunkStart, chunkStart + len));
         remaining -= len;
         start = 0;
 
@@ -127,76 +103,75 @@ class DataQueueImpl final : public DataQueue,
     return std::make_shared<DataQueueImpl>(std::move(slices), len);
   }
 
-  Maybe<size_t> size() const override { return size_; }
+  std::optional<uint64_t> size() const override { return size_; }
 
-  bool isIdempotent() const override { return idempotent_; }
+  bool is_idempotent() const override { return idempotent_; }
 
-  bool isCapped() const override { return capped_size_.IsJust(); }
+  bool is_capped() const override { return capped_size_.has_value(); }
 
-  Maybe<bool> append(std::unique_ptr<Entry> entry) override {
-    if (idempotent_) return Nothing<bool>();
-    if (!entry) return Just(false);
+  std::optional<bool> append(std::unique_ptr<Entry> entry) override {
+    if (idempotent_) return std::nullopt;
+    if (!entry) return false;
 
     // If this entry successfully provides a size, we can add it to our size_
-    // if that has a value, otherwise, we keep size_t empty.
-    size_t entrySize;
-    size_t queueSize;
-    if (entry->size().To(&entrySize) && size_.To(&queueSize)) {
+    // if that has a value, otherwise, we keep uint64_t empty.
+    if (entry->size().has_value() && size_.has_value()) {
+      uint64_t entrySize = entry->size().value();
+      uint64_t size = size_.value();
       // If capped_size_ is set, size + entrySize cannot exceed capped_size_
       // or the entry cannot be added.
-      size_t capped_size;
-      if (capped_size_.To(&capped_size) && queueSize + entrySize > capped_size) {
-        return Just(false);
+      if (capped_size_.has_value() &&
+          (capped_size_.value() < entrySize + size)) {
+        return false;
       }
-
-      size_ = Just(queueSize + entrySize);
+      size_ = size + entrySize;
     } else {
       // This entry cannot provide a size. We can still add it but we have to
       // clear the known size.
-      size_ = Nothing<size_t>();
+      size_ = std::nullopt;
     }
 
     entries_.push_back(std::move(entry));
-    return Just(true);
+    return true;
   }
 
-  void cap(size_t limit = 0) override {
-    if (isIdempotent()) return;
-    size_t current_cap;
+  void cap(uint64_t limit = 0) override {
+    if (is_idempotent()) return;
     // If the data queue is already capped, it is possible to call
     // cap again with a smaller size.
-    if (capped_size_.To(&current_cap)) {
-      capped_size_ = Just(std::min(limit, current_cap));
+    if (capped_size_.has_value()) {
+      capped_size_ = std::min(limit, capped_size_.value());
       return;
     }
 
     // Otherwise just set the limit.
-    capped_size_ = Just(limit);
+    capped_size_ = limit;
   }
 
-  Maybe<size_t> maybeCapRemaining() const override {
-    size_t capped_size;
-    size_t size;
-    if (capped_size_.To(&capped_size) && size_.To(&size)) {
-      return capped_size > size ? Just(capped_size - size) : Just<size_t>(0UL);
+  std::optional<uint64_t> maybeCapRemaining() const override {
+    if (capped_size_.has_value() && size_.has_value()) {
+      uint64_t capped_size = capped_size_.value();
+      uint64_t size = size_.value();
+      return capped_size > size ? capped_size - size : 0UL;
     }
-    return Nothing<size_t>();
+    return std::nullopt;
   }
 
   void MemoryInfo(node::MemoryTracker* tracker) const override {
-    tracker->TrackField("entries", entries_);
+    tracker->TrackField(
+        "entries", entries_, "std::vector<std::unique_ptr<Entry>>");
   }
 
-  std::unique_ptr<Reader> getReader() override;
-  SET_MEMORY_INFO_NAME(DataQueue);
-  SET_SELF_SIZE(DataQueueImpl);
+  std::shared_ptr<Reader> get_reader() override;
+  SET_MEMORY_INFO_NAME(DataQueue)
+  SET_SELF_SIZE(DataQueueImpl)
 
  private:
   std::vector<std::unique_ptr<Entry>> entries_;
   bool idempotent_;
-  Maybe<size_t> size_;
-  Maybe<size_t> capped_size_;
-  bool lockedToReader_ = false;
+  std::optional<uint64_t> size_ = std::nullopt;
+  std::optional<uint64_t> capped_size_ = std::nullopt;
+  bool locked_to_reader_ = false;
 
   friend class DataQueue;
   friend class IdempotentDataQueueReader;
@@ -207,123 +182,108 @@ class DataQueueImpl final : public DataQueue,
 // DataQueue with which it is associated, and always from the beginning.
 // Reads are non-destructive, meaning that the state of the DataQueue
 // will not and cannot be changed.
-class IdempotentDataQueueReader final : public DataQueue::Reader {
+class IdempotentDataQueueReader final
+    : public DataQueue::Reader,
+      public std::enable_shared_from_this<IdempotentDataQueueReader> {
  public:
   IdempotentDataQueueReader(std::shared_ptr<DataQueueImpl> data_queue)
       : data_queue_(std::move(data_queue)) {
-    CHECK(data_queue_->isIdempotent());
+    CHECK(data_queue_->is_idempotent());
   }
 
   // Disallow moving and copying.
   IdempotentDataQueueReader(const IdempotentDataQueueReader&) = delete;
   IdempotentDataQueueReader(IdempotentDataQueueReader&&) = delete;
-  IdempotentDataQueueReader& operator=(const IdempotentDataQueueReader&) = delete;
+  IdempotentDataQueueReader& operator=(const IdempotentDataQueueReader&) =
+      delete;
   IdempotentDataQueueReader& operator=(IdempotentDataQueueReader&&) = delete;
 
-  int Pull(
-      Next next,
-      int options,
-      DataQueue::Vec* data,
-      size_t count,
-      size_t max_count_hint = bob::kMaxCountHint) override {
+  int Pull(Next next,
+           int options,
+           DataQueue::Vec* data,
+           size_t count,
+           size_t max_count_hint = bob::kMaxCountHint) override {
+    std::shared_ptr<DataQueue::Reader> self = shared_from_this();
+
     // If ended is true, this reader has already reached the end and cannot
     // provide any more data.
     if (ended_) {
-      std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](size_t) {});
+      std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](uint64_t) {});
       return bob::Status::STATUS_EOS;
     }
 
     // If this is the first pull from this reader, we are first going to
     // check to see if there is anything at all to actually do.
-    if (current_index_.IsNothing()) {
+    if (!current_index_.has_value()) {
       // First, let's check the number of entries. If there are no entries,
       // we've reached the end and have nothing to do.
-      bool empty = data_queue_->entries_.empty();
-
-      // Second, if there are entries, let's check the known size to see if
-      // it is zero or not.
-      if (!empty) {
-        size_t size;
-        if (data_queue_->size().To(&size)) {
-          // If the size is known to be zero, there's absolutely nothing else for
-          // us to do but end.
-          empty = (size == 0);
-        }
-        // If the size cannot be determined, we will have to try reading from
-        // the entry to see if it has any data or not, so fall through here.
-      }
-
-      if (empty) {
+      // Because this is an idempotent dataqueue, we should always know the
+      // size...
+      if (data_queue_->entries_.empty()) {
         ended_ = true;
-        std::move(next)(bob::Status::STATUS_END, nullptr, 0, [](size_t) {});
-        return bob::Status::STATUS_END;
+        std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](uint64_t) {});
+        return bob::Status::STATUS_EOS;
       }
 
-      current_index_ = Just(0U);
+      current_index_ = 0;
     }
 
     // We have current_index_, awesome, we are going to keep reading from
     // it until we receive and end.
-    CHECK(!pull_pending_);
-    pull_pending_ = true;
-    int status = getCurrentReader().Pull(
-        [this, next = std::move(next)]
-        (int status, const DataQueue::Vec* vecs, size_t count, Done done) {
-      pull_pending_ = false;
-      last_status_ = status;
-
-      // In each of these cases, we do not expect that the source will
-      // actually have provided any actual data.
-      CHECK_IMPLIES(status == bob::Status::STATUS_BLOCK ||
-                    status == bob::Status::STATUS_WAIT ||
-                    status == bob::Status::STATUS_EOS,
-                    vecs == nullptr && count == 0);
-
-      // Technically, receiving a STATUS_EOS is really an error because
-      // we've read past the end of the data, but we are going to treat
-      // it the same as end.
-      if (status == bob::Status::STATUS_END ||
-          status == bob::Status::STATUS_EOS) {
-        uint32_t current = current_index_.FromJust() + 1;
-        // We have reached the end of this entry. If this is the last entry,
-        // then we are done. Otherwise, we advance the current_index_, clear
-        // the current_reader_ and wait for the next read.
-        if (current == data_queue_->entries_.size()) {
-          // Yes, this was the final entry. We're all done.
-          ended_ = true;
-          status = bob::Status::STATUS_END;
-        } else {
-          // This was not the final entry, so we update the index and
-          // continue on.
-          current_index_ = Just(current);
-          status = bob::Status::STATUS_CONTINUE;
-        }
-        current_reader_ = nullptr;
-      }
 
-      // Now that we have updated this readers state, we can forward
-      // everything on to the outer next.
-      std::move(next)(status, vecs, count, std::move(done));
-    }, options, data, count, max_count_hint);
+    auto current_reader = getCurrentReader();
+    if (current_reader == nullptr) {
+      // Getting the current reader for an entry could fail for several
+      // reasons. For an FdEntry, for instance, getting the reader may
+      // fail if the file has been modified since the FdEntry was created.
+      // We handle the case simply by erroring.
+      std::move(next)(UV_EINVAL, nullptr, 0, [](uint64_t) {});
+      return UV_EINVAL;
+    }
 
+    CHECK(!pull_pending_);
+    pull_pending_ = true;
+    int status = current_reader->Pull(
+        [this, next = std::move(next)](
+            int status, const DataQueue::Vec* vecs, uint64_t count, Done done) {
+          pull_pending_ = false;
+          // In each of these cases, we do not expect that the source will
+          // actually have provided any actual data.
+          CHECK_IMPLIES(status == bob::Status::STATUS_BLOCK ||
+                            status == bob::Status::STATUS_WAIT ||
+                            status == bob::Status::STATUS_EOS,
+                        vecs == nullptr && count == 0);
+          if (status == bob::Status::STATUS_EOS) {
+            uint32_t current = current_index_.value() + 1;
+            current_reader_ = nullptr;
+            // We have reached the end of this entry. If this is the last entry,
+            // then we are done. Otherwise, we advance the current_index_, clear
+            // the current_reader_ and wait for the next read.
+
+            if (current == data_queue_->entries_.size()) {
+              // Yes, this was the final entry. We're all done.
+              ended_ = true;
+            } else {
+              // This was not the final entry, so we update the index and
+              // continue on by performing another read.
+              current_index_ = current;
+              status = bob::STATUS_CONTINUE;
+            }
+            std::move(next)(status, nullptr, 0, [](uint64_t) {});
+            return;
+          }
+
+          std::move(next)(status, vecs, count, std::move(done));
+        },
+        options,
+        data,
+        count,
+        max_count_hint);
+
+    // The pull was handled synchronously. If we're not ended, we want to
+    // make sure status returned is CONTINUE.
     if (!pull_pending_) {
-      // The callback was resolved synchronously. Let's check our status.
-
-      // Just as a double check, when next is called synchronous, the status
-      // provided there should match the status returned.
-      CHECK(status == last_status_);
-
-      if (ended_) {
-        // Awesome, we read everything. Return status end here and we're done.
-        return bob::Status::STATUS_END;
-      }
-
-      if (status == bob::Status::STATUS_END ||
-          status == bob::Status::STATUS_EOS) {
-        // If we got here and ended_ is not true, there's more to read.
-        return bob::Status::STATUS_CONTINUE;
-      }
-
+      if (!ended_) return bob::Status::STATUS_CONTINUE;
       // For all other status, we just fall through and return it straightaway.
     }
 
@@ -345,60 +305,63 @@ class IdempotentDataQueueReader final : public DataQueue::Reader {
     return status;
   }
 
-  DataQueue::Reader& getCurrentReader() {
+  DataQueue::Reader* getCurrentReader() {
     CHECK(!ended_);
-    CHECK(current_index_.IsJust());
+    CHECK(current_index_.has_value());
     if (current_reader_ == nullptr) {
-      auto& entry = data_queue_->entries_[current_index_.FromJust()];
+      auto& entry = data_queue_->entries_[current_index_.value()];
       // Because this is an idempotent reader, let's just be sure to
       // doublecheck that the entry itself is actually idempotent
-      DCHECK(entry->isIdempotent());
-      current_reader_ = static_cast<EntryBase&>(*entry).getReader();
+      DCHECK(entry->is_idempotent());
+      current_reader_ = static_cast<EntryImpl&>(*entry).get_reader();
     }
-    CHECK_NOT_NULL(current_reader_);
-    return *current_reader_;
+    return current_reader_.get();
   }
 
   SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(IdempotentDataQueueReader);
-  SET_SELF_SIZE(IdempotentDataQueueReader);
+  SET_MEMORY_INFO_NAME(IdempotentDataQueueReader)
+  SET_SELF_SIZE(IdempotentDataQueueReader)
 
  private:
   std::shared_ptr<DataQueueImpl> data_queue_;
-  Maybe<uint32_t> current_index_ = Nothing<uint32_t>();
-  std::unique_ptr<DataQueue::Reader> current_reader_ = nullptr;
+  std::optional<uint32_t> current_index_ = std::nullopt;
+  std::shared_ptr<DataQueue::Reader> current_reader_ = nullptr;
   bool ended_ = false;
   bool pull_pending_ = false;
-  int last_status_ = 0;
 };
 
 // A NonIdempotentDataQueueReader reads entries from the DataEnqueue
 // and removes those entries from the queue as they are fully consumed.
 // This means that reads are destructive and the state of the DataQueue
 // is mutated as the read proceeds.
-class NonIdempotentDataQueueReader final : public DataQueue::Reader {
+class NonIdempotentDataQueueReader final
+    : public DataQueue::Reader,
+      public std::enable_shared_from_this<NonIdempotentDataQueueReader> {
  public:
   NonIdempotentDataQueueReader(std::shared_ptr<DataQueueImpl> data_queue)
       : data_queue_(std::move(data_queue)) {
-    CHECK(!data_queue_->isIdempotent());
+    CHECK(!data_queue_->is_idempotent());
   }
 
   // Disallow moving and copying.
   NonIdempotentDataQueueReader(const NonIdempotentDataQueueReader&) = delete;
   NonIdempotentDataQueueReader(NonIdempotentDataQueueReader&&) = delete;
-  NonIdempotentDataQueueReader& operator=(const NonIdempotentDataQueueReader&) = delete;
-  NonIdempotentDataQueueReader& operator=(NonIdempotentDataQueueReader&&) = delete;
-
-  int Pull(
-      Next next,
-      int options,
-      DataQueue::Vec* data,
-      size_t count,
-      size_t max_count_hint = bob::kMaxCountHint) override {
+  NonIdempotentDataQueueReader& operator=(const NonIdempotentDataQueueReader&) =
+      delete;
+  NonIdempotentDataQueueReader& operator=(NonIdempotentDataQueueReader&&) =
+      delete;
+
+  int Pull(Next next,
+           int options,
+           DataQueue::Vec* data,
+           size_t count,
+           size_t max_count_hint = bob::kMaxCountHint) override {
+    std::shared_ptr<DataQueue::Reader> self = shared_from_this();
+
     // If ended is true, this reader has already reached the end and cannot
     // provide any more data.
     if (ended_) {
-      std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](size_t) {});
+      std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](uint64_t) {});
       return bob::Status::STATUS_EOS;
     }
 
@@ -410,21 +373,21 @@ class NonIdempotentDataQueueReader final : public DataQueue::Reader {
       // expect more data to be provided later, but we don't know exactly when
       // that'll happe, so the proper response here is to return a blocked
       // status.
-      if (!data_queue_->isCapped()) {
-        std::move(next)(bob::Status::STATUS_BLOCK, nullptr, 0, [](size_t) {});
+      if (!data_queue_->is_capped()) {
+        std::move(next)(bob::Status::STATUS_BLOCK, nullptr, 0, [](uint64_t) {});
         return bob::STATUS_BLOCK;
       }
 
       // However, if we are capped, the status will depend on whether the size
       // of the data_queue_ is known or not.
 
-      size_t size;
-      if (data_queue_->size().To(&size)) {
-        // If the size is known, and it is still less than the cap, then we still
-        // might get more data. We just don't know exactly when that'll come, so
-        // let's return a blocked status.
-        if (size < data_queue_->capped_size_.FromJust()) {
-          std::move(next)(bob::Status::STATUS_BLOCK, nullptr, 0, [](size_t) {});
+      if (data_queue_->size().has_value()) {
+        // If the size is known, and it is still less than the cap, then we
+        // still might get more data. We just don't know exactly when that'll
+        // come, so let's return a blocked status.
+        if (data_queue_->size().value() < data_queue_->capped_size_.value()) {
+          std::move(next)(
+              bob::Status::STATUS_BLOCK, nullptr, 0, [](uint64_t) {});
           return bob::STATUS_BLOCK;
         }
 
@@ -437,75 +400,51 @@ class NonIdempotentDataQueueReader final : public DataQueue::Reader {
       // entries, we're done. There's nothing left to read.
       current_reader_ = nullptr;
       ended_ = true;
-      std::move(next)(bob::Status::STATUS_END, nullptr, 0, [](size_t) {});
-      return bob::STATUS_END;
+      std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](uint64_t) {});
+      return bob::STATUS_EOS;
+    }
+
+    auto current_reader = getCurrentReader();
+    if (current_reader == nullptr) {
+      std::move(next)(UV_EINVAL, nullptr, 0, [](uint64_t) {});
+      return UV_EINVAL;
     }
 
     // If we got here, we have an entry to read from.
     CHECK(!pull_pending_);
     pull_pending_ = true;
-    int status = getCurrentReader().Pull(
-        [this, next = std::move(next)]
-        (int status, const DataQueue::Vec* vecs, size_t count, Done done) {
-      pull_pending_ = false;
-      last_status_ = status;
-
-      // In each of these cases, we do not expect that the source will
-      // actually have provided any actual data.
-      CHECK_IMPLIES(status == bob::Status::STATUS_BLOCK ||
-                    status == bob::Status::STATUS_WAIT ||
-                    status == bob::Status::STATUS_EOS,
-                    vecs == nullptr && count == 0);
-
-      // Technically, receiving a STATUS_EOS is really an error because
-      // we've read past the end of the data, but we are going to treat
-      // it the same as end.
-      if (status == bob::Status::STATUS_END ||
-          status == bob::Status::STATUS_EOS) {
-        data_queue_->entries_.erase(data_queue_->entries_.begin());
-
-        // We have reached the end of this entry. If this is the last entry,
-        // then we are done. Otherwise, we advance the current_index_, clear
-        // the current_reader_ and wait for the next read.
-        if (data_queue_->entries_.empty()) {
-          // Yes, this was the final entry. We're all done.
-          ended_ = true;
-          status = bob::Status::STATUS_END;
-        } else {
-          // This was not the final entry, so we update the index and
-          // continue on.
-          status = bob::Status::STATUS_CONTINUE;
-        }
-        current_reader_ = nullptr;
-      }
-
-      // Now that we have updated this readers state, we can forward
-      // everything on to the outer next.
-      std::move(next)(status, vecs, count, std::move(done));
-    }, options, data, count, max_count_hint);
+    int status = current_reader->Pull(
+        [this, next = std::move(next)](
+            int status, const DataQueue::Vec* vecs, uint64_t count, Done done) {
+          pull_pending_ = false;
+
+          // In each of these cases, we do not expect that the source will
+          // actually have provided any actual data.
+          CHECK_IMPLIES(status == bob::Status::STATUS_BLOCK ||
+                            status == bob::Status::STATUS_WAIT ||
+                            status == bob::Status::STATUS_EOS,
+                        vecs == nullptr && count == 0);
+          if (status == bob::Status::STATUS_EOS) {
+            data_queue_->entries_.erase(data_queue_->entries_.begin());
+            ended_ = data_queue_->entries_.empty();
+            current_reader_ = nullptr;
+            if (!ended_) status = bob::Status::STATUS_CONTINUE;
+            std::move(next)(status, nullptr, 0, [](uint64_t) {});
+            return;
+          }
+
+          // Now that we have updated this readers state, we can forward
+          // everything on to the outer next.
+          std::move(next)(status, vecs, count, std::move(done));
+        },
+        options,
+        data,
+        count,
+        max_count_hint);
 
     if (!pull_pending_) {
       // The callback was resolved synchronously. Let's check our status.
-
-      // Just as a double check, when next is called synchronous, the status
-      // provided there should match the status returned.
-      CHECK(status == last_status_);
-
-      if (ended_) {
-        // Awesome, we read everything. Return status end here and we're done.
-
-        // Let's just make sure we've removed all of the entries.
-        CHECK(data_queue_->entries_.empty());
-
-        return bob::Status::STATUS_END;
-      }
-
-      if (status == bob::Status::STATUS_END ||
-          status == bob::Status::STATUS_EOS) {
-        // If we got here and ended_ is not true, there's more to read.
-        return bob::Status::STATUS_CONTINUE;
-      }
-
+      if (!ended_) return bob::Status::STATUS_CONTINUE;
       // For all other status, we just fall through and return it straightaway.
     }
 
@@ -527,68 +466,68 @@ class NonIdempotentDataQueueReader final : public DataQueue::Reader {
     return status;
   }
 
-  DataQueue::Reader& getCurrentReader() {
+  DataQueue::Reader* getCurrentReader() {
     CHECK(!ended_);
     CHECK(!data_queue_->entries_.empty());
     if (current_reader_ == nullptr) {
       auto& entry = data_queue_->entries_.front();
-      current_reader_ = static_cast<EntryBase&>(*entry).getReader();
+      current_reader_ = static_cast<EntryImpl&>(*entry).get_reader();
     }
-    return *current_reader_;
+    return current_reader_.get();
   }
 
   SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(NonIdempotentDataQueueReader);
-  SET_SELF_SIZE(NonIdempotentDataQueueReader);
+  SET_MEMORY_INFO_NAME(NonIdempotentDataQueueReader)
+  SET_SELF_SIZE(NonIdempotentDataQueueReader)
 
  private:
   std::shared_ptr<DataQueueImpl> data_queue_;
-  std::unique_ptr<DataQueue::Reader> current_reader_ = nullptr;
+  std::shared_ptr<DataQueue::Reader> current_reader_ = nullptr;
   bool ended_ = false;
   bool pull_pending_ = false;
-  int last_status_ = 0;
 };
 
-std::unique_ptr<DataQueue::Reader> DataQueueImpl::getReader() {
-  if (isIdempotent()) {
-    return std::make_unique<IdempotentDataQueueReader>(shared_from_this());
+std::shared_ptr<DataQueue::Reader> DataQueueImpl::get_reader() {
+  if (is_idempotent()) {
+    return std::make_shared<IdempotentDataQueueReader>(shared_from_this());
   }
 
-  if (lockedToReader_) return nullptr;
-  lockedToReader_ = true;
+  if (locked_to_reader_) return nullptr;
+  locked_to_reader_ = true;
 
-  return std::make_unique<NonIdempotentDataQueueReader>(shared_from_this());
+  return std::make_shared<NonIdempotentDataQueueReader>(shared_from_this());
 }
 
 // ============================================================================
 
 // An empty, always idempotent entry.
-class EmptyEntry final : public EntryBase {
+class EmptyEntry final : public EntryImpl {
  public:
-  class EmptyReader final : public DataQueue::Reader {
-    public:
-
-    int Pull(
-        Next next,
-        int options,
-        DataQueue::Vec* data,
-        size_t count,
-        size_t max_count_hint = bob::kMaxCountHint) override {
+  class EmptyReader final : public DataQueue::Reader,
+                            public std::enable_shared_from_this<EmptyReader> {
+   public:
+    int Pull(Next next,
+             int options,
+             DataQueue::Vec* data,
+             size_t count,
+             size_t max_count_hint = bob::kMaxCountHint) override {
+      auto self = shared_from_this();
       if (ended_) {
-        std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](size_t) {});
+        std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](uint64_t) {});
         return bob::Status::STATUS_EOS;
       }
 
       ended_ = true;
-      std::move(next)(bob::Status::STATUS_END, nullptr, 0, [](size_t) {});
-      return bob::Status::STATUS_END;
+      std::move(next)(
+          bob::Status::STATUS_CONTINUE, nullptr, 0, [](uint64_t) {});
+      return bob::Status::STATUS_CONTINUE;
     }
 
     SET_NO_MEMORY_INFO()
-    SET_MEMORY_INFO_NAME(EmptyReader);
-    SET_SELF_SIZE(EmptyReader);
+    SET_MEMORY_INFO_NAME(EmptyReader)
+    SET_SELF_SIZE(EmptyReader)
 
-    private:
+   private:
     bool ended_ = false;
   };
 
@@ -600,73 +539,71 @@ class EmptyEntry final : public EntryBase {
   EmptyEntry& operator=(const EmptyEntry&) = delete;
   EmptyEntry& operator=(EmptyEntry&&) = delete;
 
-  std::unique_ptr<DataQueue::Reader> getReader() override {
-    return std::make_unique<EmptyReader>();
+  std::shared_ptr<DataQueue::Reader> get_reader() override {
+    return std::make_shared<EmptyReader>();
   }
 
   std::unique_ptr<Entry> slice(
-      size_t start,
-      Maybe<size_t> maybeEnd = Nothing<size_t>()) override {
+      uint64_t start,
+      std::optional<uint64_t> maybeEnd = std::nullopt) override {
     if (start != 0) return nullptr;
-    size_t end;
-    if (maybeEnd.To(&end)) {
-      if (end != 0) return nullptr;
-    }
     return std::make_unique<EmptyEntry>();
   }
 
-  Maybe<size_t> size() const override { return Just<size_t>(0UL); }
+  std::optional<uint64_t> size() const override { return 0; }
 
-  bool isIdempotent() const override { return true; }
+  bool is_idempotent() const override { return true; }
 
   SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(EmptyEntry);
-  SET_SELF_SIZE(EmptyEntry);
+  SET_MEMORY_INFO_NAME(EmptyEntry)
+  SET_SELF_SIZE(EmptyEntry)
 };
 
 // ============================================================================
 
 // An entry that consists of a single memory resident v8::BackingStore.
 // These are always idempotent and always a fixed, known size.
-class InMemoryEntry final : public EntryBase {
+class InMemoryEntry final : public EntryImpl {
  public:
   struct InMemoryFunctor final {
     std::shared_ptr<BackingStore> backing_store;
-    void operator()(size_t) {
-      backing_store = nullptr;
-    };
+    void operator()(uint64_t) { backing_store = nullptr; }
   };
 
-  class InMemoryReader final : public DataQueue::Reader {
+  class InMemoryReader final
+      : public DataQueue::Reader,
+        public std::enable_shared_from_this<InMemoryReader> {
    public:
-    InMemoryReader(InMemoryEntry& entry)
-        : entry_(entry) {}
-
-    int Pull(
-        Next next,
-        int options,
-        DataQueue::Vec* data,
-        size_t count,
-        size_t max_count_hint = bob::kMaxCountHint) override {
+    InMemoryReader(InMemoryEntry& entry) : entry_(entry) {}
+
+    int Pull(Next next,
+             int options,
+             DataQueue::Vec* data,
+             size_t count,
+             size_t max_count_hint = bob::kMaxCountHint) override {
+      auto self = shared_from_this();
       if (ended_) {
-        std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](size_t) {});
+        std::move(next)(bob::Status::STATUS_EOS, nullptr, 0, [](uint64_t) {});
         return bob::Status::STATUS_EOS;
       }
 
       ended_ = true;
-      DataQueue::Vec vec {
-        reinterpret_cast<uint8_t*>(entry_.backing_store_->Data()) + entry_.offset_,
-        entry_.byte_length_,
+      DataQueue::Vec vec{
+          reinterpret_cast<uint8_t*>(entry_.backing_store_->Data()) +
+              entry_.offset_,
+          entry_.byte_length_,
       };
-      std::move(next)(bob::Status::STATUS_END, &vec, 1, InMemoryFunctor({
-        entry_.backing_store_
-      }));
-      return bob::Status::STATUS_END;
+
+      std::move(next)(bob::Status::STATUS_CONTINUE,
+                      &vec,
+                      1,
+                      InMemoryFunctor({entry_.backing_store_}));
+      return bob::Status::STATUS_CONTINUE;
     }
 
     SET_NO_MEMORY_INFO()
-    SET_MEMORY_INFO_NAME(InMemoryReader);
-    SET_SELF_SIZE(InMemoryReader);
+    SET_MEMORY_INFO_NAME(InMemoryReader)
+    SET_SELF_SIZE(InMemoryReader)
 
    private:
     InMemoryEntry& entry_;
@@ -674,8 +611,8 @@ class InMemoryEntry final : public EntryBase {
   };
 
   InMemoryEntry(std::shared_ptr<BackingStore> backing_store,
-                size_t offset,
-                size_t byte_length)
+                uint64_t offset,
+                uint64_t byte_length)
       : backing_store_(std::move(backing_store)),
         offset_(offset),
         byte_length_(byte_length) {
@@ -690,14 +627,15 @@ class InMemoryEntry final : public EntryBase {
   InMemoryEntry& operator=(const InMemoryEntry&) = delete;
   InMemoryEntry& operator=(InMemoryEntry&&) = delete;
 
-  std::unique_ptr<DataQueue::Reader> getReader() override {
-    return std::make_unique<InMemoryReader>(*this);
+  std::shared_ptr<DataQueue::Reader> get_reader() override {
+    return std::make_shared<InMemoryReader>(*this);
   }
 
   std::unique_ptr<Entry> slice(
-      size_t start,
-      Maybe<size_t> maybeEnd = Nothing<size_t>()) override {
-    const auto makeEntry = [&](size_t start, size_t len) -> std::unique_ptr<Entry> {
+      uint64_t start,
+      std::optional<uint64_t> maybeEnd = std::nullopt) override {
+    const auto makeEntry = [&](uint64_t start,
+                               uint64_t len) -> std::unique_ptr<Entry> {
       if (len == 0) {
         return std::make_unique<EmptyEntry>();
       }
@@ -710,8 +648,8 @@ class InMemoryEntry final : public EntryBase {
     // The start cannot extend beyond the maximum end point of this entry.
     start = std::min(start, offset_ + byte_length_);
 
-    size_t end;
-    if (maybeEnd.To(&end)) {
+    if (maybeEnd.has_value()) {
+      uint64_t end = maybeEnd.value();
       // The end cannot extend beyond the maximum end point of this entry,
       // and the end must be equal to or greater than the start.
       end = std::max(start, std::min(offset_ + end, offset_ + byte_length_));
@@ -724,20 +662,21 @@ class InMemoryEntry final : public EntryBase {
     return makeEntry(start, byte_length_ - start);
   }
 
-  Maybe<size_t> size() const override { return Just(byte_length_); }
+  std::optional<uint64_t> size() const override { return byte_length_; }
 
-  bool isIdempotent() const override { return true; }
+  bool is_idempotent() const override { return true; }
 
   void MemoryInfo(node::MemoryTracker* tracker) const override {
-    tracker->TrackField("store", backing_store_);
+    tracker->TrackField(
+        "store", backing_store_, "std::shared_ptr<v8::BackingStore>");
   }
-  SET_MEMORY_INFO_NAME(InMemoryEntry);
-  SET_SELF_SIZE(InMemoryEntry);
+  SET_MEMORY_INFO_NAME(InMemoryEntry)
+  SET_SELF_SIZE(InMemoryEntry)
 
  private:
   std::shared_ptr<BackingStore> backing_store_;
-  size_t offset_;
-  size_t byte_length_;
+  uint64_t offset_;
+  uint64_t byte_length_;
 
   friend class InMemoryReader;
 };
@@ -746,9 +685,9 @@ class InMemoryEntry final : public EntryBase {
 
 // An entry that wraps a DataQueue. The entry takes on the characteristics
 // of the wrapped dataqueue.
-class DataQueueEntry : public EntryBase {
+class DataQueueEntry : public EntryImpl {
  public:
-  DataQueueEntry(std::shared_ptr<DataQueue> data_queue)
+  explicit DataQueueEntry(std::shared_ptr<DataQueue> data_queue)
       : data_queue_(std::move(data_queue)) {
     CHECK(data_queue_);
   }
@@ -759,13 +698,12 @@ class DataQueueEntry : public EntryBase {
   DataQueueEntry& operator=(const DataQueueEntry&) = delete;
   DataQueueEntry& operator=(DataQueueEntry&&) = delete;
 
-  std::unique_ptr<DataQueue::Reader> getReader() override {
-    return data_queue_->getReader();
+  std::shared_ptr<DataQueue::Reader> get_reader() override {
+    return std::make_shared<ReaderImpl>(data_queue_->get_reader());
   }
 
   std::unique_ptr<Entry> slice(
-      size_t start,
-      Maybe<size_t> end = Nothing<size_t>()) override {
+      uint64_t start, std::optional<uint64_t> end = std::nullopt) override {
     std::shared_ptr<DataQueue> sliced = data_queue_->slice(start, end);
     if (!sliced) return nullptr;
 
@@ -775,10 +713,10 @@ class DataQueueEntry : public EntryBase {
   // Returns the number of bytes represented by this Entry if it is
   // known. Certain types of entries, such as those backed by streams
   // might not know the size in advance and therefore cannot provide
-  // a value. In such cases, size() must return v8::Nothing<size_t>.
+  // a value. In such cases, size() must return std::nullopt.
   //
   // If the entry is idempotent, a size should always be available.
-  Maybe<size_t> size() const override { return data_queue_->size(); }
+  std::optional<uint64_t> size() const override { return data_queue_->size(); }
 
   // When true, multiple reads on the object must produce the exact
   // same data or the reads will fail. Some sources of entry data,
@@ -786,19 +724,44 @@ class DataQueueEntry : public EntryBase {
   // and therefore must not claim to be. If an entry claims to be
   // idempotent and cannot preserve that quality, subsequent reads
   // must fail with an error when a variance is detected.
-  bool isIdempotent() const override { return data_queue_->isIdempotent(); }
+  bool is_idempotent() const override { return data_queue_->is_idempotent(); }
 
   void MemoryInfo(node::MemoryTracker* tracker) const override {
-    tracker->TrackField("data_queue", data_queue_);
+    tracker->TrackField(
+        "data_queue", data_queue_, "std::shared_ptr<DataQueue>");
   }
 
   DataQueue& getDataQueue() { return *data_queue_; }
 
-  SET_MEMORY_INFO_NAME(DataQueueEntry);
-  SET_SELF_SIZE(DataQueueEntry);
+  SET_MEMORY_INFO_NAME(DataQueueEntry)
+  SET_SELF_SIZE(DataQueueEntry)
 
  private:
   std::shared_ptr<DataQueue> data_queue_;
+
+  class ReaderImpl : public DataQueue::Reader,
+                     public std::enable_shared_from_this<ReaderImpl> {
+   public:
+    explicit ReaderImpl(std::shared_ptr<DataQueue::Reader> inner)
+        : inner_(std::move(inner)) {}
+
+    int Pull(DataQueue::Reader::Next next,
+             int options,
+             DataQueue::Vec* data,
+             size_t count,
+             size_t max_count_hint) override {
+      auto self = shared_from_this();
+      return inner_->Pull(
+          std::move(next), options, data, count, max_count_hint);
+    }
+
+    SET_NO_MEMORY_INFO()
+    SET_MEMORY_INFO_NAME(ReaderImpl)
+    SET_SELF_SIZE(ReaderImpl)
+
+   private:
+    std::shared_ptr<DataQueue::Reader> inner_;
+  };
 };
 
 // ============================================================================
@@ -811,77 +774,61 @@ class DataQueueEntry : public EntryBase {
 // a tolerable risk here. While FdEntry is considered idempotent, this race
 // means that it is indeed possible for multiple reads to return different
 // results if the file just happens to get modified.
-class FdEntry final : public EntryBase {
+class FdEntry final : public EntryImpl {
   // TODO(@jasnell, @flakey5):
-  // * This should only allow reading from regular files. No directories, no pipes, etc.
-  // * The reader should support accepting the buffer(s) from the pull, if any. It should
+  // * This should only allow reading from regular files. No directories, no
+  // pipes, etc.
+  // * The reader should support accepting the buffer(s) from the pull, if any.
+  // It should
   //   only allocate a managed buffer if the pull doesn't provide any.
-  // * We might want to consider making the stat on each read sync to eliminate the race
+  // * We might want to consider making the stat on each read sync to eliminate
+  // the race
   //   condition described in the comment above.
  public:
-  FdEntry(Environment* env,
-          int fd,
-          size_t start,
-          v8::Maybe<size_t> end,
-          BaseObjectPtr<fs::FileHandle> maybe_file_handle =
-              BaseObjectPtr<fs::FileHandle>())
-      : env_(env),
-        fd_(fd),
-        start_(0),
-        maybe_file_handle_(maybe_file_handle) {
-    CHECK(fd);
-    if (GetStat(stat_) == 0) {
-      if (end.IsNothing()) {
-        end_ = stat_.st_size;
-      } else {
-        end_ = std::min(stat_.st_size, end.FromJust());
-      }
-    }
-  }
+  static std::unique_ptr<FdEntry> Create(Environment* env, Local<Value> path) {
+    // We're only going to create the FdEntry if the file exists.
+    uv_fs_t req;
+    auto cleanup = OnScopeLeave([&] { uv_fs_req_cleanup(&req); });
 
-  FdEntry(Environment* env, BaseObjectPtr<fs::FileHandle> handle)
-      : FdEntry(env, handle->GetFD(), 0, Nothing<size_t>(), handle) {}
+    auto buf = std::make_shared<BufferValue>(env->isolate(), path);
+    if (uv_fs_stat(nullptr, &req, buf->out(), nullptr) < 0) return nullptr;
+
+    return std::make_unique<FdEntry>(
+        env, std::move(buf), req.statbuf, 0, req.statbuf.st_size);
+  }
 
   FdEntry(Environment* env,
-          int fd,
+          std::shared_ptr<BufferValue> path_,
           uv_stat_t stat,
-          size_t start,
-          size_t end,
-          BaseObjectPtr<fs::FileHandle> maybe_file_handle =
-             BaseObjectPtr<fs::FileHandle>())
+          uint64_t start,
+          uint64_t end)
       : env_(env),
-        fd_(end),
-        start_(start),
-        end_(end),
+        path_(std::move(path_)),
         stat_(stat),
-        maybe_file_handle_(maybe_file_handle){}
+        start_(start),
+        end_(end) {}
 
-  std::unique_ptr<DataQueue::Reader> getReader() override {
-    return std::make_unique<Reader>(this);
+  std::shared_ptr<DataQueue::Reader> get_reader() override {
+    return ReaderImpl::Create(this);
   }
 
   std::unique_ptr<Entry> slice(
-      size_t start,
-      Maybe<size_t> end = Nothing<size_t>()) override {
-    size_t new_start = start_ + start;
-    size_t new_end = end_;
-    if (end.IsJust()) {
-      new_end = std::min(end.FromJust() + start, new_end);
+      uint64_t start, std::optional<uint64_t> end = std::nullopt) override {
+    uint64_t new_start = start_ + start;
+    uint64_t new_end = end_;
+    if (end.has_value()) {
+      new_end = std::min(end.value() + start, new_end);
     }
 
     CHECK(new_start >= start_);
     CHECK(new_end <= end_);
 
-    return std::make_unique<FdEntry>(env_, fd_, stat_, new_start, new_end, maybe_file_handle_);
+    return std::make_unique<FdEntry>(env_, path_, stat_, new_start, new_end);
   }
 
-  Maybe<size_t> size() const override {
-    return Just(end_ - start_);
-  }
+  std::optional<uint64_t> size() const override { return end_ - start_; }
 
-  bool isIdempotent() const override {
-    return true;
-  }
+  bool is_idempotent() const override { return true; }
 
   Environment* env() const { return env_; }
 
@@ -889,229 +836,193 @@ class FdEntry final : public EntryBase {
   SET_MEMORY_INFO_NAME(FdEntry)
   SET_SELF_SIZE(FdEntry)
 
-  class Wrap : public BaseObject {
-   public:
-    static void New(const FunctionCallbackInfo<Value>& args) {
-      CHECK(args.IsConstructCall());
-      Environment* env = Environment::GetCurrent(args);
-
-      CHECK(args[0]->IsInt32());
-      CHECK(args[1]->IsUint32());
-      CHECK(args[2]->IsUint32());
-
-      int fd = args[0].As<Int32>()->Value();
-      size_t start = args[1].As<Uint32>()->Value();
-      size_t end = args[1].As<Uint32>()->Value();
-
-      new Wrap(env, args.This(), fd, start, Just(end));
-    }
+ private:
+  Environment* env_;
+  std::shared_ptr<BufferValue> path_;
+  uv_stat_t stat_;
+  uint64_t start_ = 0;
+  uint64_t end_ = 0;
 
-    static Local<FunctionTemplate> GetConstructorTemplate(Environment* env) {
-      Local<FunctionTemplate> tmpl = env->fdentry_constructor_template();
-      if (tmpl.IsEmpty()) {
-        Isolate* isolate = env->isolate();
-        tmpl = NewFunctionTemplate(isolate, New);
+  bool is_modified(const uv_stat_t& other) {
+    return other.st_size != stat_.st_size ||
+           other.st_mtim.tv_nsec != stat_.st_mtim.tv_nsec;
+  }
 
-        tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "FdEntry"));
-        tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
+  static bool CheckModified(FdEntry* entry, int fd) {
+    uv_fs_t req;
+    auto cleanup = OnScopeLeave([&] { uv_fs_req_cleanup(&req); });
+    // TODO(jasnell): Note the use of a sync fs call here is a bit unfortunate.
+    // Doing this asynchronously creates a bit of a race condition tho, a file
+    // could be unmodified when we call the operation but then by the time the
+    // async callback is triggered to give us that answer the file is modified.
+    // While such silliness is still possible here, the sync call at least makes
+    // it less likely to hit the race.
+    if (uv_fs_fstat(nullptr, &req, fd, nullptr) < 0) return true;
+    return entry->is_modified(req.statbuf);
+  }
 
-        env->set_fdentry_constructor_template(tmpl);
+  class ReaderImpl final : public DataQueue::Reader,
+                           public StreamListener,
+                           public std::enable_shared_from_this<ReaderImpl> {
+   public:
+    static std::shared_ptr<ReaderImpl> Create(FdEntry* entry) {
+      uv_fs_t req;
+      auto cleanup = OnScopeLeave([&] { uv_fs_req_cleanup(&req); });
+      int file =
+          uv_fs_open(nullptr, &req, entry->path_->out(), O_RDONLY, 0, nullptr);
+      if (file < 0 || FdEntry::CheckModified(entry, file)) {
+        uv_fs_close(nullptr, &req, file, nullptr);
+        return nullptr;
       }
+      return std::make_shared<ReaderImpl>(
+          BaseObjectPtr<fs::FileHandle>(
+              fs::FileHandle::New(entry->env()->GetBindingData<fs::BindingData>(
+                                      entry->env()->context()),
+                                  file,
+                                  Local<Object>(),
+                                  entry->start_,
+                                  entry->end_)),
+          entry);
+    }
 
-      return tmpl;
+    explicit ReaderImpl(BaseObjectPtr<fs::FileHandle> handle, FdEntry* entry)
+        : env_(handle->env()), handle_(std::move(handle)), entry_(entry) {
+      handle_->PushStreamListener(this);
+      handle_->env()->AddCleanupHook(cleanup, this);
     }
 
-    static void Initialize(Environment* env, Local<Object> target) {
-      SetConstructorFunction(
-        env->context(), target, "FdEntry", GetConstructorTemplate(env));
+    ~ReaderImpl() override {
+      handle_->env()->RemoveCleanupHook(cleanup, this);
+      DrainAndClose();
+      handle_->RemoveStreamListener(this);
     }
 
-    static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
-      registry->Register(New);
+    uv_buf_t OnStreamAlloc(size_t suggested_size) override {
+      return env_->allocate_managed_buffer(suggested_size);
     }
 
-    static BaseObjectPtr<Wrap> Create(
-        Environment* env,
-        int fd,
-        size_t start = 0,
-        Maybe<size_t> end = Nothing<size_t>()) {
-      Local<Object> obj;
-      if (!GetConstructorTemplate(env)
-          ->InstanceTemplate()
-          ->NewInstance(env->context())
-          .ToLocal(&obj)) {
-        return BaseObjectPtr<Wrap>();
+    void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override {
+      std::shared_ptr<v8::BackingStore> store =
+          env_->release_managed_buffer(buf);
+
+      if (ended_) {
+        // If we got here and ended_ is true, it means we ended and drained
+        // while the read was pending. We're just going to do nothing.
+        CHECK(pending_pulls_.empty());
+        return;
       }
 
-      return MakeBaseObject<Wrap>(env, obj, fd, start, end);
-    }
+      CHECK(reading_);
+      auto pending = DequeuePendingPull();
 
-    Wrap(Environment* env, Local<Object> obj, int fd, size_t start, v8::Maybe<size_t> end)
-        : BaseObject(env, obj),
-          inner_(std::make_unique<FdEntry>(env, fd, start, end)) {
-      MakeWeak();
-    }
+      if (CheckModified(entry_, handle_->GetFD())) {
+        DrainAndClose();
+        // The file was modified while the read was pending. We need to error.
+        std::move(pending.next)(UV_EINVAL, nullptr, 0, [](uint64_t) {});
+        return;
+      }
 
-    std::unique_ptr<DataQueue::Entry> detach() {
-      return std::move(inner_);
-    }
+      if (nread < 0) {
+        if (nread == UV_EOF) {
+          std::move(pending.next)(bob::STATUS_EOS, nullptr, 0, [](uint64_t) {});
+        } else {
+          std::move(pending.next)(nread, nullptr, 0, [](uint64_t) {});
+        }
 
-    bool isDetached() const { return inner_ == nullptr; }
+        return DrainAndClose();
+      }
 
-    void MemoryInfo(MemoryTracker* tracker) const override {
-      tracker->TrackField("entry", inner_);
-    }
-    SET_MEMORY_INFO_NAME(FdEntry::Wrap)
-    SET_SELF_SIZE(Wrap)
+      DataQueue::Vec vec;
+      vec.base = static_cast<uint8_t*>(store->Data());
+      vec.len = static_cast<uint64_t>(nread);
+      std::move(pending.next)(
+          bob::STATUS_CONTINUE, &vec, 1, [store](uint64_t) {});
 
-   private:
-    std::unique_ptr<FdEntry> inner_;
-  };
+      if (pending_pulls_.empty()) {
+        reading_ = false;
+        if (handle_->IsAlive()) handle_->ReadStop();
+      }
+    }
 
- private:
-  Environment* env_;
-  int fd_;
-  size_t start_ = 0;
-  size_t end_ = 0;
-  uv_stat_t stat_;
-  uv_fs_t req;
-  BaseObjectPtr<fs::FileHandle> maybe_file_handle_;
+    int Pull(Next next,
+             int options,
+             DataQueue::Vec* data,
+             size_t count,
+             size_t max_count_hint = bob::kMaxCountHint) override {
+      if (ended_ || !handle_->IsAlive()) {
+        std::move(next)(bob::STATUS_EOS, nullptr, 0, [](uint64_t) {});
+        return bob::STATUS_EOS;
+      }
 
-  int GetStat(uv_stat_t& stat) {
-    int err = uv_fs_fstat(env_->event_loop(), &req, fd_, nullptr);
-    stat = req.statbuf;
-    return err;
-  }
+      if (FdEntry::CheckModified(entry_, handle_->GetFD())) {
+        DrainAndClose();
+        std::move(next)(UV_EINVAL, nullptr, 0, [](uint64_t) {});
+        return UV_EINVAL;
+      }
 
-  class Reader : public DataQueue::Reader {
-   public:
-    Reader(FdEntry* entry)
-        : entry_(entry),
-          offset_(entry->start_),
-          end_(entry_->end_) {}
-
-    int Pull(
-        Next next,
-        int options,
-        DataQueue::Vec* data,
-        size_t count,
-        size_t max_count_hint = bob::kMaxCountHint) override {
-      // TODO(@jasnell): For now, we're going to ignore data and count.
-      // Later, we can support these to allow the caller to allocate the
-      // buffers we read into. To keep things easier for now, we're going
-      // to read into a pre-allocated buffer.
-      if (ended_ || offset_ == end_) {
-        std::move(next)(bob::STATUS_EOS, nullptr, 0, [](size_t) {});
-        return bob::STATUS_EOS;
+      pending_pulls_.emplace_back(std::move(next), shared_from_this());
+      if (!reading_) {
+        reading_ = true;
+        handle_->ReadStart();
       }
-      // offset_ should always be less than end_ here
-      CHECK_LT(offset_, end_);
-      new PendingRead(this, std::move(next));
       return bob::STATUS_WAIT;
     }
 
     SET_NO_MEMORY_INFO()
     SET_MEMORY_INFO_NAME(FdEntry::Reader)
-    SET_SELF_SIZE(Reader)
+    SET_SELF_SIZE(ReaderImpl)
 
    private:
-    FdEntry* entry_;
-    bool ended_ = false;
-    size_t offset_;
-    size_t end_;
-
-    struct PendingRead {
-      static constexpr size_t DEFAULT_BUFFER_SIZE = 4096;
-      Reader* reader;
+    struct PendingPull {
       Next next;
-      uv_fs_t req_;
-      uv_buf_t uvbuf;
-
-      PendingRead(Reader* reader, Next next)
-          : reader(reader),
-            next(std::move(next)),
-            uvbuf(reader->entry_->env()->allocate_managed_buffer(
-              std::min(DEFAULT_BUFFER_SIZE, reader->end_ - reader->offset_)
-            )) {
-        req_.data = this;
-        uv_fs_fstat(reader->entry_->env()->event_loop(), &req_,
-                    reader->entry_->fd_, &PendingRead::OnStat);
-      }
-
-      void Done() {
-        delete this;
-      }
-
-      bool checkEnded() {
-        if (reader->ended_) {
-          // A previous read ended this readable. Let's stop here.
-          std::move(next)(bob::STATUS_EOS, nullptr, 0, [](size_t) {});
-          return true;
-        }
-        if (req_.result < 0) {
-          std::move(next)(req_.result, nullptr, 0, [](size_t) {});
-          return true;
-        }
-        return false;
-      }
-
-      void OnStat() {
-        if (checkEnded()) return Done();
-        uv_stat_t current_stat = req_.statbuf;
-        uv_stat_t& orig = reader->entry_->stat_;
-        if (current_stat.st_size != orig.st_size ||
-            current_stat.st_ctim.tv_nsec != orig.st_ctim.tv_nsec ||
-            current_stat.st_mtim.tv_nsec != orig.st_mtim.tv_nsec) {
-          // The fd was modified. Fail the read.
-          std::move(next)(UV_EINVAL, nullptr, 0, [](size_t) {});
-          return;
-        }
+      std::shared_ptr<ReaderImpl> self;
+      PendingPull(Next next, std::shared_ptr<ReaderImpl> self)
+          : next(std::move(next)), self(std::move(self)) {}
+    };
 
-        // Now we read from the file.
-        uv_fs_read(reader->entry_->env()->event_loop(), &req_,
-                   reader->entry_->fd_,
-                   &uvbuf, 1,
-                   reader->offset_,
-                   OnRead);
-      }
+    Environment* env_;
+    BaseObjectPtr<fs::FileHandle> handle_;
+    FdEntry* entry_;
+    std::deque<PendingPull> pending_pulls_;
+    bool reading_ = false;
+    bool ended_ = false;
 
-      void OnRead() {
-        auto on_exit = OnScopeLeave([this] { Done(); });
-        if (checkEnded()) return;
-        std::shared_ptr<BackingStore> store =
-            reader->entry_->env()->release_managed_buffer(uvbuf);
-        size_t amountRead = req_.result;
-        // We should never read past end_
-        CHECK_LE(amountRead + reader->offset_, reader->end_);
-        reader->offset_ += amountRead;
-        if (reader->offset_ == reader->end_)
-          reader->ended_ = true;
-        DataQueue::Vec vec = {
-          reinterpret_cast<uint8_t*>(store->Data()),
-          amountRead
-        };
-        std::move(next)(
-          reader->ended_ ? bob::STATUS_END : bob::STATUS_CONTINUE,
-          &vec, 1, [store](size_t) mutable {});
-      }
+    static void cleanup(void* self) {
+      auto ptr = static_cast<ReaderImpl*>(self);
+      ptr->DrainAndClose();
+    }
 
-      static void OnStat(uv_fs_t* req) {
-        PendingRead* read = ContainerOf(&PendingRead::req_, req);
-        read->OnStat();
+    void DrainAndClose() {
+      if (ended_) return;
+      ended_ = true;
+      while (!pending_pulls_.empty()) {
+        auto pending = DequeuePendingPull();
+        std::move(pending.next)(bob::STATUS_EOS, nullptr, 0, [](uint64_t) {});
       }
+      handle_->ReadStop();
+
+      // We fallback to a sync close on the raw fd here because it is the
+      // easiest, simplest thing to do. All of FileHandle's close mechanisms
+      // assume async close and cleanup, while DrainAndClose might be running
+      // in the destructor during GC, for instance. As a todo, FileHandle could
+      // provide a sync mechanism for closing the FD but, for now, this
+      // approach works.
+      int fd = handle_->Release();
+      uv_fs_t req;
+      uv_fs_close(nullptr, &req, fd, nullptr);
+      uv_fs_req_cleanup(&req);
+    }
 
-      static void OnRead(uv_fs_t* req) {
-        PendingRead* read = ContainerOf(&PendingRead::req_, req);
-        read->OnRead();
-      }
-    };
+    PendingPull DequeuePendingPull() {
+      CHECK(!pending_pulls_.empty());
+      auto pop = OnScopeLeave([this] { pending_pulls_.pop_front(); });
+      return std::move(pending_pulls_.front());
+    }
 
-    friend struct PendingRead;
     friend class FdEntry;
   };
 
-  friend class Reader;
-  friend struct Reader::PendingRead;
+  friend class ReaderImpl;
 };
 
 // ============================================================================
@@ -1122,9 +1033,9 @@ std::shared_ptr<DataQueue> DataQueue::CreateIdempotent(
     std::vector<std::unique_ptr<Entry>> list) {
   // Any entry is invalid for an idempotent DataQueue if any of the entries
   // are nullptr or is not idempotent.
-  size_t size = 0;
+  uint64_t size = 0;
   const auto isInvalid = [&size](auto& item) {
-    if (item == nullptr || !item->isIdempotent()) {
+    if (item == nullptr || !item->is_idempotent()) {
       return true;  // true means the entry is not valid here.
     }
 
@@ -1133,9 +1044,11 @@ std::shared_ptr<DataQueue> DataQueue::CreateIdempotent(
     // of the entries are unable to provide a size, then
     // we assume we cannot safely treat this entry as
     // idempotent even if it claims to be.
-    size_t itemSize;
-    if (item->size().To(&itemSize)) { size += itemSize; }
-    else return true;  // true means the entry is not valid here.
+    if (item->size().has_value()) {
+      size += item->size().value();
+    } else {
+      return true;  // true means the entry is not valid here.
+    }
 
     return false;
   };
@@ -1147,7 +1060,7 @@ std::shared_ptr<DataQueue> DataQueue::CreateIdempotent(
   return std::make_shared<DataQueueImpl>(std::move(list), size);
 }
 
-std::shared_ptr<DataQueue> DataQueue::Create(Maybe<size_t> capped) {
+std::shared_ptr<DataQueue> DataQueue::Create(std::optional<uint64_t> capped) {
   return std::make_shared<DataQueueImpl>(capped);
 }
 
@@ -1170,9 +1083,7 @@ std::unique_ptr<DataQueue::Entry> DataQueue::CreateInMemoryEntryFromView(
 
 std::unique_ptr<DataQueue::Entry>
 DataQueue::CreateInMemoryEntryFromBackingStore(
-    std::shared_ptr<BackingStore> store,
-    size_t offset,
-    size_t length) {
+    std::shared_ptr<BackingStore> store, uint64_t offset, uint64_t length) {
   CHECK(store);
   if (offset + length > store->ByteLength()) {
     return nullptr;
@@ -1185,18 +1096,18 @@ std::unique_ptr<DataQueue::Entry> DataQueue::CreateDataQueueEntry(
   return std::make_unique<DataQueueEntry>(std::move(data_queue));
 }
 
-std::unique_ptr<DataQueue::Entry> DataQueue::CreateFdEntry(
-    BaseObjectPtr<fs::FileHandle> handle) {
-  return std::make_unique<FdEntry>(handle->env(), handle);
+std::unique_ptr<DataQueue::Entry> DataQueue::CreateFdEntry(Environment* env,
+                                                           Local<Value> path) {
+  return FdEntry::Create(env, path);
 }
 
 void DataQueue::Initialize(Environment* env, v8::Local<v8::Object> target) {
-  FdEntry::Wrap::Initialize(env, target);
+  // Nothing to do here currently.
 }
 
 void DataQueue::RegisterExternalReferences(
     ExternalReferenceRegistry* registry) {
-  FdEntry::Wrap::RegisterExternalReferences(registry);
+  // Nothing to do here currently.
 }
 
 }  // namespace node
diff --git a/src/dataqueue/queue.h b/src/dataqueue/queue.h
index 955f9ec589e388..a1a297a8fc2911 100644
--- a/src/dataqueue/queue.h
+++ b/src/dataqueue/queue.h
@@ -3,15 +3,16 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include <base_object.h>
+#include <memory_tracker.h>
 #include <node.h>
 #include <node_bob.h>
 #include <node_file.h>
-#include <memory_tracker.h>
 #include <stream_base.h>
-#include <v8.h>
 #include <uv.h>
+#include <v8.h>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 namespace node {
@@ -101,17 +102,18 @@ namespace node {
 // To read from a DataQueue, we use the node::bob::Source API
 // (see src/node_bob.h).
 //
-//   std::unique_ptr<DataQueue::Reader> reader = data_queue->getReader();
+//   std::shared_ptr<DataQueue::Reader> reader = data_queue->get_reader();
 //
 //   reader->Pull(
-//        [](int status, const DataQueue::Vec* vecs, size_t count, Done done) {
+//        [](int status, const DataQueue::Vec* vecs,
+//           uint64_t count, Done done) {
 //     // status is one of node::bob::Status
 //     // vecs is zero or more data buffers containing the read data
 //     // count is the number of vecs
 //     // done is a callback to be invoked when done processing the data
 //   }, options, nullptr, 0, 16);
 //
-// Keep calling Pull() until status is equal to node::bob::Status::STATUS_END.
+// Keep calling Pull() until status is equal to node::bob::Status::STATUS_EOS.
 //
 // For idempotent DataQueues, any number of readers can be created and
 // pull concurrently from the same DataQueue. The DataQueue can be read
@@ -126,15 +128,14 @@ class DataQueue : public MemoryRetainer {
  public:
   struct Vec {
     uint8_t* base;
-    size_t len;
+    uint64_t len;
   };
 
   // A DataQueue::Reader consumes the DataQueue. If the data queue is
   // idempotent, multiple Readers can be attached to the DataQueue at
   // any given time, all guaranteed to yield the same result when the
   // data is read. Otherwise, only a single Reader can be attached.
-  class Reader : public MemoryRetainer,
-                 public bob::Source<Vec> {
+  class Reader : public MemoryRetainer, public bob::Source<Vec> {
    public:
     using Next = bob::Next<Vec>;
     using Done = bob::Done;
@@ -150,26 +151,25 @@ class DataQueue : public MemoryRetainer {
     // offset is omitted, the slice extends to the end of the
     // data.
     //
-    // Creating a slice is only possible if isIdempotent() returns
+    // Creating a slice is only possible if is_idempotent() returns
     // true. This is because consuming either the original entry or
     // the new entry would change the state of the other in non-
-    // deterministic ways. When isIdempotent() returns false, slice()
+    // deterministic ways. When is_idempotent() returns false, slice()
     // must return a nulled unique_ptr.
     //
     // Creating a slice is also only possible if the size of the
-    // entry is known. If size() returns v8::Nothing<size_t>, slice()
+    // entry is known. If size() returns std::nullopt, slice()
     // must return a nulled unique_ptr.
     virtual std::unique_ptr<Entry> slice(
-        size_t start,
-        v8::Maybe<size_t> end = v8::Nothing<size_t>()) = 0;
+        uint64_t start, std::optional<uint64_t> end = std::nullopt) = 0;
 
     // Returns the number of bytes represented by this Entry if it is
     // known. Certain types of entries, such as those backed by streams
     // might not know the size in advance and therefore cannot provide
-    // a value. In such cases, size() must return v8::Nothing<size_t>.
+    // a value. In such cases, size() must return v8::Nothing<uint64_t>.
     //
     // If the entry is idempotent, a size should always be available.
-    virtual v8::Maybe<size_t> size() const = 0;
+    virtual std::optional<uint64_t> size() const = 0;
 
     // When true, multiple reads on the object must produce the exact
     // same data or the reads will fail. Some sources of entry data,
@@ -177,7 +177,7 @@ class DataQueue : public MemoryRetainer {
     // and therefore must not claim to be. If an entry claims to be
     // idempotent and cannot preserve that quality, subsequent reads
     // must fail with an error when a variance is detected.
-    virtual bool isIdempotent() const = 0;
+    virtual bool is_idempotent() const = 0;
   };
 
   // Creates an idempotent DataQueue with a pre-established collection
@@ -190,7 +190,7 @@ class DataQueue : public MemoryRetainer {
   // mutated and updated such that multiple reads are not guaranteed
   // to produce the same result. The entries added can be of any type.
   static std::shared_ptr<DataQueue> Create(
-      v8::Maybe<size_t> capped = v8::Nothing<size_t>());
+      std::optional<uint64_t> capped = std::nullopt);
 
   // Creates an idempotent Entry from a v8::ArrayBufferView. To help
   // ensure idempotency, the underlying ArrayBuffer is detached from
@@ -207,26 +207,26 @@ class DataQueue : public MemoryRetainer {
   // is not detachable, nullptr will be returned.
   static std::unique_ptr<Entry> CreateInMemoryEntryFromBackingStore(
       std::shared_ptr<v8::BackingStore> store,
-      size_t offset,
-      size_t length);
+      uint64_t offset,
+      uint64_t length);
 
   static std::unique_ptr<Entry> CreateDataQueueEntry(
       std::shared_ptr<DataQueue> data_queue);
 
-  static std::unique_ptr<Entry> CreateFdEntry(
-      BaseObjectPtr<fs::FileHandle> handle);
+  static std::unique_ptr<Entry> CreateFdEntry(Environment* env,
+                                              v8::Local<v8::Value> path);
 
   // Creates a Reader for the given queue. If the queue is idempotent,
   // any number of readers can be created, all of which are guaranteed
   // to provide the same data. Otherwise, only a single reader is
   // permitted.
-  virtual std::unique_ptr<Reader> getReader() = 0;
+  virtual std::shared_ptr<Reader> get_reader() = 0;
 
   // Append a single new entry to the queue. Appending is only allowed
-  // when isIdempotent() is false. v8::Nothing<bool>() will be returned
-  // if isIdempotent() is true. v8::Just(false) will be returned if the
+  // when is_idempotent() is false. std::nullopt will be returned
+  // if is_idempotent() is true. std::optional(false) will be returned if the
   // data queue is not idempotent but the entry otherwise cannot be added.
-  virtual v8::Maybe<bool> append(std::unique_ptr<Entry> entry) = 0;
+  virtual std::optional<bool> append(std::unique_ptr<Entry> entry) = 0;
 
   // Caps the size of this DataQueue preventing additional entries to
   // be added if those cause the size to extend beyond the specified
@@ -239,12 +239,12 @@ class DataQueue : public MemoryRetainer {
   // If the size of the data queue is not known, the limit will be
   // ignored and no additional entries will be allowed at all.
   //
-  // If isIdempotent is true capping is unnecessary because the data
+  // If is_idempotent is true capping is unnecessary because the data
   // queue cannot be appended to. In that case, cap() is a non-op.
   //
   // If the data queue has already been capped, cap can be called
   // again with a smaller size.
-  virtual void cap(size_t limit = 0) = 0;
+  virtual void cap(uint64_t limit = 0) = 0;
 
   // Returns a new DataQueue that is a view over this queues data
   // from the start offset to the ending offset. If the end offset
@@ -252,39 +252,38 @@ class DataQueue : public MemoryRetainer {
   //
   // The slice will coverage a range from start up to, but excluding, end.
   //
-  // Creating a slice is only possible if isIdempotent() returns
+  // Creating a slice is only possible if is_idempotent() returns
   // true. This is because consuming either the original DataQueue or
   // the new queue would change the state of the other in non-
-  // deterministic ways. When isIdempotent() returns false, slice()
+  // deterministic ways. When is_idempotent() returns false, slice()
   // must return a nulled unique_ptr.
   //
   // Creating a slice is also only possible if the size of the
-  // DataQueue is known. If size() returns v8::Nothing<size_t>, slice()
+  // DataQueue is known. If size() returns std::nullopt, slice()
   // must return a null unique_ptr.
   virtual std::shared_ptr<DataQueue> slice(
-      size_t start,
-      v8::Maybe<size_t> end = v8::Nothing<size_t>()) = 0;
+      uint64_t start, std::optional<uint64_t> end = std::nullopt) = 0;
 
   // The size of DataQueue is the total size of all of its member entries.
   // If any of the entries is not able to specify a size, the DataQueue
   // will also be incapable of doing so, in which case size() must return
-  // v8::Nothing<size_t>.
-  virtual v8::Maybe<size_t> size() const = 0;
+  // std::nullopt.
+  virtual std::optional<uint64_t> size() const = 0;
 
   // A DataQueue is idempotent only if all of its member entries are
   // idempotent.
-  virtual bool isIdempotent() const = 0;
+  virtual bool is_idempotent() const = 0;
 
   // True only if cap is called or the data queue is a limited to a
   // fixed size.
-  virtual bool isCapped() const = 0;
+  virtual bool is_capped() const = 0;
 
   // If the data queue has been capped, and the size of the data queue
   // is known, maybeCapRemaining will return the number of additional
   // bytes the data queue can receive before reaching the cap limit.
   // If the size of the queue cannot be known, or the cap has not
-  // been set, maybeCapRemaining() will return v8::Nothing<size_t>.
-  virtual v8::Maybe<size_t> maybeCapRemaining() const = 0;
+  // been set, maybeCapRemaining() will return std::nullopt.
+  virtual std::optional<uint64_t> maybeCapRemaining() const = 0;
 
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
diff --git a/src/env_properties.h b/src/env_properties.h
index 4c931826d089e3..fcae9d8887483f 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -371,7 +371,6 @@
   V(worker_heap_snapshot_taker_template, v8::ObjectTemplate)                   \
   V(x509_constructor_template, v8::FunctionTemplate)
 
-
 #define PER_REALM_STRONG_PERSISTENT_VALUES(V)                                  \
   V(async_hooks_after_function, v8::Function)                                  \
   V(async_hooks_before_function, v8::Function)                                 \
diff --git a/src/node_blob.cc b/src/node_blob.cc
index bf9201600d469e..884e9d61c9b95c 100644
--- a/src/node_blob.cc
+++ b/src/node_blob.cc
@@ -1,7 +1,6 @@
 #include "node_blob.h"
 #include "async_wrap-inl.h"
 #include "base_object-inl.h"
-#include "base_object.h"
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_bob-inl.h"
@@ -19,7 +18,6 @@ using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::BackingStore;
 using v8::Context;
-using v8::EscapableHandleScope;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -28,8 +26,6 @@ using v8::HandleScope;
 using v8::Int32;
 using v8::Isolate;
 using v8::Local;
-using v8::MaybeLocal;
-using v8::Number;
 using v8::Object;
 using v8::String;
 using v8::Uint32;
@@ -54,55 +50,58 @@ void Concat(const FunctionCallbackInfo<Value>& args) {
   std::vector<View> views;
   size_t total = 0;
 
-  const auto doConcat = [&](View* view, size_t size) {
-    std::shared_ptr<BackingStore> store =
-      ArrayBuffer::NewBackingStore(env->isolate(), total);
-    uint8_t* ptr = static_cast<uint8_t*>(store->Data());
-    for (size_t n = 0; n < size; n++) {
-      uint8_t* from = static_cast<uint8_t*>(view[n].store->Data()) + view[n].offset;
-      std::copy(from, from + view[n].length, ptr);
-      ptr += view[n].length;
-    }
-    return ArrayBuffer::New(env->isolate(), store);
-  };
-
   for (uint32_t n = 0; n < array->Length(); n++) {
     Local<Value> val;
-    if (!array->Get(env->context(), n).ToLocal(&val))
-      return;
+    if (!array->Get(env->context(), n).ToLocal(&val)) return;
     if (val->IsArrayBuffer()) {
       auto ab = val.As<ArrayBuffer>();
-      views.push_back(View { ab->GetBackingStore(), ab->ByteLength(), 0 });
+      views.push_back(View{ab->GetBackingStore(), ab->ByteLength(), 0});
       total += ab->ByteLength();
     } else {
       CHECK(val->IsArrayBufferView());
       auto view = val.As<ArrayBufferView>();
-      views.push_back(View {
-        view->Buffer()->GetBackingStore(),
-        view->ByteLength(),
-        view->ByteOffset()
-      });
+      views.push_back(View{view->Buffer()->GetBackingStore(),
+                           view->ByteLength(),
+                           view->ByteOffset()});
       total += view->ByteLength();
     }
   }
-  args.GetReturnValue().Set(doConcat(views.data(), views.size()));
+
+  std::shared_ptr<BackingStore> store =
+      ArrayBuffer::NewBackingStore(env->isolate(), total);
+  uint8_t* ptr = static_cast<uint8_t*>(store->Data());
+  for (size_t n = 0; n < views.size(); n++) {
+    uint8_t* from =
+        static_cast<uint8_t*>(views[n].store->Data()) + views[n].offset;
+    std::copy(from, from + views[n].length, ptr);
+    ptr += views[n].length;
+  }
+
+  args.GetReturnValue().Set(ArrayBuffer::New(env->isolate(), std::move(store)));
 }
 
-void BlobFromFileHandle(const FunctionCallbackInfo<Value>& args) {
+void BlobFromFilePath(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  fs::FileHandle* fileHandle;
-  ASSIGN_OR_RETURN_UNWRAP(&fileHandle, args[0]);
+  auto entry = DataQueue::CreateFdEntry(env, args[0]);
+  if (entry == nullptr) {
+    return THROW_ERR_INVALID_ARG_VALUE(env, "Unabled to open file as blob");
+  }
 
   std::vector<std::unique_ptr<DataQueue::Entry>> entries;
-  entries.push_back(DataQueue::CreateFdEntry(BaseObjectPtr<fs::FileHandle>(fileHandle)));
+  entries.push_back(std::move(entry));
 
-  auto blob = Blob::Create(env, DataQueue::CreateIdempotent(std::move(entries)));
+  auto blob =
+      Blob::Create(env, DataQueue::CreateIdempotent(std::move(entries)));
 
-  auto array = Array::New(env->isolate(), 2);
-  USE(array->Set(env->context(), 0, blob->object()));
-  USE(array->Set(env->context(), 1, Uint32::NewFromUnsigned(env->isolate(), blob->length())));
+  if (blob) {
+    auto array = Array::New(env->isolate(), 2);
+    USE(array->Set(env->context(), 0, blob->object()));
+    USE(array->Set(env->context(),
+                   1,
+                   Uint32::NewFromUnsigned(env->isolate(), blob->length())));
 
-  if (blob) args.GetReturnValue().Set(array);
+    args.GetReturnValue().Set(array);
+  }
 }
 }  // namespace
 
@@ -122,7 +121,7 @@ void Blob::Initialize(
   SetMethod(context, target, "getDataObject", GetDataObject);
   SetMethod(context, target, "revokeDataObject", RevokeDataObject);
   SetMethod(context, target, "concat", Concat);
-  SetMethod(context, target, "createBlobFromFileHandle", BlobFromFileHandle);
+  SetMethod(context, target, "createBlobFromFilePath", BlobFromFilePath);
 }
 
 Local<FunctionTemplate> Blob::GetConstructorTemplate(Environment* env) {
@@ -146,9 +145,8 @@ bool Blob::HasInstance(Environment* env, v8::Local<v8::Value> object) {
   return GetConstructorTemplate(env)->HasInstance(object);
 }
 
-BaseObjectPtr<Blob> Blob::Create(
-    Environment* env,
-    std::shared_ptr<DataQueue> data_queue) {
+BaseObjectPtr<Blob> Blob::Create(Environment* env,
+                                 std::shared_ptr<DataQueue> data_queue) {
   HandleScope scope(env->isolate());
 
   Local<Function> ctor;
@@ -175,10 +173,9 @@ void Blob::New(const FunctionCallbackInfo<Value>& args) {
       return;
     }
 
-    const auto entryFromArrayBuffer = [env](
-        v8::Local<v8::ArrayBuffer> buf,
-        size_t byte_length,
-        size_t byte_offset = 0) {
+    const auto entryFromArrayBuffer = [env](v8::Local<v8::ArrayBuffer> buf,
+                                            size_t byte_length,
+                                            size_t byte_offset = 0) {
       if (buf->IsDetachable()) {
         std::shared_ptr<BackingStore> store = buf->GetBackingStore();
         USE(buf->Detach(Local<Value>()));
@@ -210,9 +207,7 @@ void Blob::New(const FunctionCallbackInfo<Value>& args) {
     } else if (entry->IsArrayBufferView()) {
       Local<ArrayBufferView> view = entry.As<ArrayBufferView>();
       entries[i] = entryFromArrayBuffer(
-          view->Buffer(),
-          view->ByteLength(),
-          view->ByteOffset());
+          view->Buffer(), view->ByteLength(), view->ByteOffset());
     } else if (Blob::HasInstance(env, entry)) {
       Blob* blob;
       ASSIGN_OR_RETURN_UNWRAP(&blob, entry);
@@ -251,33 +246,31 @@ void Blob::ToSlice(const FunctionCallbackInfo<Value>& args) {
 }
 
 void Blob::MemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackField("data_queue_", data_queue_);
+  tracker->TrackField("data_queue_", data_queue_, "std::shared_ptr<DataQueue>");
 }
 
 BaseObjectPtr<Blob> Blob::Slice(Environment* env, size_t start, size_t end) {
-  return Create(env, this->data_queue_->slice(start, v8::Just(end)));
+  return Create(env,
+                this->data_queue_->slice(start, static_cast<uint64_t>(end)));
 }
 
-Blob::Blob(
-    Environment* env,
-    v8::Local<v8::Object> obj,
-    std::shared_ptr<DataQueue> data_queue)
-    : BaseObject(env, obj),
-      data_queue_(data_queue) {
+Blob::Blob(Environment* env,
+           v8::Local<v8::Object> obj,
+           std::shared_ptr<DataQueue> data_queue)
+    : BaseObject(env, obj), data_queue_(data_queue) {
   MakeWeak();
 }
 
-Blob::Reader::Reader(
-    Environment* env,
-    v8::Local<v8::Object> obj,
-    BaseObjectPtr<Blob> strong_ptr)
+Blob::Reader::Reader(Environment* env,
+                     v8::Local<v8::Object> obj,
+                     BaseObjectPtr<Blob> strong_ptr)
     : AsyncWrap(env, obj, AsyncWrap::PROVIDER_BLOBREADER),
-      inner_(strong_ptr->data_queue_->getReader()),
+      inner_(strong_ptr->data_queue_->get_reader()),
       strong_ptr_(std::move(strong_ptr)) {
   MakeWeak();
 }
 
-bool Blob::Reader::HasInstance(Environment *env, v8::Local<v8::Value> value) {
+bool Blob::Reader::HasInstance(Environment* env, v8::Local<v8::Value> value) {
   return GetConstructorTemplate(env)->HasInstance(value);
 }
 
@@ -289,27 +282,27 @@ Local<FunctionTemplate> Blob::Reader::GetConstructorTemplate(Environment* env) {
     tmpl->InstanceTemplate()->SetInternalFieldCount(
         BaseObject::kInternalFieldCount);
     tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
-    tmpl->SetClassName(
-        FIXED_ONE_BYTE_STRING(env->isolate(), "BlobReader"));
+    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "BlobReader"));
     SetProtoMethod(env->isolate(), tmpl, "pull", Pull);
     env->set_blob_reader_constructor_template(tmpl);
   }
   return tmpl;
 }
 
-BaseObjectPtr<Blob::Reader> Blob::Reader::Create(
-    Environment* env,
-    BaseObjectPtr<Blob> blob) {
+BaseObjectPtr<Blob::Reader> Blob::Reader::Create(Environment* env,
+                                                 BaseObjectPtr<Blob> blob) {
   Local<Object> obj;
-  if (!GetConstructorTemplate(env)->InstanceTemplate()
-          ->NewInstance(env->context()).ToLocal(&obj)) {
+  if (!GetConstructorTemplate(env)
+           ->InstanceTemplate()
+           ->NewInstance(env->context())
+           .ToLocal(&obj)) {
     return BaseObjectPtr<Blob::Reader>();
   }
 
   return MakeBaseObject<Blob::Reader>(env, obj, std::move(blob));
 }
 
-void Blob::Reader::Pull(const FunctionCallbackInfo<Value> &args) {
+void Blob::Reader::Pull(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Blob::Reader* reader;
   ASSIGN_OR_RETURN_UNWRAP(&reader, args.Holder());
@@ -329,16 +322,18 @@ void Blob::Reader::Pull(const FunctionCallbackInfo<Value> &args) {
     Global<Function> callback;
     Environment* env;
   };
+  // TODO(@jasnell): A unique_ptr is likely better here but making this a unique
+  // pointer that is passed into the lambda causes the std::move(next) below to
+  // complain about std::function needing to be copy-constructible.
   Impl* impl = new Impl();
   impl->reader = BaseObjectPtr<Blob::Reader>(reader);
   impl->callback.Reset(env->isolate(), fn);
   impl->env = env;
 
-  auto next = [impl](
-      int status,
-      const DataQueue::Vec* vecs,
-      size_t count,
-      bob::Done doneCb) mutable {
+  auto next = [impl](int status,
+                     const DataQueue::Vec* vecs,
+                     size_t count,
+                     bob::Done doneCb) mutable {
     auto dropMe = std::unique_ptr<Impl>(impl);
     Environment* env = impl->env;
     HandleScope handleScope(env->isolate());
@@ -360,17 +355,15 @@ void Blob::Reader::Pull(const FunctionCallbackInfo<Value> &args) {
       }
       // Since we copied the data buffers, signal that we're done with them.
       std::move(doneCb)(0);
-      Local<Value> argv[2] = {
-        Uint32::New(env->isolate(), status),
-        ArrayBuffer::New(env->isolate(), store)
-      };
+      Local<Value> argv[2] = {Uint32::New(env->isolate(), status),
+                              ArrayBuffer::New(env->isolate(), store)};
       impl->reader->MakeCallback(fn, arraysize(argv), argv);
       return;
     }
 
     Local<Value> argv[2] = {
-      Int32::New(env->isolate(), status),
-      Undefined(env->isolate()),
+        Int32::New(env->isolate(), status),
+        Undefined(env->isolate()),
     };
     impl->reader->MakeCallback(fn, arraysize(argv), argv);
   };
@@ -473,7 +466,7 @@ void Blob::GetDataObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
 void BlobBindingData::StoredDataObject::MemoryInfo(
     MemoryTracker* tracker) const {
-  tracker->TrackField("blob", blob);
+  tracker->TrackField("blob", blob, "BaseObjectPtr<Blob>");
 }
 
 BlobBindingData::StoredDataObject::StoredDataObject(
@@ -490,7 +483,9 @@ BlobBindingData::BlobBindingData(Environment* env, Local<Object> wrap)
 }
 
 void BlobBindingData::MemoryInfo(MemoryTracker* tracker) const {
-  tracker->TrackField("data_objects_", data_objects_);
+  tracker->TrackField("data_objects_",
+                      data_objects_,
+                      "std::unordered_map<std::string, StoredDataObject>");
 }
 
 void BlobBindingData::store_data_object(
@@ -551,7 +546,7 @@ void Blob::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(Blob::RevokeDataObject);
   registry->Register(Blob::Reader::Pull);
   registry->Register(Concat);
-  registry->Register(BlobFromFileHandle);
+  registry->Register(BlobFromFilePath);
 }
 
 }  // namespace node
diff --git a/src/node_blob.h b/src/node_blob.h
index f540d18b03e772..e56627cf35cf76 100644
--- a/src/node_blob.h
+++ b/src/node_blob.h
@@ -42,7 +42,8 @@ class Blob : public BaseObject {
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);
 
-  static BaseObjectPtr<Blob> Create(Environment* env, std::shared_ptr<DataQueue> data_queue);
+  static BaseObjectPtr<Blob> Create(Environment* env,
+                                    std::shared_ptr<DataQueue> data_queue);
 
   static bool HasInstance(Environment* env, v8::Local<v8::Value> object);
 
@@ -52,12 +53,12 @@ class Blob : public BaseObject {
 
   BaseObjectPtr<Blob> Slice(Environment* env, size_t start, size_t end);
 
-  inline size_t length() const { return this->data_queue_->size().ToChecked(); }
+  inline size_t length() const { return this->data_queue_->size().value(); }
 
   class BlobTransferData : public worker::TransferData {
    public:
     explicit BlobTransferData(std::shared_ptr<DataQueue> data_queue)
-      : data_queue(data_queue) {}
+        : data_queue(data_queue) {}
 
     BaseObjectPtr<BaseObject> Deserialize(
         Environment* env,
@@ -69,30 +70,28 @@ class Blob : public BaseObject {
     SET_NO_MEMORY_INFO()
 
    private:
-     std::shared_ptr<DataQueue> data_queue;
+    std::shared_ptr<DataQueue> data_queue;
   };
 
   class Reader final : public AsyncWrap {
-  public:
+   public:
     static bool HasInstance(Environment* env, v8::Local<v8::Value> value);
     static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
         Environment* env);
-    static BaseObjectPtr<Reader> Create(
-        Environment* env,
-        BaseObjectPtr<Blob> blob);
+    static BaseObjectPtr<Reader> Create(Environment* env,
+                                        BaseObjectPtr<Blob> blob);
     static void Pull(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-    explicit Reader(
-        Environment* env,
-        v8::Local<v8::Object> obj,
-        BaseObjectPtr<Blob> strong_ptr);
+    explicit Reader(Environment* env,
+                    v8::Local<v8::Object> obj,
+                    BaseObjectPtr<Blob> strong_ptr);
 
     SET_NO_MEMORY_INFO()
     SET_MEMORY_INFO_NAME(Blob::Reader)
     SET_SELF_SIZE(Reader)
 
-  private:
-    std::unique_ptr<DataQueue::Reader> inner_;
+   private:
+    std::shared_ptr<DataQueue::Reader> inner_;
     BaseObjectPtr<Blob> strong_ptr_;
     bool eos_ = false;
   };
@@ -100,10 +99,9 @@ class Blob : public BaseObject {
   BaseObject::TransferMode GetTransferMode() const override;
   std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
 
-  Blob(
-    Environment* env,
-    v8::Local<v8::Object> obj,
-    std::shared_ptr<DataQueue> data_queue);
+  Blob(Environment* env,
+       v8::Local<v8::Object> obj,
+       std::shared_ptr<DataQueue> data_queue);
 
   DataQueue& getDataQueue() const { return *data_queue_; }
 
diff --git a/src/node_bob-inl.h b/src/node_bob-inl.h
index 578e45e9ff6149..5dec96282ad305 100644
--- a/src/node_bob-inl.h
+++ b/src/node_bob-inl.h
@@ -25,8 +25,7 @@ int SourceImpl<T>::Pull(
 
   status = DoPull(std::move(next), options, data, count, max_count_hint);
 
-  if (status == bob::Status::STATUS_END)
-    eos_ = true;
+  if (status == bob::Status::STATUS_EOS) eos_ = true;
 
   return status;
 }
diff --git a/src/node_bob.h b/src/node_bob.h
index d0160b393c9b39..b56c5f02cc70d6 100644
--- a/src/node_bob.h
+++ b/src/node_bob.h
@@ -10,17 +10,8 @@ constexpr size_t kMaxCountHint = 16;
 
 // Negative status codes indicate error conditions.
 enum Status : int {
-  // Indicates that there was an error while pulling.
-  // Should be treated similar to STATUS_EOS
-  STATUS_FAILED = -2,
-	
   // Indicates that an attempt was made to pull after end.
-  STATUS_EOS = -1,
-
-  // Indicates the end of the stream. No additional
-  // data will be available and the consumer should stop
-  // pulling.
-  STATUS_END = 0,
+  STATUS_EOS = 0,
 
   // Indicates that there is additional data available
   // and the consumer may continue to pull.
diff --git a/src/node_file.cc b/src/node_file.cc
index 49ed96eca05416..673d67e2d3c010 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -242,14 +242,20 @@ FileHandle::FileHandle(BindingData* binding_data,
 }
 
 FileHandle* FileHandle::New(BindingData* binding_data,
-                            int fd, Local<Object> obj) {
+                            int fd,
+                            Local<Object> obj,
+                            std::optional<int64_t> maybeOffset,
+                            std::optional<int64_t> maybeLength) {
   Environment* env = binding_data->env();
   if (obj.IsEmpty() && !env->fd_constructor_template()
                             ->NewInstance(env->context())
                             .ToLocal(&obj)) {
     return nullptr;
   }
-  return new FileHandle(binding_data, obj, fd);
+  auto handle = new FileHandle(binding_data, obj, fd);
+  if (maybeOffset.has_value()) handle->read_offset_ = maybeOffset.value();
+  if (maybeLength.has_value()) handle->read_length_ = maybeLength.value();
+  return handle;
 }
 
 void FileHandle::New(const FunctionCallbackInfo<Value>& args) {
@@ -258,13 +264,18 @@ void FileHandle::New(const FunctionCallbackInfo<Value>& args) {
   CHECK(args.IsConstructCall());
   CHECK(args[0]->IsInt32());
 
-  FileHandle* handle =
-      FileHandle::New(binding_data, args[0].As<Int32>()->Value(), args.This());
-  if (handle == nullptr) return;
+  std::optional<int64_t> maybeOffset = std::nullopt;
+  std::optional<int64_t> maybeLength = std::nullopt;
   if (args[1]->IsNumber())
-    handle->read_offset_ = args[1]->IntegerValue(env->context()).FromJust();
+    maybeOffset = args[1]->IntegerValue(env->context()).FromJust();
   if (args[2]->IsNumber())
-    handle->read_length_ = args[2]->IntegerValue(env->context()).FromJust();
+    maybeLength = args[2]->IntegerValue(env->context()).FromJust();
+
+  FileHandle::New(binding_data,
+                  args[0].As<Int32>()->Value(),
+                  args.This(),
+                  maybeOffset,
+                  maybeLength);
 }
 
 FileHandle::~FileHandle() {
@@ -503,10 +514,15 @@ void FileHandle::Close(const FunctionCallbackInfo<Value>& args) {
 void FileHandle::ReleaseFD(const FunctionCallbackInfo<Value>& args) {
   FileHandle* fd;
   ASSIGN_OR_RETURN_UNWRAP(&fd, args.Holder());
-  // Just act as if this FileHandle has been closed.
-  fd->AfterClose();
+  fd->Release();
 }
 
+int FileHandle::Release() {
+  int fd = GetFD();
+  // Just pretend that Close was called and we're all done.
+  AfterClose();
+  return fd;
+}
 
 void FileHandle::AfterClose() {
   closing_ = false;
diff --git a/src/node_file.h b/src/node_file.h
index 5554ba7de51a2a..28c62bef799f81 100644
--- a/src/node_file.h
+++ b/src/node_file.h
@@ -3,6 +3,7 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <optional>
 #include "aliased_buffer.h"
 #include "node_messaging.h"
 #include "node_snapshotable.h"
@@ -302,13 +303,17 @@ class FileHandle final : public AsyncWrap, public StreamBase {
 
   static FileHandle* New(BindingData* binding_data,
                          int fd,
-                         v8::Local<v8::Object> obj = v8::Local<v8::Object>());
+                         v8::Local<v8::Object> obj = v8::Local<v8::Object>(),
+                         std::optional<int64_t> maybeOffset = std::nullopt,
+                         std::optional<int64_t> maybeLength = std::nullopt);
   ~FileHandle() override;
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   int GetFD() override { return fd_; }
 
+  int Release();
+
   // Will asynchronously close the FD and return a Promise that will
   // be resolved once closing is complete.
   static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/test/cctest/test_dataqueue.cc b/test/cctest/test_dataqueue.cc
index 88611e13a5d7d9..73488fcab0a4d1 100644
--- a/test/cctest/test_dataqueue.cc
+++ b/test/cctest/test_dataqueue.cc
@@ -1,8 +1,7 @@
-#include "dataqueue/queue.h"
-#include "node_bob-inl.h"
-#include "node_bob.h"
-#include "util-inl.h"
-#include "gtest/gtest.h"
+#include <dataqueue/queue.h>
+#include <gtest/gtest.h>
+#include <node_bob-inl.h>
+#include <util-inl.h>
 #include <v8.h>
 #include <memory>
 #include <vector>
@@ -10,68 +9,70 @@
 using node::DataQueue;
 using v8::ArrayBuffer;
 using v8::BackingStore;
-using v8::Just;
 
 TEST(DataQueue, InMemoryEntry) {
   char buffer[] = "hello world";
   size_t len = strlen(buffer);
 
-  std::shared_ptr<BackingStore> store =
-      ArrayBuffer::NewBackingStore(
-          &buffer, len, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store = ArrayBuffer::NewBackingStore(
+      &buffer, len, [](void*, size_t, void*) {}, nullptr);
 
   // We can create an InMemoryEntry from a v8::BackingStore.
   std::unique_ptr<DataQueue::Entry> entry =
       DataQueue::CreateInMemoryEntryFromBackingStore(store, 0, len);
 
   // The entry is idempotent.
-  CHECK(entry->isIdempotent());
+  CHECK(entry->is_idempotent());
 
   // The size is known.
-  CHECK_EQ(entry->size().ToChecked(), len);
+  CHECK_EQ(entry->size().value(), len);
 
   // We can slice it.
   // slice: "llo world"
   std::unique_ptr<DataQueue::Entry> slice1 = entry->slice(2);
 
   // The slice is idempotent.
-  CHECK(slice1->isIdempotent());
+  CHECK(slice1->is_idempotent());
 
   // The slice size is known.
-  CHECK_EQ(slice1->size().ToChecked(), len - 2);
+  CHECK_EQ(slice1->size().value(), len - 2);
 
   // We can slice the slice with a length.
   // slice: "o w"
-  std::unique_ptr<DataQueue::Entry> slice2 = slice1->slice(2, Just(5UL));
+  uint64_t end = 5;
+  std::unique_ptr<DataQueue::Entry> slice2 = slice1->slice(2, end);
 
   // That slice is idempotent.
-  CHECK(slice2->isIdempotent());
+  CHECK(slice2->is_idempotent());
 
   // That slice size is known.
-  CHECK_EQ(slice2->size().ToChecked(), 3);
+  CHECK_EQ(slice2->size().value(), 3);
 
   // The slice end can extend beyond the actual size and will be adjusted.
   // slice: "orld"
-  std::unique_ptr<DataQueue::Entry> slice3 = slice1->slice(5, Just(100UL));
+  end = 100;
+  std::unique_ptr<DataQueue::Entry> slice3 = slice1->slice(5, end);
   CHECK_NOT_NULL(slice3);
 
   // The slice size is known.
-  CHECK_EQ(slice3->size().ToChecked(), 4);
+  CHECK_EQ(slice3->size().value(), 4);
 
   // If the slice start is greater than the length, we get a zero length slice.
   std::unique_ptr<DataQueue::Entry> slice4 = entry->slice(100);
   CHECK_NOT_NULL(slice4);
-  CHECK_EQ(slice4->size().ToChecked(), 0);
+  CHECK_EQ(slice4->size().value(), 0);
 
   // If the slice end is less than the start, we get a zero length slice.
-  std::unique_ptr<DataQueue::Entry> slice5 = entry->slice(2, Just(1UL));
+  end = 1;
+  std::unique_ptr<DataQueue::Entry> slice5 = entry->slice(2, end);
   CHECK_NOT_NULL(slice5);
-  CHECK_EQ(slice5->size().ToChecked(), 0);
+  CHECK_EQ(slice5->size().value(), 0);
 
   // If the slice end equal to the start, we get a zero length slice.
-  std::unique_ptr<DataQueue::Entry> slice6 = entry->slice(2, Just(2UL));
+  end = 2;
+  std::unique_ptr<DataQueue::Entry> slice6 = entry->slice(2, end);
   CHECK_NOT_NULL(slice6);
-  CHECK_EQ(slice6->size().ToChecked(), 0);
+  CHECK_EQ(slice6->size().value(), 0);
 
   // The shared_ptr for the BackingStore should show only 5 uses because
   // the zero-length slices do not maintain a reference to it.
@@ -86,57 +87,58 @@ TEST(DataQueue, IdempotentDataQueue) {
   size_t len2 = strlen(buffer2);
   size_t len3 = strlen(buffer3);
 
-  std::shared_ptr<BackingStore> store1 =
-      ArrayBuffer::NewBackingStore(
-          &buffer1, len1, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store1 = ArrayBuffer::NewBackingStore(
+      &buffer1, len1, [](void*, size_t, void*) {}, nullptr);
 
-  std::shared_ptr<BackingStore> store2 =
-      ArrayBuffer::NewBackingStore(
-          &buffer2, len2, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store2 = ArrayBuffer::NewBackingStore(
+      &buffer2, len2, [](void*, size_t, void*) {}, nullptr);
 
   std::vector<std::unique_ptr<DataQueue::Entry>> list;
-  list.push_back(DataQueue::CreateInMemoryEntryFromBackingStore(store1, 0, len1));
-  list.push_back(DataQueue::CreateInMemoryEntryFromBackingStore(store2, 0, len2));
+  list.push_back(
+      DataQueue::CreateInMemoryEntryFromBackingStore(store1, 0, len1));
+  list.push_back(
+      DataQueue::CreateInMemoryEntryFromBackingStore(store2, 0, len2));
 
   // We can create an idempotent DataQueue from a list of entries.
-  std::shared_ptr<DataQueue> data_queue = DataQueue::CreateIdempotent(std::move(list));
+  std::shared_ptr<DataQueue> data_queue =
+      DataQueue::CreateIdempotent(std::move(list));
 
   CHECK_NOT_NULL(data_queue);
 
   // The data_queue is idempotent.
-  CHECK(data_queue->isIdempotent());
+  CHECK(data_queue->is_idempotent());
 
   // The data_queue is capped.
-  CHECK(data_queue->isCapped());
+  CHECK(data_queue->is_capped());
 
   // maybeCapRemaining() returns zero.
-  CHECK_EQ(data_queue->maybeCapRemaining().ToChecked(), 0);
+  CHECK_EQ(data_queue->maybeCapRemaining().value(), 0);
 
   // Calling cap() is a nonop but doesn't crash or error.
   data_queue->cap();
   data_queue->cap(100);
 
   // maybeCapRemaining() still returns zero.
-  CHECK_EQ(data_queue->maybeCapRemaining().ToChecked(), 0);
+  CHECK_EQ(data_queue->maybeCapRemaining().value(), 0);
 
   // The size is known to be the sum of the in memory-entries.
-  CHECK_EQ(data_queue->size().ToChecked(), len1 + len2);
+  CHECK_EQ(data_queue->size().value(), len1 + len2);
 
-  std::shared_ptr<BackingStore> store3 =
-      ArrayBuffer::NewBackingStore(
-          &buffer3, len3, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store3 = ArrayBuffer::NewBackingStore(
+      &buffer3, len3, [](void*, size_t, void*) {}, nullptr);
 
-  // Trying to append a new entry does not crash, but returns v8::Nothing.
-  CHECK(data_queue->append(
-      DataQueue::CreateInMemoryEntryFromBackingStore(store3, 0, len3))
-          .IsNothing());
+  // Trying to append a new entry does not crash, but returns std::nullopt.
+  CHECK(!data_queue
+             ->append(DataQueue::CreateInMemoryEntryFromBackingStore(
+                 store3, 0, len3))
+             .has_value());
 
   // The size has not changed after the append.
-  CHECK_EQ(data_queue->size().ToChecked(), len1 + len2);
+  CHECK_EQ(data_queue->size().value(), len1 + len2);
 
   // We can acquire multiple readers from the data_queue.
-  std::unique_ptr<DataQueue::Reader> reader1 = data_queue->getReader();
-  std::unique_ptr<DataQueue::Reader> reader2 = data_queue->getReader();
+  std::shared_ptr<DataQueue::Reader> reader1 = data_queue->get_reader();
+  std::shared_ptr<DataQueue::Reader> reader2 = data_queue->get_reader();
 
   CHECK_NOT_NULL(reader1);
   CHECK_NOT_NULL(reader2);
@@ -149,13 +151,17 @@ TEST(DataQueue, IdempotentDataQueue) {
     // The first read produces buffer1
     int status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_CONTINUE);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len1);
-      CHECK_EQ(memcmp(vecs[0].base, buffer1, len1), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len1);
+          CHECK_EQ(memcmp(vecs[0].base, buffer1, len1), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_CONTINUE);
@@ -164,29 +170,49 @@ TEST(DataQueue, IdempotentDataQueue) {
     // InMemoryEntry instances, reads will be fully synchronous here.
     waitingForPull = true;
 
-    // The second read produces buffer2, and should be the end.
+    // The second read should have status CONTINUE but no buffer.
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_END);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len2);
-      CHECK_EQ(memcmp(vecs[0].base, buffer2, len2), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
-    CHECK_EQ(status, node::bob::STATUS_END);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+
+    // The third read produces buffer2, and should be the end.
+    status = reader->Pull(
+        [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len2);
+          CHECK_EQ(memcmp(vecs[0].base, buffer2, len2), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
+
+    CHECK(!waitingForPull);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
 
-    // The third read produces EOS
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_EOS);
-      CHECK_EQ(count, 0);
-      CHECK_NULL(vecs);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_EOS);
+          CHECK_EQ(count, 0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_EOS);
@@ -202,13 +228,13 @@ TEST(DataQueue, IdempotentDataQueue) {
   CHECK_NOT_NULL(slice1);
 
   // The slice is idempotent.
-  CHECK(slice1->isIdempotent());
+  CHECK(slice1->is_idempotent());
 
   // And capped.
-  CHECK(slice1->isCapped());
+  CHECK(slice1->is_capped());
 
   // The size is two-bytes less than the original.
-  CHECK_EQ(slice1->size().ToChecked(), data_queue->size().ToChecked() - 2);
+  CHECK_EQ(slice1->size().value(), data_queue->size().value() - 2);
 
   const auto testSlice = [&](auto& reader) {
     // We can read the expected data from reader. Because the entries are
@@ -218,13 +244,17 @@ TEST(DataQueue, IdempotentDataQueue) {
     // The first read produces a slice of buffer1
     int status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_CONTINUE);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len1 - 2);
-      CHECK_EQ(memcmp(vecs[0].base, buffer1 + 2, len1 - 2), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len1 - 2);
+          CHECK_EQ(memcmp(vecs[0].base, buffer1 + 2, len1 - 2), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_CONTINUE);
@@ -233,43 +263,67 @@ TEST(DataQueue, IdempotentDataQueue) {
     // InMemoryEntry instances, reads will be fully synchronous here.
     waitingForPull = true;
 
+    // The second read should have status CONTINUE but no buffer.
+    status = reader->Pull(
+        [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
+
+    CHECK(!waitingForPull);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+
     // The second read produces buffer2, and should be the end.
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_END);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len2);
-      CHECK_EQ(memcmp(vecs[0].base, buffer2, len2), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len2);
+          CHECK_EQ(memcmp(vecs[0].base, buffer2, len2), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
-    CHECK_EQ(status, node::bob::STATUS_END);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
 
     // The third read produces EOS
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_EOS);
-      CHECK_EQ(count, 0);
-      CHECK_NULL(vecs);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_EOS);
+          CHECK_EQ(count, 0);
+          CHECK_NULL(vecs);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_EOS);
   };
 
   // We can read the expected slice data.
-  std::unique_ptr<DataQueue::Reader> reader3 = slice1->getReader();
+  std::shared_ptr<DataQueue::Reader> reader3 = slice1->get_reader();
   testSlice(reader3);
 
   // We can slice correctly across boundaries.
-  std::shared_ptr<DataQueue> slice2 = data_queue->slice(5, Just(20UL));
+  uint64_t end = 20;
+  std::shared_ptr<DataQueue> slice2 = data_queue->slice(5, end);
 
   // The size is known.
-  CHECK_EQ(slice2->size().ToChecked(), 15);
+  CHECK_EQ(slice2->size().value(), 15);
 
   const auto testSlice2 = [&](auto& reader) {
     // We can read the expected data from reader. Because the entries are
@@ -279,14 +333,18 @@ TEST(DataQueue, IdempotentDataQueue) {
     // The first read produces a slice of buffer1
     int status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-
-      CHECK_EQ(status, node::bob::STATUS_CONTINUE);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len1 - 5);
-      CHECK_EQ(memcmp(vecs[0].base, buffer1 + 5, len1 - 5), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len1 - 5);
+          CHECK_EQ(memcmp(vecs[0].base, buffer1 + 5, len1 - 5), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_CONTINUE);
@@ -295,36 +353,58 @@ TEST(DataQueue, IdempotentDataQueue) {
     // InMemoryEntry instances, reads will be fully synchronous here.
     waitingForPull = true;
 
-    // The second read produces buffer2, and should be the end.
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_END);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len2 - 7);
-      CHECK_EQ(memcmp(vecs[0].base, buffer2, len2 - 7), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
+
+    CHECK(!waitingForPull);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+
+    // The next read produces buffer2, and should be the end.
+    status = reader->Pull(
+        [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len2 - 7);
+          CHECK_EQ(memcmp(vecs[0].base, buffer2, len2 - 7), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
-    CHECK_EQ(status, node::bob::STATUS_END);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
 
-    // The third read produces EOS
+    // The next read produces EOS
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_EOS);
-      CHECK_EQ(count, 0);
-      CHECK_NULL(vecs);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_EOS);
+          CHECK_EQ(count, 0);
+          CHECK_NULL(vecs);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_EOS);
   };
 
   // We can read the expected slice data.
-  std::unique_ptr<DataQueue::Reader> reader4 = slice2->getReader();
+  std::shared_ptr<DataQueue::Reader> reader4 = slice2->get_reader();
   testSlice2(reader4);
 }
 
@@ -336,56 +416,58 @@ TEST(DataQueue, NonIdempotentDataQueue) {
   size_t len2 = strlen(buffer2);
   size_t len3 = strlen(buffer3);
 
-  std::shared_ptr<BackingStore> store1 =
-      ArrayBuffer::NewBackingStore(
-          &buffer1, len1, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store1 = ArrayBuffer::NewBackingStore(
+      &buffer1, len1, [](void*, size_t, void*) {}, nullptr);
 
-  std::shared_ptr<BackingStore> store2 =
-      ArrayBuffer::NewBackingStore(
-          &buffer2, len2, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store2 = ArrayBuffer::NewBackingStore(
+      &buffer2, len2, [](void*, size_t, void*) {}, nullptr);
 
-  std::shared_ptr<BackingStore> store3 =
-      ArrayBuffer::NewBackingStore(
-          &buffer3, len3, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store3 = ArrayBuffer::NewBackingStore(
+      &buffer3, len3, [](void*, size_t, void*) {}, nullptr);
 
   // We can create an non-idempotent DataQueue from a list of entries.
   std::shared_ptr<DataQueue> data_queue = DataQueue::Create();
 
-  CHECK(!data_queue->isIdempotent());
-  CHECK_EQ(data_queue->size().ToChecked(), 0);
+  CHECK(!data_queue->is_idempotent());
+  CHECK_EQ(data_queue->size().value(), 0);
 
-  data_queue->append(DataQueue::CreateInMemoryEntryFromBackingStore(store1, 0, len1));
-  CHECK_EQ(data_queue->size().ToChecked(), len1);
+  data_queue->append(
+      DataQueue::CreateInMemoryEntryFromBackingStore(store1, 0, len1));
+  CHECK_EQ(data_queue->size().value(), len1);
 
-  data_queue->append(DataQueue::CreateInMemoryEntryFromBackingStore(store2, 0, len2));
-  CHECK_EQ(data_queue->size().ToChecked(), len1 + len2);
+  data_queue->append(
+      DataQueue::CreateInMemoryEntryFromBackingStore(store2, 0, len2));
+  CHECK_EQ(data_queue->size().value(), len1 + len2);
 
-  CHECK(!data_queue->isCapped());
-  CHECK(data_queue->maybeCapRemaining().IsNothing());
+  CHECK(!data_queue->is_capped());
+  CHECK(!data_queue->maybeCapRemaining().has_value());
 
   data_queue->cap(100);
-  CHECK(data_queue->isCapped());
-  CHECK_EQ(data_queue->maybeCapRemaining().ToChecked(), 100 - (len1 + len2));
+  CHECK(data_queue->is_capped());
+  CHECK_EQ(data_queue->maybeCapRemaining().value(), 100 - (len1 + len2));
 
   data_queue->cap(101);
-  CHECK(data_queue->isCapped());
-  CHECK_EQ(data_queue->maybeCapRemaining().ToChecked(), 100 - (len1 + len2));
+  CHECK(data_queue->is_capped());
+  CHECK_EQ(data_queue->maybeCapRemaining().value(), 100 - (len1 + len2));
 
   data_queue->cap();
-  CHECK(data_queue->isCapped());
-  CHECK_EQ(data_queue->maybeCapRemaining().ToChecked(), 0);
+  CHECK(data_queue->is_capped());
+  CHECK_EQ(data_queue->maybeCapRemaining().value(), 0);
 
   // We can't add any more because the data queue is capped.
-  CHECK_EQ(data_queue->append(
-      DataQueue::CreateInMemoryEntryFromBackingStore(store3, 0, len3)).FromJust(), false);
+  CHECK_EQ(data_queue
+               ->append(DataQueue::CreateInMemoryEntryFromBackingStore(
+                   store3, 0, len3))
+               .value(),
+           false);
 
   // We cannot slice a non-idempotent data queue
   std::shared_ptr<DataQueue> slice1 = data_queue->slice(2);
   CHECK_NULL(slice1);
 
   // We can acquire only a single reader for a non-idempotent data queue
-  std::unique_ptr<DataQueue::Reader> reader1 = data_queue->getReader();
-  std::unique_ptr<DataQueue::Reader> reader2 = data_queue->getReader();
+  std::shared_ptr<DataQueue::Reader> reader1 = data_queue->get_reader();
+  std::shared_ptr<DataQueue::Reader> reader2 = data_queue->get_reader();
 
   CHECK_NOT_NULL(reader1);
   CHECK_NULL(reader2);
@@ -398,13 +480,17 @@ TEST(DataQueue, NonIdempotentDataQueue) {
     // The first read produces buffer1
     int status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_CONTINUE);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len1);
-      CHECK_EQ(memcmp(vecs[0].base, buffer1, len1), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len1);
+          CHECK_EQ(memcmp(vecs[0].base, buffer1, len1), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_CONTINUE);
@@ -413,29 +499,51 @@ TEST(DataQueue, NonIdempotentDataQueue) {
     // InMemoryEntry instances, reads will be fully synchronous here.
     waitingForPull = true;
 
-    // The second read produces buffer2, and should be the end.
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_END);
-      CHECK_EQ(count, 1);
-      CHECK_EQ(vecs[0].len, len2);
-      CHECK_EQ(memcmp(vecs[0].base, buffer2, len2), 0);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
-    CHECK_EQ(status, node::bob::STATUS_END);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
 
-    // The third read produces EOS
+    // The next read produces buffer2, and should be the end.
     status = reader->Pull(
         [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-      waitingForPull = false;
-      CHECK_EQ(status, node::bob::STATUS_EOS);
-      CHECK_EQ(count, 0);
-      CHECK_NULL(vecs);
-      std::move(done)(0);
-    }, node::bob::OPTIONS_SYNC, nullptr, 0, node::bob::kMaxCountHint);
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+          CHECK_EQ(count, 1);
+          CHECK_EQ(vecs[0].len, len2);
+          CHECK_EQ(memcmp(vecs[0].base, buffer2, len2), 0);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
+
+    CHECK(!waitingForPull);
+    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+
+    // The next read produces EOS
+    status = reader->Pull(
+        [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
+          waitingForPull = false;
+          CHECK_EQ(status, node::bob::STATUS_EOS);
+          CHECK_EQ(count, 0);
+          CHECK_NULL(vecs);
+          std::move(done)(0);
+        },
+        node::bob::OPTIONS_SYNC,
+        nullptr,
+        0,
+        node::bob::kMaxCountHint);
 
     CHECK(!waitingForPull);
     CHECK_EQ(status, node::bob::STATUS_EOS);
@@ -445,7 +553,7 @@ TEST(DataQueue, NonIdempotentDataQueue) {
   testRead(reader1);
 
   // We still cannot acquire another reader.
-  std::unique_ptr<DataQueue::Reader> reader3 = data_queue->getReader();
+  std::shared_ptr<DataQueue::Reader> reader3 = data_queue->get_reader();
   CHECK_NULL(reader3);
 
   CHECK_NOT_NULL(data_queue);
@@ -457,20 +565,21 @@ TEST(DataQueue, DataQueueEntry) {
   size_t len1 = strlen(buffer1);
   size_t len2 = strlen(buffer2);
 
-  std::shared_ptr<BackingStore> store1 =
-      ArrayBuffer::NewBackingStore(
-          &buffer1, len1, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store1 = ArrayBuffer::NewBackingStore(
+      &buffer1, len1, [](void*, size_t, void*) {}, nullptr);
 
-  std::shared_ptr<BackingStore> store2 =
-      ArrayBuffer::NewBackingStore(
-          &buffer2, len2, [](void*, size_t, void*) {}, nullptr);
+  std::shared_ptr<BackingStore> store2 = ArrayBuffer::NewBackingStore(
+      &buffer2, len2, [](void*, size_t, void*) {}, nullptr);
 
   std::vector<std::unique_ptr<DataQueue::Entry>> list;
-  list.push_back(DataQueue::CreateInMemoryEntryFromBackingStore(store1, 0, len1));
-  list.push_back(DataQueue::CreateInMemoryEntryFromBackingStore(store2, 0, len2));
+  list.push_back(
+      DataQueue::CreateInMemoryEntryFromBackingStore(store1, 0, len1));
+  list.push_back(
+      DataQueue::CreateInMemoryEntryFromBackingStore(store2, 0, len2));
 
   // We can create an idempotent DataQueue from a list of entries.
-  std::shared_ptr<DataQueue> data_queue = DataQueue::CreateIdempotent(std::move(list));
+  std::shared_ptr<DataQueue> data_queue =
+      DataQueue::CreateIdempotent(std::move(list));
 
   CHECK_NOT_NULL(data_queue);
 
@@ -479,37 +588,41 @@ TEST(DataQueue, DataQueueEntry) {
       DataQueue::CreateDataQueueEntry(data_queue);
 
   // The entry should be idempotent since the data queue is idempotent.
-  CHECK(entry->isIdempotent());
+  CHECK(entry->is_idempotent());
 
   // The entry size should match the data queue size.
-  CHECK_EQ(entry->size().ToChecked(), data_queue->size().ToChecked());
+  CHECK_EQ(entry->size().value(), data_queue->size().value());
 
   // We can slice it since it is idempotent.
-  std::unique_ptr<DataQueue::Entry> slice = entry->slice(5, Just(20UL));
+  uint64_t end = 20;
+  std::unique_ptr<DataQueue::Entry> slice = entry->slice(5, end);
 
   // The slice has the expected length.
-  CHECK_EQ(slice->size().ToChecked(), 15);
+  CHECK_EQ(slice->size().value(), 15);
 
   // We can add it to another data queue, even if the new one is not
   // idempotent.
 
   std::shared_ptr<DataQueue> data_queue2 = DataQueue::Create();
-  CHECK(data_queue2->append(std::move(slice)).IsJust());
+  CHECK(data_queue2->append(std::move(slice)).value());
 
   // Our original data queue should have a use count of 2.
   CHECK_EQ(data_queue.use_count(), 2);
 
-  std::unique_ptr<DataQueue::Reader> reader = data_queue2->getReader();
+  std::shared_ptr<DataQueue::Reader> reader = data_queue2->get_reader();
 
   bool pullIsPending = true;
 
   int status = reader->Pull(
       [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-    pullIsPending = false;
-    CHECK_EQ(count, 1);
-    CHECK_EQ(memcmp(vecs[0].base, buffer1 + 5, len1 - 5), 0);
-    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
-  }, node::bob::OPTIONS_SYNC, nullptr, 0);
+        pullIsPending = false;
+        CHECK_EQ(count, 1);
+        CHECK_EQ(memcmp(vecs[0].base, buffer1 + 5, len1 - 5), 0);
+        CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+      },
+      node::bob::OPTIONS_SYNC,
+      nullptr,
+      0);
 
   // All of the actual entries are in-memory entries so reads should be sync.
   CHECK(!pullIsPending);
@@ -517,26 +630,29 @@ TEST(DataQueue, DataQueueEntry) {
 
   // Read to completion...
   while (status != node::bob::STATUS_EOS) {
-    status = reader->Pull([&](auto, auto, auto, auto) {},
-                          node::bob::OPTIONS_SYNC, nullptr, 0);
+    status = reader->Pull(
+        [&](auto, auto, auto, auto) {}, node::bob::OPTIONS_SYNC, nullptr, 0);
   }
 
   // Because the original data queue is idempotent, we can still read from it,
   // even though we have already consumed the non-idempotent data queue that
   // contained it.
 
-  std::unique_ptr<DataQueue::Reader> reader2 = data_queue->getReader();
+  std::shared_ptr<DataQueue::Reader> reader2 = data_queue->get_reader();
   CHECK_NOT_NULL(reader2);
 
   pullIsPending = true;
 
   status = reader2->Pull(
       [&](int status, const DataQueue::Vec* vecs, size_t count, auto done) {
-    pullIsPending = false;
-    CHECK_EQ(count, 1);
-    CHECK_EQ(memcmp(vecs[0].base, buffer1, len1), 0);
-    CHECK_EQ(status, node::bob::STATUS_CONTINUE);
-  }, node::bob::OPTIONS_SYNC, nullptr, 0);
+        pullIsPending = false;
+        CHECK_EQ(count, 1);
+        CHECK_EQ(memcmp(vecs[0].base, buffer1, len1), 0);
+        CHECK_EQ(status, node::bob::STATUS_CONTINUE);
+      },
+      node::bob::OPTIONS_SYNC,
+      nullptr,
+      0);
 
   // All of the actual entries are in-memory entries so reads should be sync.
   CHECK(!pullIsPending);
diff --git a/test/parallel/test-blob-file-backed.js b/test/parallel/test-blob-file-backed.js
index 5591b548d74c4d..7271fef2f3ce46 100644
--- a/test/parallel/test-blob-file-backed.js
+++ b/test/parallel/test-blob-file-backed.js
@@ -1,25 +1,34 @@
 'use strict';
 
 const common = require('../common');
-const { strictEqual } = require('assert');
-const { open } = require('fs/promises');
-const { TextEncoder } = require('util');
-const fs = require('fs');
+const {
+  strictEqual,
+  rejects,
+} = require('assert');
+const { TextDecoder } = require('util');
+const {
+  writeFileSync,
+  openAsBlob,
+} = require('fs');
+
+const {
+  unlink
+} = require('fs/promises');
 const path = require('path');
+const { Blob } = require('buffer');
 
 const tmpdir = require('../common/tmpdir');
-const testfile = path.join(tmpdir.path, 'test.txt');
-
+const testfile = path.join(tmpdir.path, 'test-file-backed-blob.txt');
+const testfile2 = path.join(tmpdir.path, 'test-file-backed-blob2.txt');
 tmpdir.refresh();
 
 const data = `${'a'.repeat(1000)}${'b'.repeat(2000)}`;
 
-fs.writeFileSync(testfile, data);
+writeFileSync(testfile, data);
+writeFileSync(testfile2, data.repeat(100));
 
 (async () => {
-
-  const fh = await open(testfile);
-  const blob = fh.blob();
+  const blob = await openAsBlob(testfile);
 
   const ab = await blob.arrayBuffer();
   const dec = new TextDecoder();
@@ -27,21 +36,46 @@ fs.writeFileSync(testfile, data);
   strictEqual(dec.decode(new Uint8Array(ab)), data);
   strictEqual(await blob.text(), data);
 
+  // Can be read multiple times
   let stream = blob.stream();
   let check = '';
   for await (const chunk of stream)
     check = dec.decode(chunk);
   strictEqual(check, data);
 
+  // Can be combined with other Blob's and read
+  const combined = new Blob(['hello', blob, 'world']);
+  const ab2 = await combined.arrayBuffer();
+  strictEqual(dec.decode(ab2.slice(0, 5)), 'hello');
+  strictEqual(dec.decode(ab2.slice(5, -5)), data);
+  strictEqual(dec.decode(ab2.slice(-5)), 'world');
+
   // If the file is modified tho, the stream errors.
-  fs.writeFileSync(testfile, data + 'abc');
+  writeFileSync(testfile, data + 'abc');
 
   stream = blob.stream();
-  try {
-    for await (const chunk of stream) {}
-  } catch (err) {
-    strictEqual(err.message, 'read EINVAL');
-    strictEqual(err.code, 'EINVAL');
-  }
 
+  const read = async () => {
+    // eslint-disable-next-line no-unused-vars, no-empty
+    for await (const _ of stream) {}
+  };
+
+  await rejects(read(), { name: 'NotReadableError' });
+
+  await unlink(testfile);
+})().then(common.mustCall());
+
+(async () => {
+  const blob = await openAsBlob(testfile2);
+  const stream = blob.stream();
+  const read = async () => {
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of stream) {
+      writeFileSync(testfile2, data + 'abc');
+    }
+  };
+
+  await rejects(read(), { name: 'NotReadableError' });
+
+  await unlink(testfile2);
 })().then(common.mustCall());
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index 693fa9efb4111b..c0fd99055de445 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -9,83 +9,86 @@ const common = require('../common');
 const assert = require('assert');
 
 const expectedModules = new Set([
-  'Internal Binding async_wrap',
-  'Internal Binding blob',
-  'Internal Binding buffer',
   'Internal Binding builtins',
-  'Internal Binding config',
-  'Internal Binding constants',
-  'Internal Binding contextify',
-  'Internal Binding credentials',
   'Internal Binding errors',
-  'Internal Binding fs',
-  'Internal Binding messaging',
-  'Internal Binding mksnapshot',
-  'Internal Binding module_wrap',
-  'Internal Binding options',
-  'Internal Binding performance',
-  'Internal Binding process_methods',
-  'Internal Binding string_decoder',
-  'Internal Binding symbols',
-  'Internal Binding task_queue',
+  'Internal Binding util',
+  'NativeModule internal/errors',
+  'Internal Binding config',
   'Internal Binding timers',
-  'Internal Binding trace_events',
+  'Internal Binding async_wrap',
+  'Internal Binding task_queue',
+  'Internal Binding symbols',
+  'NativeModule internal/async_hooks',
+  'Internal Binding constants',
   'Internal Binding types',
-  'Internal Binding url',
-  'Internal Binding util',
-  'Internal Binding wasm_web_api',
-  'Internal Binding worker',
-  'NativeModule async_hooks',
-  'NativeModule buffer',
-  'NativeModule events',
-  'NativeModule fs',
+  'NativeModule internal/util',
+  'NativeModule internal/util/types',
+  'NativeModule internal/validators',
+  'NativeModule internal/linkedlist',
+  'NativeModule internal/priority_queue',
   'NativeModule internal/assert',
-  'NativeModule internal/async_hooks',
+  'NativeModule internal/util/inspect',
+  'NativeModule internal/util/debuglog',
+  'NativeModule internal/timers',
+  'NativeModule events',
+  'Internal Binding buffer',
+  'Internal Binding string_decoder',
   'NativeModule internal/buffer',
+  'NativeModule buffer',
+  'Internal Binding messaging',
+  'NativeModule internal/worker/js_transferable',
+  'Internal Binding process_methods',
+  'NativeModule internal/process/per_thread',
+  'Internal Binding credentials',
+  'NativeModule internal/process/promises',
+  'NativeModule internal/fixed_queue',
+  'NativeModule async_hooks',
+  'NativeModule internal/process/task_queues',
+  'NativeModule timers',
+  'Internal Binding trace_events',
+  'NativeModule internal/constants',
+  'NativeModule path',
+  'NativeModule internal/process/execution',
+  'NativeModule internal/process/warning',
   'NativeModule internal/console/constructor',
   'NativeModule internal/console/global',
-  'NativeModule internal/constants',
-  'NativeModule internal/dns/utils',
-  'NativeModule internal/errors',
+  'NativeModule internal/querystring',
+  'NativeModule querystring',
+  'Internal Binding url',
+  'Internal Binding blob',
+  'NativeModule internal/url',
+  'NativeModule util',
+  'Internal Binding performance',
+  'NativeModule internal/perf/utils',
   'NativeModule internal/event_target',
-  'NativeModule internal/fixed_queue',
+  'Internal Binding mksnapshot',
+  'NativeModule internal/v8/startup_snapshot',
+  'NativeModule internal/process/signal',
+  'Internal Binding fs',
+  'NativeModule internal/encoding',
+  'NativeModule internal/webstreams/util',
+  'NativeModule internal/webstreams/queuingstrategies',
+  'NativeModule internal/blob',
   'NativeModule internal/fs/utils',
+  'NativeModule fs',
   'NativeModule internal/idna',
-  'NativeModule internal/linkedlist',
-  'NativeModule internal/modules/cjs/loader',
-  'NativeModule internal/modules/esm/utils',
+  'Internal Binding options',
+  'NativeModule internal/options',
+  'NativeModule internal/source_map/source_map_cache',
+  'Internal Binding contextify',
+  'NativeModule internal/vm',
   'NativeModule internal/modules/helpers',
   'NativeModule internal/modules/package_json_reader',
+  'Internal Binding module_wrap',
+  'NativeModule internal/modules/cjs/loader',
+  'NativeModule internal/vm/module',
+  'NativeModule internal/modules/esm/utils',
+  'Internal Binding wasm_web_api',
+  'Internal Binding worker',
   'NativeModule internal/modules/run_main',
   'NativeModule internal/net',
-  'NativeModule internal/options',
-  'NativeModule internal/perf/utils',
-  'NativeModule internal/priority_queue',
-  'NativeModule internal/process/execution',
-  'NativeModule internal/process/per_thread',
+  'NativeModule internal/dns/utils',
   'NativeModule internal/process/pre_execution',
-  'NativeModule internal/process/promises',
-  'NativeModule internal/process/signal',
-  'NativeModule internal/process/task_queues',
-  'NativeModule internal/process/warning',
-  'NativeModule internal/querystring',
-  'NativeModule internal/source_map/source_map_cache',
-  'NativeModule internal/timers',
-  'NativeModule internal/url',
-  'NativeModule internal/util',
-  'NativeModule internal/util/debuglog',
-  'NativeModule internal/util/inspect',
-  'NativeModule internal/util/types',
-  'NativeModule internal/v8/startup_snapshot',
-  'NativeModule internal/validators',
-  'NativeModule internal/vm',
-  'NativeModule internal/vm/module',
-  'NativeModule internal/worker/js_transferable',
-  'NativeModule path',
-  'NativeModule querystring',
-  'NativeModule timers',
-  'NativeModule url',
-  'NativeModule util',
 ]);
 
 if (!common.isMainThread) {
@@ -127,6 +130,7 @@ if (common.isWindows) {
 
 if (common.hasIntl) {
   expectedModules.add('Internal Binding icu');
+  expectedModules.add('NativeModule url');
 } else {
   expectedModules.add('NativeModule url');
 }
diff --git a/test/parallel/test-trace-events-threadpool.js b/test/parallel/test-trace-events-threadpool.js
index dd1cc02e53d793..a5af5e78661dab 100644
--- a/test/parallel/test-trace-events-threadpool.js
+++ b/test/parallel/test-trace-events-threadpool.js
@@ -5,20 +5,18 @@ const cp = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const tmpdir = require('../common/tmpdir');
+const { scheduler } = require('timers/promises');
 
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
 const { hkdf } = require('crypto');
 const { deflate } = require('zlib');
-const { Blob } = require('buffer');
 
 if (process.env.isChild === '1') {
   hkdf('sha512', 'key', 'salt', 'info', 64, () => {});
   deflate('hello', () => {});
-  // Make async call
-  const blob = new Blob(['h'.repeat(4096 * 2)]);
-  blob.arrayBuffer();
+  scheduler.wait(10);
   return;
 }
 
@@ -46,7 +44,6 @@ const traces = JSON.parse(data.toString()).traceEvents;
 
 assert(traces.length > 0);
 
-let blobCount = 0;
 let zlibCount = 0;
 let cryptoCount = 0;
 
@@ -55,9 +52,7 @@ traces.forEach((item) => {
     'node,node.threadpoolwork,node.threadpoolwork.sync',
     'node,node.threadpoolwork,node.threadpoolwork.async',
   ].includes(item.cat)) {
-    if (item.name === 'blob') {
-      blobCount++;
-    } else if (item.name === 'zlib') {
+    if (item.name === 'zlib') {
       zlibCount++;
     } else if (item.name === 'crypto') {
       cryptoCount++;
@@ -65,7 +60,6 @@ traces.forEach((item) => {
   }
 });
 
-// There are three types, each type has two async events and sync events at least
-assert.ok(blobCount >= 4);
+// There are two types, each type has two async events and sync events at least
 assert.ok(zlibCount >= 4);
 assert.ok(cryptoCount >= 4);