diff --git a/system/ulib/async-loop/loop.c b/system/ulib/async-loop/loop.c
index fe75712..17433fa 100644
--- a/system/ulib/async-loop/loop.c
+++ b/system/ulib/async-loop/loop.c
@@ -167,11 +167,6 @@
     if (status == ZX_OK)
         status = zx_timer_create(ZX_TIMER_SLACK_LATE, ZX_CLOCK_MONOTONIC, &loop->timer);
     if (status == ZX_OK) {
-        status = zx_object_wait_async(loop->timer, loop->port, KEY_CONTROL,
-                                      ZX_TIMER_SIGNALED,
-                                      ZX_WAIT_ASYNC_REPEATING);
-    }
-    if (status == ZX_OK) {
         *out_loop = loop;
         if (loop->config.make_default_for_current_thread) {
             ZX_DEBUG_ASSERT(async_get_default_dispatcher() == NULL);
@@ -269,7 +264,7 @@
             return ZX_OK;
 
         // Handle task timer expirations.
-        if (packet.type == ZX_PKT_TYPE_SIGNAL_REP &&
+        if (packet.type == ZX_PKT_TYPE_SIGNAL_ONE &&
             packet.signal.observed & ZX_TIMER_SIGNALED) {
             return async_loop_dispatch_tasks(loop);
         }
@@ -731,6 +726,10 @@
 
     zx_status_t status = zx_timer_set(loop->timer, deadline, 0);
     ZX_ASSERT_MSG(status == ZX_OK, "zx_timer_set: status=%d", status);
+    status = zx_object_wait_async(loop->timer, loop->port, KEY_CONTROL,
+                                              ZX_TIMER_SIGNALED,
+                                              ZX_WAIT_ASYNC_ONCE);
+    ZX_ASSERT_MSG(status == ZX_OK, "zx_object_wait_async: status=%d", status);
 }
 
 static void async_loop_invoke_prologue(async_loop_t* loop) {
diff --git a/system/ulib/port/include/port/port.h b/system/ulib/port/include/port/port.h
index 4f700a9..06d7afb 100644
--- a/system/ulib/port/include/port/port.h
+++ b/system/ulib/port/include/port/port.h
@@ -30,10 +30,6 @@
 // the provided port handler.
 zx_status_t port_wait(port_t* port, port_handler_t* ph);
 
-// Wait for an event on a handle, as specified by
-// the provided port handler, in repeating mode.
-zx_status_t port_wait_repeating(port_t* port, port_handler_t* ph);
-
 // Wait for a packet to arrive of for the port to timeout
 // If the port wait returns and error or timeout, returns that.
 // If once is true, returns ZX_OK after handling a packet.
diff --git a/system/ulib/port/port.c b/system/ulib/port/port.c
index 8fdbc3a..cbc5b60 100644
--- a/system/ulib/port/port.c
+++ b/system/ulib/port/port.c
@@ -34,15 +34,6 @@
                                 ph->waitfor, ZX_WAIT_ASYNC_ONCE);
 }
 
-zx_status_t port_wait_repeating(port_t* port, port_handler_t* ph) {
-    zprintf("port_wait_repeating(%p, %p) obj=%x port=%x\n",
-            port, ph, ph->handle, port->handle);
-    return zx_object_wait_async(ph->handle, port->handle,
-                                (uint64_t)(uintptr_t)ph,
-                                ph->waitfor, ZX_WAIT_ASYNC_REPEATING);
-}
-
-
 zx_status_t port_cancel(port_t* port, port_handler_t* ph) {
     zx_status_t r = zx_port_cancel(port->handle, ph->handle,
                                    (uint64_t)(uintptr_t)ph);
diff --git a/system/utest/core/port/ports.cpp b/system/utest/core/port/ports.cpp
index 370ccb3..16f6c2f 100644
--- a/system/utest/core/port/ports.cpp
+++ b/system/utest/core/port/ports.cpp
@@ -200,38 +200,32 @@
 
 static bool async_wait_close_order_1() {
     int order[] = {0, 1, 2};
-    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE) &&
-           async_wait_close_order(order, ZX_WAIT_ASYNC_REPEATING);
+    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE);
 }
 
 static bool async_wait_close_order_2() {
     int order[] = {0, 2, 1};
-    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE) &&
-           async_wait_close_order(order, ZX_WAIT_ASYNC_REPEATING);
+    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE);
 }
 
 static bool async_wait_close_order_3() {
     int order[] = {1, 2, 0};
-    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE) &&
-           async_wait_close_order(order, ZX_WAIT_ASYNC_REPEATING);
+    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE);
 }
 
 static bool async_wait_close_order_4() {
     int order[] = {1, 0, 2};
-    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE) &&
-           async_wait_close_order(order, ZX_WAIT_ASYNC_REPEATING);
+    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE);
 }
 
 static bool async_wait_close_order_5() {
     int order[] = {2, 1, 0};
-    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE) &&
-           async_wait_close_order(order, ZX_WAIT_ASYNC_REPEATING);
+    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE);
 }
 
 static bool async_wait_close_order_6() {
     int order[] = {2, 0, 1};
-    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE) &&
-           async_wait_close_order(order, ZX_WAIT_ASYNC_REPEATING);
+    return async_wait_close_order(order, ZX_WAIT_ASYNC_ONCE);
 }
 
 static bool async_wait_event_test_single(void) {
@@ -294,20 +288,20 @@
 
     const uint64_t key0 = 1122ull;
 
-    status = zx_object_wait_async(ev, port, key0,
-        ZX_EVENT_SIGNALED | ZX_USER_SIGNAL_2, ZX_WAIT_ASYNC_REPEATING);
-    EXPECT_EQ(status, ZX_OK);
-
     zx_port_packet_t out = {};
     uint64_t count[3] = {};
 
     for (int ix = 0; ix != 24; ++ix) {
+        status = zx_object_wait_async(ev, port, key0,
+            ZX_EVENT_SIGNALED | ZX_USER_SIGNAL_2, ZX_WAIT_ASYNC_ONCE);
+        EXPECT_EQ(status, ZX_OK);
+
         uint32_t ub = (ix % 2) ? 0u : ZX_USER_SIGNAL_2;
         EXPECT_EQ(zx_object_signal(ev, 0u, ZX_EVENT_SIGNALED | ub), ZX_OK);
         EXPECT_EQ(zx_object_signal(ev, ZX_EVENT_SIGNALED | ub, 0u), ZX_OK);
 
         ASSERT_EQ(zx_port_wait(port, 0ull, &out), ZX_OK);
-        ASSERT_EQ(out.type, ZX_PKT_TYPE_SIGNAL_REP);
+        ASSERT_EQ(out.type, ZX_PKT_TYPE_SIGNAL_ONE);
         ASSERT_EQ(out.signal.count, 1u);
         count[0] += (out.signal.observed & ZX_EVENT_SIGNALED) ? 1 : 0;
         count[1] += (out.signal.observed & ZX_USER_SIGNAL_2) ? 1 : 0;
@@ -340,7 +334,7 @@
     zx_handle_t event;
     ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);
     const uint64_t kKey = 0;
-    const uint32_t kInvalidOption = ZX_WAIT_ASYNC_REPEATING + 1;
+    const uint32_t kInvalidOption = ZX_WAIT_ASYNC_ONCE + 2;
     EXPECT_EQ(zx_object_wait_async(event, port, kKey, ZX_EVENT_SIGNALED,
                                    kInvalidOption), ZX_ERR_INVALID_ARGS);
     ASSERT_EQ(zx_handle_close(event), ZX_OK);
@@ -348,7 +342,7 @@
     END_TEST;
 }
 
