Are there more examples of readOnly being used at several levels of a schema to clarify the semantics?

I've been using the readOnly keyword in my schemas and I just realized that I was just making up my own semantics. Now I'm cleaning up a bunch of my designs and trying to validate that I was using this annotation as it was intended. The validation spec is what I'm basing this question on but I'd like to be aware of more example usage scenarios.

Let me give three examples. In this first example I mean to say the entire resource is read only. Nothing can be mutated at any level.

{
    "type": "object",
    "readOnly": true,
    "properties": {
        "name": {
            "type": "string",
        },
        "members": {
            "type": "object",
            "properties": {
                "member1": { "type" : "string" },
                "member2": { "type" : "string" }
            }
        }
    }
}

I don't think that's too controversial. But originally, my own mental model was that readOnly at the top level meant you couldn't replace this resource with a new resource. The server would prevent that. But the internal members were still mutable. So I sprinkled readOnly at the name sub-schema and each member sub-schema. I think removing all of those was correct. (My mental model was maybe loosely based on how I interpret const variables in JavaScript. If my const var is an object, I can't change the value of the variable, but I can mutate its members or even add members to it.)

In the second example I leave readOnly out of the schema completely. So it's not too controversial to take that to mean anything is mutable in the resource.

{
    "type": "object",
    "properties": {
        "name": {
            "type": "string",
        },
        "members": {
            "type": "object",
            "properties": {
                "member1": { "type" : "string" },
                "member2": { "type" : "string" }
            }
        }
    }
}

In the third example, I want to mix and match

{
    "type": "object",
    "properties": {
        "name": {
            "type": "string",
            "readOnly": true
        },
        "members": {
            "type": "object",
            "properties": {
                "member1": { "type" : "string", "readOnly": true },
                "member2": { "type" : "string", "readOnly": true },
                "member3": { "type" : "string"},
                "member4": { "type" : "string"}
            }
        }
    }
}

In this example the name, member1 and member2 are immutable. member3 and member4 can be modified.

So the question is, is there anything wrong about my interpretation of readOnly?