diff --git a/system/ulib/fit/include/lib/fit/bridge.h b/system/ulib/fit/include/lib/fit/bridge.h
index 3fed908..f5cfb24 100644
--- a/system/ulib/fit/include/lib/fit/bridge.h
+++ b/system/ulib/fit/include/lib/fit/bridge.h
@@ -13,9 +13,9 @@
 // by the association of two distinct participants: a completer and a consumer.
 //
 // - The completer is responsible for reporting completion of an asynchronous
-//   task and providing its result.  See |completer()| and |fit::completer|.
+//   task and providing its result.  See |completer| and |fit::completer|.
 // - The consumer is responsible for consuming the result of the asynchronous
-//   task.  See |consumer()| and |fit::consumer|.
+//   task.  See |consumer| and |fit::consumer|.
 //
 // This class is often used for binding a |fit::promise| to a callback,
 // facilitating interoperation of promises with functions that asynchronously
@@ -50,7 +50,7 @@
 //
 // DECOUPLING
 //
-// See |fit::schedule_for_consumer()| for a helper which uses a bridge to
+// See |fit::schedule_for_consumer| for a helper which uses a bridge to
 // decouple completion and consumption of a task's result so they can be
 // performed on different executors.
 //
@@ -79,8 +79,8 @@
 //
 //     fit::promise<size_t> promise_read(uint8_t* buffer, size_t num_bytes) {
 //         fit::bridge<size_t> bridge;
-//         read_async(num_bytes, buffer, bridge.completer().bind());
-//         return bridge.consumer().promise_or(::fit::error());
+//         read_async(num_bytes, buffer, bridge.completer.bind());
+//         return bridge.consumer.promise_or(::fit::error());
 //     }
 //
 // Finally we can chain additional asynchronous tasks to be performed upon
@@ -109,14 +109,14 @@
 //     fit::promise<size_t, int> promise_write(uint8_t* buffer, size_t num_bytes) {
 //         fit::bridge<size_t, int> bridge;
 //         write_async(num_bytes, buffer,
-//             [completer = std::move(bridge.completer())](size_t bytes_written, int error) {
+//             [completer = std::move(bridge.completer)](size_t bytes_written, int error) {
 //             if (bytes_written == 0) {
 //                 completer.complete_error(error);
 //                 return;
 //             }
 //             completer.complete_ok(bytes_written);
 //         });
-//         return bridge.consumer().promise_or(::fit::error(ERR_ABANDONED));
+//         return bridge.consumer.promise_or(::fit::error(ERR_ABANDONED));
 //     }
 //
 //     uint8_t buffer[4096];
@@ -134,8 +134,6 @@
 // See documentation of |fit::promise| for more information.
 template <typename V, typename E>
 class bridge final {
-    using bridge_state = ::fit::internal::bridge_state<V, E>;
-
 public:
     using value_type = V;
     using error_type = E;
@@ -146,30 +144,22 @@
     // Creates a bridge representing a new asynchronous task formed by the
     // association of a completer and consumer.
     bridge() {
-        bridge_state::create(&completer_.completion_ref_,
-                             &consumer_.consumption_ref_);
+        ::fit::internal::bridge_state<V, E>::create(
+            &completer.completion_ref_,
+            &consumer.consumption_ref_);
     }
     bridge(bridge&& other) = default;
+    bridge(const bridge& other) = delete;
     ~bridge() = default;
 
     bridge& operator=(bridge&& other) = default;
-
-    // Gets a reference to the bridge's completer capability.
-    // The completer can be moved out of the bridge, if desired.
-    completer_type& completer() { return completer_; }
-    const completer_type& completer() const { return completer_; }
-
-    // Gets a reference to the bridge's consumer capability.
-    // The consumer can be moved out of the bridge, if desired.
-    consumer_type& consumer() { return consumer_; }
-    const consumer_type& consumer() const { return consumer_; }
-
-    bridge(const bridge& other) = delete;
     bridge& operator=(const bridge& other) = delete;
 
-private:
-    completer_type completer_;
-    consumer_type consumer_;
+    // The bridge's completer capability.
+    completer_type completer;
+
+    // The bridge's consumer capability.
+    consumer_type consumer;
 };
 
 // Provides a result upon completion of an asynchronous task.
