diff --git a/Sources/AblyChat/Errors.swift b/Sources/AblyChat/Errors.swift
index d4d153c8..2ae459b8 100644
--- a/Sources/AblyChat/Errors.swift
+++ b/Sources/AblyChat/Errors.swift
@@ -11,6 +11,8 @@ public let errorDomain = "AblyChatErrorDomain"
  The error codes for errors in the ``errorDomain`` error domain.
  */
 public enum ErrorCode: Int {
+    case nonspecific = 40000
+
     /// ``Rooms.get(roomID:options:)`` was called with a different set of room options than was used on a previous call. You must first release the existing room instance using ``Rooms.release(roomID:)``.
     ///
     /// TODO this code is a guess, revisit in https://github.com/ably-labs/ably-chat-swift/issues/32
@@ -36,7 +38,8 @@ public enum ErrorCode: Int {
     internal var statusCode: Int {
         // TODO: These are currently a guess, revisit once outstanding spec question re status codes is answered (https://github.com/ably/specification/pull/200#discussion_r1755222945), and also revisit in https://github.com/ably-labs/ably-chat-swift/issues/32
         switch self {
-        case .inconsistentRoomOptions,
+        case .nonspecific,
+             .inconsistentRoomOptions,
              .messagesDetachmentFailed,
              .presenceDetachmentFailed,
              .reactionsDetachmentFailed,
@@ -69,6 +72,8 @@ internal enum ChatError {
     case roomInFailedState
     case roomIsReleasing
     case roomIsReleased
+    case presenceOperationRequiresRoomAttach(feature: RoomFeature)
+    case presenceOperationDisallowedForCurrentRoomStatus(feature: RoomFeature)
 
     /// The ``ARTErrorInfo.code`` that should be returned for this error.
     internal var code: ErrorCode {
@@ -107,20 +112,14 @@ internal enum ChatError {
             .roomIsReleasing
         case .roomIsReleased:
             .roomIsReleased
+        case .presenceOperationRequiresRoomAttach,
+             .presenceOperationDisallowedForCurrentRoomStatus:
+            .nonspecific
         }
     }
 
-    /// A helper type for parameterising the construction of error messages.
-    private enum AttachOrDetach {
-        case attach
-        case detach
-    }
-
-    private static func localizedDescription(
-        forFailureOfOperation operation: AttachOrDetach,
-        feature: RoomFeature
-    ) -> String {
-        let featureDescription = switch feature {
+    private static func descriptionOfFeature(_ feature: RoomFeature) -> String {
+        switch feature {
         case .messages:
             "messages"
         case .occupancy:
@@ -132,7 +131,18 @@ internal enum ChatError {
         case .typing:
             "typing"
         }
+    }
+
+    /// A helper type for parameterising the construction of error messages.
+    private enum AttachOrDetach {
+        case attach
+        case detach
+    }
 
+    private static func localizedDescription(
+        forFailureOfOperation operation: AttachOrDetach,
+        feature: RoomFeature
+    ) -> String {
         let operationDescription = switch operation {
         case .attach:
             "attach"
@@ -140,7 +150,7 @@ internal enum ChatError {
             "detach"
         }
 
-        return "The \(featureDescription) feature failed to \(operationDescription)."
+        return "The \(descriptionOfFeature(feature)) feature failed to \(operationDescription)."
     }
 
     /// The ``ARTErrorInfo.localizedDescription`` that should be returned for this error.
@@ -158,6 +168,10 @@ internal enum ChatError {
             "Cannot perform operation because the room is in a releasing state."
         case .roomIsReleased:
             "Cannot perform operation because the room is in a released state."
+        case let .presenceOperationRequiresRoomAttach(feature):
+            "To perform this \(Self.descriptionOfFeature(feature)) operation, you must first attach the room."
+        case let .presenceOperationDisallowedForCurrentRoomStatus(feature):
+            "This \(Self.descriptionOfFeature(feature)) operation can not be performed given the current room status."
         }
     }
 
@@ -171,7 +185,9 @@ internal enum ChatError {
         case .inconsistentRoomOptions,
              .roomInFailedState,
              .roomIsReleasing,
-             .roomIsReleased:
+             .roomIsReleased,
+             .presenceOperationRequiresRoomAttach,
+             .presenceOperationDisallowedForCurrentRoomStatus:
             nil
         }
     }
diff --git a/Sources/AblyChat/Room.swift b/Sources/AblyChat/Room.swift
index 99653346..4c2bf869 100644
--- a/Sources/AblyChat/Room.swift
+++ b/Sources/AblyChat/Room.swift
@@ -82,15 +82,17 @@ internal actor DefaultRoom<LifecycleManagerFactory: RoomLifecycleManagerFactory>
             throw ARTErrorInfo.create(withCode: 40000, message: "Ensure your Realtime instance is initialized with a clientId.")
         }
 
-        let featureChannels = Self.createFeatureChannels(roomID: roomID, realtime: realtime)
-        channels = featureChannels.mapValues(\.channel)
-        let contributors = featureChannels.values.map(\.contributor)
+        let featureChannelPartialDependencies = Self.createFeatureChannelPartialDependencies(roomID: roomID, realtime: realtime)
+        channels = featureChannelPartialDependencies.mapValues(\.channel)
+        let contributors = featureChannelPartialDependencies.values.map(\.contributor)
 
         lifecycleManager = await lifecycleManagerFactory.createManager(
             contributors: contributors,
             logger: logger
         )
 
+        let featureChannels = Self.createFeatureChannels(partialDependencies: featureChannelPartialDependencies, lifecycleManager: lifecycleManager)
+
         // TODO: Address force unwrapping of `channels` within feature initialisation below: https://github.com/ably-labs/ably-chat-swift/issues/105
 
         messages = await DefaultMessages(
@@ -108,7 +110,12 @@ internal actor DefaultRoom<LifecycleManagerFactory: RoomLifecycleManagerFactory>
         ) : nil
     }
 
-    private static func createFeatureChannels(roomID: String, realtime: RealtimeClient) -> [RoomFeature: DefaultFeatureChannel] {
+    private struct FeatureChannelPartialDependencies {
+        internal var channel: RealtimeChannelProtocol
+        internal var contributor: DefaultRoomLifecycleContributor
+    }
+
+    private static func createFeatureChannelPartialDependencies(roomID: String, realtime: RealtimeClient) -> [RoomFeature: FeatureChannelPartialDependencies] {
         .init(uniqueKeysWithValues: [RoomFeature.messages, RoomFeature.reactions].map { feature in
             let channel = realtime.getChannel(feature.channelNameForRoomID(roomID))
             let contributor = DefaultRoomLifecycleContributor(channel: .init(underlyingChannel: channel), feature: feature)
@@ -117,6 +124,16 @@ internal actor DefaultRoom<LifecycleManagerFactory: RoomLifecycleManagerFactory>
         })
     }
 
+    private static func createFeatureChannels(partialDependencies: [RoomFeature: FeatureChannelPartialDependencies], lifecycleManager: RoomLifecycleManager) -> [RoomFeature: DefaultFeatureChannel] {
+        partialDependencies.mapValues { partialDependencies in
+            .init(
+                channel: partialDependencies.channel,
+                contributor: partialDependencies.contributor,
+                roomLifecycleManager: lifecycleManager
+            )
+        }
+    }
+
     public nonisolated var presence: any Presence {
         fatalError("Not yet implemented")
     }
diff --git a/Sources/AblyChat/RoomFeature.swift b/Sources/AblyChat/RoomFeature.swift
index d630c3e2..42cf71b7 100644
--- a/Sources/AblyChat/RoomFeature.swift
+++ b/Sources/AblyChat/RoomFeature.swift
@@ -29,19 +29,38 @@ internal enum RoomFeature {
 
 /// Provides all of the channel-related functionality that a room feature (e.g. an implementation of ``Messages``) needs.
 ///
-/// This mishmash exists to give a room feature access to both:
+/// This mishmash exists to give a room feature access to:
 ///
 /// - a `RealtimeChannelProtocol` object (this is the interface that our features are currently written against, as opposed to, say, `RoomLifecycleContributorChannel`)
 /// - the discontinuities emitted by the room lifecycle
+/// - the presence-readiness wait mechanism supplied by the room lifecycle
 internal protocol FeatureChannel: Sendable, EmitsDiscontinuities {
     var channel: RealtimeChannelProtocol { get }
+
+    /// Waits until we can perform presence operations on the contributors of this room without triggering an implicit attach.
+    ///
+    /// Implements the checks described by CHA-PR3d, CHA-PR3e, CHA-PR3f, and CHA-PR3g (and similar ones described by other functionality that performs contributor presence operations). Namely:
+    ///
+    /// - CHA-PR3d, CHA-PR10d, CHA-PR6c, CHA-T2c: If the room is in the ATTACHING status, it waits for the current ATTACH to complete and then returns. If the current ATTACH fails, then it re-throws that operation’s error.
+    /// - CHA-PR3e, CHA-PR11e, CHA-PR6d, CHA-T2d: If the room is in the ATTACHED status, it returns immediately.
+    /// - CHA-PR3f, CHA-PR11f, CHA-PR6e, CHA-T2e: If the room is in the DETACHED status, it throws an `ARTErrorInfo` derived from ``ChatError.presenceOperationRequiresRoomAttach(feature:)``.
+    /// - // CHA-PR3g, CHA-PR11g, CHA-PR6f, CHA-T2f: If the room is in any other status, it throws an `ARTErrorInfo` derived from ``ChatError.presenceOperationDisallowedForCurrentRoomStatus(feature:)``.
+    ///
+    /// - Parameters:
+    ///   - requester: The room feature that wishes to perform a presence operation. This is only used for customising the message of the thrown error.
+    func waitToBeAbleToPerformPresenceOperations(requestedByFeature requester: RoomFeature) async throws(ARTErrorInfo)
 }
 
 internal struct DefaultFeatureChannel: FeatureChannel {
     internal var channel: RealtimeChannelProtocol
     internal var contributor: DefaultRoomLifecycleContributor
+    internal var roomLifecycleManager: RoomLifecycleManager
 
     internal func subscribeToDiscontinuities() async -> Subscription<ARTErrorInfo> {
         await contributor.subscribeToDiscontinuities()
     }
+
+    internal func waitToBeAbleToPerformPresenceOperations(requestedByFeature requester: RoomFeature) async throws(ARTErrorInfo) {
+        try await roomLifecycleManager.waitToBeAbleToPerformPresenceOperations(requestedByFeature: requester)
+    }
 }
diff --git a/Sources/AblyChat/RoomLifecycleManager.swift b/Sources/AblyChat/RoomLifecycleManager.swift
index 433456fd..dcdc7aad 100644
--- a/Sources/AblyChat/RoomLifecycleManager.swift
+++ b/Sources/AblyChat/RoomLifecycleManager.swift
@@ -46,6 +46,7 @@ internal protocol RoomLifecycleManager: Sendable {
     func performReleaseOperation() async
     var roomStatus: RoomStatus { get async }
     func onChange(bufferingPolicy: BufferingPolicy) async -> Subscription<RoomStatusChange>
+    func waitToBeAbleToPerformPresenceOperations(requestedByFeature requester: RoomFeature) async throws(ARTErrorInfo)
 }
 
 internal protocol RoomLifecycleManagerFactory: Sendable {
@@ -556,7 +557,7 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
         /// The manager emits an `OperationWaitEvent` each time one room lifecycle operation is going to wait for another to complete. These events are emitted to support testing of the manager; see ``testsOnly_subscribeToOperationWaitEvents``.
         internal struct OperationWaitEvent: Equatable {
             /// The ID of the operation which initiated the wait. It is waiting for the operation with ID ``waitedOperationID`` to complete.
-            internal var waitingOperationID: UUID
+            internal var waitingOperationID: UUID?
             /// The ID of the operation whose completion will be awaited.
             internal var waitedOperationID: UUID
         }
@@ -573,6 +574,29 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
         }
     #endif
 
+    private enum OperationWaitRequester {
+        case anotherOperation(operationID: UUID)
+        case waitToBeAbleToPerformPresenceOperations
+
+        internal var loggingDescription: String {
+            switch self {
+            case let .anotherOperation(operationID):
+                "Operation \(operationID)"
+            case .waitToBeAbleToPerformPresenceOperations:
+                "waitToBeAbleToPerformPresenceOperations"
+            }
+        }
+
+        internal var waitingOperationID: UUID? {
+            switch self {
+            case let .anotherOperation(operationID):
+                operationID
+            case .waitToBeAbleToPerformPresenceOperations:
+                nil
+            }
+        }
+    }
+
     /// Waits for the operation with ID `waitedOperationID` to complete, re-throwing any error thrown by that operation.
     ///
     /// Note that this method currently treats all waited operations as throwing. If you wish to wait for an operation that you _know_ to be non-throwing (which the RELEASE operation currently is) then you’ll need to call this method with `try!` or equivalent. (It might be possible to improve this in the future, but I didn’t want to put much time into figuring it out.)
@@ -581,12 +605,12 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
     ///
     /// - Parameters:
     ///   - waitedOperationID: The ID of the operation whose completion will be awaited.
-    ///   - waitingOperationID: The ID of the operation which is awaiting this result. Only used for logging.
+    ///   - requester: A description of who is awaiting this result. Only used for logging.
     private func waitForCompletionOfOperationWithID(
         _ waitedOperationID: UUID,
-        waitingOperationID: UUID
+        requester: OperationWaitRequester
     ) async throws(ARTErrorInfo) {
-        logger.log(message: "Operation \(waitingOperationID) started waiting for result of operation \(waitedOperationID)", level: .debug)
+        logger.log(message: "\(requester.loggingDescription) started waiting for result of operation \(waitedOperationID)", level: .debug)
 
         do {
             let result = await withCheckedContinuation { (continuation: OperationResultContinuations.Continuation) in
@@ -594,7 +618,7 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
                 operationResultContinuations.addContinuation(continuation, forResultOfOperationWithID: waitedOperationID)
 
                 #if DEBUG
-                    let operationWaitEvent = OperationWaitEvent(waitingOperationID: waitingOperationID, waitedOperationID: waitedOperationID)
+                    let operationWaitEvent = OperationWaitEvent(waitingOperationID: requester.waitingOperationID, waitedOperationID: waitedOperationID)
                     for subscription in operationWaitEventSubscriptions {
                         subscription.emit(operationWaitEvent)
                     }
@@ -603,9 +627,9 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
 
             try result.get()
 
-            logger.log(message: "Operation \(waitingOperationID) completed waiting for result of operation \(waitedOperationID), which completed successfully", level: .debug)
+            logger.log(message: "\(requester.loggingDescription) completed waiting for result of operation \(waitedOperationID), which completed successfully", level: .debug)
         } catch {
-            logger.log(message: "Operation \(waitingOperationID) completed waiting for result of operation \(waitedOperationID), which threw error \(error)", level: .debug)
+            logger.log(message: "\(requester.loggingDescription) completed waiting for result of operation \(waitedOperationID), which threw error \(error)", level: .debug)
             throw error
         }
     }
@@ -686,7 +710,7 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
 
         // CHA-RL1d
         if let currentOperationID = status.operationID {
-            try? await waitForCompletionOfOperationWithID(currentOperationID, waitingOperationID: operationID)
+            try? await waitForCompletionOfOperationWithID(currentOperationID, requester: .anotherOperation(operationID: operationID))
         }
 
         // CHA-RL1e
@@ -903,7 +927,7 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
             // CHA-RL3c
             // See note on waitForCompletionOfOperationWithID for the current need for this force try
             // swiftlint:disable:next force_try
-            return try! await waitForCompletionOfOperationWithID(releaseOperationID, waitingOperationID: operationID)
+            return try! await waitForCompletionOfOperationWithID(releaseOperationID, requester: .anotherOperation(operationID: operationID))
         case .initialized, .attached, .attachingDueToAttachOperation, .attachingDueToContributorStateChange, .detaching, .suspended, .failed:
             break
         }
@@ -942,4 +966,31 @@ internal actor DefaultRoomLifecycleManager<Contributor: RoomLifecycleContributor
         // CHA-RL3g
         changeStatus(to: .released)
     }
+
+    // MARK: - Waiting to be able to perform presence operations
+
+    internal func waitToBeAbleToPerformPresenceOperations(requestedByFeature requester: RoomFeature) async throws(ARTErrorInfo) {
+        switch status {
+        case let .attachingDueToAttachOperation(attachOperationID):
+            // CHA-PR3d, CHA-PR10d, CHA-PR6c, CHA-T2c
+            try await waitForCompletionOfOperationWithID(attachOperationID, requester: .waitToBeAbleToPerformPresenceOperations)
+        case .attachingDueToContributorStateChange:
+            // TODO: Spec doesn’t say what to do in this situation; asked in https://github.com/ably/specification/issues/228
+            fatalError("waitToBeAbleToPerformPresenceOperations doesn’t currently handle attachingDueToContributorStateChange")
+        case .attached:
+            // CHA-PR3e, CHA-PR11e, CHA-PR6d, CHA-T2d
+            break
+        case .detached:
+            // CHA-PR3f, CHA-PR11f, CHA-PR6e, CHA-T2e
+            throw .init(chatError: .presenceOperationRequiresRoomAttach(feature: requester))
+        case .detaching,
+             .failed,
+             .initialized,
+             .released,
+             .releasing,
+             .suspended:
+            // CHA-PR3g, CHA-PR11g, CHA-PR6f, CHA-T2f
+            throw .init(chatError: .presenceOperationDisallowedForCurrentRoomStatus(feature: requester))
+        }
+    }
 }
diff --git a/Tests/AblyChatTests/DefaultRoomLifecycleManagerTests.swift b/Tests/AblyChatTests/DefaultRoomLifecycleManagerTests.swift
index 6eeb654e..8677215a 100644
--- a/Tests/AblyChatTests/DefaultRoomLifecycleManagerTests.swift
+++ b/Tests/AblyChatTests/DefaultRoomLifecycleManagerTests.swift
@@ -1363,4 +1363,156 @@ struct DefaultRoomLifecycleManagerTests {
 
         #expect(await !manager.testsOnly_hasTransientDisconnectTimeoutForAnyContributor)
     }
+
+    // MARK: - Waiting to be able to perform presence operations
+
+    // @specPartial CHA-PR3d - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR10d - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR6c - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-T2c - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    @Test
+    func waitToBeAbleToPerformPresenceOperations_whenAttaching_whenAttachSucceeds() async throws {
+        // Given: A DefaultRoomLifecycleManager, with an ATTACH operation in progress and hence in the ATTACHING status
+        let contributorAttachOperation = SignallableChannelOperation()
+
+        let contributor = createContributor(attachBehavior: contributorAttachOperation.behavior)
+
+        let manager = await createManager(
+            contributors: [contributor]
+        )
+
+        let roomStatusSubscription = await manager.onChange(bufferingPolicy: .unbounded)
+
+        let attachOperationID = UUID()
+        async let _ = manager.performAttachOperation(testsOnly_forcingOperationID: attachOperationID)
+
+        // Wait for room to become ATTACHING
+        _ = await roomStatusSubscription.attachingElements().first { _ in true }
+
+        // When: `waitToBeAbleToPerformPresenceOperations(requestedByFeature:)` is called on the lifecycle manager
+        let operationWaitSubscription = await manager.testsOnly_subscribeToOperationWaitEvents()
+        async let waitToBeAbleToPerformPresenceOperationsResult: Void = manager.waitToBeAbleToPerformPresenceOperations(requestedByFeature: .messages /* arbitrary */ )
+
+        // Then: The manager waits for the ATTACH operation to complete
+        let operationWaitEvent = try #require(await operationWaitSubscription.first { _ in true })
+        #expect(operationWaitEvent.waitedOperationID == attachOperationID)
+
+        // and When: The ATTACH operation succeeds
+        contributorAttachOperation.complete(behavior: .success)
+
+        // Then: The call to `waitToBeAbleToPerformPresenceOperations(requestedByFeature:)` succeeds
+        try await waitToBeAbleToPerformPresenceOperationsResult
+    }
+
+    // @specPartial CHA-PR3d - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR10d - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR6c - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-T2c - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    @Test
+    func waitToBeAbleToPerformPresenceOperations_whenAttaching_whenAttachFails() async throws {
+        // Given: A DefaultRoomLifecycleManager, with an ATTACH operation in progress and hence in the ATTACHING status
+        let contributorAttachOperation = SignallableChannelOperation()
+
+        let contributor = createContributor(attachBehavior: contributorAttachOperation.behavior)
+
+        let manager = await createManager(
+            contributors: [contributor]
+        )
+
+        let roomStatusSubscription = await manager.onChange(bufferingPolicy: .unbounded)
+
+        let attachOperationID = UUID()
+        async let _ = manager.performAttachOperation(testsOnly_forcingOperationID: attachOperationID)
+
+        // Wait for room to become ATTACHING
+        _ = await roomStatusSubscription.attachingElements().first { _ in true }
+
+        // When: `waitToBeAbleToPerformPresenceOperations(requestedByFeature:)` is called on the lifecycle manager
+        let operationWaitSubscription = await manager.testsOnly_subscribeToOperationWaitEvents()
+        async let waitToBeAbleToPerformPresenceOperationsResult: Void = manager.waitToBeAbleToPerformPresenceOperations(requestedByFeature: .messages /* arbitrary */ )
+
+        // Then: The manager waits for the ATTACH operation to complete
+        let operationWaitEvent = try #require(await operationWaitSubscription.first { _ in true })
+        #expect(operationWaitEvent.waitedOperationID == attachOperationID)
+
+        // and When: The ATTACH operation fails
+        let contributorAttachError = ARTErrorInfo.createUnknownError() // arbitrary
+        contributorAttachOperation.complete(behavior: .completeAndChangeState(.failure(contributorAttachError), newState: .failed))
+
+        // Then: The call to `waitToBeAbleToPerformPresenceOperations(requestedByFeature:)` fails with the same error
+        var caughtError: Error?
+        do {
+            try await waitToBeAbleToPerformPresenceOperationsResult
+        } catch {
+            caughtError = error
+        }
+
+        #expect(isChatError(caughtError, withCode: .messagesAttachmentFailed, cause: contributorAttachError))
+    }
+
+    // @specPartial CHA-PR3e - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR10e - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR6d - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-T2d - Tests the wait described in the spec point, but not that the feature actually performs this wait nor the side effect. TODO change this to a specOneOf once the feature is implemented
+    @Test
+    func waitToBeAbleToPerformPresenceOperations_whenAttached() async throws {
+        // Given: A DefaultRoomLifecycleManager in the ATTACHED status
+        let manager = await createManager(
+            forTestingWhatHappensWhenCurrentlyIn: .attached
+        )
+
+        // When: `waitToBeAbleToPerformPresenceOperations(requestedByFeature:)` is called on the lifecycle manager
+        // Then: It returns
+        try await manager.waitToBeAbleToPerformPresenceOperations(requestedByFeature: .messages /* arbitrary */ )
+    }
+
+    // @specPartial CHA-PR3f - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR10f - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR6e - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-T2e - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    @Test
+    func waitToBeAbleToPerformPresenceOperations_whenDetached() async throws {
+        // Given: A DefaultRoomLifecycleManager in the DETACHED status
+        let manager = await createManager(
+            forTestingWhatHappensWhenCurrentlyIn: .detached
+        )
+
+        // (Note: I wanted to use #expect(…, throws:) below, but for some reason it made the compiler _crash_! No idea why. So, gave up on that.)
+
+        // When: `waitToBeAbleToPerformPresenceOperations(requestedByFeature:)` is called on the lifecycle manager
+        var caughtError: ARTErrorInfo?
+        do {
+            try await manager.waitToBeAbleToPerformPresenceOperations(requestedByFeature: .messages /* arbitrary */ )
+        } catch {
+            caughtError = error
+        }
+
+        // Then: It throws a presenceOperationRequiresRoomAttach error for that feature (which we just check via its error code, i.e. `.nonspecific`, and its message)
+        #expect(isChatError(caughtError, withCode: .nonspecific, message: "To perform this messages operation, you must first attach the room."))
+    }
+
+    // @specPartial CHA-PR3f - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR10f - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-PR6e - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    // @specPartial CHA-T2e - Tests the wait described in the spec point, but not that the feature actually performs this wait. TODO change this to a specOneOf once the feature is implemented
+    @Test
+    func waitToBeAbleToPerformPresenceOperations_whenAnyOtherStatus() async throws {
+        // Given: A DefaultRoomLifecycleManager in a status other than ATTACHING, ATTACHED or DETACHED
+        let manager = await createManager(
+            forTestingWhatHappensWhenCurrentlyIn: .detaching(detachOperationID: .init()) // arbitrary given the above constraints
+        )
+
+        // (Note: I wanted to use #expect(…, throws:) below, but for some reason it made the compiler _crash_! No idea why. So, gave up on that.)
+
+        // When: `waitToBeAbleToPerformPresenceOperations(requestedByFeature:)` is called on the lifecycle manager
+        var caughtError: ARTErrorInfo?
+        do {
+            try await manager.waitToBeAbleToPerformPresenceOperations(requestedByFeature: .messages /* arbitrary */ )
+        } catch {
+            caughtError = error
+        }
+
+        // Then: It throws a presenceOperationDisallowedForCurrentRoomStatus error for that feature (which we just check via its error code, i.e. `.nonspecific`, and its message)
+        #expect(isChatError(caughtError, withCode: .nonspecific, message: "This messages operation can not be performed given the current room status."))
+    }
 }
diff --git a/Tests/AblyChatTests/Helpers/Helpers.swift b/Tests/AblyChatTests/Helpers/Helpers.swift
index aca7489b..1d0fc482 100644
--- a/Tests/AblyChatTests/Helpers/Helpers.swift
+++ b/Tests/AblyChatTests/Helpers/Helpers.swift
@@ -2,9 +2,9 @@ import Ably
 @testable import AblyChat
 
 /**
- Tests whether a given optional `Error` is an `ARTErrorInfo` in the chat error domain with a given code and cause.
+ Tests whether a given optional `Error` is an `ARTErrorInfo` in the chat error domain with a given code and cause. Can optionally pass a message and it will check that it matches.
  */
-func isChatError(_ maybeError: (any Error)?, withCode code: AblyChat.ErrorCode, cause: ARTErrorInfo? = nil) -> Bool {
+func isChatError(_ maybeError: (any Error)?, withCode code: AblyChat.ErrorCode, cause: ARTErrorInfo? = nil, message: String? = nil) -> Bool {
     guard let ablyError = maybeError as? ARTErrorInfo else {
         return false
     }
@@ -13,4 +13,11 @@ func isChatError(_ maybeError: (any Error)?, withCode code: AblyChat.ErrorCode,
         && ablyError.code == code.rawValue
         && ablyError.statusCode == code.statusCode
         && ablyError.cause == cause
+        && {
+            guard let message else {
+                return true
+            }
+
+            return ablyError.message == message
+        }()
 }
diff --git a/Tests/AblyChatTests/Mocks/MockFeatureChannel.swift b/Tests/AblyChatTests/Mocks/MockFeatureChannel.swift
index 41759530..2b12b92f 100644
--- a/Tests/AblyChatTests/Mocks/MockFeatureChannel.swift
+++ b/Tests/AblyChatTests/Mocks/MockFeatureChannel.swift
@@ -5,9 +5,14 @@ final actor MockFeatureChannel: FeatureChannel {
     let channel: RealtimeChannelProtocol
     // TODO: clean up old subscriptions (https://github.com/ably-labs/ably-chat-swift/issues/36)
     private var discontinuitySubscriptions: [Subscription<ARTErrorInfo>] = []
+    private let resultOfWaitToBeAbleToPerformPresenceOperations: Result<Void, ARTErrorInfo>?
 
-    init(channel: RealtimeChannelProtocol) {
+    init(
+        channel: RealtimeChannelProtocol,
+        resultOfWaitToBeAblePerformPresenceOperations: Result<Void, ARTErrorInfo>? = nil
+    ) {
         self.channel = channel
+        resultOfWaitToBeAbleToPerformPresenceOperations = resultOfWaitToBeAblePerformPresenceOperations
     }
 
     func subscribeToDiscontinuities() async -> Subscription<ARTErrorInfo> {
@@ -21,4 +26,12 @@ final actor MockFeatureChannel: FeatureChannel {
             subscription.emit(discontinuity)
         }
     }
+
+    func waitToBeAbleToPerformPresenceOperations(requestedByFeature _: RoomFeature) async throws(ARTErrorInfo) {
+        guard let resultOfWaitToBeAbleToPerformPresenceOperations else {
+            fatalError("resultOfWaitToBeAblePerformPresenceOperations must be set before waitToBeAbleToPerformPresenceOperations is called")
+        }
+
+        try resultOfWaitToBeAbleToPerformPresenceOperations.get()
+    }
 }
diff --git a/Tests/AblyChatTests/Mocks/MockRoomLifecycleManager.swift b/Tests/AblyChatTests/Mocks/MockRoomLifecycleManager.swift
index ad1e004f..2cd797a7 100644
--- a/Tests/AblyChatTests/Mocks/MockRoomLifecycleManager.swift
+++ b/Tests/AblyChatTests/Mocks/MockRoomLifecycleManager.swift
@@ -55,4 +55,8 @@ actor MockRoomLifecycleManager: RoomLifecycleManager {
             subscription.emit(statusChange)
         }
     }
+
+    func waitToBeAbleToPerformPresenceOperations(requestedByFeature _: RoomFeature) async throws(ARTErrorInfo) {
+        fatalError("Not implemented")
+    }
 }