-static bool pre_writes_channel_test(uint32_t mode) {
+static bool channel_pre_writes_test() {
     BEGIN_TEST;
     zx_status_t status;
 
@@ -370,7 +364,7 @@
     EXPECT_EQ(status, ZX_OK);
 
     status = zx_object_wait_async(ch[1], port, key0,
-        ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, mode);
+        ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, ZX_WAIT_ASYNC_ONCE);
     EXPECT_EQ(status, ZX_OK);
 
     zx_port_packet_t out = {};
@@ -382,7 +376,7 @@
         if (status != ZX_OK)
             break;
         wait_count++;
-        if (out.signal.trigger != ZX_CHANNEL_PEER_CLOSED)
+        if (out.signal.observed != ZX_CHANNEL_PEER_CLOSED)
             read_count += out.signal.count;
         EXPECT_NE(out.signal.count, 0u);
     }
@@ -400,15 +394,7 @@
     END_TEST;
 }
 
-static bool channel_pre_writes_once() {
-    return pre_writes_channel_test(ZX_WAIT_ASYNC_ONCE);
-}
-
-static bool channel_pre_writes_repeat() {
-    return pre_writes_channel_test(ZX_WAIT_ASYNC_REPEATING);
-}
-
-static bool cancel_event(uint32_t wait_mode) {
+static bool cancel_event_key() {
     BEGIN_TEST;
     zx_status_t status;
 
@@ -423,7 +409,7 @@
 
     for (uint32_t ix = 0; ix != fbl::count_of(keys); ++ix) {
         EXPECT_EQ(zx_object_wait_async(
-            ev, port, keys[ix], ZX_EVENT_SIGNALED, wait_mode), ZX_OK);
+            ev, port, keys[ix], ZX_EVENT_SIGNALED, ZX_WAIT_ASYNC_ONCE), ZX_OK);
     }
 
     // We cancel before it is signaled so no packets from |13| are seen.
