From e65aea4b6cfd98426b666e3f0ae245a4c1e3fa00 Mon Sep 17 00:00:00 2001
From: Hong Minhee <hong@minhee.org>
Date: Mon, 5 Oct 2026 23:17:09 +0900
Subject: [PATCH 1/2] Document shallow vocabulary clones and hydration

Clarify that clone() copies property arrays but shares nested objects
and URLs, and that dereferencing accessors cache fetched objects.
Explain parent serialization caches and embedded @context reparsing.

Show a JSON-LD round trip for resolving a separate object graph, with
custom loaders and a caveat about cross-origin objects being fetched
again. Link the clone() JSDoc to the manual and refresh all runtime
snapshots.

Codex drafted the documentation and example. Claude Code reviewed them
and helped correct the cache and loader caveats.

Fixes https://github.com/fedify-dev/fedify/issues/1242

Changelog: none
Assisted-by: Codex:gpt-6.1-sol
Assisted-by: Claude Code:claude-fable-5-1
---
 docs/manual/vocab.md                          |   64 +-
 .../src/__snapshots__/class.test.ts.deno.snap | 1118 +++++++++++++++++
 .../src/__snapshots__/class.test.ts.node.snap | 1118 +++++++++++++++++
 .../src/__snapshots__/class.test.ts.snap      | 1118 +++++++++++++++++
 packages/vocab-tools/src/constructor.ts       |   13 +
 5 files changed, 3419 insertions(+), 12 deletions(-)

diff --git a/docs/manual/vocab.md b/docs/manual/vocab.md
index 384a896be..9d190fa74 100644
--- a/docs/manual/vocab.md
+++ b/docs/manual/vocab.md
@@ -835,7 +835,18 @@ const note = await create.getObject();
 const note2 = await create.getObject();
 ~~~~
 
-Hydrating the property also affects the JSON-LD representation of the object.
+Hydration caches the fetched object in the instance whose accessor was called.
+All references to that instance see the hydrated property, including references
+from a source and its [shallow clone](#immutability) to a shared nested object,
+or from an activity that embeds it.  Hydrating a top-level property of a clone
+does not update the source's property, because their property arrays are
+separate.
+
+Hydration can also affect `toJsonLd()` output, including output from activities
+that embed the hydrated object.  Objects parsed with `fromJsonLd()` may retain
+cached JSON-LD.  Hydration clears the cache only on the instance whose accessor
+fetched the object; parent caches remain intact.  A parent may therefore
+serialize differently on its own and when embedded in another activity.
 
 For example, since the following code does not hydrate the `object` property,
 the JSON-LD representation of the `Create` object has the `object` property
@@ -904,16 +915,13 @@ attributes are simplified or omitted for readability):
 Immutability
 ------------
 
