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

package/dist/mod.js

@@ -12,7 +12,7 @@ import { isTemporalDuration, isTemporalInstant } from "@fedify/vocab-runtime/tem
 import { delay } from "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) {
@@ -687,6 +687,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
@@ -10139,6 +10152,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
@@ -10367,6 +10393,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
@@ -11333,6 +11372,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
@@ -13761,6 +13813,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
@@ -14022,6 +14087,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
@@ -14386,6 +14464,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
@@ -14703,6 +14794,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
@@ -15484,6 +15588,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
@@ -15754,6 +15871,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
@@ -16255,6 +16385,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
@@ -16566,6 +16709,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
@@ -17346,6 +17502,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
@@ -17562,6 +17731,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
@@ -18342,6 +18524,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
@@ -18558,6 +18753,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
@@ -19339,6 +19547,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
@@ -19657,6 +19878,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
@@ -20573,6 +20807,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
@@ -21351,6 +21598,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
@@ -21628,6 +21888,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
@@ -25394,6 +25667,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
@@ -26048,6 +26334,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
@@ -26390,6 +26689,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
@@ -27226,6 +27538,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
@@ -27466,6 +27791,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
@@ -27726,6 +28064,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
@@ -28395,6 +28746,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
@@ -29054,6 +29418,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
@@ -29672,6 +30049,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
@@ -30097,6 +30487,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
@@ -30484,6 +30887,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
@@ -30976,6 +31392,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
@@ -31441,6 +31870,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
@@ -31642,6 +32084,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
@@ -31841,6 +32296,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
@@ -32222,6 +32690,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
@@ -37557,6 +38038,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
@@ -37759,6 +38253,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
@@ -37971,6 +38478,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
@@ -38866,6 +39386,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
@@ -39232,6 +39765,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
@@ -39446,6 +39992,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
@@ -39647,6 +40206,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
@@ -39864,6 +40436,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
@@ -40968,6 +41553,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
@@ -41196,6 +41794,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
@@ -41419,6 +42030,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
@@ -41693,6 +42317,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
@@ -42228,6 +42865,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
@@ -42441,6 +43091,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
@@ -42641,6 +43304,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
@@ -42996,6 +43672,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
@@ -48431,6 +49120,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
@@ -49476,6 +50178,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
@@ -49676,6 +50391,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
@@ -49891,6 +50619,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
@@ -50090,6 +50831,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
@@ -50288,6 +51042,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
@@ -50486,6 +51253,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
@@ -50684,6 +51464,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
@@ -50885,6 +51678,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
@@ -51082,6 +51888,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
@@ -51284,6 +52103,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
@@ -51497,6 +52329,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
@@ -52394,6 +53239,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
@@ -53243,6 +54101,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
@@ -58576,6 +59447,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
@@ -58944,6 +59828,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
@@ -64297,6 +65194,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
@@ -64814,6 +65724,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
@@ -65347,6 +66270,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
@@ -66805,6 +67741,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
@@ -67003,6 +67952,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
@@ -67239,6 +68201,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
@@ -68459,6 +69434,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
@@ -68811,6 +69799,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
@@ -74207,6 +75208,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
@@ -74508,6 +75522,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
@@ -74706,6 +75733,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
@@ -74916,6 +75956,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
@@ -75246,6 +76299,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
@@ -75449,6 +76515,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
@@ -75659,6 +76738,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
@@ -75915,6 +77007,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
@@ -76128,6 +77233,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