@@ -476,11 +466,11 @@
                 typename Promise::error_type>
         bridge;
     executor->schedule_task(
-        promise.then([completer = std::move(bridge.completer())](
+        promise.then([completer = std::move(bridge.completer)](
                          typename Promise::result_type& result) mutable {
             completer.complete_or_abandon(std::move(result));
         }));
-    return std::move(bridge.consumer());
+    return std::move(bridge.consumer);
 }
 
 } // namespace fit
diff --git a/system/ulib/fit/include/lib/fit/sequencer.h b/system/ulib/fit/include/lib/fit/sequencer.h
index 509cd8e..996bc68 100644
--- a/system/ulib/fit/include/lib/fit/sequencer.h
+++ b/system/ulib/fit/include/lib/fit/sequencer.h
@@ -52,10 +52,10 @@
         assert(promise);
 
         fit::bridge<> bridge;
-        fit::consumer<> prior = swap_prior(std::move(bridge.consumer()));
+        fit::consumer<> prior = swap_prior(std::move(bridge.consumer));
         return prior.promise_or(fit::ok())
             .then([promise = std::move(promise),
-                   completer = std::move(bridge.completer())](
+                   completer = std::move(bridge.completer)](
                       fit::context& context, fit::result<>) mutable {
                 // This handler will run once the completer associated
                 // with the |prior| promise is abandoned.  Once the promise
diff --git a/system/ulib/fit/sequencer.cpp b/system/ulib/fit/sequencer.cpp
index 687db67..b490455 100644
--- a/system/ulib/fit/sequencer.cpp
+++ b/system/ulib/fit/sequencer.cpp
@@ -14,7 +14,7 @@
     // completer so that a promise chained onto the consumer using
     // |promise_or()| will become immediately runnable.
     fit::bridge<> bridge;
-    prior_ = std::move(bridge.consumer());
+    prior_ = std::move(bridge.consumer);
 }
 
 sequencer::~sequencer() = default;
diff --git a/system/utest/fit/bridge_tests.cpp b/system/utest/fit/bridge_tests.cpp
index 391e9d4..c783a87 100644
--- a/system/utest/fit/bridge_tests.cpp
+++ b/system/utest/fit/bridge_tests.cpp
@@ -45,29 +45,29 @@
 
     // Create a new bridge.
     fit::bridge<int, const char*> bridge;
-    EXPECT_TRUE(bridge.completer());
-    EXPECT_TRUE(bridge.consumer());
+    EXPECT_TRUE(bridge.completer);
+    EXPECT_TRUE(bridge.consumer);
 
     // Can move-construct.
     fit::bridge<int, const char*> bridge2(std::move(bridge));
-    EXPECT_TRUE(bridge2.completer());
-    EXPECT_TRUE(bridge2.consumer());
-    EXPECT_FALSE(bridge.completer());
-    EXPECT_FALSE(bridge.consumer());
+    EXPECT_TRUE(bridge2.completer);
+    EXPECT_TRUE(bridge2.consumer);
+    EXPECT_FALSE(bridge.completer);
+    EXPECT_FALSE(bridge.consumer);
 
     // Can move-assign.
     bridge = std::move(bridge2);
-    EXPECT_TRUE(bridge.completer());
-    EXPECT_TRUE(bridge.consumer());
-    EXPECT_FALSE(bridge2.completer());
-    EXPECT_FALSE(bridge2.consumer());
+    EXPECT_TRUE(bridge.completer);
+    EXPECT_TRUE(bridge.consumer);
+    EXPECT_FALSE(bridge2.completer);
+    EXPECT_FALSE(bridge2.consumer);
 
     // It still works.
-    bridge.completer().complete_error("Test");
-    EXPECT_FALSE(bridge.completer());
+    bridge.completer.complete_error("Test");
+    EXPECT_FALSE(bridge.completer);
     fit::result<int, const char*> result =
-        fit::run_single_threaded(bridge.consumer().promise());
-    EXPECT_FALSE(bridge.consumer());
+        fit::run_single_threaded(bridge.consumer.promise());
+    EXPECT_FALSE(bridge.consumer);
     EXPECT_EQ(fit::result_state::error, result.state());
     EXPECT_STR_EQ("Test", result.error());
 
@@ -83,7 +83,7 @@
 
     // Can move-construct from non-empty.
     fit::bridge<int, const char*> bridge;
-    fit::completer<int, const char*> completer2(std::move(bridge.completer()));
+    fit::completer<int, const char*> completer2(std::move(bridge.completer));
     EXPECT_TRUE(completer2);
 
     // Can move-assign from non-empty.
@@ -95,8 +95,8 @@
     completer.complete_error("Test");
     EXPECT_FALSE(completer);
     fit::result<int, const char*> result =
-        fit::run_single_threaded(bridge.consumer().promise());
-    EXPECT_FALSE(bridge.consumer());
+        fit::run_single_threaded(bridge.consumer.promise());
+    EXPECT_FALSE(bridge.consumer);
     EXPECT_EQ(fit::result_state::error, result.state());
     EXPECT_STR_EQ("Test", result.error());
 
@@ -119,17 +119,17 @@
     // abandon()
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().abandon();
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_TRUE(bridge.consumer().was_abandoned());
+        bridge.completer.abandon();
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_TRUE(bridge.consumer.was_abandoned());
 
         fit::result<int, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise_or(
+            fit::run_single_threaded(bridge.consumer.promise_or(
                 fit::error("Abandoned")));
-        EXPECT_FALSE(bridge.consumer());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::error, result.state());
         EXPECT_STR_EQ("Abandoned", result.error());
     }
