@fedify/vocab-tools 2.5.0-dev.2364 → 2.5.0-dev.2378

package/src/__snapshots__/class.test.ts.node.snap

@@ -1328,6 +1328,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -19239,6 +19252,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -19722,6 +19748,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -21635,6 +21674,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -26550,6 +26602,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -27064,6 +27129,19 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -27818,6 +27896,19 @@ unit?: string | null;numericalValue?: Decimal | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -28495,6 +28586,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -30009,6 +30113,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -30572,6 +30689,19 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?:
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -31662,6 +31792,19 @@ manualApprovals?: (URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -32368,6 +32511,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -33881,6 +34037,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -34340,6 +34509,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -35853,6 +36035,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -36312,6 +36507,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -37824,6 +38032,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -38455,6 +38676,19 @@ urls?: ((URL | Link))[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -40355,6 +40589,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -41862,6 +42109,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -42498,6 +42758,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -49515,6 +49788,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -50552,6 +50838,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -51253,6 +51552,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -52858,6 +53170,19 @@ endpoints?: (URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -53377,6 +53702,19 @@ endpoints?: (URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -53907,6 +54245,19 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -55284,6 +55635,19 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -56533,6 +56897,19 @@ controller?: Application | Group | Organization | Person | Service | URL | null;
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -57725,6 +58102,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -58498,6 +58888,19 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -59281,6 +59684,19 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -60338,6 +60754,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -61244,6 +61673,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -61677,6 +62119,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -62105,6 +62560,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -63068,6 +63536,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -73410,6 +73891,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -73850,6 +74344,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -74315,6 +74822,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76001,6 +76521,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76796,6 +77329,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -77236,6 +77782,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -77669,6 +78228,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -78139,6 +78711,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -80177,6 +80762,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -80604,6 +81202,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -81029,6 +81640,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -81613,6 +82237,19 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -82832,6 +83469,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -83273,6 +83923,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -83702,6 +84365,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -84665,6 +85341,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -95271,6 +95960,19 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97389,6 +98091,19 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97796,6 +98511,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -98237,6 +98965,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -98668,6 +99409,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99095,6 +99849,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99522,6 +100289,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99949,6 +100729,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -100374,6 +101167,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -100779,6 +101585,19 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -101195,6 +102014,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -101662,6 +102494,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -103345,6 +104190,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -105007,6 +105865,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -115340,6 +116211,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -116316,6 +117200,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -126736,6 +127633,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -127885,6 +128795,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -128982,6 +129905,19 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -131820,6 +132756,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -132247,6 +133196,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -132781,6 +133743,19 @@ relationships?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -135216,6 +136191,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -136179,6 +137167,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -146631,6 +147632,19 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147319,6 +148333,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147746,6 +148773,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -148220,6 +149260,19 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -148951,6 +150004,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -149383,6 +150449,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -149813,6 +150892,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -150232,6 +151324,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -150671,6 +151776,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document