@fedify/vocab 2.4.0 → 2.4.2-dev.2347

package/dist/mod.d.ts

@@ -101,6 +101,19 @@ declare class Object$1 {
   /**
   * 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
@@ -109,7 +122,8 @@ declare class Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -1504,6 +1518,19 @@ declare class Emoji extends Object$1 {
   /**
   * 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
@@ -1512,7 +1539,8 @@ declare class Emoji extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -1707,6 +1735,19 @@ declare class ChatMessage extends Object$1 {
   /**
   * 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
@@ -1715,7 +1756,8 @@ declare class ChatMessage extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -1997,6 +2039,19 @@ declare class Activity extends Object$1 {
   /**
   * 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
@@ -2005,7 +2060,8 @@ declare class Activity extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -2606,6 +2662,19 @@ declare class EmojiReact extends Activity {
   /**
   * 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
@@ -2614,7 +2683,8 @@ declare class EmojiReact extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -2778,6 +2848,19 @@ declare class PropertyValue {
   /**
   * 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
@@ -2786,7 +2869,8 @@ declare class PropertyValue {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -2892,6 +2976,19 @@ declare class Measure {
   /**
   * 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
@@ -2900,7 +2997,8 @@ declare class Measure {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -3054,6 +3152,19 @@ declare class AnnounceAuthorization extends Object$1 {
   /**
   * 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
@@ -3062,7 +3173,8 @@ declare class AnnounceAuthorization extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -3334,6 +3446,19 @@ declare class AnnounceRequest extends Activity {
   /**
   * 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
@@ -3342,7 +3467,8 @@ declare class AnnounceRequest extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -3515,6 +3641,19 @@ declare class InteractionPolicy {
   /**
   * 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
@@ -3523,7 +3662,8 @@ declare class InteractionPolicy {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -3675,6 +3815,19 @@ declare class InteractionRule {
   /**
   * 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
@@ -3683,7 +3836,8 @@ declare class InteractionRule {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -3848,6 +4002,19 @@ declare class LikeAuthorization extends Object$1 {
   /**
   * 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
@@ -3856,7 +4023,8 @@ declare class LikeAuthorization extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -4127,6 +4295,19 @@ declare class LikeRequest extends Activity {
   /**
   * 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
@@ -4135,7 +4316,8 @@ declare class LikeRequest extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -4344,6 +4526,19 @@ declare class ReplyAuthorization extends Object$1 {
   /**
   * 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
@@ -4352,7 +4547,8 @@ declare class ReplyAuthorization extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -4623,6 +4819,19 @@ declare class ReplyRequest extends Activity {
   /**
   * 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
@@ -4631,7 +4840,8 @@ declare class ReplyRequest extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -4840,6 +5050,19 @@ declare class QuoteAuthorization extends Object$1 {
   /**
   * 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
@@ -4848,7 +5071,8 @@ declare class QuoteAuthorization extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -5118,6 +5342,19 @@ declare class QuoteRequest extends Activity {
   /**
   * 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
@@ -5126,7 +5363,8 @@ declare class QuoteRequest extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -5302,6 +5540,19 @@ declare class Translation {
   /**
   * 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
@@ -5310,7 +5561,8 @@ declare class Translation {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -5553,6 +5805,19 @@ declare class FeatureAuthorization extends Object$1 {
   /**
   * 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
@@ -5561,7 +5826,8 @@ declare class FeatureAuthorization extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -5828,6 +6094,19 @@ declare class FeatureRequest extends Activity {
   /**
   * 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
@@ -5836,7 +6115,8 @@ declare class FeatureRequest extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -6053,6 +6333,19 @@ declare class Collection extends Object$1 {
   /**
   * 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
@@ -6061,7 +6354,8 @@ declare class Collection extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -6645,6 +6939,19 @@ declare class OrderedCollection extends Collection {
   /**
   * 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
@@ -6653,7 +6960,8 @@ declare class OrderedCollection extends Collection {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -6902,6 +7210,19 @@ declare class FeaturedCollection extends OrderedCollection {
   /**
   * 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
@@ -6910,7 +7231,8 @@ declare class FeaturedCollection extends OrderedCollection {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -7126,6 +7448,19 @@ declare class FeaturedItem extends Object$1 {
   /**
   * 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
@@ -7134,7 +7469,8 @@ declare class FeaturedItem extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -7352,6 +7688,19 @@ declare class DidService {
   /**
   * 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
@@ -7360,7 +7709,8 @@ declare class DidService {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -7451,6 +7801,19 @@ declare class Export extends DidService {
   /**
   * 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
@@ -7459,7 +7822,8 @@ declare class Export extends DidService {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -7563,6 +7927,19 @@ declare class DataIntegrityProof {
   /**
   * 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
@@ -7571,7 +7948,8 @@ declare class DataIntegrityProof {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -7725,6 +8103,19 @@ declare class CryptographicKey {
   /**
   * 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
@@ -7733,7 +8124,8 @@ declare class CryptographicKey {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -7869,6 +8261,19 @@ declare class Multikey {
   /**
   * 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
@@ -7877,7 +8282,8 @@ declare class Multikey {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -8062,6 +8468,19 @@ declare class Agreement extends Object$1 {
   /**
   * 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
@@ -8070,7 +8489,8 @@ declare class Agreement extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -8237,6 +8657,19 @@ declare class Commitment {
   /**
   * 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
@@ -8245,7 +8678,8 @@ declare class Commitment {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -8361,6 +8795,19 @@ declare class Intent {
   /**
   * 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
@@ -8369,7 +8816,8 @@ declare class Intent {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -8539,6 +8987,19 @@ declare class Proposal extends Object$1 {
   /**
   * 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
@@ -8547,7 +9008,8 @@ declare class Proposal extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -8767,6 +9229,19 @@ declare class Accept extends Activity {
   /**
   * 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
@@ -8775,7 +9250,8 @@ declare class Accept extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -8989,6 +9465,19 @@ declare class Add extends Activity {
   /**
   * 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
@@ -8997,7 +9486,8 @@ declare class Add extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -9210,6 +9700,19 @@ declare class Announce extends Activity {
   /**
   * 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
@@ -9218,7 +9721,8 @@ declare class Announce extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -9448,6 +9952,19 @@ declare class Application extends Object$1 {
   /**
   * 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
@@ -9456,7 +9973,8 @@ declare class Application extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -10347,6 +10865,19 @@ declare class IntransitiveActivity extends Activity {
   /**
   * 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
@@ -10355,7 +10886,8 @@ declare class IntransitiveActivity extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -10568,6 +11100,19 @@ declare class Arrive extends IntransitiveActivity {
   /**
   * 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
@@ -10576,7 +11121,8 @@ declare class Arrive extends IntransitiveActivity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -10779,6 +11325,19 @@ declare class Article extends Object$1 {
   /**
   * 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
@@ -10787,7 +11346,8 @@ declare class Article extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -11056,6 +11616,19 @@ declare class Document extends Object$1 {
   /**
   * 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
@@ -11064,7 +11637,8 @@ declare class Document extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -11271,6 +11845,19 @@ declare class Audio extends Document {
   /**
   * 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
@@ -11279,7 +11866,8 @@ declare class Audio extends Document {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -11482,6 +12070,19 @@ declare class Ignore extends Activity {
   /**
   * 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
@@ -11490,7 +12091,8 @@ declare class Ignore extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -11704,6 +12306,19 @@ declare class Block extends Ignore {
   /**
   * 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
@@ -11712,7 +12327,8 @@ declare class Block extends Ignore {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -11930,6 +12546,19 @@ declare class CollectionPage extends Collection {
   /**
   * 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
@@ -11938,7 +12567,8 @@ declare class CollectionPage extends Collection {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -12244,6 +12874,19 @@ declare class Create extends Activity {
   /**
   * 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
@@ -12252,7 +12895,8 @@ declare class Create extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -12464,6 +13108,19 @@ declare class Delete extends Activity {
   /**
   * 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
@@ -12472,7 +13129,8 @@ declare class Delete extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -12683,6 +13341,19 @@ declare class Dislike extends Activity {
   /**
   * 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
@@ -12691,7 +13362,8 @@ declare class Dislike extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -12860,6 +13532,19 @@ declare class Endpoints {
   /**
   * 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
@@ -12868,7 +13553,8 @@ declare class Endpoints {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -13057,6 +13743,19 @@ declare class Event extends Object$1 {
   /**
   * 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
@@ -13065,7 +13764,8 @@ declare class Event extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -13266,6 +13966,19 @@ declare class Flag extends Activity {
   /**
   * 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
@@ -13274,7 +13987,8 @@ declare class Flag extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -13488,6 +14202,19 @@ declare class Follow extends Activity {
   /**
   * 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
@@ -13496,7 +14223,8 @@ declare class Follow extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -13726,6 +14454,19 @@ declare class Group extends Object$1 {
   /**
   * 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
@@ -13734,7 +14475,8 @@ declare class Group extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -14592,6 +15334,19 @@ declare class 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
@@ -14600,7 +15355,8 @@ declare class Link {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -14783,6 +15539,19 @@ declare class Hashtag extends 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
@@ -14791,7 +15560,8 @@ declare class Hashtag extends Link {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -14938,6 +15708,19 @@ declare class Image extends Document {
   /**
   * 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
@@ -14946,7 +15729,8 @@ declare class Image extends Document {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -15150,6 +15934,19 @@ declare class Offer extends Activity {
   /**
   * 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
@@ -15158,7 +15955,8 @@ declare class Offer extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -15370,6 +16168,19 @@ declare class Invite extends Offer {
   /**
   * 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
@@ -15378,7 +16189,8 @@ declare class Invite extends Offer {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -15590,6 +16402,19 @@ declare class Join extends Activity {
   /**
   * 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
@@ -15598,7 +16423,8 @@ declare class Join extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -15810,6 +16636,19 @@ declare class Leave extends Activity {
   /**
   * 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
@@ -15818,7 +16657,8 @@ declare class Leave extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -16030,6 +16870,19 @@ declare class Like extends Activity {
   /**
   * 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
@@ -16038,7 +16891,8 @@ declare class Like extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -16249,6 +17103,19 @@ declare class Listen extends Activity {
   /**
   * 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
@@ -16257,7 +17124,8 @@ declare class Listen extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -16413,6 +17281,19 @@ declare class Mention extends 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
@@ -16421,7 +17302,8 @@ declare class Mention extends Link {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -16579,6 +17461,19 @@ declare class Move extends Activity {
   /**
   * 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
@@ -16587,7 +17482,8 @@ declare class Move extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -16791,6 +17687,19 @@ declare class Note extends Object$1 {
   /**
   * 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
@@ -16799,7 +17708,8 @@ declare class Note extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -17084,6 +17994,19 @@ declare class OrderedCollectionPage extends CollectionPage {
   /**
   * 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
@@ -17092,7 +18015,8 @@ declare class OrderedCollectionPage extends CollectionPage {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -17362,6 +18286,19 @@ declare class Organization extends Object$1 {
   /**
   * 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
@@ -17370,7 +18307,8 @@ declare class Organization extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -18250,6 +19188,19 @@ declare class Page extends Document {
   /**
   * 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
@@ -18258,7 +19209,8 @@ declare class Page extends Document {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -18479,6 +19431,19 @@ declare class Person extends Object$1 {
   /**
   * 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
@@ -18487,7 +19452,8 @@ declare class Person extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -19373,6 +20339,19 @@ declare class Place extends Object$1 {
   /**
   * 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
@@ -19381,7 +20360,8 @@ declare class Place extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -19606,6 +20586,19 @@ declare class Profile extends Object$1 {
   /**
   * 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
@@ -19614,7 +20607,8 @@ declare class Profile extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -19860,6 +20854,19 @@ declare class Question extends IntransitiveActivity {
   /**
   * 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
@@ -19868,7 +20875,8 @@ declare class Question extends IntransitiveActivity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -20233,6 +21241,19 @@ declare class Read extends Activity {
   /**
   * 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
@@ -20241,7 +21262,8 @@ declare class Read extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -20453,6 +21475,19 @@ declare class Reject extends Activity {
   /**
   * 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
@@ -20461,7 +21496,8 @@ declare class Reject extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -20672,6 +21708,19 @@ declare class Relationship extends Object$1 {
   /**
   * 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
@@ -20680,7 +21729,8 @@ declare class Relationship extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -21042,6 +22092,19 @@ declare class Remove extends Activity {
   /**
   * 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
@@ -21050,7 +22113,8 @@ declare class Remove extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -21280,6 +22344,19 @@ declare class Service extends Object$1 {
   /**
   * 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
@@ -21288,7 +22365,8 @@ declare class Service extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -22131,6 +23209,19 @@ declare class Source {
   /**
   * 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
@@ -22139,7 +23230,8 @@ declare class Source {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   clone(values?: {
     id?: URL | null;
@@ -22297,6 +23389,19 @@ declare class TentativeAccept extends Accept {
   /**
   * 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
@@ -22305,7 +23410,8 @@ declare class TentativeAccept extends Accept {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -22517,6 +23623,19 @@ declare class TentativeReject extends Reject {
   /**
   * 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
@@ -22525,7 +23644,8 @@ declare class TentativeReject extends Reject {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -22730,6 +23850,19 @@ declare class Tombstone extends Object$1 {
   /**
   * 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
@@ -22738,7 +23871,8 @@ declare class Tombstone extends Object$1 {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -22955,6 +24089,19 @@ declare class Travel extends IntransitiveActivity {
   /**
   * 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
@@ -22963,7 +24110,8 @@ declare class Travel extends IntransitiveActivity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -23180,6 +24328,19 @@ declare class Undo extends Activity {
   /**
   * 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
@@ -23188,7 +24349,8 @@ declare class Undo extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -23403,6 +24565,19 @@ declare class Update extends Activity {
   /**
   * 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
@@ -23411,7 +24586,8 @@ declare class Update extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -23613,6 +24789,19 @@ declare class Video extends Document {
   /**
   * 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
@@ -23621,7 +24810,8 @@ declare class Video extends Document {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;
@@ -23823,6 +25013,19 @@ declare class View extends Activity {
   /**
   * 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
@@ -23831,7 +25034,8 @@ declare class View extends Activity {
   *
   * @param values The values to update the clone with.
   * @param options The options to use for cloning.
-  * @returns The cloned instance.
+  * @returns The cloned instance with its own property arrays.  Nested objects
+  *          and URLs are shared with this instance.
   */
   override clone(values?: {
     id?: URL | null;