@@ -137,17 +137,17 @@
     // completer is discarded
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer() = fit::completer<int, const char*>();
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_TRUE(bridge.consumer().was_abandoned());
+        bridge.completer = fit::completer<int, const char*>();
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_TRUE(bridge.consumer.was_abandoned());
 
         fit::result<int, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise_or(
+            fit::run_single_threaded(bridge.consumer.promise_or(
                 fit::error("Abandoned")));
-        EXPECT_FALSE(bridge.consumer());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::error, result.state());
         EXPECT_STR_EQ("Abandoned", result.error());
     }
@@ -161,32 +161,32 @@
     // complete_ok()
     {
         fit::bridge<void, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().complete_ok();
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        bridge.completer.complete_ok();
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<void, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise());
-        EXPECT_FALSE(bridge.consumer());
+            fit::run_single_threaded(bridge.consumer.promise());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::ok, result.state());
     }
 
     // complete_ok(value)
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().complete_ok(42);
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        bridge.completer.complete_ok(42);
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<int, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise());
-        EXPECT_FALSE(bridge.consumer());
+            fit::run_single_threaded(bridge.consumer.promise());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::ok, result.state());
         EXPECT_EQ(42, result.value());
     }
@@ -194,32 +194,32 @@
     // complete_error()
     {
         fit::bridge<int, void> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().complete_error();
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        bridge.completer.complete_error();
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<int, void> result =
-            fit::run_single_threaded(bridge.consumer().promise());
-        EXPECT_FALSE(bridge.consumer());
+            fit::run_single_threaded(bridge.consumer.promise());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::error, result.state());
     }
 
     // complete_error(error)
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().complete_error("Test");
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        bridge.completer.complete_error("Test");
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<int, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise());
-        EXPECT_FALSE(bridge.consumer());
+            fit::run_single_threaded(bridge.consumer.promise());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::error, result.state());
         EXPECT_STR_EQ("Test", result.error());
     }
