Bump protocol version to 6

Implements the ObjectOperation field changes specified in spec commit
47a9d51. Integration test updates ported from JS commit fdc33cb
(excluding the public API changes, since we don't yet expose any sort of
ObjectOperation, nor does the spec).

Note that this is the first time that we've had to bump the protocol
version in a way that affects LiveObjects, and here we're following the
process documented in the pinned plugin-support commit.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: lawrence-forooghian

AblyLiveObjects.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -20,13 +20,13 @@ let package = Package(
     dependencies: [
         // TODO: Unpin before release
         .package(
-            url: "https://github.com/ably/ably-cocoa.git",
-            revision: "dbdd4db5c0c64f4330e200ff2ca9bc9528598ff3",
+            url: "https://github.com/ably/ably-cocoa",
+            revision: "154b6cd",
         ),
         // TODO: Unpin before release
         .package(
             url: "https://github.com/ably/ably-cocoa-plugin-support",
-            revision: "242fac1d4a829c8a63f9b3f96a71809e1f6eeffc",
+            revision: "b0ac0e1684b9e5a2c3fb38bcfa68b49f7767b6b4",
         ),
         .package(
             url: "https://github.com/apple/swift-argument-parser",

Package.resolved

@@ -9,7 +9,13 @@ import ObjectiveC.NSObject
 internal final class DefaultInternalPlugin: NSObject, _AblyPluginSupportPrivate.LiveObjectsInternalPluginProtocol {
     private let pluginAPI: _AblyPluginSupportPrivate.PluginAPIProtocol
 
+    internal var compatibleWithProtocolV6: Bool { true }
+
     internal init(pluginAPI: _AblyPluginSupportPrivate.PluginAPIProtocol) {
+        precondition(
+            pluginAPI.usesLiveObjectsProtocolV6,
+            "This version of the LiveObjects plugin requires a version of ably-cocoa that uses LiveObjects protocol v6.",
+        )
         self.pluginAPI = pluginAPI
     }
 

Package.swift

@@ -124,9 +124,9 @@ internal final class InternalDefaultLiveCounter: Sendable {
                             action: .known(.counterInc),
                             // RTLC12e3
                             objectId: mutableState.liveObjectMutableState.objectID,
-                            counterOp: .init(
-                                // RTLC12e4
-                                amount: .init(value: amount),
+                            counterInc: .init(
+                                // RTLC12e5
+                                number: .init(value: amount),
                             ),
                         ),
                     )
@@ -223,7 +223,7 @@ internal final class InternalDefaultLiveCounter: Sendable {
         }
     }
 
-    /// Merges the initial value from an ObjectOperation into this LiveCounter, per RTLC10.
+    /// Merges the initial value from an ObjectOperation into this LiveCounter, per RTLC16.
     internal func nosync_mergeInitialValue(from operation: ObjectOperation) -> LiveObjectUpdate<DefaultLiveCounterUpdate> {
         mutableStateMutex.withoutSync { mutableState in
             mutableState.mergeInitialValue(from: operation)
@@ -238,7 +238,7 @@ internal final class InternalDefaultLiveCounter: Sendable {
     }
 
     /// Test-only method to apply a COUNTER_INC operation, per RTLC9.
-    internal func testsOnly_applyCounterIncOperation(_ operation: WireObjectsCounterOp?) -> LiveObjectUpdate<DefaultLiveCounterUpdate> {
+    internal func testsOnly_applyCounterIncOperation(_ operation: CounterInc?) -> LiveObjectUpdate<DefaultLiveCounterUpdate> {
         mutableStateMutex.withSync { mutableState in
             mutableState.applyCounterIncOperation(operation)
         }
@@ -352,7 +352,7 @@ internal final class InternalDefaultLiveCounter: Sendable {
             // RTLC6c: Set data to the value of ObjectState.counter.count, or to 0 if it does not exist
             data = state.counter?.count?.doubleValue ?? 0
 
-            // RTLC6d: If ObjectState.createOp is present, merge the initial value into the LiveCounter as described in RTLC10
+            // RTLC6d: If ObjectState.createOp is present, merge the initial value into the LiveCounter as described in RTLC16
             // Discard the LiveCounterUpdate object returned by the merge operation
             if let createOp = state.createOp {
                 _ = mergeInitialValue(from: createOp)
@@ -362,21 +362,25 @@ internal final class InternalDefaultLiveCounter: Sendable {
             return ObjectDiffHelpers.calculateCounterDiff(previousData: previousData, newData: data)
         }
 
-        /// Merges the initial value from an ObjectOperation into this LiveCounter, per RTLC10.
+        /// Merges the initial value from an ObjectOperation into this LiveCounter, per RTLC16.
         internal mutating func mergeInitialValue(from operation: ObjectOperation) -> LiveObjectUpdate<DefaultLiveCounterUpdate> {
             let update: LiveObjectUpdate<DefaultLiveCounterUpdate>
 
-            // RTLC10a: Add ObjectOperation.counter.count to data, if it exists
-            if let operationCount = operation.counter?.count?.doubleValue {
+            // RTLC16: Resolve counterCreate from either the direct property or the one
+            // from which counterCreateWithObjectId was derived (RTO12f16)
+            let counterCreate = operation.counterCreate ?? operation.counterCreateWithObjectId?.derivedFrom
+
+            // RTLC16a: Add counterCreate.count to data, if it exists
+            if let operationCount = counterCreate?.count?.doubleValue {
                 data += operationCount
-                // RTLC10c
+                // RTLC16c
                 update = .update(DefaultLiveCounterUpdate(amount: operationCount))
             } else {
-                // RTLC10d
+                // RTLC16d
                 update = .noop
             }
 
-            // RTLC10b: Set the private flag createOperationIsMerged to true
+            // RTLC16b: Set the private flag createOperationIsMerged to true
             liveObjectMutableState.createOperationIsMerged = true
 
             return update
@@ -425,11 +429,11 @@ internal final class InternalDefaultLiveCounter: Sendable {
                 // RTLC7d1b
                 return true
             case .known(.counterInc):
-                // RTLC7d2
-                let update = applyCounterIncOperation(operation.counterOp)
-                // RTLC7d2a
+                // RTLC7d5
+                let update = applyCounterIncOperation(operation.counterInc)
+                // RTLC7d5a
                 liveObjectMutableState.emit(update, on: userCallbackQueue)
-                // RTLC7d2b
+                // RTLC7d5b
                 return true
             case .known(.objectDelete):
                 let dataBeforeApplyingOperation = data
@@ -469,14 +473,14 @@ internal final class InternalDefaultLiveCounter: Sendable {
         }
 
         /// Applies a `COUNTER_INC` operation, per RTLC9.
-        internal mutating func applyCounterIncOperation(_ operation: WireObjectsCounterOp?) -> LiveObjectUpdate<DefaultLiveCounterUpdate> {
+        internal mutating func applyCounterIncOperation(_ operation: CounterInc?) -> LiveObjectUpdate<DefaultLiveCounterUpdate> {
             guard let operation else {
                 // RTL9e
                 return .noop
             }
 
-            // RTLC9b, RTLC9d
-            let amount = operation.amount.doubleValue
+            // RTLC9f, RTLC9g
+            let amount = operation.number.doubleValue
             data += amount
             return .update(DefaultLiveCounterUpdate(amount: amount))
         }

Sources/AblyLiveObjects/Internal/DefaultInternalPlugin.swift

@@ -172,11 +172,11 @@ internal final class InternalDefaultLiveMap: Sendable {
                             action: .known(.mapSet),
                             // RTLM20e3
                             objectId: mutableState.liveObjectMutableState.objectID,
-                            mapOp: .init(
-                                // RTLM20e4
+                            mapSet: .init(
+                                // RTLM20e6
                                 key: key,
-                                // RTLM20e5
-                                data: value.nosync_toObjectData,
+                                // RTLM20e7
+                                value: value.nosync_toObjectData,
                             ),
                         ),
                     )
@@ -205,8 +205,8 @@ internal final class InternalDefaultLiveMap: Sendable {
                             action: .known(.mapRemove),
                             // RTLM21e3
                             objectId: mutableState.liveObjectMutableState.objectID,
-                            mapOp: .init(
-                                // RTLM21e4
+                            mapRemove: .init(
+                                // RTLM21e5
                                 key: key,
                             ),
                         ),
@@ -303,7 +303,7 @@ internal final class InternalDefaultLiveMap: Sendable {
         }
     }
 
-    /// Merges the initial value from an ObjectOperation into this LiveMap, per RTLM17.
+    /// Merges the initial value from an ObjectOperation into this LiveMap, per RTLM23.
     internal func nosync_mergeInitialValue(from operation: ObjectOperation, objectsPool: inout ObjectsPool) -> LiveObjectUpdate<DefaultLiveMapUpdate> {
         mutableStateMutex.withoutSync { mutableState in
             mutableState.mergeInitialValue(
@@ -516,7 +516,7 @@ internal final class InternalDefaultLiveMap: Sendable {
                 return .init(objectsMapEntry: entry, tombstonedAt: tombstonedAt)
             } ?? [:]
 
-            // RTLM6d: If ObjectState.createOp is present, merge the initial value into the LiveMap as described in RTLM17
+            // RTLM6d: If ObjectState.createOp is present, merge the initial value into the LiveMap as described in RTLM23
             // Discard the LiveMapUpdate object returned by the merge operation
             if let createOp = state.createOp {
                 _ = mergeInitialValue(
@@ -533,7 +533,7 @@ internal final class InternalDefaultLiveMap: Sendable {
             return ObjectDiffHelpers.calculateMapDiff(previousData: previousData, newData: data)
         }
 
-        /// Merges the initial value from an ObjectOperation into this LiveMap, per RTLM17.
+        /// Merges the initial value from an ObjectOperation into this LiveMap, per RTLM23.
         internal mutating func mergeInitialValue(
             from operation: ObjectOperation,
             objectsPool: inout ObjectsPool,
@@ -542,11 +542,15 @@ internal final class InternalDefaultLiveMap: Sendable {
             userCallbackQueue: DispatchQueue,
             clock: SimpleClock,
         ) -> LiveObjectUpdate<DefaultLiveMapUpdate> {
-            // RTLM17a: For each key–ObjectsMapEntry pair in ObjectOperation.map.entries
-            let perKeyUpdates: [LiveObjectUpdate<DefaultLiveMapUpdate>] = if let entries = operation.map?.entries {
+            // RTLM23: Resolve mapCreate from either the direct property or the one
+            // from which mapCreateWithObjectId was derived (RTO11f18)
+            let mapCreate = operation.mapCreate ?? operation.mapCreateWithObjectId?.derivedFrom
+
+            // RTLM23a: For each key–ObjectsMapEntry pair in mapCreate.entries
+            let perKeyUpdates: [LiveObjectUpdate<DefaultLiveMapUpdate>] = if let entries = mapCreate?.entries {
                 entries.map { key, entry in
                     if entry.tombstone == true {
-                        // RTLM17a2: If ObjectsMapEntry.tombstone is true, apply the MAP_REMOVE operation
+                        // RTLM23a2: If ObjectsMapEntry.tombstone is true, apply the MAP_REMOVE operation
                         // as described in RTLM8, passing in the current key as ObjectsMapOp, ObjectsMapEntry.timeserial as the operation's serial, and ObjectsMapEntry.serialTimestamp as the operation's serial timestamp
                         applyMapRemoveOperation(
                             key: key,
@@ -556,7 +560,7 @@ internal final class InternalDefaultLiveMap: Sendable {
                             clock: clock,
                         )
                     } else {
-                        // RTLM17a1: If ObjectsMapEntry.tombstone is false, apply the MAP_SET operation
+                        // RTLM23a1: If ObjectsMapEntry.tombstone is false, apply the MAP_SET operation
                         // as described in RTLM7, passing in ObjectsMapEntry.data and the current key as ObjectsMapOp, and ObjectsMapEntry.timeserial as the operation's serial
                         applyMapSetOperation(
                             key: key,
@@ -574,10 +578,10 @@ internal final class InternalDefaultLiveMap: Sendable {
                 []
             }
 
-            // RTLM17b: Set the private flag createOperationIsMerged to true
+            // RTLM23b: Set the private flag createOperationIsMerged to true
             liveObjectMutableState.createOperationIsMerged = true
 
-            // RTLM17c: Merge the updates, skipping no-ops
+            // RTLM23c: Merge the updates, skipping no-ops
             // I don't love having to use uniqueKeysWithValues, when I shouldn't have to. I should be able to reason _statically_ that there are no overlapping keys. The problem that we're trying to use LiveMapUpdate throughout instead of something more communicative. But I don't know what's to come in the spec so I don't want to mess with this internal interface.
             let filteredPerKeyUpdates = perKeyUpdates.compactMap { update -> LiveMapUpdate? in
                 switch update {
@@ -642,46 +646,46 @@ internal final class InternalDefaultLiveMap: Sendable {
                 // RTLM15d1b
                 return true
             case .known(.mapSet):
-                guard let mapOp = operation.mapOp else {
-                    logger.log("Could not apply MAP_SET since operation.mapOp is missing", level: .warn)
+                guard let mapSet = operation.mapSet else {
+                    logger.log("Could not apply MAP_SET since operation.mapSet is missing", level: .warn)
                     return false
                 }
-                guard let data = mapOp.data else {
-                    logger.log("Could not apply MAP_SET since operation.data is missing", level: .warn)
+                guard let value = mapSet.value else {
+                    logger.log("Could not apply MAP_SET since operation.mapSet.value is missing", level: .warn)
                     return false
                 }
 
-                // RTLM15d2
+                // RTLM15d6
                 let update = applyMapSetOperation(
-                    key: mapOp.key,
+                    key: mapSet.key,
                     operationTimeserial: applicableOperation.objectMessageSerial,
-                    operationData: data,
+                    operationData: value,
                     objectsPool: &objectsPool,
                     logger: logger,
                     internalQueue: internalQueue,
                     userCallbackQueue: userCallbackQueue,
                     clock: clock,
                 )
-                // RTLM15d2a
+                // RTLM15d6a
                 liveObjectMutableState.emit(update, on: userCallbackQueue)
-                // RTLM15d2b
+                // RTLM15d6b
                 return true
             case .known(.mapRemove):
-                guard let mapOp = operation.mapOp else {
+                guard let mapRemove = operation.mapRemove else {
                     return false
                 }
 
-                // RTLM15d3
+                // RTLM15d7
                 let update = applyMapRemoveOperation(
-                    key: mapOp.key,
+                    key: mapRemove.key,
                     operationTimeserial: applicableOperation.objectMessageSerial,
                     operationSerialTimestamp: objectMessageSerialTimestamp,
                     logger: logger,
                     clock: clock,
                 )
-                // RTLM15d3a
+                // RTLM15d7a
                 liveObjectMutableState.emit(update, on: userCallbackQueue)
-                // RTLM15d3b
+                // RTLM15d7b
                 return true
             case .known(.objectDelete):
                 let dataBeforeApplyingOperation = data