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

package/dist-tests/{vocab-Cg2PG-xH.mjs → vocab-jHKm_LJ6.mjs}

@@ -798,6 +798,19 @@ var Object$1 = 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
@@ -10250,6 +10263,19 @@ var Emoji = 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
@@ -10478,6 +10504,19 @@ var ChatMessage = 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
@@ -11444,6 +11483,19 @@ var Activity = 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
@@ -13872,6 +13924,19 @@ var EmojiReact = 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
@@ -14133,6 +14198,19 @@ var PropertyValue = class {
 	/**
 	* 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
@@ -14497,6 +14575,19 @@ var Measure = class {
 	/**
 	* 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
@@ -14814,6 +14905,19 @@ var AnnounceAuthorization = 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
@@ -15595,6 +15699,19 @@ var AnnounceRequest = 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
@@ -15865,6 +15982,19 @@ var InteractionPolicy = class {
 	/**
 	* 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
@@ -16366,6 +16496,19 @@ var InteractionRule = class {
 	/**
 	* 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
@@ -16677,6 +16820,19 @@ var LikeAuthorization = 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
@@ -17457,6 +17613,19 @@ var LikeRequest = 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
@@ -17673,6 +17842,19 @@ var ReplyAuthorization = 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
@@ -18453,6 +18635,19 @@ var ReplyRequest = 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
@@ -18669,6 +18864,19 @@ var QuoteAuthorization = 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
@@ -19450,6 +19658,19 @@ var QuoteRequest = 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
@@ -19768,6 +19989,19 @@ var Translation = class {
 	/**
 	* 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
@@ -20684,6 +20918,19 @@ var FeatureAuthorization = 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
@@ -21462,6 +21709,19 @@ var FeatureRequest = 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
@@ -21739,6 +21999,19 @@ var Collection = 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
@@ -25505,6 +25778,19 @@ var OrderedCollection = 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
@@ -26159,6 +26445,19 @@ var FeaturedCollection = 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
@@ -26501,6 +26800,19 @@ var FeaturedItem = 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
@@ -27337,6 +27649,19 @@ var DidService = class {
 	/**
 	* 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
@@ -27577,6 +27902,19 @@ var Export = 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
@@ -27837,6 +28175,19 @@ var DataIntegrityProof = class {
 	/**
 	* 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
@@ -28506,6 +28857,19 @@ var CryptographicKey = class {
 	/**
 	* 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
@@ -29165,6 +29529,19 @@ var Multikey = class {
 	/**
 	* 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
@@ -29783,6 +30160,19 @@ var Agreement = 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
@@ -30208,6 +30598,19 @@ var Commitment = class {
 	/**
 	* 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
@@ -30595,6 +30998,19 @@ var Intent = class {
 	/**
 	* 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
@@ -31087,6 +31503,19 @@ var Proposal = 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
@@ -31552,6 +31981,19 @@ var Accept = 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
@@ -31753,6 +32195,19 @@ var Add = 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
@@ -31952,6 +32407,19 @@ var Announce = 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
@@ -32333,6 +32801,19 @@ var Application = 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
@@ -37668,6 +38149,19 @@ var IntransitiveActivity = 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
@@ -37870,6 +38364,19 @@ var Arrive = 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
@@ -38082,6 +38589,19 @@ var Article = 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
@@ -38977,6 +39497,19 @@ var Document = 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
@@ -39343,6 +39876,19 @@ var Audio = 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
@@ -39557,6 +40103,19 @@ var Ignore = 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
@@ -39758,6 +40317,19 @@ var Block = 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
@@ -39975,6 +40547,19 @@ var CollectionPage = 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
@@ -41079,6 +41664,19 @@ var Create = 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
@@ -41307,6 +41905,19 @@ var Delete = 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
@@ -41530,6 +42141,19 @@ var Dislike = 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
@@ -41804,6 +42428,19 @@ var Endpoints = class {
 	/**
 	* 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
@@ -42339,6 +42976,19 @@ var Event = 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
@@ -42552,6 +43202,19 @@ var Flag = 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
@@ -42752,6 +43415,19 @@ var Follow = 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
@@ -43107,6 +43783,19 @@ var Group = 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
@@ -48542,6 +49231,19 @@ var Link = 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
@@ -49587,6 +50289,19 @@ var Hashtag = 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
@@ -49787,6 +50502,19 @@ var Image = 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
@@ -50002,6 +50730,19 @@ var Offer = 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
@@ -50201,6 +50942,19 @@ var Invite = 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
@@ -50399,6 +51153,19 @@ var Join = 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
@@ -50597,6 +51364,19 @@ var Leave = 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
@@ -50795,6 +51575,19 @@ var Like = 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
@@ -50996,6 +51789,19 @@ var Listen = 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
@@ -51193,6 +51999,19 @@ var Mention = 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
@@ -51395,6 +52214,19 @@ var Move = 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
@@ -51608,6 +52440,19 @@ var Note = 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
@@ -52505,6 +53350,19 @@ var OrderedCollectionPage = 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
@@ -53354,6 +54212,19 @@ var Organization = 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
@@ -58687,6 +59558,19 @@ var Page = 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
@@ -59055,6 +59939,19 @@ var Person = 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
@@ -64408,6 +65305,19 @@ var Place = 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
@@ -64925,6 +65835,19 @@ var Profile = 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
@@ -65458,6 +66381,19 @@ var Question = 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
@@ -66916,6 +67852,19 @@ var Read = 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
@@ -67114,6 +68063,19 @@ var Reject = 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
@@ -67350,6 +68312,19 @@ var Relationship = 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
@@ -68570,6 +69545,19 @@ var Remove = 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
@@ -68922,6 +69910,19 @@ var Service = 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
@@ -74318,6 +75319,19 @@ var Source = class {
 	/**
 	* 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
@@ -74619,6 +75633,19 @@ var TentativeAccept = 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
@@ -74817,6 +75844,19 @@ var TentativeReject = 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
@@ -75027,6 +76067,19 @@ var Tombstone = 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
@@ -75357,6 +76410,19 @@ var Travel = 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
@@ -75560,6 +76626,19 @@ var Undo = 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
@@ -75770,6 +76849,19 @@ var Update = 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
@@ -76026,6 +77118,19 @@ var Video = 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
@@ -76239,6 +77344,19 @@ var View = 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