@@ -227,16 +227,16 @@
     // complete_or_abandon(fit::ok(...))
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().complete_or_abandon(fit::ok(42));
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        bridge.completer.complete_or_abandon(fit::ok(42));
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<int, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise());
-        EXPECT_FALSE(bridge.consumer());
+            fit::run_single_threaded(bridge.consumer.promise());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::ok, result.state());
         EXPECT_EQ(42, result.value());
     }
@@ -244,16 +244,16 @@
     // complete_or_abandon(fit::error(...))
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().complete_or_abandon(fit::error("Test"));
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        bridge.completer.complete_or_abandon(fit::error("Test"));
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<int, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise());
-        EXPECT_FALSE(bridge.consumer());
+            fit::run_single_threaded(bridge.consumer.promise());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::error, result.state());
         EXPECT_STR_EQ("Test", result.error());
     }
@@ -261,17 +261,17 @@
     // complete_or_abandon(fit::pending())
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        EXPECT_TRUE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
-        bridge.completer().complete_or_abandon(fit::pending());
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_TRUE(bridge.consumer().was_abandoned());
+        bridge.completer.complete_or_abandon(fit::pending());
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_TRUE(bridge.consumer.was_abandoned());
 
         fit::result<int, const char*> result =
-            fit::run_single_threaded(bridge.consumer().promise_or(
+            fit::run_single_threaded(bridge.consumer.promise_or(
                 fit::error("Abandoned")));
-        EXPECT_FALSE(bridge.consumer());
+        EXPECT_FALSE(bridge.consumer);
         EXPECT_EQ(fit::result_state::error, result.state());
         EXPECT_STR_EQ("Abandoned", result.error());
     }
@@ -286,12 +286,12 @@
     {
         uint64_t run_count = 0;
         fit::bridge<> bridge;
-        async_invoke_callback_no_args(&run_count, bridge.completer().bind());
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        async_invoke_callback_no_args(&run_count, bridge.completer.bind());
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<> result = fit::run_single_threaded(
-            bridge.consumer().promise());
+            bridge.consumer.promise());
         EXPECT_EQ(fit::result_state::ok, result.state());
         EXPECT_EQ(1, run_count);
     }
@@ -300,12 +300,12 @@
     {
         uint64_t run_count = 0;
         fit::bridge<std::tuple<>> bridge;
-        async_invoke_callback_no_args(&run_count, bridge.completer().bind_tuple());
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        async_invoke_callback_no_args(&run_count, bridge.completer.bind_tuple());
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<std::tuple<>> result = fit::run_single_threaded(
-            bridge.consumer().promise());
+            bridge.consumer.promise());
         EXPECT_EQ(fit::result_state::ok, result.state());
         EXPECT_EQ(1, run_count);
     }
@@ -320,12 +320,12 @@
     {
         uint64_t run_count = 0;
         fit::bridge<std::string> bridge;
-        async_invoke_callback_one_arg(&run_count, bridge.completer().bind());
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        async_invoke_callback_one_arg(&run_count, bridge.completer.bind());
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<std::string> result = fit::run_single_threaded(
-            bridge.consumer().promise());
+            bridge.consumer.promise());
         EXPECT_EQ(fit::result_state::ok, result.state());
         EXPECT_TRUE(result.value() == "Hippopotamus");
         EXPECT_EQ(1, run_count);
@@ -335,12 +335,12 @@
     {
         uint64_t run_count = 0;
         fit::bridge<std::tuple<std::string>> bridge;
-        async_invoke_callback_one_arg(&run_count, bridge.completer().bind_tuple());
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        async_invoke_callback_one_arg(&run_count, bridge.completer.bind_tuple());
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<std::tuple<std::string>> result = fit::run_single_threaded(
-            bridge.consumer().promise());
+            bridge.consumer.promise());
         EXPECT_EQ(fit::result_state::ok, result.state());
         EXPECT_TRUE(std::get<0>(result.value()) == "Hippopotamus");
         EXPECT_EQ(1, run_count);