@@ -448,10 +434,8 @@
         EXPECT_EQ(out.signal.observed, ZX_EVENT_SIGNALED);
     }
 
-    if (wait_mode == ZX_WAIT_ASYNC_ONCE) {
-        // We cancel after the packet has been delivered.
-        EXPECT_EQ(zx_port_cancel(port, ev, 128u), ZX_ERR_NOT_FOUND);
-    }
+    // We cancel after the packet has been delivered.
+    EXPECT_EQ(zx_port_cancel(port, ev, 128u), ZX_ERR_NOT_FOUND);
 
     EXPECT_EQ(wait_count, 2);
     EXPECT_EQ(key_sum, keys[0] + keys[2]);
@@ -461,15 +445,7 @@
     END_TEST;
 }
 
-static bool cancel_event_key_once() {
-    return cancel_event(ZX_WAIT_ASYNC_ONCE);
-}
-
-static bool cancel_event_key_repeat() {
-    return cancel_event(ZX_WAIT_ASYNC_REPEATING);
-}
-
-static bool cancel_event_after(uint32_t wait_mode) {
+static bool cancel_event_key_after() {
     BEGIN_TEST;
 
     zx_status_t status;
@@ -484,7 +460,7 @@
 
         EXPECT_EQ(zx_event_create(0u, &ev[ix]), ZX_OK);
         EXPECT_EQ(zx_object_wait_async(
-            ev[ix], port, keys[ix], ZX_EVENT_SIGNALED, wait_mode), ZX_OK);
+            ev[ix], port, keys[ix], ZX_EVENT_SIGNALED, ZX_WAIT_ASYNC_ONCE), ZX_OK);
     }
 
     EXPECT_EQ(zx_object_signal(ev[0], 0u, ZX_EVENT_SIGNALED), ZX_OK);
@@ -520,13 +496,6 @@
     END_TEST;
 }
 
-static bool cancel_event_key_once_after() {
-    return cancel_event_after(ZX_WAIT_ASYNC_ONCE);
-}
-
-static bool cancel_event_key_repeat_after() {
-    return cancel_event_after(ZX_WAIT_ASYNC_REPEATING);
-}
 
 struct test_context {
     zx_handle_t port;
@@ -546,7 +515,7 @@
     return 0;
 }
 
-static bool threads_event(uint32_t wait_mode) {
+static bool threads_event() {
     BEGIN_TEST;
 
     zx_handle_t port;
@@ -563,7 +532,7 @@
         ctx[ix] = { port, 1u };
 
         EXPECT_EQ(zx_object_wait_async(
-                  ev, port, (500u + ix), ZX_EVENT_SIGNALED, wait_mode), ZX_OK);
+                  ev, port, (500u + ix), ZX_EVENT_SIGNALED, ZX_WAIT_ASYNC_ONCE), ZX_OK);
         EXPECT_EQ(thrd_create(&threads[ix], port_reader_thread, &ctx[ix]),
                   thrd_success);
     }
@@ -583,14 +552,6 @@
     END_TEST;
 }
 
-static bool threads_event_once() {
-    return threads_event(ZX_WAIT_ASYNC_ONCE);
-}
-
-static bool threads_event_repeat() {
-    return threads_event(ZX_WAIT_ASYNC_REPEATING);
-}
-
 
 static constexpr uint32_t kStressCount = 20000u;
 static constexpr uint64_t kSleeps[] = { 0, 10, 2, 0, 15, 0};
@@ -691,14 +652,10 @@
 RUN_TEST(async_wait_close_order_4)
 RUN_TEST(async_wait_close_order_5)
 RUN_TEST(async_wait_close_order_6)