-Every object in the Activity Vocabulary is represented as an immutable object.
-This means that you cannot change the properties of the object after the object
-is instantiated.  This is for ensuring the consistency of the objects and the
-safety of the objects in the concurrent environment.
+Activity Vocabulary objects are immutable in the sense that you cannot assign
+new property values after construction.  Dereferencing accessors can still
+cache fetched objects through [property hydration](#property-hydration).
 
-In order to change the properties of the object, you need to clone the object
-with the new properties.  Fortunately, the objects have a `clone()` method that
-takes an object with the new properties and returns a new object with the new
-properties.  The following shows an example of changing the `~Object.content`
-property of a `Note` object:
+To replace property values, use `clone()`.  It returns a new instance with the
+given values and leaves the source's property values unchanged.  The following
+example replaces the `~Object.content` property of a `Note` object:
 
 ~~~~ typescript{8-10} twoslash
 import { Note } from "@fedify/vocab";
@@ -929,8 +937,40 @@ const noteInChinese = noteInEnglish.clone({
 });
 ~~~~
 
-Parameters of the `clone()` method share the same type with parameters of
-the constructor.
+The `clone()` method accepts the same property values as the constructor.
+It makes a *shallow copy*: the clone has its own property arrays, but nested
+objects and URLs are shared with the source.  Hydrating a shared nested object
+through either instance changes that nested object for both when their accessors
+return the shared instance.  A parsed source can return a fresh object instead:
+if its cached JSON-LD contains an embedded object with its own `@context`, the
+accessor re-parses that object on each call.  Hydrating that returned object
+does not update the nested instance stored in the source or clone.
+
+If you need to preserve the received representation while resolving properties,
+keep the received JSON-LD document.  To resolve properties in a separate object
+graph, serialize and re-parse the object before hydrating any properties rather
+than using `clone()`:
+
+~~~~ typescript twoslash
+import { Create } from "@fedify/vocab";
+import type { DocumentLoader } from "@fedify/vocab-runtime";
+declare const original: Create;
+declare const documentLoader: DocumentLoader;
+declare const contextLoader: DocumentLoader;
+// ---cut-before---
+const options = { documentLoader, contextLoader };
+const copy = await Create.fromJsonLd(await original.toJsonLd(), options);
+// Resolve properties on copy while keeping original separate:
+const note = await copy.getObject(options);
+if (note != null) await note.getAttribution(options);
+~~~~
+
+This round trip separates nested vocabulary objects; it does not preserve the
+original JSON bytes.  Pass any custom loaders again, as in the example above.
+The copy also does not inherit trust in embedded objects.  Under the
+[origin-based security model](#origin-based-security-model), accessors may fetch
+cross-origin objects again, even if the original already hydrated them.  The
+fetched data may have changed, or the fetch may fail.
 
 
 Looking up remote objects
diff --git a/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap b/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap
index f9a1a6c3a..3980adb5b 100644
--- a/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap
+++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 |
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
diff --git a/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap b/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap
index 076a316b6..eab12f8ff 100644
--- a/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap
+++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap
@@ -1278,6 +1278,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -19040,6 +19053,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -19512,6 +19538,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -21414,6 +21453,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -26318,6 +26370,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -26821,6 +26886,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -27564,6 +27642,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -28230,6 +28321,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -29733,6 +29837,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -30285,6 +30402,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -31364,6 +31494,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -32059,6 +32202,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -33561,6 +33717,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -34009,6 +34178,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -35511,6 +35693,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -35959,6 +36154,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -37460,6 +37668,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -38080,6 +38301,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -39969,6 +40203,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -41465,6 +41712,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -42090,6 +42350,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -49096,6 +49369,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -50122,6 +50408,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -50812,6 +51111,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -52406,6 +52718,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -52914,6 +53239,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -53433,6 +53771,19 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -54799,6 +55150,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -56037,6 +56401,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -57218,6 +57595,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -57980,6 +58370,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -58752,6 +59155,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -59798,6 +60214,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -60693,6 +61122,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -61115,6 +61557,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -61532,6 +61987,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -62470,6 +62938,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -72679,6 +73160,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -73108,6 +73602,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -73562,6 +74069,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -75237,6 +75757,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76021,6 +76554,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76450,6 +76996,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -76872,6 +77431,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -77331,6 +77903,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -79358,6 +79943,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -79774,6 +80372,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -80188,6 +80799,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -80761,6 +81385,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -81969,6 +82606,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -82399,6 +83049,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -82817,6 +83480,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -83755,6 +84431,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -94212,6 +94901,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -96186,6 +96888,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -96582,6 +97297,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97012,6 +97740,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97432,6 +98173,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -97848,6 +98602,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -98264,6 +99031,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -98680,6 +99460,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99094,6 +99887,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99488,6 +100294,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -99893,6 +100712,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -100349,6 +101181,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -102021,6 +102866,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -103658,6 +104516,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -113858,6 +114729,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -114809,6 +115693,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -125096,6 +125993,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -126234,6 +127144,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -127320,6 +128243,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -130147,6 +131083,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -130563,6 +131512,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -131086,6 +132048,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -133510,6 +134485,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -134448,6 +135436,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -144767,6 +145768,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -145444,6 +146458,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -145860,6 +146887,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -146323,6 +147363,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147043,6 +148096,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147464,6 +148530,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -147883,6 +148962,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -148291,6 +149383,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
@@ -148719,6 +149824,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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
diff --git a/packages/vocab-tools/src/__snapshots__/class.test.ts.snap b/packages/vocab-tools/src/__snapshots__/class.test.ts.snap
index 5b03d3825..a615c6a67 100644
--- a/packages/vocab-tools/src/__snapshots__/class.test.ts.snap
+++ b/packages/vocab-tools/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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation 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 cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document
diff --git a/packages/vocab-tools/src/constructor.ts b/packages/vocab-tools/src/constructor.ts
index 41070a382..c8a16b8a1 100644
--- a/packages/vocab-tools/src/constructor.ts
+++ b/packages/vocab-tools/src/constructor.ts
@@ -211,6 +211,19 @@ export async function* generateCloner(
   /**
    * Clones this instance, optionally updating it with the given values.
    *
+   * This is a shallow copy: property arrays are copied, but nested objects
+   * and URLs are shared with this instance.  Dereferencing accessors cache
+   * fetched objects in the instance whose accessor is called.  Hydrating a
+   * shared nested object through the clone can affect the original as well,
+   * and can change JSON-LD output when either is embedded in another
+   * object.  Hydrating a top-level property of the clone does not update this
+   * instance's property.
+   *
+   * To resolve properties without sharing nested objects, serialize and
+   * re-parse the instance before hydration rather than using this method.
+   * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+   * for details, including how cached JSON-LD affects serialization.
+   *
    * A clone never inherits a signed JSON-LD representation retained by
    * \`signObject()\`: the clone may differ from the document that the proof
    * covers, so embedding the original secured JSON in a parent document

From 453e505063bad57a100c7c489cd59e4cb85c1b7d Mon Sep 17 00:00:00 2001
From: Hong Minhee <hong@minhee.org>
Date: Tue, 6 Oct 2026 00:22:07 +0900
Subject: [PATCH 2/2] Qualify hydration caching in vocabulary docs

Unverified portable claims are returned without replacing property URLs
or invalidating cached JSON-LD. Explain this exception in the manual
and qualify the clone() JSDoc so readers do not expect every accessor
result to be cached. Refresh the three runtime generation snapshots.

Codex assisted with the documentation and validation.

https://github.com/fedify-dev/fedify/pull/1246#discussion_r4185514128

Changelog: none
Assisted-by: Codex:gpt-6.1-sol
---
 docs/manual/vocab.md                          |  15 +-
 .../src/__snapshots__/class.test.ts.deno.snap | 172 +++++++++---------
 .../src/__snapshots__/class.test.ts.node.snap | 172 +++++++++---------
 .../src/__snapshots__/class.test.ts.snap      | 172 +++++++++---------
 packages/vocab-tools/src/constructor.ts       |   2 +-
 5 files changed, 269 insertions(+), 264 deletions(-)

diff --git a/docs/manual/vocab.md b/docs/manual/vocab.md
index 9d190fa74..b35264802 100644
--- a/docs/manual/vocab.md
+++ b/docs/manual/vocab.md
@@ -835,8 +835,12 @@ const note = await create.getObject();
 const note2 = await create.getObject();
 ~~~~
 
-Hydration caches the fetched object in the instance whose accessor was called.
-All references to that instance see the hydrated property, including references
+When hydration caches a fetched object, it replaces the property's URL in the
+instance whose accessor was called.  An unverified portable claim can be
+returned without replacing that URL or clearing the JSON-LD cache, so a later
+accessor call can fetch it again.
+When the result is cached, all references to that instance see the hydrated
+property, including references
 from a source and its [shallow clone](#immutability) to a shared nested object,
 or from an activity that embeds it.  Hydrating a top-level property of a clone
 does not update the source's property, because their property arrays are
@@ -844,9 +848,10 @@ separate.
 
 Hydration can also affect `toJsonLd()` output, including output from activities
 that embed the hydrated object.  Objects parsed with `fromJsonLd()` may retain
-cached JSON-LD.  Hydration clears the cache only on the instance whose accessor
-fetched the object; parent caches remain intact.  A parent may therefore
-serialize differently on its own and when embedded in another activity.
+cached JSON-LD.  Caching a fetched object clears the JSON-LD cache only on the
+instance whose accessor fetched it; parent caches remain intact.  A parent may
+therefore serialize differently on its own and when embedded in another
+activity.
 
 For example, since the following code does not hydrate the `object` property,
 the JSON-LD representation of the `Create` object has the `object` property
diff --git a/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap b/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap
index 3980adb5b..998deb769 100644
--- a/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap
+++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap
@@ -1281,7 +1281,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -19056,7 +19056,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -19541,7 +19541,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -21456,7 +21456,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -26373,7 +26373,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -26889,7 +26889,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -27645,7 +27645,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -28324,7 +28324,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -29840,7 +29840,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -30405,7 +30405,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -31497,7 +31497,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -32205,7 +32205,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -33720,7 +33720,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -34181,7 +34181,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -35696,7 +35696,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -36157,7 +36157,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -37671,7 +37671,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -38304,7 +38304,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -40206,7 +40206,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -41715,7 +41715,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -42353,7 +42353,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -49372,7 +49372,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -50411,7 +50411,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -51114,7 +51114,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -52721,7 +52721,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -53242,7 +53242,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -53774,7 +53774,7 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -55153,7 +55153,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -56404,7 +56404,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -57598,7 +57598,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -58373,7 +58373,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -59158,7 +59158,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -60217,7 +60217,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61125,7 +61125,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61560,7 +61560,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61990,7 +61990,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -62941,7 +62941,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -73163,7 +73163,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -73605,7 +73605,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -74072,7 +74072,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -75760,7 +75760,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -76557,7 +76557,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -76999,7 +76999,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -77434,7 +77434,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -77906,7 +77906,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -79946,7 +79946,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -80375,7 +80375,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -80802,7 +80802,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -81388,7 +81388,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -82609,7 +82609,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -83052,7 +83052,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -83483,7 +83483,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -84434,7 +84434,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -94904,7 +94904,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -96891,7 +96891,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -97300,7 +97300,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -97743,7 +97743,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -98176,7 +98176,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -98605,7 +98605,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99034,7 +99034,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99463,7 +99463,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99890,7 +99890,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -100297,7 +100297,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -100715,7 +100715,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -101184,7 +101184,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -102869,7 +102869,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -104519,7 +104519,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -114732,7 +114732,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -115696,7 +115696,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -125996,7 +125996,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -127147,7 +127147,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -128246,7 +128246,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -131086,7 +131086,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -131515,7 +131515,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -132051,7 +132051,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -134488,7 +134488,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -135439,7 +135439,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -145771,7 +145771,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -146461,7 +146461,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -146890,7 +146890,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -147366,7 +147366,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148099,7 +148099,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148533,7 +148533,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148965,7 +148965,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -149386,7 +149386,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -149827,7 +149827,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
diff --git a/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap b/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap
index eab12f8ff..302171821 100644
--- a/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap
+++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap
@@ -1279,7 +1279,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -19054,7 +19054,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -19539,7 +19539,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -21454,7 +21454,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -26371,7 +26371,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -26887,7 +26887,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -27643,7 +27643,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -28322,7 +28322,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -29838,7 +29838,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -30403,7 +30403,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -31495,7 +31495,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -32203,7 +32203,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -33718,7 +33718,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -34179,7 +34179,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -35694,7 +35694,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -36155,7 +36155,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -37669,7 +37669,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -38302,7 +38302,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -40204,7 +40204,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -41713,7 +41713,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -42351,7 +42351,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -49370,7 +49370,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -50409,7 +50409,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -51112,7 +51112,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -52719,7 +52719,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -53240,7 +53240,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -53772,7 +53772,7 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -55151,7 +55151,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -56402,7 +56402,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -57596,7 +57596,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -58371,7 +58371,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -59156,7 +59156,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -60215,7 +60215,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61123,7 +61123,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61558,7 +61558,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61988,7 +61988,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -62939,7 +62939,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -73161,7 +73161,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -73603,7 +73603,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -74070,7 +74070,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -75758,7 +75758,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -76555,7 +76555,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -76997,7 +76997,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -77432,7 +77432,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -77904,7 +77904,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -79944,7 +79944,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -80373,7 +80373,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -80800,7 +80800,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -81386,7 +81386,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -82607,7 +82607,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -83050,7 +83050,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -83481,7 +83481,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -84432,7 +84432,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -94902,7 +94902,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -96889,7 +96889,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -97298,7 +97298,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -97741,7 +97741,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -98174,7 +98174,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -98603,7 +98603,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99032,7 +99032,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99461,7 +99461,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99888,7 +99888,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -100295,7 +100295,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -100713,7 +100713,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -101182,7 +101182,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -102867,7 +102867,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -104517,7 +104517,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -114730,7 +114730,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -115694,7 +115694,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -125994,7 +125994,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -127145,7 +127145,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -128244,7 +128244,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -131084,7 +131084,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -131513,7 +131513,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -132049,7 +132049,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -134486,7 +134486,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -135437,7 +135437,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -145769,7 +145769,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -146459,7 +146459,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -146888,7 +146888,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -147364,7 +147364,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148097,7 +148097,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148531,7 +148531,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148963,7 +148963,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -149384,7 +149384,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -149825,7 +149825,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
diff --git a/packages/vocab-tools/src/__snapshots__/class.test.ts.snap b/packages/vocab-tools/src/__snapshots__/class.test.ts.snap
index a615c6a67..4f271e087 100644
--- a/packages/vocab-tools/src/__snapshots__/class.test.ts.snap
+++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.snap
@@ -1281,7 +1281,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -19056,7 +19056,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -19541,7 +19541,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -21456,7 +21456,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -26373,7 +26373,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -26889,7 +26889,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -27645,7 +27645,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -28324,7 +28324,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -29840,7 +29840,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -30405,7 +30405,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -31497,7 +31497,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -32205,7 +32205,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -33720,7 +33720,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -34181,7 +34181,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -35696,7 +35696,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -36157,7 +36157,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -37671,7 +37671,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -38304,7 +38304,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -40206,7 +40206,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -41715,7 +41715,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -42353,7 +42353,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -49372,7 +49372,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -50411,7 +50411,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -51114,7 +51114,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -52721,7 +52721,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -53242,7 +53242,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -53774,7 +53774,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -55153,7 +55153,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -56404,7 +56404,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -57598,7 +57598,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -58373,7 +58373,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -59158,7 +59158,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -60217,7 +60217,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61125,7 +61125,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61560,7 +61560,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -61990,7 +61990,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -62941,7 +62941,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -73163,7 +73163,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -73605,7 +73605,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -74072,7 +74072,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -75760,7 +75760,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -76557,7 +76557,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -76999,7 +76999,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -77434,7 +77434,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -77906,7 +77906,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -79946,7 +79946,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -80375,7 +80375,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -80802,7 +80802,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -81388,7 +81388,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -82609,7 +82609,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -83052,7 +83052,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -83483,7 +83483,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -84434,7 +84434,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -94904,7 +94904,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -96891,7 +96891,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -97300,7 +97300,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -97743,7 +97743,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -98176,7 +98176,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -98605,7 +98605,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99034,7 +99034,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99463,7 +99463,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -99890,7 +99890,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -100297,7 +100297,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -100715,7 +100715,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -101184,7 +101184,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -102869,7 +102869,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -104519,7 +104519,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -114732,7 +114732,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -115696,7 +115696,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -125996,7 +125996,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -127147,7 +127147,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -128246,7 +128246,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -131086,7 +131086,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -131515,7 +131515,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -132051,7 +132051,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -134488,7 +134488,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -135439,7 +135439,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -145771,7 +145771,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -146461,7 +146461,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -146890,7 +146890,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -147366,7 +147366,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148099,7 +148099,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148533,7 +148533,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -148965,7 +148965,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -149386,7 +149386,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
@@ -149827,7 +149827,7 @@ 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 cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another
diff --git a/packages/vocab-tools/src/constructor.ts b/packages/vocab-tools/src/constructor.ts
index c8a16b8a1..a27a2c5f4 100644
--- a/packages/vocab-tools/src/constructor.ts
+++ b/packages/vocab-tools/src/constructor.ts
@@ -212,7 +212,7 @@ export async function* generateCloner(
    * Clones this instance, optionally updating it with the given values.
    *
    * This is a shallow copy: property arrays are copied, but nested objects
-   * and URLs are shared with this instance.  Dereferencing accessors cache
+   * and URLs are shared with this instance.  Dereferencing accessors can cache
    * fetched objects in the instance whose accessor is called.  Hydrating a
    * shared nested object through the clone can affect the original as well,
    * and can change JSON-LD output when either is embedded in another