@@ -356,12 +356,12 @@
     {
         uint64_t run_count = 0;
         fit::bridge<std::tuple<std::string, int>> bridge;
-        async_invoke_callback_two_args(&run_count, bridge.completer().bind_tuple());
-        EXPECT_FALSE(bridge.completer());
-        EXPECT_FALSE(bridge.consumer().was_abandoned());
+        async_invoke_callback_two_args(&run_count, bridge.completer.bind_tuple());
+        EXPECT_FALSE(bridge.completer);
+        EXPECT_FALSE(bridge.consumer.was_abandoned());
 
         fit::result<std::tuple<std::string, int>> result = fit::run_single_threaded(
-            bridge.consumer().promise());
+            bridge.consumer.promise());
         EXPECT_EQ(fit::result_state::ok, result.state());
         EXPECT_TRUE(std::get<0>(result.value()) ==
                     "What do you get when you multiply six by nine?");
@@ -381,7 +381,7 @@
 
     // Can move-construct from non-empty.
     fit::bridge<int, const char*> bridge;
-    fit::consumer<int, const char*> consumer2(std::move(bridge.consumer()));
+    fit::consumer<int, const char*> consumer2(std::move(bridge.consumer));
     EXPECT_TRUE(consumer2);
 
     // Can move-assign from non-empty.
@@ -390,8 +390,8 @@
     EXPECT_FALSE(consumer2);
 
     // It still works.
-    bridge.completer().complete_error("Test");
-    EXPECT_FALSE(bridge.completer());
+    bridge.completer.complete_error("Test");
+    EXPECT_FALSE(bridge.completer);
     fit::result<int, const char*> result =
         fit::run_single_threaded(consumer.promise());
     EXPECT_FALSE(consumer);
@@ -417,29 +417,29 @@
     // cancel()
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_TRUE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        bridge.consumer().cancel();
-        EXPECT_FALSE(bridge.consumer());
-        EXPECT_TRUE(bridge.completer().was_canceled());
+        bridge.consumer.cancel();
+        EXPECT_FALSE(bridge.consumer);
+        EXPECT_TRUE(bridge.completer.was_canceled());
 
-        bridge.completer().complete_ok(42);
-        EXPECT_FALSE(bridge.completer());
+        bridge.completer.complete_ok(42);
+        EXPECT_FALSE(bridge.completer);
     }
 
     // consumer is discarded()
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_TRUE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        bridge.consumer() = fit::consumer<int, const char*>();
-        EXPECT_FALSE(bridge.consumer());
-        EXPECT_TRUE(bridge.completer().was_canceled());
+        bridge.consumer = fit::consumer<int, const char*>();
+        EXPECT_FALSE(bridge.consumer);
+        EXPECT_TRUE(bridge.completer.was_canceled());
 
-        bridge.completer().complete_ok(42);
-        EXPECT_FALSE(bridge.completer());
+        bridge.completer.complete_ok(42);
+        EXPECT_FALSE(bridge.completer);
     }
 
     END_TEST;
@@ -451,15 +451,15 @@
     // promise() when completed
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_TRUE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        fit::promise<int, const char*> promise = bridge.consumer().promise();
-        EXPECT_FALSE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        fit::promise<int, const char*> promise = bridge.consumer.promise();
+        EXPECT_FALSE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        bridge.completer().complete_ok(42);
-        EXPECT_FALSE(bridge.completer());
+        bridge.completer.complete_ok(42);
+        EXPECT_FALSE(bridge.completer);
 
         fit::result<int, const char*> result =
             fit::run_single_threaded(std::move(promise));