-RUN_TEST(channel_pre_writes_once)
-RUN_TEST(channel_pre_writes_repeat)
-RUN_TEST(cancel_event_key_once)
-RUN_TEST(cancel_event_key_repeat)
-RUN_TEST(cancel_event_key_once_after)
-RUN_TEST(cancel_event_key_repeat_after)
-RUN_TEST(threads_event_once)
-RUN_TEST(threads_event_repeat)
+RUN_TEST(channel_pre_writes_test)
+RUN_TEST(cancel_event_key)
+RUN_TEST(cancel_event_key_after)
+RUN_TEST(threads_event)
 RUN_TEST_LARGE(cancel_stress)
 END_TEST_CASE(port_tests)
 
diff --git a/system/utest/core/threads/threads.cpp b/system/utest/core/threads/threads.cpp
index 8f4b23d..10fd889 100644
--- a/system/utest/core/threads/threads.cpp
+++ b/system/utest/core/threads/threads.cpp
@@ -878,7 +878,7 @@
     END_TEST;
 }
 
-static bool port_wait_for_signal_once(zx_handle_t port, zx_handle_t thread,
+static bool port_wait_for_signal(zx_handle_t port, zx_handle_t thread,
                                       zx_time_t deadline, zx_signals_t mask,
                                       zx_port_packet_t* packet) {
     ASSERT_EQ(zx_object_wait_async(thread, port, 0u, mask,
@@ -889,16 +889,8 @@
     return true;
 }
 
-static bool port_wait_for_signal_repeating(zx_handle_t port,
-                                           zx_time_t deadline,
-                                           zx_port_packet_t* packet) {
-    ASSERT_EQ(zx_port_wait(port, deadline, packet), ZX_OK);
-    ASSERT_EQ(packet->type, ZX_PKT_TYPE_SIGNAL_REP);
-    return true;
-}
-
 // Test signal delivery of suspended threads via async wait.
-static bool TestSuspendWaitAsyncSignalDeliveryWorker(bool use_repeating) {
+static bool TestSuspendWaitAsyncSignalDeliveryWorker(void) {
     zx_handle_t event;
     zx_handle_t port;
     zxr_thread_t thread;
@@ -909,35 +901,21 @@
     ASSERT_TRUE(start_thread(threads_test_wait_fn, &event, &thread, &thread_h));
 
     ASSERT_EQ(zx_port_create(0, &port), ZX_OK);
-    if (use_repeating) {
-        ASSERT_EQ(zx_object_wait_async(thread_h, port, 0u, run_susp_mask,
-                                       ZX_WAIT_ASYNC_REPEATING),
-                  ZX_OK);
-    }
 
     zx_port_packet_t packet;
     // There should be a RUNNING signal packet present and not SUSPENDED.
     // This is from when the thread first started to run.
-    if (use_repeating) {
-        ASSERT_TRUE(port_wait_for_signal_repeating(port, 0u, &packet));
-    } else {
-        ASSERT_TRUE(port_wait_for_signal_once(port, thread_h, 0u, run_susp_mask, &packet));
-    }
+    ASSERT_TRUE(port_wait_for_signal(port, thread_h, 0u, run_susp_mask, &packet));
     ASSERT_EQ(packet.signal.observed & run_susp_mask, ZX_THREAD_RUNNING);
 
     // Make sure there are no more packets.
-    if (use_repeating) {
-        ASSERT_EQ(zx_port_wait(port, 0u, &packet), ZX_ERR_TIMED_OUT);
-    } else {
-        // In the non-repeating case we have to do things differently as one of
-        // RUNNING or SUSPENDED is always asserted.
-        ASSERT_EQ(zx_object_wait_async(thread_h, port, 0u,
-                                       ZX_THREAD_SUSPENDED,
-                                       ZX_WAIT_ASYNC_ONCE),
-                  ZX_OK);
-        ASSERT_EQ(zx_port_wait(port, 0u, &packet), ZX_ERR_TIMED_OUT);
-        ASSERT_EQ(zx_port_cancel(port, thread_h, 0u), ZX_OK);
-    }
+    // RUNNING or SUSPENDED is always asserted.
+    ASSERT_EQ(zx_object_wait_async(thread_h, port, 0u,
+                                   ZX_THREAD_SUSPENDED,
+                                   ZX_WAIT_ASYNC_ONCE),
+              ZX_OK);
+    ASSERT_EQ(zx_port_wait(port, 0u, &packet), ZX_ERR_TIMED_OUT);
+    ASSERT_EQ(zx_port_cancel(port, thread_h, 0u), ZX_OK);
 
     zx_handle_t suspend_token = ZX_HANDLE_INVALID;
     ASSERT_TRUE(suspend_thread_synchronous(thread_h, &suspend_token));
@@ -954,21 +932,11 @@
     ASSERT_TRUE(info.state == ZX_THREAD_STATE_RUNNING ||
                     info.state == ZX_THREAD_STATE_BLOCKED_WAIT_ONE);
 
-    // For repeating async waits we should see both SUSPENDED and RUNNING on
-    // the port. And we should see them at the same time (and not one followed
-    // by the other).
-    if (use_repeating) {
-        ASSERT_TRUE(port_wait_for_signal_repeating(port,
-                                                   zx_deadline_after(ZX_MSEC(100)),
-                                                   &packet));
-        ASSERT_EQ(packet.signal.observed & run_susp_mask, run_susp_mask);
-    } else {
-        // For non-repeating async waits we should see just RUNNING,
-        // and it should be immediately present (no deadline).
-        ASSERT_TRUE(port_wait_for_signal_once(port, thread_h, 0u, run_susp_mask,
-                                              &packet));
-        ASSERT_EQ(packet.signal.observed & run_susp_mask, ZX_THREAD_RUNNING);
-    }
+    // We should see just RUNNING,
+    // and it should be immediately present (no deadline).
+    ASSERT_TRUE(port_wait_for_signal(port, thread_h, 0u, run_susp_mask,
+                                          &packet));
+    ASSERT_EQ(packet.signal.observed & run_susp_mask, ZX_THREAD_RUNNING);
 
     // The thread should still be blocked on the event when it wakes up.
     ASSERT_TRUE(wait_thread_blocked(thread_h, ZX_THREAD_STATE_BLOCKED_WAIT_ONE));
@@ -977,29 +945,17 @@
     // the expected behavior and is visible via async wait.
     suspend_token = ZX_HANDLE_INVALID;
     ASSERT_EQ(zx_task_suspend_token(thread_h, &suspend_token), ZX_OK);
-    if (use_repeating) {
-        ASSERT_TRUE(port_wait_for_signal_repeating(port,
-                                                   zx_deadline_after(ZX_MSEC(100)),
-                                                   &packet));
-    } else {
-        ASSERT_TRUE(port_wait_for_signal_once(port, thread_h,
-                                              zx_deadline_after(ZX_MSEC(100)),
-                                              ZX_THREAD_SUSPENDED, &packet));
-    }
+    ASSERT_TRUE(port_wait_for_signal(port, thread_h,
+                                     zx_deadline_after(ZX_MSEC(100)),
+                                     ZX_THREAD_SUSPENDED, &packet));
     ASSERT_EQ(packet.signal.observed & run_susp_mask, ZX_THREAD_SUSPENDED);
 
     ASSERT_TRUE(get_thread_info(thread_h, &info));
     ASSERT_EQ(info.state, ZX_THREAD_STATE_SUSPENDED);
     ASSERT_EQ(zx_handle_close(suspend_token), ZX_OK);
-    if (use_repeating) {
-        ASSERT_TRUE(port_wait_for_signal_repeating(port,
-                                                   zx_deadline_after(ZX_MSEC(100)),
-                                                   &packet));
-    } else {
-        ASSERT_TRUE(port_wait_for_signal_once(port, thread_h,
-                                              zx_deadline_after(ZX_MSEC(100)),
-                                              ZX_THREAD_RUNNING, &packet));
-    }
+    ASSERT_TRUE(port_wait_for_signal(port, thread_h,
+                                     zx_deadline_after(ZX_MSEC(100)),
+                                     ZX_THREAD_RUNNING, &packet));
     ASSERT_EQ(packet.signal.observed & run_susp_mask, ZX_THREAD_RUNNING);
 
     // Resumption from being suspended back into a blocking syscall will be
@@ -1023,14 +979,14 @@
 // Test signal delivery of suspended threads via single async wait.
 static bool TestSuspendSingleWaitAsyncSignalDelivery() {
     BEGIN_TEST;
-    EXPECT_TRUE(TestSuspendWaitAsyncSignalDeliveryWorker(false));
+    EXPECT_TRUE(TestSuspendWaitAsyncSignalDeliveryWorker());
     END_TEST;
 }
 
 // Test signal delivery of suspended threads via repeating async wait.
 static bool TestSuspendRepeatingWaitAsyncSignalDelivery() {
     BEGIN_TEST;
-    EXPECT_TRUE(TestSuspendWaitAsyncSignalDeliveryWorker(true));
+    EXPECT_TRUE(TestSuspendWaitAsyncSignalDeliveryWorker());
     END_TEST;
 }