@fedify/vocab-tools 2.4.1 → 2.4.2-dev.2357

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

@@ -1280,6 +1280,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -19042,6 +19055,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -19514,6 +19540,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -21416,6 +21455,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -26320,6 +26372,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -26823,6 +26888,19 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -27566,6 +27644,19 @@ unit?: string | null;numericalValue?: Decimal | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -28232,6 +28323,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -29735,6 +29839,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -30287,6 +30404,19 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?:
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -31366,6 +31496,19 @@ manualApprovals?: (URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -32061,6 +32204,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -33563,6 +33719,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -34011,6 +34180,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -35513,6 +35695,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -35961,6 +36156,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -37462,6 +37670,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -38082,6 +38303,19 @@ urls?: ((URL | Link))[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -39971,6 +40205,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -41467,6 +41714,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -42092,6 +42352,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -49098,6 +49371,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -50124,6 +50410,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -50814,6 +51113,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -52408,6 +52720,19 @@ endpoints?: (URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -52916,6 +53241,19 @@ endpoints?: (URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -53435,6 +53773,19 @@ cryptosuite?: "eddsa-jcs-2022" | null;verificationMethod?: Multikey | URL | null
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -54801,6 +55152,19 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -56039,6 +56403,19 @@ controller?: Application | Group | Organization | Person | Service | URL | null;
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -57220,6 +57597,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -57982,6 +58372,19 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -58754,6 +59157,19 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -59800,6 +60216,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -60695,6 +61124,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -61117,6 +61559,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -61534,6 +61989,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -62472,6 +62940,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -72681,6 +73162,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -73110,6 +73604,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -73564,6 +74071,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -75239,6 +75759,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76023,6 +76556,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76452,6 +76998,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76874,6 +77433,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -77333,6 +77905,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -79360,6 +79945,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -79776,6 +80374,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -80190,6 +80801,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -80763,6 +81387,19 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -81971,6 +82608,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -82401,6 +83051,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -82819,6 +83482,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -83757,6 +84433,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -94214,6 +94903,19 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -96188,6 +96890,19 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -96584,6 +97299,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97014,6 +97742,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97434,6 +98175,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97850,6 +98604,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -98266,6 +99033,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -98682,6 +99462,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99096,6 +99889,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99490,6 +100296,19 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99895,6 +100714,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -100351,6 +101183,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -102023,6 +102868,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -103660,6 +104518,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -113860,6 +114731,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -114811,6 +115695,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -125098,6 +125995,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -126236,6 +127146,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -127322,6 +128245,19 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -130149,6 +131085,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -130565,6 +131514,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -131088,6 +132050,19 @@ relationships?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -133512,6 +134487,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -134450,6 +135438,19 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -144769,6 +145770,19 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -145446,6 +146460,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -145862,6 +146889,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -146325,6 +147365,19 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147045,6 +148098,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147466,6 +148532,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147885,6 +148964,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -148293,6 +149385,19 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -148721,6 +149826,19 @@ instruments?: (Object | URL)[];}
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document