@@ -470,15 +470,15 @@
     // promise() when abandoned
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_TRUE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        fit::promise<int, const char*> promise = bridge.consumer().promise();
-        EXPECT_FALSE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        fit::promise<int, const char*> promise = bridge.consumer.promise();
+        EXPECT_FALSE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        bridge.completer().abandon();
-        EXPECT_FALSE(bridge.completer());
+        bridge.completer.abandon();
+        EXPECT_FALSE(bridge.completer);
 
         fit::result<int, const char*> result =
             fit::run_single_threaded(std::move(promise));
@@ -488,16 +488,16 @@
     // promise_or() when completed
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_TRUE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        fit::promise<int, const char*> promise = bridge.consumer().promise_or(
+        fit::promise<int, const char*> promise = bridge.consumer.promise_or(
             fit::error("Abandoned"));
-        EXPECT_FALSE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_FALSE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        bridge.completer().complete_ok(42);
-        EXPECT_FALSE(bridge.completer());
+        bridge.completer.complete_ok(42);
+        EXPECT_FALSE(bridge.completer);
 
         fit::result<int, const char*> result =
             fit::run_single_threaded(std::move(promise));
@@ -508,16 +508,16 @@
     // promise_or() when abandoned
     {
         fit::bridge<int, const char*> bridge;
-        EXPECT_TRUE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_TRUE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        fit::promise<int, const char*> promise = bridge.consumer().promise_or(
+        fit::promise<int, const char*> promise = bridge.consumer.promise_or(
             fit::error("Abandoned"));
-        EXPECT_FALSE(bridge.consumer());
-        EXPECT_FALSE(bridge.completer().was_canceled());
+        EXPECT_FALSE(bridge.consumer);
+        EXPECT_FALSE(bridge.completer.was_canceled());
 
-        bridge.completer().abandon();
-        EXPECT_FALSE(bridge.completer());
+        bridge.completer.abandon();
+        EXPECT_FALSE(bridge.completer);
 
         fit::result<int, const char*> result =
             fit::run_single_threaded(std::move(promise));
diff --git a/system/utest/fit/scope_tests.cpp b/system/utest/fit/scope_tests.cpp
index 102decd..aa41cdf 100644
--- a/system/utest/fit/scope_tests.cpp
+++ b/system/utest/fit/scope_tests.cpp
@@ -204,7 +204,7 @@
     for (int i = 0; i < num_threads; i++) {
         fit::bridge bridge;
         threads[i] =
-            std::thread([&, completer = std::move(bridge.completer())]() mutable {
+            std::thread([&, completer = std::move(bridge.completer)]() mutable {
                 for (int j = 0; j < num_tasks_per_thread; j++) {
                     if (j == exit_threshold) {
                         executor.schedule_task(fit::make_promise([&] {
@@ -219,7 +219,7 @@
                 }
                 completer.complete_ok();
             });
-        executor.schedule_task(bridge.consumer().promise());
+        executor.schedule_task(bridge.consumer.promise());
     }
 
     // Run the tasks.
diff --git a/system/utest/fit/sequencer_tests.cpp b/system/utest/fit/sequencer_tests.cpp
index 13161a2..8c83683 100644
--- a/system/utest/fit/sequencer_tests.cpp
+++ b/system/utest/fit/sequencer_tests.cpp
@@ -93,7 +93,7 @@
     for (int i = 0; i < num_threads; i++) {
         fit::bridge bridge;
         threads[i] =
-            std::thread([&, completer = std::move(bridge.completer())]() mutable {
+            std::thread([&, completer = std::move(bridge.completer)]() mutable {
                 for (int j = 0; j < num_tasks_per_thread; j++) {
                     executor.schedule_task(
                         fit::make_promise([&] { run_count++; }).wrap_with(seq));
@@ -101,7 +101,7 @@
                 }
                 completer.complete_ok();
             });
-        executor.schedule_task(bridge.consumer().promise());
+        executor.schedule_task(bridge.consumer.promise());
     }
 
     // Run the tasks.