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/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, 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