From 119852c8163e58656f36f5c65948d9f2d8b7598e Mon Sep 17 00:00:00 2001 From: Hong Minhee Date: Sun, 15 Nov 2026 04:01:11 +0900 Subject: [PATCH 1/2] Warn when clone() drops the portable verifier Generated clone() methods do not inherit the source object's default FEP-ef61 portable object verifier. Objects that Fedify parses for applications, such as inbox activities and lookupObject() results, carry ctx.verifyPortableObject as their default, so cloning them silently turned verification off for the clone's accessors. The contract was only mentioned in the manual. clone() keeps its behavior, but now: - documents the contract in its generated JSDoc, including that loaders are not inherited either; - logs a warning in the ["fedify", "vocab", "portable"] category when the source has a default verifier and the call does not pass the verifyPortableObject option. An explicit verifyPortableObject: undefined opts out, and the option type accepts undefined so that the opt-out also type-checks with exactOptionalPropertyTypes. The warning is emitted only by the root class, so it fires once per call through the subclass chain, and the options spread for $warning keeps an inherited or non-enumerable verifyPortableObject key. Fedify's own clone() calls no longer drop the verifier: signObject(), autoIdAssigner(), actorDehydrator(), the key-fetching paths, and MockFederation.receiveActivity() pass the source's default verifier on, read through the protected _verifyPortableObject accessor, which is now documented as an internal cross-package contract. The temporary clone that createProof() serializes opts out explicitly. The vocabulary and logging manuals describe the warning and how to keep or drop the verifier. Sacho is upgraded from 0.3.2 to 0.4.0, since 0.3.2 refuses to sync the unreleased region of this long CHANGES.md with a spurious link-target error ("would change a link target outside the unreleased region") as soon as any fragment exists. https://github.com/fedify-dev/fedify/issues/1399 Assisted-by: Claude Code:claude-opus-5-5 Assisted-by: Codex:gpt-6-astra Assisted-by: Antigravity:gemini-4-hydrogen Assisted-by: Claude Code:claude-fable-5-2 --- CHANGES.md | 49 + changes.d/fedify/clone-portable-verifier.md | 14 + changes.d/testing/clone-portable-verifier.md | 11 + .../vocab-tools/clone-portable-verifier.md | 15 + changes.d/vocab/clone-portable-verifier.md | 21 + docs/manual/log.md | 11 + docs/manual/vocab.md | 33 +- mise.toml | 2 +- packages/fedify/src/compat/transformers.ts | 9 +- packages/fedify/src/sig/key.ts | 13 +- packages/fedify/src/sig/owner.ts | 7 +- packages/fedify/src/sig/proof.ts | 9 +- .../src/utils/portable-verifier.test.ts | 149 + .../fedify/src/utils/portable-verifier.ts | 23 + packages/testing/package.json | 1 + packages/testing/src/mock.test.ts | 60 + packages/testing/src/mock.ts | 4 + .../src/__snapshots__/class.test.ts.deno.snap | 3568 +++++++++++++++-- .../src/__snapshots__/class.test.ts.node.snap | 3568 +++++++++++++++-- .../src/__snapshots__/class.test.ts.snap | 3568 +++++++++++++++-- packages/vocab-tools/src/class.ts | 6 + packages/vocab-tools/src/constructor.ts | 55 +- packages/vocab/src/gateway.test.ts | 104 + pnpm-lock.yaml | 3 + 24 files changed, 10517 insertions(+), 786 deletions(-) create mode 100644 changes.d/fedify/clone-portable-verifier.md create mode 100644 changes.d/testing/clone-portable-verifier.md create mode 100644 changes.d/vocab-tools/clone-portable-verifier.md create mode 100644 changes.d/vocab/clone-portable-verifier.md create mode 100644 packages/fedify/src/utils/portable-verifier.test.ts create mode 100644 packages/fedify/src/utils/portable-verifier.ts diff --git a/CHANGES.md b/CHANGES.md index 9b8fdf817..60b3d664b 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -8,6 +8,55 @@ Version 2.4.6 To be released. +### @fedify/fedify + + - Fixed `signObject()` and the default activity transformers, + `autoIdAssigner()` and `actorDehydrator()`, dropping the default [FEP-ef61] + portable object verifier of the object they returned a copy of. Their + results now keep the verifier, so their accessors verify portable objects + as the original object's accessors do, and they no longer log + the warning that `clone()` logs when it drops the verifier. + [[#1399], [#1442]] + +[FEP-ef61]: https://w3id.org/fep/ef61 +[#1399]: https://github.com/fedify-dev/fedify/issues/1399 +[#1442]: https://github.com/fedify-dev/fedify/pull/1442 + +### @fedify/testing + + - Fixed `MockFederation.receiveActivity()` dropping the default [FEP-ef61] + portable object verifier of the received activity when it attaches its + document loaders to the activity passed to inbox listeners. + [[#1399], [#1442]] + +### @fedify/vocab + + - Added a warning when `clone()` drops the default [FEP-ef61] portable object + verifier of a vocabulary object, and documented that `clone()` does not + inherit it. Objects that Fedify parses for you, such as activities that + inboxes receive and the results of `Context.lookupObject()`, have + `Context.verifyPortableObject` as their default, so an existing + application that clones them now logs a warning in the + `["fedify", "vocab", "portable"]` category. A clone without a verifier + does not verify the portable objects embedded in it, and refuses to + dereference portable references. Pass + `verifyPortableObject: ctx.verifyPortableObject` to `clone()` to keep + verifying them, or `verifyPortableObject: undefined` to drop the verifier + deliberately without the warning. The `verifyPortableObject` option of + `clone()` now explicitly accepts `undefined`, so that the opt-out also + type-checks with `exactOptionalPropertyTypes`. [[#1399], [#1442]] + +### @fedify/vocab-tools + + - Generated `clone()` methods now log a warning in the + `["fedify", "vocab", "portable"]` category when they drop the default + [FEP-ef61] portable object verifier of the source object, i.e., when the + source has one and the call does not pass the `verifyPortableObject` + option. An explicit `verifyPortableObject: undefined` drops it without + the warning. Their API documentation now states that `clone()` does not + inherit the default verifier. Regenerate custom vocabularies to get + the warning. [[#1399], [#1442]] + Version 2.4.5 ------------- diff --git a/changes.d/fedify/clone-portable-verifier.md b/changes.d/fedify/clone-portable-verifier.md new file mode 100644 index 000000000..01d822781 --- /dev/null +++ b/changes.d/fedify/clone-portable-verifier.md @@ -0,0 +1,14 @@ +--- +links: + '#1399': https://github.com/fedify-dev/fedify/issues/1399 + '#1442': https://github.com/fedify-dev/fedify/pull/1442 +--- + - Fixed `signObject()` and the default activity transformers, + `autoIdAssigner()` and `actorDehydrator()`, dropping the default [FEP-ef61] + portable object verifier of the object they returned a copy of. Their + results now keep the verifier, so their accessors verify portable objects + as the original object's accessors do, and they no longer log + the warning that `clone()` logs when it drops the verifier. + [[#1399], [#1442]] + +[FEP-ef61]: https://w3id.org/fep/ef61 diff --git a/changes.d/testing/clone-portable-verifier.md b/changes.d/testing/clone-portable-verifier.md new file mode 100644 index 000000000..98d5b59e2 --- /dev/null +++ b/changes.d/testing/clone-portable-verifier.md @@ -0,0 +1,11 @@ +--- +links: + '#1399': https://github.com/fedify-dev/fedify/issues/1399 + '#1442': https://github.com/fedify-dev/fedify/pull/1442 +--- + - Fixed `MockFederation.receiveActivity()` dropping the default [FEP-ef61] + portable object verifier of the received activity when it attaches its + document loaders to the activity passed to inbox listeners. + [[#1399], [#1442]] + +[FEP-ef61]: https://w3id.org/fep/ef61 diff --git a/changes.d/vocab-tools/clone-portable-verifier.md b/changes.d/vocab-tools/clone-portable-verifier.md new file mode 100644 index 000000000..09cae641d --- /dev/null +++ b/changes.d/vocab-tools/clone-portable-verifier.md @@ -0,0 +1,15 @@ +--- +links: + '#1399': https://github.com/fedify-dev/fedify/issues/1399 + '#1442': https://github.com/fedify-dev/fedify/pull/1442 +--- + - Generated `clone()` methods now log a warning in the + `["fedify", "vocab", "portable"]` category when they drop the default + [FEP-ef61] portable object verifier of the source object, i.e., when the + source has one and the call does not pass the `verifyPortableObject` + option. An explicit `verifyPortableObject: undefined` drops it without + the warning. Their API documentation now states that `clone()` does not + inherit the default verifier. Regenerate custom vocabularies to get + the warning. [[#1399], [#1442]] + +[FEP-ef61]: https://w3id.org/fep/ef61 diff --git a/changes.d/vocab/clone-portable-verifier.md b/changes.d/vocab/clone-portable-verifier.md new file mode 100644 index 000000000..63ea6e1be --- /dev/null +++ b/changes.d/vocab/clone-portable-verifier.md @@ -0,0 +1,21 @@ +--- +links: + '#1399': https://github.com/fedify-dev/fedify/issues/1399 + '#1442': https://github.com/fedify-dev/fedify/pull/1442 +--- + - Added a warning when `clone()` drops the default [FEP-ef61] portable object + verifier of a vocabulary object, and documented that `clone()` does not + inherit it. Objects that Fedify parses for you, such as activities that + inboxes receive and the results of `Context.lookupObject()`, have + `Context.verifyPortableObject` as their default, so an existing + application that clones them now logs a warning in the + `["fedify", "vocab", "portable"]` category. A clone without a verifier + does not verify the portable objects embedded in it, and refuses to + dereference portable references. Pass + `verifyPortableObject: ctx.verifyPortableObject` to `clone()` to keep + verifying them, or `verifyPortableObject: undefined` to drop the verifier + deliberately without the warning. The `verifyPortableObject` option of + `clone()` now explicitly accepts `undefined`, so that the opt-out also + type-checks with `exactOptionalPropertyTypes`. [[#1399], [#1442]] + +[FEP-ef61]: https://w3id.org/fep/ef61 diff --git a/docs/manual/log.md b/docs/manual/log.md index 745123671..0bc73aee3 100644 --- a/docs/manual/log.md +++ b/docs/manual/log.md @@ -301,6 +301,17 @@ related to looking up ActivityPub objects. When you are curious about the lookup process, you can check the log messages in this category with the `"debug"` level. +### `["fedify", "vocab", "portable"]` + +*This category is available since Fedify 2.4.6.* + +The `["fedify", "vocab", "portable"]` category is used for logging warnings +about [FEP-ef61 portable objects](./vocab.md#fep-ef61-portable-objects) in +the vocabulary API. For example, `clone()` logs a warning with the +`"warning"` level when it drops the default portable object verifier of +an object; see the [*Default verifiers* section](./vocab.md#default-verifiers) +of the *Vocabulary* chapter. + ### `["fedify", "webfinger", "server"]` *This category is available since Fedify 0.13.0.* diff --git a/docs/manual/vocab.md b/docs/manual/vocab.md index b35264802..2e9f801a4 100644 --- a/docs/manual/vocab.md +++ b/docs/manual/vocab.md @@ -545,8 +545,34 @@ have `~Context.verifyPortableObject` as their default: activities that inboxes receive, including queued ones, objects that `~Context.lookupObject()` returns, and the activities passed to the `onOutboxError` callback. So `create.getObject()` in an inbox listener verifies portable objects even -without options. A clone does not inherit the default; pass -`verifyPortableObject` to `clone()` if you need it. +without options. + +A [clone](#immutability) does not inherit the default, though. Without +a verifier, the clone's accessors no longer verify embedded portable objects, +and refuse to dereference portable references. So pass `verifyPortableObject` +to `clone()` if you need it: + +~~~~ typescript twoslash +import type { Context } from "@fedify/fedify"; +import type { Create } from "@fedify/vocab"; +declare const ctx: Context; +declare const create: Create; +// ---cut-before--- +const copy = create.clone( + { summary: "A copy" }, + // Keeps verifying portable objects that the copy's accessors dereference: + { verifyPortableObject: ctx.verifyPortableObject }, +); +~~~~ + +Cloning an object that has a default verifier without +the `verifyPortableObject` option logs a warning in the +[`["fedify", "vocab", "portable"]`](./log.md#fedify-vocab-portable) category. +Pass `verifyPortableObject: undefined` to drop the default deliberately +without the warning. Either way, nested objects that the clone shares with +the source keep their own defaults. To get a separate copy instead, serialize +the object and re-parse it with `fromJsonLd()`, passing the verifier again, +as the [*Immutability* section](#immutability) shows. #### Compatible identifiers @@ -950,6 +976,9 @@ 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. +The clone also does not inherit the source's document loaders or default +portable object verifier; see the [*Default verifiers* +section](#default-verifiers). If you need to preserve the received representation while resolving properties, keep the received JSON-LD document. To resolve properties in a separate object diff --git a/mise.toml b/mise.toml index 3acff559c..15b68e1db 100644 --- a/mise.toml +++ b/mise.toml @@ -20,7 +20,7 @@ pnpm = "10.28.0" # check-each, test-each, check-versions) so they run identically on Windows, # macOS, and Linux without Bash. "aqua:nushell/nushell" = "0.114.0" -"github:dahlia/sacho" = "0.3.2" +"github:dahlia/sacho" = "0.4.0" # Dependency providers # diff --git a/packages/fedify/src/compat/transformers.ts b/packages/fedify/src/compat/transformers.ts index c649935ec..265856c45 100644 --- a/packages/fedify/src/compat/transformers.ts +++ b/packages/fedify/src/compat/transformers.ts @@ -1,6 +1,7 @@ import type { Activity } from "@fedify/vocab"; import { getLogger } from "@logtape/logtape"; import type { Context } from "../federation/context.ts"; +import { getDefaultPortableObjectVerifier } from "../utils/portable-verifier.ts"; import type { ActivityTransformer } from "./types.ts"; const logger = getLogger(["fedify", "compat", "transformers"]); @@ -38,7 +39,10 @@ export function autoIdAssigner( "set the id for the activity.", { id: id.href }, ); - return activity.clone({ id }); + return activity.clone({ id }, { + // A clone does not inherit the default verifier, so keep it: + verifyPortableObject: getDefaultPortableObjectVerifier(activity), + }); } /** @@ -93,6 +97,9 @@ export function actorDehydrator( if (activity.actorIds.length < 1) return activity; return activity.clone({ actors: activity.actorIds, + }, { + // A clone does not inherit the default verifier, so keep it: + verifyPortableObject: getDefaultPortableObjectVerifier(activity), }); } diff --git a/packages/fedify/src/sig/key.ts b/packages/fedify/src/sig/key.ts index f19fbf6b1..7cfdd35fd 100644 --- a/packages/fedify/src/sig/key.ts +++ b/packages/fedify/src/sig/key.ts @@ -47,6 +47,7 @@ import type { PortableActorKeyResolution, PortableGatewayKeyResolution, } from "./portable-key.ts"; +import { getDefaultPortableObjectVerifier } from "../utils/portable-verifier.ts"; /** Classifies decoding failures without hiding unexpected loader errors. */ function classifyKeyJsonLdError( @@ -1300,7 +1301,9 @@ async function resolveFetchedKey( // fetched from is then the only id it has, and the ownership check below // needs an id to look for in the owner's document. key = object.id == null - ? (object as CryptographicKey).clone({ id: cacheKey }) as T + ? (object as CryptographicKey).clone({ id: cacheKey }, { + verifyPortableObject: getDefaultPortableObjectVerifier(object), + }) as T : object; } else if (isActor(object)) { // A host may only speak for actor ids on its own origin. Without this @@ -1423,8 +1426,12 @@ async function resolveFetchedKey( // own, so that one fetch settled the question. Record the answer on the // key, so that callers—and the key cache—never have to take it up again. key = key instanceof CryptographicKey - ? key.clone({ owner: ownerDocument.id! }) as T - : (key as Multikey).clone({ controller: ownerDocument.id! }) as T; + ? key.clone({ owner: ownerDocument.id! }, { + verifyPortableObject: getDefaultPortableObjectVerifier(key), + }) as T + : (key as Multikey).clone({ controller: ownerDocument.id! }, { + verifyPortableObject: getDefaultPortableObjectVerifier(key), + }) as T; } else if ( claimedOwnerId != null && claimedOwnerId.href !== ownerDocument?.id?.href diff --git a/packages/fedify/src/sig/owner.ts b/packages/fedify/src/sig/owner.ts index 9fa0a3818..9de59e572 100644 --- a/packages/fedify/src/sig/owner.ts +++ b/packages/fedify/src/sig/owner.ts @@ -30,6 +30,7 @@ import { isPortableUri, isSamePublicKey as isSameKeyMaterial, } from "./portable-key-id.ts"; +import { getDefaultPortableObjectVerifier } from "../utils/portable-verifier.ts"; export { exportJwk, generateCryptoKeyPair, importJwk } from "./key.ts"; const logger = getLogger(["fedify", "sig", "owner"]); @@ -338,7 +339,11 @@ export async function getKeyOwner( // key at all. if (object.id != null && object.id.href !== keyId.href) return null; return await verifyKeyOwnership( - object.id == null ? object.clone({ id: keyId }) : object, + object.id == null + ? object.clone({ id: keyId }, { + verifyPortableObject: getDefaultPortableObjectVerifier(object), + }) + : object, fetchOptions, ); } diff --git a/packages/fedify/src/sig/proof.ts b/packages/fedify/src/sig/proof.ts index 53d6466dc..83af39cc9 100644 --- a/packages/fedify/src/sig/proof.ts +++ b/packages/fedify/src/sig/proof.ts @@ -58,6 +58,7 @@ import { } from "./key.ts"; import { getNormalizationContextLoader } from "./ld.ts"; import { getPortableDid, isPortableId } from "./portable-key-id.ts"; +import { getDefaultPortableObjectVerifier } from "../utils/portable-verifier.ts"; /** * Known Object Integrity Proof `cryptosuite` values, used to keep @@ -263,7 +264,10 @@ async function createProofInternal( if (privateKey.algorithm.name !== "Ed25519") { throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name); } - const objectWithoutProofs = object.clone({ proofs: [] }); + // Only serialized below, so it needs no portable object verifier: + const objectWithoutProofs = object.clone({ proofs: [] }, { + verifyPortableObject: undefined, + }); let compactMsg = await objectWithoutProofs.toJsonLd({ format: "compact", contextLoader, @@ -427,6 +431,9 @@ export async function signObject( } const signed = object.clone({ proofs: [...existingProofs, proof], + }, { + // A clone does not inherit the default verifier, so keep it: + verifyPortableObject: getDefaultPortableObjectVerifier(object), }) as T; if (securedDocument != null) { // Retain the secured JSON document so that embedding this object in diff --git a/packages/fedify/src/utils/portable-verifier.test.ts b/packages/fedify/src/utils/portable-verifier.test.ts new file mode 100644 index 000000000..f27834f10 --- /dev/null +++ b/packages/fedify/src/utils/portable-verifier.test.ts @@ -0,0 +1,149 @@ +import { mockDocumentLoader, test } from "@fedify/fixture"; +import { Create, Follow, Note } from "@fedify/vocab"; +import type { + DocumentLoader, + PortableObjectVerifier, +} from "@fedify/vocab-runtime"; +import { configure, type LogRecord, reset } from "@logtape/logtape"; +import { + assertEquals, + assertInstanceOf, + assertStrictEquals, +} from "@std/assert"; +import { actorDehydrator, autoIdAssigner } from "../compat/transformers.ts"; +import { MemoryKvStore } from "../federation/kv.ts"; +import { FederationImpl } from "../federation/middleware.ts"; +import { createProof, signObject } from "../sig/proof.ts"; +import { ed25519Multikey, ed25519PrivateKey } from "../testing/keys.ts"; +import { getDefaultPortableObjectVerifier } from "./portable-verifier.ts"; + +const did = "did:key:z6Mkabc"; +const compatibleNoteId = + `https://gw.example/.well-known/apgateway/${did}/objects/1`; + +const documentLoader: DocumentLoader = (url) => { + if (url !== compatibleNoteId) return mockDocumentLoader(url); + return Promise.resolve({ + contextUrl: null, + documentUrl: url, + document: { + "@context": "https://www.w3.org/ns/activitystreams", + id: `ap://${did}/objects/1`, + type: "Note", + content: "Portable note", + }, + }); +}; + +function createRecordingVerifier(): PortableObjectVerifier & { calls: number } { + const verifier = Object.assign( + // deno-lint-ignore require-await + async () => { + verifier.calls++; + return { verified: true as const }; + }, + { calls: 0 }, + ); + return verifier; +} + +/** + * Runs the callback while collecting warnings of the category that `clone()` + * logs when it drops a default verifier. + */ +async function collectPortableWarnings( + callback: () => Promise, +): Promise { + const records: LogRecord[] = []; + await reset(); + try { + await configure({ + sinks: { buffer: (record: LogRecord) => records.push(record) }, + loggers: [ + { category: ["fedify", "vocab", "portable"], sinks: ["buffer"] }, + { category: ["logtape", "meta"], sinks: [] }, + ], + }); + await callback(); + } finally { + await reset(); + } + return records; +} + +/** Asserts that the object verifies its portable references with `verifier`. */ +async function assertVerifiesWith( + object: Create | Follow, + verifier: PortableObjectVerifier & { calls: number }, +): Promise { + const before = verifier.calls; + assertInstanceOf( + await object.getObject({ + documentLoader, + contextLoader: mockDocumentLoader, + }), + Note, + ); + assertEquals(verifier.calls, before + 1); +} + +test("getDefaultPortableObjectVerifier()", () => { + const verifier = createRecordingVerifier(); + assertStrictEquals( + getDefaultPortableObjectVerifier( + new Note({}, { verifyPortableObject: verifier }), + ), + verifier, + ); + assertStrictEquals(getDefaultPortableObjectVerifier(new Note({})), undefined); + assertStrictEquals(getDefaultPortableObjectVerifier({}), undefined); +}); + +test("signObject() keeps the default portable object verifier", async () => { + const verifier = createRecordingVerifier(); + const create = new Create({ + id: new URL("https://example.com/activities/1"), + actor: new URL("https://example.com/users/alice"), + object: new URL(compatibleNoteId), + }, { contextLoader: mockDocumentLoader, verifyPortableObject: verifier }); + let signed: Create | undefined; + const warnings = await collectPortableWarnings(async () => { + await createProof(create, ed25519PrivateKey, ed25519Multikey.id!, { + contextLoader: mockDocumentLoader, + }); + signed = await signObject(create, ed25519PrivateKey, ed25519Multikey.id!, { + contextLoader: mockDocumentLoader, + documentLoader: mockDocumentLoader, + }); + }); + assertEquals(warnings, []); + assertInstanceOf(signed, Create); + await assertVerifiesWith(signed, verifier); +}); + +test("default activity transformers keep the default portable object verifier", async () => { + const federation = new FederationImpl({ kv: new MemoryKvStore() }); + const context = federation.createContext(new URL("http://example.com/")); + const verifier = createRecordingVerifier(); + const follow = new Follow({ + actor: new URL("http://example.com/actors/1"), + object: new URL(compatibleNoteId), + }, { contextLoader: mockDocumentLoader, verifyPortableObject: verifier }); + let assigned: Follow | undefined; + let dehydrated: Follow | undefined; + const warnings = await collectPortableWarnings(() => { + assigned = autoIdAssigner(follow, context) as Follow; + dehydrated = actorDehydrator( + assigned.clone({ + actor: new URL("http://example.com/actors/1"), + }, { verifyPortableObject: verifier }), + context, + ) as Follow; + return Promise.resolve(); + }); + assertEquals(warnings, []); + assertInstanceOf(assigned, Follow); + assertInstanceOf(dehydrated, Follow); + await assertVerifiesWith(assigned, verifier); + await assertVerifiesWith(dehydrated, verifier); +}); diff --git a/packages/fedify/src/utils/portable-verifier.ts b/packages/fedify/src/utils/portable-verifier.ts new file mode 100644 index 000000000..e8ea47550 --- /dev/null +++ b/packages/fedify/src/utils/portable-verifier.ts @@ -0,0 +1,23 @@ +import type { PortableObjectVerifier } from "@fedify/vocab-runtime"; + +/** + * Gets the default FEP-ef61 portable object verifier of a vocabulary object, + * so that Fedify can pass it on to a clone of the object explicitly, since + * `clone()` does not inherit it. + * + * This reads the protected `_verifyPortableObject` accessor of generated + * vocabulary classes, which is an internal cross-package contract with + * `@fedify/vocab-tools`. + * + * @param object The vocabulary object. + * @returns The object's default verifier, or `undefined` if it has none. + * @internal + */ +export function getDefaultPortableObjectVerifier( + object: object, +): PortableObjectVerifier | undefined { + const verifier: unknown = Reflect.get(object, "_verifyPortableObject"); + return typeof verifier === "function" + ? verifier as PortableObjectVerifier + : undefined; +} diff --git a/packages/testing/package.json b/packages/testing/package.json index 4198a1307..6a29f0dfd 100644 --- a/packages/testing/package.json +++ b/packages/testing/package.json @@ -58,6 +58,7 @@ }, "devDependencies": { "@fedify/fixture": "workspace:^", + "@logtape/logtape": "catalog:", "@standard-schema/spec": "catalog:", "@std/assert": "catalog:", "@std/async": "catalog:", diff --git a/packages/testing/src/mock.test.ts b/packages/testing/src/mock.test.ts index 443cbe84d..c2cf3dcb8 100644 --- a/packages/testing/src/mock.test.ts +++ b/packages/testing/src/mock.test.ts @@ -41,6 +41,7 @@ import { createRequestContext, } from "./mock.ts"; import { getDocumentLoader, UrlError } from "@fedify/vocab-runtime"; +import { configure, type LogRecord, reset } from "@logtape/logtape"; import { metrics, trace } from "@opentelemetry/api"; test("MockFederation preserves telemetry providers with private-address loaders", () => { @@ -2813,3 +2814,62 @@ test("MockFederation explicit loaders take precedence over private-address defau assertStrictEquals(context.contextLoader, contextLoader); } }); + +test("receiveActivity keeps the default portable object verifier", async () => { + const did = "did:key:z6Mkabc"; + const compatibleNoteId = + `https://gw.example/.well-known/apgateway/${did}/objects/1`; + const mockFederation = createFederation({ + contextData: null, + documentLoader: (url) => + url === compatibleNoteId + ? Promise.resolve({ + contextUrl: null, + documentUrl: url, + document: { + "@context": "https://www.w3.org/ns/activitystreams", + id: `ap://${did}/objects/1`, + type: "Note", + content: "Portable note", + }, + }) + : mockDocumentLoader(url), + contextLoader: mockDocumentLoader, + }); + let object: unknown; + mockFederation + .setInboxListeners("/users/{identifier}/inbox") + .on(Create, async (_ctx, activity) => { + object = await activity.getObject(); + }); + let calls = 0; + const activity = new Create({ + id: new URL("https://example.com/activities/1"), + actor: new URL("https://example.com/users/alice"), + object: new URL(compatibleNoteId), + }, { + contextLoader: mockDocumentLoader, + // deno-lint-ignore require-await + verifyPortableObject: async () => { + calls++; + return { verified: true }; + }, + }); + const records: LogRecord[] = []; + await reset(); + try { + await configure({ + sinks: { buffer: (record: LogRecord) => records.push(record) }, + loggers: [ + { category: ["fedify", "vocab", "portable"], sinks: ["buffer"] }, + { category: ["logtape", "meta"], sinks: [] }, + ], + }); + await mockFederation.receiveActivity(activity); + } finally { + await reset(); + } + assertEquals(records, []); + assertInstanceOf(object, Note); + assertEquals(calls, 1); +}); diff --git a/packages/testing/src/mock.ts b/packages/testing/src/mock.ts index fbcbe71c1..b9c753a4a 100644 --- a/packages/testing/src/mock.ts +++ b/packages/testing/src/mock.ts @@ -855,6 +855,10 @@ class MockFederation implements Federation { ? activity.clone({}, { documentLoader: this.documentLoader, contextLoader: this.contextLoader, + // _verifyPortableObject is an internal cross-package contract + // documented in @fedify/vocab-tools. clone() does not inherit + // the default verifier, so pass it on: + verifyPortableObject: Reflect.get(activity, "_verifyPortableObject"), }) : activity; if (receivedActivity !== activity) { 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 caa564047..a3d97ff90 100644 --- a/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap +++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.deno.snap @@ -157,6 +157,12 @@ export class Object { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -1304,8 +1310,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -1335,7 +1366,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Object { if (this._warning != null) { @@ -1343,8 +1374,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -2306,6 +2344,20 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -19079,8 +19131,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -19110,7 +19187,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Emoji { if (this._warning != null) { @@ -19118,8 +19195,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Emoji; return clone; @@ -19564,8 +19648,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -19595,7 +19704,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ChatMessage { if (this._warning != null) { @@ -19603,8 +19712,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ChatMessage;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if (\\"quote\\" in values && values.quote != null) { @@ -21479,8 +21595,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -21516,7 +21657,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Activity { if (this._warning != null) { @@ -21524,8 +21665,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Activity;clone.#_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor = this.#_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor.slice();clone.#_trust_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor = new Set(this.#_trust_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor); if (\\"actor\\" in values && values.actor != null) { @@ -26396,8 +26544,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -26433,7 +26606,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): EmojiReact { if (this._warning != null) { @@ -26441,8 +26614,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as EmojiReact; return clone; @@ -26778,6 +26958,12 @@ export class PropertyValue { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -26917,8 +27103,33 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -26932,7 +27143,7 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): PropertyValue { if (this._warning != null) { @@ -26940,8 +27151,15 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -26977,6 +27195,20 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -27539,6 +27771,12 @@ export class Measure { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -27678,8 +27916,33 @@ unit?: string | null;numericalValue?: Decimal | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -27693,7 +27956,7 @@ unit?: string | null;numericalValue?: Decimal | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Measure { if (this._warning != null) { @@ -27701,8 +27964,15 @@ unit?: string | null;numericalValue?: Decimal | null;} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -27738,6 +28008,20 @@ unit?: string | null;numericalValue?: Decimal | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -28357,8 +28641,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -28388,7 +28697,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): AnnounceAuthorization { if (this._warning != null) { @@ -28396,8 +28705,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as AnnounceAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -29873,8 +30189,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -29910,7 +30251,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): AnnounceRequest { if (this._warning != null) { @@ -29918,8 +30259,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as AnnounceRequest; return clone; @@ -30262,6 +30610,12 @@ export class InteractionPolicy { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -30443,8 +30797,33 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -30458,7 +30837,7 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): InteractionPolicy { if (this._warning != null) { @@ -30466,8 +30845,15 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -30542,6 +30928,20 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -31353,6 +31753,12 @@ export class InteractionRule { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -31540,8 +31946,33 @@ manualApprovals?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -31557,7 +31988,7 @@ manualApprovals?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): InteractionRule { if (this._warning != null) { @@ -31565,8 +31996,15 @@ manualApprovals?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -31648,6 +32086,20 @@ manualApprovals?: (URL)[];} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -32248,8 +32700,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -32279,7 +32756,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): LikeAuthorization { if (this._warning != null) { @@ -32287,8 +32764,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as LikeAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -33763,8 +34247,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -33800,7 +34309,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): LikeRequest { if (this._warning != null) { @@ -33808,8 +34317,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as LikeRequest; return clone; @@ -34224,8 +34740,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -34255,7 +34796,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ReplyAuthorization { if (this._warning != null) { @@ -34263,8 +34804,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ReplyAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -35739,8 +36287,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -35776,7 +36349,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ReplyRequest { if (this._warning != null) { @@ -35784,8 +36357,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ReplyRequest; return clone; @@ -36200,8 +36780,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -36231,7 +36836,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): QuoteAuthorization { if (this._warning != null) { @@ -36239,8 +36844,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as QuoteAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -37714,8 +38326,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -37751,7 +38388,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): QuoteRequest { if (this._warning != null) { @@ -37759,8 +38396,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as QuoteRequest; return clone; @@ -38103,6 +38747,12 @@ export class Translation { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -38352,8 +39002,33 @@ urls?: ((URL | Link))[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -38369,7 +39044,7 @@ urls?: ((URL | Link))[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Translation { if (this._warning != null) { @@ -38377,8 +39052,15 @@ urls?: ((URL | Link))[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -38517,6 +39199,20 @@ urls?: ((URL | Link))[];} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -40254,8 +40950,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -40285,7 +41006,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeatureAuthorization { if (this._warning != null) { @@ -40293,8 +41014,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeatureAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -41763,8 +42491,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -41800,7 +42553,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeatureRequest { if (this._warning != null) { @@ -41808,8 +42561,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeatureRequest; return clone; @@ -42401,8 +43161,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -42432,7 +43217,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Collection { if (this._warning != null) { @@ -42440,8 +43225,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Collection;clone.#_XDbmNDuWHmrhqH712zqtecdbv1V_totalItems = this.#_XDbmNDuWHmrhqH712zqtecdbv1V_totalItems.slice(); if (\\"totalItems\\" in values && values.totalItems != null) { @@ -49420,8 +50212,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -49451,7 +50268,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): OrderedCollection { if (this._warning != null) { @@ -49459,8 +50276,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as OrderedCollection;clone.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = this.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items.slice();clone.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = new Set(this.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items); if (\\"items\\" in values && values.items != null) { @@ -50459,8 +51283,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -50490,7 +51339,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeaturedCollection { if (this._warning != null) { @@ -50498,8 +51347,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeaturedCollection;clone.#_pc4UXYHNrYa2zyQ8Bh7zvdZRKnZ_topic = this.#_pc4UXYHNrYa2zyQ8Bh7zvdZRKnZ_topic.slice(); if (\\"topic\\" in values && values.topic != null) { @@ -51162,8 +52018,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -51193,7 +52074,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeaturedItem { if (this._warning != null) { @@ -51201,8 +52082,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeaturedItem;clone.#_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject = this.#_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject.slice();clone.#_trust_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject = new Set(this.#_trust_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject); if (\\"featuredObject\\" in values && values.featuredObject != null) { @@ -52625,6 +53513,12 @@ export class DidService { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -52774,8 +53668,33 @@ endpoints?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -52790,7 +53709,7 @@ endpoints?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): DidService { if (this._warning != null) { @@ -52798,8 +53717,15 @@ endpoints?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -52845,6 +53771,20 @@ endpoints?: (URL)[];} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -53295,8 +54235,33 @@ endpoints?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -53311,7 +54276,7 @@ endpoints?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Export { if (this._warning != null) { @@ -53319,8 +54284,15 @@ endpoints?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Export; return clone; @@ -53647,6 +54619,12 @@ export class DataIntegrityProof { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -53832,8 +54810,33 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -53847,7 +54850,7 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): DataIntegrityProof { if (this._warning != null) { @@ -53855,8 +54858,15 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -53933,6 +54943,20 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -55072,6 +56096,12 @@ export class CryptographicKey { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -55216,8 +56246,33 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -55231,7 +56286,7 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): CryptographicKey { if (this._warning != null) { @@ -55239,8 +56294,15 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -55279,6 +56341,20 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -56328,6 +57404,12 @@ export class Multikey { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -56472,8 +57554,33 @@ controller?: Application | Group | Organization | Person | Service | URL | null; * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -56487,7 +57594,7 @@ controller?: Application | Group | Organization | Person | Service | URL | null; options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Multikey { if (this._warning != null) { @@ -56495,8 +57602,15 @@ controller?: Application | Group | Organization | Person | Service | URL | null; this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -56535,6 +57649,20 @@ controller?: Application | Group | Organization | Person | Service | URL | null; } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -57666,8 +58794,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -57697,7 +58850,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Agreement { if (this._warning != null) { @@ -57705,8 +58858,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Agreement;clone.#_37zeAJ2NVyecrDdP8os69FGAn9Q6_stipulates = this.#_37zeAJ2NVyecrDdP8os69FGAn9Q6_stipulates.slice(); if (\\"stipulates\\" in values && values.stipulates != null) { @@ -58307,6 +59467,12 @@ export class Commitment { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -58446,8 +59612,33 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -58461,7 +59652,7 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Commitment { if (this._warning != null) { @@ -58469,8 +59660,15 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -58506,6 +59704,20 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -59055,6 +60267,12 @@ export class Intent { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -59236,8 +60454,33 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -59251,7 +60494,7 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Intent { if (this._warning != null) { @@ -59259,8 +60502,15 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -59335,6 +60585,20 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -60295,8 +61559,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -60326,7 +61615,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Proposal { if (this._warning != null) { @@ -60334,8 +61623,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Proposal;clone.#_4wb2xgUBheR2gaD2Se8QBH4LEC7_purpose = this.#_4wb2xgUBheR2gaD2Se8QBH4LEC7_purpose.slice(); if (\\"purpose\\" in values && values.purpose != null) { @@ -61203,8 +62499,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -61240,7 +62561,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Accept { if (this._warning != null) { @@ -61248,8 +62569,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Accept; return clone; @@ -61638,8 +62966,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -61675,7 +63028,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Add { if (this._warning != null) { @@ -61683,8 +63036,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Add; return clone; @@ -62068,8 +63428,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -62105,7 +63490,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Announce { if (this._warning != null) { @@ -62113,8 +63498,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Announce; return clone; @@ -63019,8 +64411,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -63056,7 +64473,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Application { if (this._warning != null) { @@ -63064,8 +64481,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Application;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -73241,8 +74665,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -73278,7 +74727,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): IntransitiveActivity { if (this._warning != null) { @@ -73286,8 +74735,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as IntransitiveActivity; return clone; @@ -73683,8 +75139,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -73720,7 +75201,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Arrive { if (this._warning != null) { @@ -73728,8 +75209,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Arrive; return clone; @@ -74150,8 +75638,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -74181,7 +75694,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Article { if (this._warning != null) { @@ -74189,8 +75702,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Article;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if (\\"quote\\" in values && values.quote != null) { @@ -75838,8 +77358,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -75869,7 +77414,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Document { if (this._warning != null) { @@ -75877,8 +77422,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Document;clone.#_2e9AP7WdHBJYAgXG6GEyq7nSkNMe_width = this.#_2e9AP7WdHBJYAgXG6GEyq7nSkNMe_width.slice(); if (\\"width\\" in values && values.width != null) { @@ -76635,8 +78187,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -76666,7 +78243,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Audio { if (this._warning != null) { @@ -76674,8 +78251,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Audio; return clone; @@ -77077,8 +78661,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -77114,7 +78723,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Ignore { if (this._warning != null) { @@ -77122,8 +78731,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Ignore; return clone; @@ -77512,8 +79128,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -77549,7 +79190,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Block { if (this._warning != null) { @@ -77557,8 +79198,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Block; return clone; @@ -77984,8 +79632,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -78015,7 +79688,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): CollectionPage { if (this._warning != null) { @@ -78023,8 +79696,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as CollectionPage;clone.#_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf = this.#_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf.slice();clone.#_trust_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf = new Set(this.#_trust_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf); if (\\"partOf\\" in values && values.partOf != null) { @@ -80024,8 +81704,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80061,7 +81766,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Create { if (this._warning != null) { @@ -80069,8 +81774,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Create; return clone; @@ -80453,8 +82165,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80490,7 +82227,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Delete { if (this._warning != null) { @@ -80498,8 +82235,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Delete; return clone; @@ -80880,8 +82624,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80917,7 +82686,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Dislike { if (this._warning != null) { @@ -80925,8 +82694,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Dislike; return clone; @@ -81262,6 +83038,12 @@ export class Endpoints { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -81471,8 +83253,33 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -81486,7 +83293,7 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Endpoints { if (this._warning != null) { @@ -81494,8 +83301,15 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -81596,6 +83410,20 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -82692,8 +84520,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -82723,7 +84576,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Event { if (this._warning != null) { @@ -82731,8 +84584,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Event; return clone; @@ -83135,8 +84995,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -83172,7 +85057,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Flag { if (this._warning != null) { @@ -83180,8 +85065,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Flag; return clone; @@ -83566,8 +85458,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -83603,7 +85520,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Follow { if (this._warning != null) { @@ -83611,8 +85528,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Follow; return clone; @@ -84517,8 +86441,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -84554,7 +86503,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Group { if (this._warning != null) { @@ -84562,8 +86511,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Group;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -94699,6 +96655,12 @@ export class Link { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -94992,8 +96954,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -95009,7 +96996,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Link { if (this._warning != null) { @@ -95017,8 +97004,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -95198,6 +97192,20 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -96979,8 +98987,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -96996,7 +99029,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Hashtag { if (this._warning != null) { @@ -97004,8 +99037,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Hashtag; return clone; @@ -97388,8 +99428,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -97419,7 +99484,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Image { if (this._warning != null) { @@ -97427,8 +99492,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Image; return clone; @@ -97831,8 +99903,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -97868,7 +99965,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Offer { if (this._warning != null) { @@ -97876,8 +99973,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Offer; return clone; @@ -98264,8 +100368,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -98301,7 +100430,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Invite { if (this._warning != null) { @@ -98309,8 +100438,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Invite; return clone; @@ -98693,8 +100829,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -98730,7 +100891,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Join { if (this._warning != null) { @@ -98738,8 +100899,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Join; return clone; @@ -99122,8 +101290,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -99159,7 +101352,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Leave { if (this._warning != null) { @@ -99167,8 +101360,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Leave; return clone; @@ -99551,8 +101751,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -99588,7 +101813,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Like { if (this._warning != null) { @@ -99596,8 +101821,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Like; return clone; @@ -99978,8 +102210,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100015,7 +102272,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Listen { if (this._warning != null) { @@ -100023,8 +102280,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Listen; return clone; @@ -100385,8 +102649,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100402,7 +102691,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Mention { if (this._warning != null) { @@ -100410,8 +102699,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Mention; return clone; @@ -100803,8 +103099,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100840,7 +103161,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Move { if (this._warning != null) { @@ -100848,8 +103169,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Move; return clone; @@ -101272,8 +103600,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -101303,7 +103656,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Note { if (this._warning != null) { @@ -101311,8 +103664,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Note;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if (\\"quote\\" in values && values.quote != null) { @@ -102957,8 +105317,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -102988,7 +105373,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): OrderedCollectionPage { if (this._warning != null) { @@ -102996,8 +105381,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as OrderedCollectionPage;clone.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = this.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items.slice();clone.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = new Set(this.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items); if (\\"items\\" in values && values.items != null) { @@ -104607,8 +106999,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -104644,7 +107061,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Organization { if (this._warning != null) { @@ -104652,8 +107069,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Organization;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -114820,8 +117244,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -114851,7 +117300,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Page { if (this._warning != null) { @@ -114859,8 +117308,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Page; return clone; @@ -115784,8 +118240,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -115821,7 +118302,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Person { if (this._warning != null) { @@ -115829,8 +118310,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Person;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -126084,8 +128572,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -126115,7 +128628,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Place { if (this._warning != null) { @@ -126123,8 +128636,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Place;clone.#_3UCsHnBHvDAXJnBuzw3zw1VVs3Ne_accuracy = this.#_3UCsHnBHvDAXJnBuzw3zw1VVs3Ne_accuracy.slice(); if (\\"accuracy\\" in values && values.accuracy != null) { @@ -127235,8 +129755,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -127266,7 +129811,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Profile { if (this._warning != null) { @@ -127274,8 +129819,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Profile;clone.#_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes = this.#_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes.slice();clone.#_trust_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes = new Set(this.#_trust_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes); if (\\"describes\\" in values && values.describes != null) { @@ -128334,8 +130886,33 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -128371,7 +130948,7 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Question { if (this._warning != null) { @@ -128379,8 +130956,15 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Question;clone.#_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf = this.#_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf.slice();clone.#_trust_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf = new Set(this.#_trust_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf); if (\\"exclusiveOptions\\" in values && values.exclusiveOptions != null) { @@ -131174,8 +133758,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -131211,7 +133820,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Read { if (this._warning != null) { @@ -131219,8 +133828,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Read; return clone; @@ -131603,8 +134219,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -131640,7 +134281,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Reject { if (this._warning != null) { @@ -131648,8 +134289,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Reject; return clone; @@ -132139,8 +134787,33 @@ relationships?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -132172,7 +134845,7 @@ relationships?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Relationship { if (this._warning != null) { @@ -132180,8 +134853,15 @@ relationships?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Relationship;clone.#_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject = this.#_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject.slice();clone.#_trust_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject = new Set(this.#_trust_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject); if (\\"subject\\" in values && values.subject != null) { @@ -134576,8 +137256,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -134613,7 +137318,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Remove { if (this._warning != null) { @@ -134621,8 +137326,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Remove; return clone; @@ -135527,8 +138239,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -135564,7 +138301,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Service { if (this._warning != null) { @@ -135572,8 +138309,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Service;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -145701,6 +148445,12 @@ export class Source { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -145864,8 +148614,33 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -145880,7 +148655,7 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Source { if (this._warning != null) { @@ -145888,8 +148663,15 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -145948,6 +148730,20 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -146554,8 +149350,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -146591,7 +149412,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): TentativeAccept { if (this._warning != null) { @@ -146599,8 +149420,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as TentativeAccept; return clone; @@ -146983,8 +149811,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -147020,7 +149873,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): TentativeReject { if (this._warning != null) { @@ -147028,8 +149881,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as TentativeReject; return clone; @@ -147459,8 +150319,33 @@ formerTypes?: (\$EntityType)[];deleted?: Temporal.Instant | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -147491,7 +150376,7 @@ formerTypes?: (\$EntityType)[];deleted?: Temporal.Instant | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Tombstone { if (this._warning != null) { @@ -147499,8 +150384,15 @@ formerTypes?: (\$EntityType)[];deleted?: Temporal.Instant | null;} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Tombstone;clone.#_Pn8kdUztYSt4nyoAkVsMcQaLo9U_formerType = this.#_Pn8kdUztYSt4nyoAkVsMcQaLo9U_formerType.slice(); if (\\"formerType\\" in values && values.formerType != null) { @@ -148192,8 +151084,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -148229,7 +151146,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Travel { if (this._warning != null) { @@ -148237,8 +151154,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Travel; return clone; @@ -148626,8 +151550,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -148663,7 +151612,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Undo { if (this._warning != null) { @@ -148671,8 +151620,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Undo; return clone; @@ -149058,8 +152014,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149095,7 +152076,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Update { if (this._warning != null) { @@ -149103,8 +152084,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Update; return clone; @@ -149479,8 +152467,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149510,7 +152523,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Video { if (this._warning != null) { @@ -149518,8 +152531,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Video; return clone; @@ -149920,8 +152940,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149957,7 +153002,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): View { if (this._warning != null) { @@ -149965,8 +153010,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: \$warning is not recognized as a property, but it is. - options = { ...options, \$warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + \$warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as View; return clone; 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 20e958d6c..dcd484b0c 100644 --- a/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap +++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.node.snap @@ -155,6 +155,12 @@ export class Object { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -1302,8 +1308,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -1333,7 +1364,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Object { if (this._warning != null) { @@ -1341,8 +1372,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -2304,6 +2342,20 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -19077,8 +19129,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -19108,7 +19185,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Emoji { if (this._warning != null) { @@ -19116,8 +19193,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Emoji; return clone; @@ -19562,8 +19646,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -19593,7 +19702,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ChatMessage { if (this._warning != null) { @@ -19601,8 +19710,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ChatMessage;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if (\\"quote\\" in values && values.quote != null) { @@ -21477,8 +21593,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -21514,7 +21655,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Activity { if (this._warning != null) { @@ -21522,8 +21663,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Activity;clone.#_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor = this.#_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor.slice();clone.#_trust_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor = new Set(this.#_trust_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor); if (\\"actor\\" in values && values.actor != null) { @@ -26394,8 +26542,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -26431,7 +26604,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): EmojiReact { if (this._warning != null) { @@ -26439,8 +26612,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as EmojiReact; return clone; @@ -26776,6 +26956,12 @@ export class PropertyValue { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -26915,8 +27101,33 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -26930,7 +27141,7 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): PropertyValue { if (this._warning != null) { @@ -26938,8 +27149,15 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -26975,6 +27193,20 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -27537,6 +27769,12 @@ export class Measure { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -27676,8 +27914,33 @@ unit?: string | null;numericalValue?: Decimal | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -27691,7 +27954,7 @@ unit?: string | null;numericalValue?: Decimal | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Measure { if (this._warning != null) { @@ -27699,8 +27962,15 @@ unit?: string | null;numericalValue?: Decimal | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -27736,6 +28006,20 @@ unit?: string | null;numericalValue?: Decimal | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -28355,8 +28639,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -28386,7 +28695,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): AnnounceAuthorization { if (this._warning != null) { @@ -28394,8 +28703,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as AnnounceAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -29871,8 +30187,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -29908,7 +30249,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): AnnounceRequest { if (this._warning != null) { @@ -29916,8 +30257,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as AnnounceRequest; return clone; @@ -30260,6 +30608,12 @@ export class InteractionPolicy { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -30441,8 +30795,33 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -30456,7 +30835,7 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): InteractionPolicy { if (this._warning != null) { @@ -30464,8 +30843,15 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -30540,6 +30926,20 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -31351,6 +31751,12 @@ export class InteractionRule { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -31538,8 +31944,33 @@ manualApprovals?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -31555,7 +31986,7 @@ manualApprovals?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): InteractionRule { if (this._warning != null) { @@ -31563,8 +31994,15 @@ manualApprovals?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -31646,6 +32084,20 @@ manualApprovals?: (URL)[];} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -32246,8 +32698,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -32277,7 +32754,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): LikeAuthorization { if (this._warning != null) { @@ -32285,8 +32762,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as LikeAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -33761,8 +34245,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -33798,7 +34307,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): LikeRequest { if (this._warning != null) { @@ -33806,8 +34315,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as LikeRequest; return clone; @@ -34222,8 +34738,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -34253,7 +34794,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ReplyAuthorization { if (this._warning != null) { @@ -34261,8 +34802,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ReplyAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -35737,8 +36285,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -35774,7 +36347,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ReplyRequest { if (this._warning != null) { @@ -35782,8 +36355,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ReplyRequest; return clone; @@ -36198,8 +36778,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -36229,7 +36834,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): QuoteAuthorization { if (this._warning != null) { @@ -36237,8 +36842,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as QuoteAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -37712,8 +38324,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -37749,7 +38386,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): QuoteRequest { if (this._warning != null) { @@ -37757,8 +38394,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as QuoteRequest; return clone; @@ -38101,6 +38745,12 @@ export class Translation { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -38350,8 +39000,33 @@ urls?: ((URL | Link))[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -38367,7 +39042,7 @@ urls?: ((URL | Link))[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Translation { if (this._warning != null) { @@ -38375,8 +39050,15 @@ urls?: ((URL | Link))[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -38515,6 +39197,20 @@ urls?: ((URL | Link))[];} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -40252,8 +40948,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -40283,7 +41004,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeatureAuthorization { if (this._warning != null) { @@ -40291,8 +41012,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeatureAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if (\\"interactingObject\\" in values && values.interactingObject != null) { @@ -41761,8 +42489,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -41798,7 +42551,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeatureRequest { if (this._warning != null) { @@ -41806,8 +42559,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeatureRequest; return clone; @@ -42399,8 +43159,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -42430,7 +43215,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Collection { if (this._warning != null) { @@ -42438,8 +43223,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Collection;clone.#_XDbmNDuWHmrhqH712zqtecdbv1V_totalItems = this.#_XDbmNDuWHmrhqH712zqtecdbv1V_totalItems.slice(); if (\\"totalItems\\" in values && values.totalItems != null) { @@ -49418,8 +50210,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -49449,7 +50266,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): OrderedCollection { if (this._warning != null) { @@ -49457,8 +50274,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as OrderedCollection;clone.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = this.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items.slice();clone.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = new Set(this.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items); if (\\"items\\" in values && values.items != null) { @@ -50457,8 +51281,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -50488,7 +51337,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeaturedCollection { if (this._warning != null) { @@ -50496,8 +51345,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeaturedCollection;clone.#_pc4UXYHNrYa2zyQ8Bh7zvdZRKnZ_topic = this.#_pc4UXYHNrYa2zyQ8Bh7zvdZRKnZ_topic.slice(); if (\\"topic\\" in values && values.topic != null) { @@ -51160,8 +52016,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -51191,7 +52072,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeaturedItem { if (this._warning != null) { @@ -51199,8 +52080,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeaturedItem;clone.#_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject = this.#_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject.slice();clone.#_trust_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject = new Set(this.#_trust_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject); if (\\"featuredObject\\" in values && values.featuredObject != null) { @@ -52623,6 +53511,12 @@ export class DidService { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -52772,8 +53666,33 @@ endpoints?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -52788,7 +53707,7 @@ endpoints?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): DidService { if (this._warning != null) { @@ -52796,8 +53715,15 @@ endpoints?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -52843,6 +53769,20 @@ endpoints?: (URL)[];} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -53293,8 +54233,33 @@ endpoints?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -53309,7 +54274,7 @@ endpoints?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Export { if (this._warning != null) { @@ -53317,8 +54282,15 @@ endpoints?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Export; return clone; @@ -53645,6 +54617,12 @@ export class DataIntegrityProof { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -53830,8 +54808,33 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -53845,7 +54848,7 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): DataIntegrityProof { if (this._warning != null) { @@ -53853,8 +54856,15 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -53931,6 +54941,20 @@ cryptosuite?: \\"eddsa-jcs-2022\\" | null;verificationMethod?: Multikey | URL | } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -55070,6 +56094,12 @@ export class CryptographicKey { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -55214,8 +56244,33 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -55229,7 +56284,7 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): CryptographicKey { if (this._warning != null) { @@ -55237,8 +56292,15 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -55277,6 +56339,20 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -56326,6 +57402,12 @@ export class Multikey { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -56470,8 +57552,33 @@ controller?: Application | Group | Organization | Person | Service | URL | null; * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -56485,7 +57592,7 @@ controller?: Application | Group | Organization | Person | Service | URL | null; options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Multikey { if (this._warning != null) { @@ -56493,8 +57600,15 @@ controller?: Application | Group | Organization | Person | Service | URL | null; this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -56533,6 +57647,20 @@ controller?: Application | Group | Organization | Person | Service | URL | null; } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -57664,8 +58792,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -57695,7 +58848,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Agreement { if (this._warning != null) { @@ -57703,8 +58856,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Agreement;clone.#_37zeAJ2NVyecrDdP8os69FGAn9Q6_stipulates = this.#_37zeAJ2NVyecrDdP8os69FGAn9Q6_stipulates.slice(); if (\\"stipulates\\" in values && values.stipulates != null) { @@ -58305,6 +59465,12 @@ export class Commitment { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -58444,8 +59610,33 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -58459,7 +59650,7 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Commitment { if (this._warning != null) { @@ -58467,8 +59658,15 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -58504,6 +59702,20 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -59053,6 +60265,12 @@ export class Intent { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -59234,8 +60452,33 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -59249,7 +60492,7 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Intent { if (this._warning != null) { @@ -59257,8 +60500,15 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -59333,6 +60583,20 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -60293,8 +61557,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -60324,7 +61613,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Proposal { if (this._warning != null) { @@ -60332,8 +61621,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Proposal;clone.#_4wb2xgUBheR2gaD2Se8QBH4LEC7_purpose = this.#_4wb2xgUBheR2gaD2Se8QBH4LEC7_purpose.slice(); if (\\"purpose\\" in values && values.purpose != null) { @@ -61201,8 +62497,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -61238,7 +62559,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Accept { if (this._warning != null) { @@ -61246,8 +62567,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Accept; return clone; @@ -61636,8 +62964,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -61673,7 +63026,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Add { if (this._warning != null) { @@ -61681,8 +63034,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Add; return clone; @@ -62066,8 +63426,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -62103,7 +63488,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Announce { if (this._warning != null) { @@ -62111,8 +63496,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Announce; return clone; @@ -63017,8 +64409,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -63054,7 +64471,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Application { if (this._warning != null) { @@ -63062,8 +64479,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Application;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -73239,8 +74663,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -73276,7 +74725,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): IntransitiveActivity { if (this._warning != null) { @@ -73284,8 +74733,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as IntransitiveActivity; return clone; @@ -73681,8 +75137,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -73718,7 +75199,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Arrive { if (this._warning != null) { @@ -73726,8 +75207,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Arrive; return clone; @@ -74148,8 +75636,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -74179,7 +75692,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Article { if (this._warning != null) { @@ -74187,8 +75700,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Article;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if (\\"quote\\" in values && values.quote != null) { @@ -75836,8 +77356,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -75867,7 +77412,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Document { if (this._warning != null) { @@ -75875,8 +77420,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Document;clone.#_2e9AP7WdHBJYAgXG6GEyq7nSkNMe_width = this.#_2e9AP7WdHBJYAgXG6GEyq7nSkNMe_width.slice(); if (\\"width\\" in values && values.width != null) { @@ -76633,8 +78185,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -76664,7 +78241,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Audio { if (this._warning != null) { @@ -76672,8 +78249,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Audio; return clone; @@ -77075,8 +78659,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -77112,7 +78721,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Ignore { if (this._warning != null) { @@ -77120,8 +78729,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Ignore; return clone; @@ -77510,8 +79126,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -77547,7 +79188,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Block { if (this._warning != null) { @@ -77555,8 +79196,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Block; return clone; @@ -77982,8 +79630,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -78013,7 +79686,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): CollectionPage { if (this._warning != null) { @@ -78021,8 +79694,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as CollectionPage;clone.#_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf = this.#_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf.slice();clone.#_trust_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf = new Set(this.#_trust_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf); if (\\"partOf\\" in values && values.partOf != null) { @@ -80022,8 +81702,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80059,7 +81764,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Create { if (this._warning != null) { @@ -80067,8 +81772,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Create; return clone; @@ -80451,8 +82163,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80488,7 +82225,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Delete { if (this._warning != null) { @@ -80496,8 +82233,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Delete; return clone; @@ -80878,8 +82622,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80915,7 +82684,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Dislike { if (this._warning != null) { @@ -80923,8 +82692,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Dislike; return clone; @@ -81260,6 +83036,12 @@ export class Endpoints { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -81469,8 +83251,33 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -81484,7 +83291,7 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Endpoints { if (this._warning != null) { @@ -81492,8 +83299,15 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -81594,6 +83408,20 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -82690,8 +84518,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -82721,7 +84574,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Event { if (this._warning != null) { @@ -82729,8 +84582,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Event; return clone; @@ -83133,8 +84993,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -83170,7 +85055,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Flag { if (this._warning != null) { @@ -83178,8 +85063,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Flag; return clone; @@ -83564,8 +85456,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -83601,7 +85518,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Follow { if (this._warning != null) { @@ -83609,8 +85526,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Follow; return clone; @@ -84515,8 +86439,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -84552,7 +86501,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Group { if (this._warning != null) { @@ -84560,8 +86509,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Group;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -94697,6 +96653,12 @@ export class Link { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -94990,8 +96952,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -95007,7 +96994,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Link { if (this._warning != null) { @@ -95015,8 +97002,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -95196,6 +97190,20 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -96977,8 +98985,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -96994,7 +99027,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Hashtag { if (this._warning != null) { @@ -97002,8 +99035,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Hashtag; return clone; @@ -97386,8 +99426,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -97417,7 +99482,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Image { if (this._warning != null) { @@ -97425,8 +99490,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Image; return clone; @@ -97829,8 +99901,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -97866,7 +99963,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Offer { if (this._warning != null) { @@ -97874,8 +99971,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Offer; return clone; @@ -98262,8 +100366,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -98299,7 +100428,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Invite { if (this._warning != null) { @@ -98307,8 +100436,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Invite; return clone; @@ -98691,8 +100827,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -98728,7 +100889,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Join { if (this._warning != null) { @@ -98736,8 +100897,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Join; return clone; @@ -99120,8 +101288,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -99157,7 +101350,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Leave { if (this._warning != null) { @@ -99165,8 +101358,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Leave; return clone; @@ -99549,8 +101749,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -99586,7 +101811,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Like { if (this._warning != null) { @@ -99594,8 +101819,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Like; return clone; @@ -99976,8 +102208,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100013,7 +102270,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Listen { if (this._warning != null) { @@ -100021,8 +102278,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Listen; return clone; @@ -100383,8 +102647,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100400,7 +102689,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Mention { if (this._warning != null) { @@ -100408,8 +102697,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Mention; return clone; @@ -100801,8 +103097,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100838,7 +103159,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Move { if (this._warning != null) { @@ -100846,8 +103167,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Move; return clone; @@ -101270,8 +103598,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -101301,7 +103654,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Note { if (this._warning != null) { @@ -101309,8 +103662,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Note;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if (\\"quote\\" in values && values.quote != null) { @@ -102955,8 +105315,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -102986,7 +105371,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): OrderedCollectionPage { if (this._warning != null) { @@ -102994,8 +105379,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as OrderedCollectionPage;clone.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = this.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items.slice();clone.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = new Set(this.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items); if (\\"items\\" in values && values.items != null) { @@ -104605,8 +106997,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -104642,7 +107059,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Organization { if (this._warning != null) { @@ -104650,8 +107067,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Organization;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -114818,8 +117242,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -114849,7 +117298,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Page { if (this._warning != null) { @@ -114857,8 +117306,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Page; return clone; @@ -115782,8 +118238,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -115819,7 +118300,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Person { if (this._warning != null) { @@ -115827,8 +118308,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Person;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -126082,8 +128570,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -126113,7 +128626,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Place { if (this._warning != null) { @@ -126121,8 +128634,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Place;clone.#_3UCsHnBHvDAXJnBuzw3zw1VVs3Ne_accuracy = this.#_3UCsHnBHvDAXJnBuzw3zw1VVs3Ne_accuracy.slice(); if (\\"accuracy\\" in values && values.accuracy != null) { @@ -127233,8 +129753,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -127264,7 +129809,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Profile { if (this._warning != null) { @@ -127272,8 +129817,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Profile;clone.#_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes = this.#_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes.slice();clone.#_trust_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes = new Set(this.#_trust_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes); if (\\"describes\\" in values && values.describes != null) { @@ -128332,8 +130884,33 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -128369,7 +130946,7 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Question { if (this._warning != null) { @@ -128377,8 +130954,15 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Question;clone.#_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf = this.#_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf.slice();clone.#_trust_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf = new Set(this.#_trust_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf); if (\\"exclusiveOptions\\" in values && values.exclusiveOptions != null) { @@ -131172,8 +133756,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -131209,7 +133818,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Read { if (this._warning != null) { @@ -131217,8 +133826,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Read; return clone; @@ -131601,8 +134217,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -131638,7 +134279,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Reject { if (this._warning != null) { @@ -131646,8 +134287,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Reject; return clone; @@ -132137,8 +134785,33 @@ relationships?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -132170,7 +134843,7 @@ relationships?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Relationship { if (this._warning != null) { @@ -132178,8 +134851,15 @@ relationships?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Relationship;clone.#_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject = this.#_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject.slice();clone.#_trust_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject = new Set(this.#_trust_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject); if (\\"subject\\" in values && values.subject != null) { @@ -134574,8 +137254,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -134611,7 +137316,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Remove { if (this._warning != null) { @@ -134619,8 +137324,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Remove; return clone; @@ -135525,8 +138237,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -135562,7 +138299,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Service { if (this._warning != null) { @@ -135570,8 +138307,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Service;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if (\\"preferredUsername\\" in values && values.preferredUsername != null) { @@ -145699,6 +148443,12 @@ export class Source { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -145862,8 +148612,33 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -145878,7 +148653,7 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Source { if (this._warning != null) { @@ -145886,8 +148661,15 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -145946,6 +148728,20 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} } } + if ( + this._verifyPortableObject != null && + !(\\"verifyPortableObject\\" in options) + ) { + getLogger([\\"fedify\\", \\"vocab\\", \\"portable\\"]).warn( + \\"Cloning {typeName} {objectId} drops its default portable object \\" + + \\"verifier, since clone() does not inherit it. Pass \\" + + \\"the verifyPortableObject option to clone() to keep verifying \\" + + \\"portable objects, or verifyPortableObject: undefined to drop \\" + + \\"the verifier deliberately without this warning.\\", + { typeName: this.constructor.name, objectId: this.id?.href ?? \\"(no id)\\" }, + ); + } + return clone; } @@ -146552,8 +149348,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -146589,7 +149410,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): TentativeAccept { if (this._warning != null) { @@ -146597,8 +149418,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as TentativeAccept; return clone; @@ -146981,8 +149809,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -147018,7 +149871,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): TentativeReject { if (this._warning != null) { @@ -147026,8 +149879,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as TentativeReject; return clone; @@ -147457,8 +150317,33 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -147489,7 +150374,7 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Tombstone { if (this._warning != null) { @@ -147497,8 +150382,15 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Tombstone;clone.#_Pn8kdUztYSt4nyoAkVsMcQaLo9U_formerType = this.#_Pn8kdUztYSt4nyoAkVsMcQaLo9U_formerType.slice(); if (\\"formerType\\" in values && values.formerType != null) { @@ -148190,8 +151082,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -148227,7 +151144,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Travel { if (this._warning != null) { @@ -148235,8 +151152,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Travel; return clone; @@ -148624,8 +151548,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -148661,7 +151610,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Undo { if (this._warning != null) { @@ -148669,8 +151618,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Undo; return clone; @@ -149056,8 +152012,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149093,7 +152074,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Update { if (this._warning != null) { @@ -149101,8 +152082,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Update; return clone; @@ -149477,8 +152465,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149508,7 +152521,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Video { if (this._warning != null) { @@ -149516,8 +152529,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Video; return clone; @@ -149918,8 +152938,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`[\\"fedify\\", \\"vocab\\", \\"portable\\"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149955,7 +153000,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): View { if (this._warning != null) { @@ -149963,8 +153008,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...(\\"verifyPortableObject\\" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as View; return clone; diff --git a/packages/vocab-tools/src/__snapshots__/class.test.ts.snap b/packages/vocab-tools/src/__snapshots__/class.test.ts.snap index 70cc9bcc6..733a9b722 100644 --- a/packages/vocab-tools/src/__snapshots__/class.test.ts.snap +++ b/packages/vocab-tools/src/__snapshots__/class.test.ts.snap @@ -157,6 +157,12 @@ export class Object { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -1304,8 +1310,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -1335,7 +1366,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Object { if (this._warning != null) { @@ -1343,8 +1374,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -2306,6 +2344,20 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -19079,8 +19131,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -19110,7 +19187,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Emoji { if (this._warning != null) { @@ -19118,8 +19195,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Emoji; return clone; @@ -19564,8 +19648,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -19595,7 +19704,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ChatMessage { if (this._warning != null) { @@ -19603,8 +19712,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ChatMessage;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if ("quote" in values && values.quote != null) { @@ -21479,8 +21595,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -21516,7 +21657,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Activity { if (this._warning != null) { @@ -21524,8 +21665,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Activity;clone.#_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor = this.#_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor.slice();clone.#_trust_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor = new Set(this.#_trust_2DjTTboo3CNHU2a2JQqUSE2dbv9D_actor); if ("actor" in values && values.actor != null) { @@ -26396,8 +26544,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -26433,7 +26606,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): EmojiReact { if (this._warning != null) { @@ -26441,8 +26614,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as EmojiReact; return clone; @@ -26778,6 +26958,12 @@ export class PropertyValue { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -26917,8 +27103,33 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -26932,7 +27143,7 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): PropertyValue { if (this._warning != null) { @@ -26940,8 +27151,15 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -26977,6 +27195,20 @@ name?: string | LanguageString | null;value?: string | LanguageString | null;} } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -27539,6 +27771,12 @@ export class Measure { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -27678,8 +27916,33 @@ unit?: string | null;numericalValue?: Decimal | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -27693,7 +27956,7 @@ unit?: string | null;numericalValue?: Decimal | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Measure { if (this._warning != null) { @@ -27701,8 +27964,15 @@ unit?: string | null;numericalValue?: Decimal | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -27738,6 +28008,20 @@ unit?: string | null;numericalValue?: Decimal | null;} } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -28357,8 +28641,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -28388,7 +28697,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): AnnounceAuthorization { if (this._warning != null) { @@ -28396,8 +28705,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as AnnounceAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if ("interactingObject" in values && values.interactingObject != null) { @@ -29873,8 +30189,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -29910,7 +30251,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): AnnounceRequest { if (this._warning != null) { @@ -29918,8 +30259,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as AnnounceRequest; return clone; @@ -30262,6 +30610,12 @@ export class InteractionPolicy { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -30443,8 +30797,33 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -30458,7 +30837,7 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): InteractionPolicy { if (this._warning != null) { @@ -30466,8 +30845,15 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -30542,6 +30928,20 @@ canFeature?: InteractionRule | null;canLike?: InteractionRule | null;canReply?: } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -31353,6 +31753,12 @@ export class InteractionRule { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -31540,8 +31946,33 @@ manualApprovals?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -31557,7 +31988,7 @@ manualApprovals?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): InteractionRule { if (this._warning != null) { @@ -31565,8 +31996,15 @@ manualApprovals?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -31648,6 +32086,20 @@ manualApprovals?: (URL)[];} } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -32248,8 +32700,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -32279,7 +32756,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): LikeAuthorization { if (this._warning != null) { @@ -32287,8 +32764,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as LikeAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if ("interactingObject" in values && values.interactingObject != null) { @@ -33763,8 +34247,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -33800,7 +34309,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): LikeRequest { if (this._warning != null) { @@ -33808,8 +34317,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as LikeRequest; return clone; @@ -34224,8 +34740,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -34255,7 +34796,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ReplyAuthorization { if (this._warning != null) { @@ -34263,8 +34804,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ReplyAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if ("interactingObject" in values && values.interactingObject != null) { @@ -35739,8 +36287,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -35776,7 +36349,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ReplyRequest { if (this._warning != null) { @@ -35784,8 +36357,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as ReplyRequest; return clone; @@ -36200,8 +36780,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -36231,7 +36836,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): QuoteAuthorization { if (this._warning != null) { @@ -36239,8 +36844,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as QuoteAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if ("interactingObject" in values && values.interactingObject != null) { @@ -37714,8 +38326,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -37751,7 +38388,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): QuoteRequest { if (this._warning != null) { @@ -37759,8 +38396,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as QuoteRequest; return clone; @@ -38103,6 +38747,12 @@ export class Translation { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -38352,8 +39002,33 @@ urls?: ((URL | Link))[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -38369,7 +39044,7 @@ urls?: ((URL | Link))[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Translation { if (this._warning != null) { @@ -38377,8 +39052,15 @@ urls?: ((URL | Link))[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -38517,6 +39199,20 @@ urls?: ((URL | Link))[];} } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -40254,8 +40950,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -40285,7 +41006,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeatureAuthorization { if (this._warning != null) { @@ -40293,8 +41014,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeatureAuthorization;clone.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = this.#_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject.slice();clone.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject = new Set(this.#_trust_2114kRKbujWhxEUghdkRYYKbXTGi_interactingObject); if ("interactingObject" in values && values.interactingObject != null) { @@ -41763,8 +42491,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -41800,7 +42553,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeatureRequest { if (this._warning != null) { @@ -41808,8 +42561,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeatureRequest; return clone; @@ -42401,8 +43161,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -42432,7 +43217,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Collection { if (this._warning != null) { @@ -42440,8 +43225,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Collection;clone.#_XDbmNDuWHmrhqH712zqtecdbv1V_totalItems = this.#_XDbmNDuWHmrhqH712zqtecdbv1V_totalItems.slice(); if ("totalItems" in values && values.totalItems != null) { @@ -49420,8 +50212,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -49451,7 +50268,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): OrderedCollection { if (this._warning != null) { @@ -49459,8 +50276,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as OrderedCollection;clone.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = this.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items.slice();clone.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = new Set(this.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items); if ("items" in values && values.items != null) { @@ -50459,8 +51283,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -50490,7 +51339,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeaturedCollection { if (this._warning != null) { @@ -50498,8 +51347,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeaturedCollection;clone.#_pc4UXYHNrYa2zyQ8Bh7zvdZRKnZ_topic = this.#_pc4UXYHNrYa2zyQ8Bh7zvdZRKnZ_topic.slice(); if ("topic" in values && values.topic != null) { @@ -51162,8 +52018,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -51193,7 +52074,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): FeaturedItem { if (this._warning != null) { @@ -51201,8 +52082,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as FeaturedItem;clone.#_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject = this.#_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject.slice();clone.#_trust_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject = new Set(this.#_trust_Ht5F1pFtcuyJkybWck37rPhwyQv_featuredObject); if ("featuredObject" in values && values.featuredObject != null) { @@ -52625,6 +53513,12 @@ export class DidService { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -52774,8 +53668,33 @@ endpoints?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -52790,7 +53709,7 @@ endpoints?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): DidService { if (this._warning != null) { @@ -52798,8 +53717,15 @@ endpoints?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -52845,6 +53771,20 @@ endpoints?: (URL)[];} } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -53295,8 +54235,33 @@ endpoints?: (URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -53311,7 +54276,7 @@ endpoints?: (URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Export { if (this._warning != null) { @@ -53319,8 +54284,15 @@ endpoints?: (URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Export; return clone; @@ -53647,6 +54619,12 @@ export class DataIntegrityProof { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -53832,8 +54810,33 @@ cryptosuite?: "eddsa-jcs-2022" | null;verificationMethod?: Multikey | URL | null * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -53847,7 +54850,7 @@ cryptosuite?: "eddsa-jcs-2022" | null;verificationMethod?: Multikey | URL | null options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): DataIntegrityProof { if (this._warning != null) { @@ -53855,8 +54858,15 @@ cryptosuite?: "eddsa-jcs-2022" | null;verificationMethod?: Multikey | URL | null this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -53933,6 +54943,20 @@ cryptosuite?: "eddsa-jcs-2022" | null;verificationMethod?: Multikey | URL | null } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -55072,6 +56096,12 @@ export class CryptographicKey { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -55216,8 +56246,33 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -55231,7 +56286,7 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): CryptographicKey { if (this._warning != null) { @@ -55239,8 +56294,15 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -55279,6 +56341,20 @@ owner?: Application | Group | Organization | Person | Service | URL | null;publi } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -56328,6 +57404,12 @@ export class Multikey { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -56472,8 +57554,33 @@ controller?: Application | Group | Organization | Person | Service | URL | null; * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -56487,7 +57594,7 @@ controller?: Application | Group | Organization | Person | Service | URL | null; options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Multikey { if (this._warning != null) { @@ -56495,8 +57602,15 @@ controller?: Application | Group | Organization | Person | Service | URL | null; this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -56535,6 +57649,20 @@ controller?: Application | Group | Organization | Person | Service | URL | null; } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -57666,8 +58794,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -57697,7 +58850,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Agreement { if (this._warning != null) { @@ -57705,8 +58858,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Agreement;clone.#_37zeAJ2NVyecrDdP8os69FGAn9Q6_stipulates = this.#_37zeAJ2NVyecrDdP8os69FGAn9Q6_stipulates.slice(); if ("stipulates" in values && values.stipulates != null) { @@ -58307,6 +59467,12 @@ export class Commitment { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -58446,8 +59612,33 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -58461,7 +59652,7 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Commitment { if (this._warning != null) { @@ -58469,8 +59660,15 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -58506,6 +59704,20 @@ satisfies?: URL | null;resourceQuantity?: Measure | null;} } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -59055,6 +60267,12 @@ export class Intent { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -59236,8 +60454,33 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -59251,7 +60494,7 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Intent { if (this._warning != null) { @@ -59259,8 +60502,15 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -59335,6 +60585,20 @@ action?: string | null;resourceConformsTo?: URL | null;resourceQuantity?: Measur } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -60295,8 +61559,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -60326,7 +61615,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Proposal { if (this._warning != null) { @@ -60334,8 +61623,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Proposal;clone.#_4wb2xgUBheR2gaD2Se8QBH4LEC7_purpose = this.#_4wb2xgUBheR2gaD2Se8QBH4LEC7_purpose.slice(); if ("purpose" in values && values.purpose != null) { @@ -61203,8 +62499,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -61240,7 +62561,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Accept { if (this._warning != null) { @@ -61248,8 +62569,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Accept; return clone; @@ -61638,8 +62966,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -61675,7 +63028,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Add { if (this._warning != null) { @@ -61683,8 +63036,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Add; return clone; @@ -62068,8 +63428,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -62105,7 +63490,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Announce { if (this._warning != null) { @@ -62113,8 +63498,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Announce; return clone; @@ -63019,8 +64411,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -63056,7 +64473,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Application { if (this._warning != null) { @@ -63064,8 +64481,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Application;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if ("preferredUsername" in values && values.preferredUsername != null) { @@ -73241,8 +74665,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -73278,7 +74727,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): IntransitiveActivity { if (this._warning != null) { @@ -73286,8 +74735,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as IntransitiveActivity; return clone; @@ -73683,8 +75139,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -73720,7 +75201,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Arrive { if (this._warning != null) { @@ -73728,8 +75209,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Arrive; return clone; @@ -74150,8 +75638,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -74181,7 +75694,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Article { if (this._warning != null) { @@ -74189,8 +75702,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Article;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if ("quote" in values && values.quote != null) { @@ -75838,8 +77358,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -75869,7 +77414,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Document { if (this._warning != null) { @@ -75877,8 +77422,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Document;clone.#_2e9AP7WdHBJYAgXG6GEyq7nSkNMe_width = this.#_2e9AP7WdHBJYAgXG6GEyq7nSkNMe_width.slice(); if ("width" in values && values.width != null) { @@ -76635,8 +78187,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -76666,7 +78243,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Audio { if (this._warning != null) { @@ -76674,8 +78251,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Audio; return clone; @@ -77077,8 +78661,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -77114,7 +78723,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Ignore { if (this._warning != null) { @@ -77122,8 +78731,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Ignore; return clone; @@ -77512,8 +79128,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -77549,7 +79190,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Block { if (this._warning != null) { @@ -77557,8 +79198,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Block; return clone; @@ -77984,8 +79632,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -78015,7 +79688,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): CollectionPage { if (this._warning != null) { @@ -78023,8 +79696,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as CollectionPage;clone.#_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf = this.#_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf.slice();clone.#_trust_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf = new Set(this.#_trust_2kWgBhQKjEauxx8C6qF3ZQamK4Le_partOf); if ("partOf" in values && values.partOf != null) { @@ -80024,8 +81704,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80061,7 +81766,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Create { if (this._warning != null) { @@ -80069,8 +81774,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Create; return clone; @@ -80453,8 +82165,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80490,7 +82227,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Delete { if (this._warning != null) { @@ -80498,8 +82235,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Delete; return clone; @@ -80880,8 +82624,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -80917,7 +82686,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Dislike { if (this._warning != null) { @@ -80925,8 +82694,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Dislike; return clone; @@ -81262,6 +83038,12 @@ export class Endpoints { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -81471,8 +83253,33 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -81486,7 +83293,7 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Endpoints { if (this._warning != null) { @@ -81494,8 +83301,15 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -81596,6 +83410,20 @@ proxyUrl?: URL | null;oauthAuthorizationEndpoint?: URL | null;oauthTokenEndpoint } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -82692,8 +84520,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -82723,7 +84576,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Event { if (this._warning != null) { @@ -82731,8 +84584,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Event; return clone; @@ -83135,8 +84995,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -83172,7 +85057,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Flag { if (this._warning != null) { @@ -83180,8 +85065,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Flag; return clone; @@ -83566,8 +85458,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -83603,7 +85520,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Follow { if (this._warning != null) { @@ -83611,8 +85528,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Follow; return clone; @@ -84517,8 +86441,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -84554,7 +86503,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Group { if (this._warning != null) { @@ -84562,8 +86511,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Group;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if ("preferredUsername" in values && values.preferredUsername != null) { @@ -94699,6 +96655,12 @@ export class Link { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -94992,8 +96954,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -95009,7 +96996,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Link { if (this._warning != null) { @@ -95017,8 +97004,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -95198,6 +97192,20 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -96979,8 +98987,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -96996,7 +99029,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Hashtag { if (this._warning != null) { @@ -97004,8 +99037,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Hashtag; return clone; @@ -97388,8 +99428,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -97419,7 +99484,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Image { if (this._warning != null) { @@ -97427,8 +99492,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Image; return clone; @@ -97831,8 +99903,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -97868,7 +99965,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Offer { if (this._warning != null) { @@ -97876,8 +99973,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Offer; return clone; @@ -98264,8 +100368,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -98301,7 +100430,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Invite { if (this._warning != null) { @@ -98309,8 +100438,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Invite; return clone; @@ -98693,8 +100829,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -98730,7 +100891,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Join { if (this._warning != null) { @@ -98738,8 +100899,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Join; return clone; @@ -99122,8 +101290,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -99159,7 +101352,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Leave { if (this._warning != null) { @@ -99167,8 +101360,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Leave; return clone; @@ -99551,8 +101751,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -99588,7 +101813,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Like { if (this._warning != null) { @@ -99596,8 +101821,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Like; return clone; @@ -99978,8 +102210,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100015,7 +102272,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Listen { if (this._warning != null) { @@ -100023,8 +102280,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Listen; return clone; @@ -100385,8 +102649,33 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100402,7 +102691,7 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Mention { if (this._warning != null) { @@ -100410,8 +102699,15 @@ names?: ((string | LanguageString))[];language?: Intl.Locale | null;height?: num this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Mention; return clone; @@ -100803,8 +103099,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -100840,7 +103161,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Move { if (this._warning != null) { @@ -100848,8 +103169,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Move; return clone; @@ -101272,8 +103600,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -101303,7 +103656,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Note { if (this._warning != null) { @@ -101311,8 +103664,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Note;clone.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = this.#_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote.slice();clone.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote = new Set(this.#_trust_3obhVLFML2Fh2Qsbg3BM2dec8S9e_quote); if ("quote" in values && values.quote != null) { @@ -102957,8 +105317,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -102988,7 +105373,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): OrderedCollectionPage { if (this._warning != null) { @@ -102996,8 +105381,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as OrderedCollectionPage;clone.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = this.#_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items.slice();clone.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items = new Set(this.#_trust_2JPCKWTcfBmTCcW8Tv3TpRaLVaqg_items); if ("items" in values && values.items != null) { @@ -104607,8 +106999,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -104644,7 +107061,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Organization { if (this._warning != null) { @@ -104652,8 +107069,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Organization;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if ("preferredUsername" in values && values.preferredUsername != null) { @@ -114820,8 +117244,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -114851,7 +117300,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Page { if (this._warning != null) { @@ -114859,8 +117308,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Page; return clone; @@ -115784,8 +118240,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -115821,7 +118302,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Person { if (this._warning != null) { @@ -115829,8 +118310,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Person;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if ("preferredUsername" in values && values.preferredUsername != null) { @@ -126084,8 +128572,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -126115,7 +128628,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Place { if (this._warning != null) { @@ -126123,8 +128636,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Place;clone.#_3UCsHnBHvDAXJnBuzw3zw1VVs3Ne_accuracy = this.#_3UCsHnBHvDAXJnBuzw3zw1VVs3Ne_accuracy.slice(); if ("accuracy" in values && values.accuracy != null) { @@ -127235,8 +129755,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -127266,7 +129811,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Profile { if (this._warning != null) { @@ -127274,8 +129819,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Profile;clone.#_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes = this.#_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes.slice();clone.#_trust_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes = new Set(this.#_trust_3CLQ1PLSXrhSQbTGGHuxNyaEFKM1_describes); if ("describes" in values && values.describes != null) { @@ -128334,8 +130886,33 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -128371,7 +130948,7 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Question { if (this._warning != null) { @@ -128379,8 +130956,15 @@ instruments?: (Object | URL)[];exclusiveOptions?: (Object | URL)[];inclusiveOpti this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Question;clone.#_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf = this.#_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf.slice();clone.#_trust_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf = new Set(this.#_trust_2N5scKaVEcdYHFmfKYYacAwUhUgQ_oneOf); if ("exclusiveOptions" in values && values.exclusiveOptions != null) { @@ -131174,8 +133758,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -131211,7 +133820,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Read { if (this._warning != null) { @@ -131219,8 +133828,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Read; return clone; @@ -131603,8 +134219,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -131640,7 +134281,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Reject { if (this._warning != null) { @@ -131648,8 +134289,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Reject; return clone; @@ -132139,8 +134787,33 @@ relationships?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -132172,7 +134845,7 @@ relationships?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Relationship { if (this._warning != null) { @@ -132180,8 +134853,15 @@ relationships?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Relationship;clone.#_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject = this.#_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject.slice();clone.#_trust_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject = new Set(this.#_trust_2Zqdmi46ZnDQsECS6mzwhrv3rUKq_subject); if ("subject" in values && values.subject != null) { @@ -134576,8 +137256,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -134613,7 +137318,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Remove { if (this._warning != null) { @@ -134621,8 +137326,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Remove; return clone; @@ -135527,8 +138239,33 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -135564,7 +138301,7 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Service { if (this._warning != null) { @@ -135572,8 +138309,15 @@ services?: (DidService | URL)[];followedMessage?: string | null;cat?: boolean | this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Service;clone.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername = this.#_3isuDgRAKSntq9XdbjiNxjwyPZAf_preferredUsername.slice(); if ("preferredUsername" in values && values.preferredUsername != null) { @@ -145701,6 +148445,12 @@ export class Source { return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } @@ -145864,8 +148614,33 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -145880,7 +148655,7 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Source { if (this._warning != null) { @@ -145888,8 +148663,15 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } // @ts-ignore: this.constructor is not recognized as a constructor, but it is. @@ -145948,6 +148730,20 @@ contents?: ((string | LanguageString))[];mediaType?: string | null;} } } + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + return clone; } @@ -146554,8 +149350,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -146591,7 +149412,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): TentativeAccept { if (this._warning != null) { @@ -146599,8 +149420,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as TentativeAccept; return clone; @@ -146983,8 +149811,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -147020,7 +149873,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): TentativeReject { if (this._warning != null) { @@ -147028,8 +149881,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as TentativeReject; return clone; @@ -147459,8 +150319,33 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -147491,7 +150376,7 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Tombstone { if (this._warning != null) { @@ -147499,8 +150384,15 @@ formerTypes?: ($EntityType)[];deleted?: Temporal.Instant | null;} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Tombstone;clone.#_Pn8kdUztYSt4nyoAkVsMcQaLo9U_formerType = this.#_Pn8kdUztYSt4nyoAkVsMcQaLo9U_formerType.slice(); if ("formerType" in values && values.formerType != null) { @@ -148192,8 +151084,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -148229,7 +151146,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Travel { if (this._warning != null) { @@ -148237,8 +151154,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Travel; return clone; @@ -148626,8 +151550,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -148663,7 +151612,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Undo { if (this._warning != null) { @@ -148671,8 +151620,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Undo; return clone; @@ -149058,8 +152014,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149095,7 +152076,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Update { if (this._warning != null) { @@ -149103,8 +152084,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Update; return clone; @@ -149479,8 +152467,33 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149510,7 +152523,7 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): Video { if (this._warning != null) { @@ -149518,8 +152531,15 @@ proofs?: (DataIntegrityProof | URL)[];interactionPolicy?: InteractionPolicy | nu this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as Video; return clone; @@ -149920,8 +152940,33 @@ instruments?: (Object | URL)[];} * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -149957,7 +153002,7 @@ instruments?: (Object | URL)[];} options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): View { if (this._warning != null) { @@ -149965,8 +153010,15 @@ instruments?: (Object | URL)[];} this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } const clone = super.clone(values, options) as unknown as View; return clone; diff --git a/packages/vocab-tools/src/class.ts b/packages/vocab-tools/src/class.ts index 49345c286..70e43ab69 100644 --- a/packages/vocab-tools/src/class.ts +++ b/packages/vocab-tools/src/class.ts @@ -136,6 +136,12 @@ async function* generateClass( return this.#tracerProvider; } + /** + * Internal cross-package contract with @fedify/fedify and @fedify/testing, + * which read this through \`Reflect.get()\` to pass an object's default + * verifier on to its clones. Keep this accessor name and its semantics + * stable. + */ protected get _verifyPortableObject(): PortableObjectVerifier | undefined { return this.#verifyPortableObject; } diff --git a/packages/vocab-tools/src/constructor.ts b/packages/vocab-tools/src/constructor.ts index a27a2c5f4..3ae3136b2 100644 --- a/packages/vocab-tools/src/constructor.ts +++ b/packages/vocab-tools/src/constructor.ts @@ -230,8 +230,33 @@ export async function* generateCloner( * would be wrong. Sign the clone again if it has to be embedded as a * secured child. * + * The clone does not inherit this instance's default FEP-ef61 portable + * object verifier, i.e., the \`verifyPortableObject\` option given when this + * instance was constructed, parsed, or fetched by an accessor, nor its + * \`documentLoader\` or \`contextLoader\`. Without a verifier, the clone's + * accessors no longer verify embedded portable objects, and refuse to + * dereference portable references. To keep verifying them, pass + * \`verifyPortableObject\` in \`options\`, or serialize this instance and + * re-parse it with \`fromJsonLd()\` and the verifier. A verifier is only + * a policy for dereferencing; passing one does not verify the clone itself. + * + * Cloning an instance that has a default verifier without passing + * the \`verifyPortableObject\` option logs a warning in the + * \`["fedify", "vocab", "portable"]\` category. Pass + * \`verifyPortableObject: undefined\` to drop the verifier deliberately + * without the warning. Either way, nested objects shared with this + * instance keep their own defaults. + * * @param values The values to update the clone with. * @param options The options to use for cloning. + * + * - \`documentLoader\`: The document loader for the clone. + * - \`contextLoader\`: The JSON-LD context loader for + * the clone. + * - \`verifyPortableObject\`: The default FEP-ef61 portable + * object verifier for the clone. It is not inherited from + * this instance. Pass \`undefined\` explicitly to clone + * without a verifier and without a warning. * @returns The cloned instance with its own property arrays. Nested objects * and URLs are shared with this instance. */ @@ -244,7 +269,7 @@ export async function* generateCloner( options: { documentLoader?: DocumentLoader, contextLoader?: DocumentLoader, - verifyPortableObject?: PortableObjectVerifier, + verifyPortableObject?: PortableObjectVerifier | undefined, } = {} ): ${type.name} { if (this._warning != null) { @@ -252,8 +277,15 @@ export async function* generateCloner( this._warning.message, this._warning.values ); - // @ts-ignore: $warning is not recognized as a property, but it is. - options = { ...options, $warning: this._warning }; + // Keep an explicit verifyPortableObject option, even an inherited or + // non-enumerable one, since its presence decides whether to warn below: + options = { + ...options, + ...("verifyPortableObject" in options + ? { verifyPortableObject: options.verifyPortableObject } + : {}), + $warning: this._warning, + } as typeof options; } `; if (type.extends == null) { @@ -357,6 +389,23 @@ export async function* generateCloner( `; } } + if (type.extends == null) { + yield ` + if ( + this._verifyPortableObject != null && + !("verifyPortableObject" in options) + ) { + getLogger(["fedify", "vocab", "portable"]).warn( + "Cloning {typeName} {objectId} drops its default portable object " + + "verifier, since clone() does not inherit it. Pass " + + "the verifyPortableObject option to clone() to keep verifying " + + "portable objects, or verifyPortableObject: undefined to drop " + + "the verifier deliberately without this warning.", + { typeName: this.constructor.name, objectId: this.id?.href ?? "(no id)" }, + ); + } + `; + } yield ` return clone; } diff --git a/packages/vocab/src/gateway.test.ts b/packages/vocab/src/gateway.test.ts index 06e72acf4..198746532 100644 --- a/packages/vocab/src/gateway.test.ts +++ b/packages/vocab/src/gateway.test.ts @@ -14,6 +14,7 @@ import { type RemoteDocument, withGatewayHints, } from "@fedify/vocab-runtime"; +import { configure, type LogRecord, reset } from "@logtape/logtape"; import fetchMock from "fetch-mock"; import { deepStrictEqual, ok, rejects } from "node:assert/strict"; import { lookupObject, traverseCollection } from "./lookup.ts"; @@ -22,6 +23,7 @@ import { Collection, CollectionPage, Create, + CryptographicKey, Image, Note, OrderedCollection, @@ -2189,6 +2191,108 @@ function getDefaultVerifier( ._verifyPortableObject; } +test("clone() warns when it drops the default portable object verifier", async () => { + const records: LogRecord[] = []; + await reset(); + try { + await configure({ + sinks: { buffer: (record: LogRecord) => records.push(record) }, + loggers: [ + { category: ["fedify", "vocab", "portable"], sinks: ["buffer"] }, + { category: ["logtape", "meta"], sinks: [] }, + ], + }); + const takeWarnings = () => records.splice(0).map((r) => r.properties); + const documentLoader = createLoader({ [compatibleNoteId]: note() }); + const options = { documentLoader, contextLoader: mockDocumentLoader }; + const verifier = createRecordingVerifier(); + const activity = new Create({ + id: new URL(gatewayUrl("https://gw.example", "/activities/1")), + object: new URL(compatibleNoteId), + }, { contextLoader: mockDocumentLoader, verifyPortableObject: verifier }); + + // Omitting the option drops the verifier with exactly one warning, even + // through the subclass chain (Create -> Activity -> Object): + const dropped = activity.clone(); + deepStrictEqual(takeWarnings(), [{ + typeName: "Create", + objectId: gatewayUrl("https://gw.example", "/activities/1"), + }]); + await rejects(() => dropped.getObject(options), TypeError); + activity.clone({ content: "Again" }); + deepStrictEqual(takeWarnings().length, 1); + + // An explicit undefined drops it deliberately without a warning: + const optedOut = activity.clone({}, { verifyPortableObject: undefined }); + deepStrictEqual(takeWarnings(), []); + await rejects(() => optedOut.getObject(options), TypeError); + + // An explicit verifier is used by the clone's accessors: + const given = createRecordingVerifier(); + const kept = activity.clone({}, { verifyPortableObject: given }); + deepStrictEqual(takeWarnings(), []); + assertInstanceOf(await kept.getObject(options), Note); + deepStrictEqual(given.calls.length, 1); + deepStrictEqual(verifier.calls.length, 0); + + // Inherited and non-enumerable options count as given: + const inherited = Object.create({ verifyPortableObject: given }); + activity.clone({}, inherited); + const nonEnumerable = Object.defineProperty({}, "verifyPortableObject", { + value: undefined, + enumerable: false, + }); + activity.clone({}, nonEnumerable); + deepStrictEqual(takeWarnings(), []); + + // A root class warns once as well, with a placeholder for a missing id: + new CryptographicKey({}, { verifyPortableObject: verifier }).clone(); + deepStrictEqual(takeWarnings(), [{ + typeName: "CryptographicKey", + objectId: "(no id)", + }]); + + // Objects without a default verifier never warn: + new Create({}).clone(); + deepStrictEqual(takeWarnings(), []); + + // A parsed object carries the default, too: + const parsed = await createCompatibleActivity( + compatibleNoteId, + undefined, + { verifyPortableObject: verifier }, + ); + parsed.clone(); + deepStrictEqual(takeWarnings().length, 1); + + // An instance with an internal $warning spreads the options, which must + // keep inherited and non-enumerable verifyPortableObject options: + const warned = new Create({ + object: new URL(compatibleNoteId), + }, { + contextLoader: mockDocumentLoader, + verifyPortableObject: verifier, + $warning: { category: ["fedify", "vocab", "test"], message: "Test" }, + } as unknown as { verifyPortableObject: PortableObjectVerifier }); + warned.clone(); + deepStrictEqual(takeWarnings().length, 1); + const given2 = createRecordingVerifier(); + const warnedClone = warned.clone( + {}, + Object.create({ + contextLoader: mockDocumentLoader, + verifyPortableObject: given2, + }), + ); + warned.clone({}, nonEnumerable); + deepStrictEqual(takeWarnings(), []); + assertInstanceOf(await warnedClone.getObject(options), Note); + deepStrictEqual(given2.calls.length, 1); + } finally { + await reset(); + } +}); + test("accessors pass the verifier of a call on to the objects they fetch", async (t) => { const actorId = `ap://${did}/actor`; const attributedNote = (id: string) => ({ diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 2c88e1e2a..cdbe2848e 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -2088,6 +2088,9 @@ importers: '@fedify/fixture': specifier: workspace:^ version: link:../fixture + '@logtape/logtape': + specifier: 'catalog:' + version: 2.2.0 '@standard-schema/spec': specifier: 'catalog:' version: 1.1.0 From 93921a388c4d3b60ffaf00d23e87a3a73f2ae77b Mon Sep 17 00:00:00 2001 From: Hong Minhee Date: Sat, 7 Nov 2026 00:00:10 +0900 Subject: [PATCH 2/2] Drop stale wasm-runtime override in Astro compat Astro 7.4.7's Rolldown binding now directly depends on @emnapi 2.0 packages and @napi-rs/wasm-runtime 1.2.6. Forcing wasm-runtime back to 1.1.6 leaves unmet @emnapi 1.x peers, so pnpm install fails. Remove the obsolete override. All five Astro compatibility cases now pass on Node.js, Deno, and Bun. Changelog: none Assisted-by: OpenCode:deepseek-flash (cherry picked from commit a042f264dee12b0f718b779fa453f8b984c35ae6) --- packages/astro/compat/run.ts | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/packages/astro/compat/run.ts b/packages/astro/compat/run.ts index dfc52cf52..90daa306e 100644 --- a/packages/astro/compat/run.ts +++ b/packages/astro/compat/run.ts @@ -83,12 +83,7 @@ async function testCompatibility(testCase: CompatibilityCase): Promise { astro: testCase.astro, }, pnpm: { - overrides: { - ...Object.fromEntries(tarballs), - // Version 1.2.0 requires @emnapi/* 2.0 prereleases, while its - // consumers still provide @emnapi/* 1.x. - "@napi-rs/wasm-runtime@^1.1.6": "1.1.6", - }, + overrides: Object.fromEntries(tarballs), }, }, null,