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

package/dist/mod.cjs

@@ -36,7 +36,7 @@ let _fedify_vocab_runtime_temporal = require("@fedify/vocab-runtime/temporal");
 let es_toolkit = require("es-toolkit");
 //#region deno.json
 var name = "@fedify/vocab";
-var version = "2.5.0-dev.2364+4d9b5f4d";
+var version = "2.5.0-dev.2378+fea9c751";
 //#endregion
 //#region src/type.ts
 function getTypeId(object) {
@@ -4276,6 +4276,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
@@ -13728,6 +13741,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
@@ -13956,6 +13982,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
@@ -14922,6 +14961,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
@@ -17350,6 +17402,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
@@ -17611,6 +17676,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
@@ -17975,6 +18053,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
@@ -18292,6 +18383,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
@@ -19073,6 +19177,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
@@ -19343,6 +19460,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
@@ -19844,6 +19974,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
@@ -20155,6 +20298,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
@@ -20935,6 +21091,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
@@ -21151,6 +21320,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
@@ -21931,6 +22113,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
@@ -22147,6 +22342,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
@@ -22928,6 +23136,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
@@ -23246,6 +23467,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
@@ -24162,6 +24396,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
@@ -24940,6 +25187,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
@@ -25217,6 +25477,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
@@ -28983,6 +29256,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
@@ -29637,6 +29923,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
@@ -29979,6 +30278,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
@@ -30815,6 +31127,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
@@ -31055,6 +31380,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
@@ -31315,6 +31653,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
@@ -31984,6 +32335,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
@@ -32643,6 +33007,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
@@ -33261,6 +33638,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
@@ -33686,6 +34076,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
@@ -34073,6 +34476,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
@@ -34565,6 +34981,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
@@ -35030,6 +35459,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
@@ -35231,6 +35673,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
@@ -35430,6 +35885,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
@@ -35811,6 +36279,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
@@ -41146,6 +41627,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
@@ -41348,6 +41842,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
@@ -41560,6 +42067,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
@@ -42455,6 +42975,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
@@ -42821,6 +43354,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
@@ -43035,6 +43581,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
@@ -43236,6 +43795,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
@@ -43453,6 +44025,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
@@ -44557,6 +45142,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
@@ -44785,6 +45383,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
@@ -45008,6 +45619,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
@@ -45282,6 +45906,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
@@ -45817,6 +46454,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
@@ -46030,6 +46680,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
@@ -46230,6 +46893,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
@@ -46585,6 +47261,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
@@ -52020,6 +52709,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
@@ -53065,6 +53767,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
@@ -53265,6 +53980,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
@@ -53480,6 +54208,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
@@ -53679,6 +54420,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
@@ -53877,6 +54631,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
@@ -54075,6 +54842,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
@@ -54273,6 +55053,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
@@ -54474,6 +55267,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
@@ -54671,6 +55477,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
@@ -54873,6 +55692,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
@@ -55086,6 +55918,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
@@ -55983,6 +56828,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
@@ -56832,6 +57690,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
@@ -62165,6 +63036,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
@@ -62533,6 +63417,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
@@ -67886,6 +68783,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
@@ -68403,6 +69313,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
@@ -68936,6 +69859,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
@@ -70394,6 +71330,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
@@ -70592,6 +71541,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
@@ -70828,6 +71790,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
@@ -72048,6 +73023,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
@@ -72400,6 +73388,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
@@ -77796,6 +78797,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
@@ -78097,6 +79111,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
@@ -78295,6 +79322,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
@@ -78505,6 +79545,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
@@ -78835,6 +79888,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
@@ -79038,6 +80104,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
@@ -79248,6 +80327,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
@@ -79504,6 +80596,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
@@ -79717,6 +80822,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