@fedify/vocab-runtime 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/src/portable-workers.test.ts

@@ -0,0 +1,81 @@
+import { test, testDefinitions } from "@fedify/fixture";
+import { deepStrictEqual, equal } from "node:assert/strict";
+import {
+  computeDigestMultibase,
+  createHashlink,
+  verifyHashlink,
+} from "./digest.ts";
+import { exportDidKey, importDidKey } from "./key.ts";
+import { getPortableGatewayCandidates } from "./internal/portable-dereference.ts";
+import {
+  canonicalizePortableUri,
+  formatIri,
+  fromCompatibleEf61Id,
+  parseIri,
+  toCompatibleEf61Id,
+} from "./url.ts";
+
+const portableId = "ap://did:key:z6Mkabc/actor";
+
+export { testDefinitions };
+
+test("vocab-runtime portable URI formats on Workers", () => {
+  equal(formatIri(parseIri(portableId)), "ap+ef61://did:key:z6Mkabc/actor");
+  equal(
+    canonicalizePortableUri(`${portableId}?@gateway=https%3A%2F%2Fa.example`),
+    "ap+ef61://did:key:z6Mkabc/actor",
+  );
+});
+
+test("vocab-runtime compatible IDs on Workers", () => {
+  const compatible = toCompatibleEf61Id(portableId, "https://gw.example");
+  equal(
+    compatible.href,
+    "https://gw.example/.well-known/apgateway/did:key:z6Mkabc/actor",
+  );
+  equal(
+    formatIri(fromCompatibleEf61Id(compatible)!),
+    "ap+ef61://did:key:z6Mkabc/actor",
+  );
+});
+
+test("vocab-runtime did:key on Workers", async () => {
+  const keys = await crypto.subtle.generateKey("Ed25519", true, [
+    "sign",
+    "verify",
+  ]) as CryptoKeyPair;
+  const did = await exportDidKey(keys.publicKey);
+  const imported = await importDidKey(did);
+  deepStrictEqual(
+    new Uint8Array(await crypto.subtle.exportKey("raw", imported)),
+    new Uint8Array(await crypto.subtle.exportKey("raw", keys.publicKey)),
+  );
+});
+
+test("vocab-runtime hashlink on Workers", async () => {
+  const bytes = new TextEncoder().encode("portable media");
+  const digest = await computeDigestMultibase(bytes);
+  equal(await verifyHashlink(bytes, createHashlink(digest)), true);
+  equal(
+    await verifyHashlink(
+      new TextEncoder().encode("tampered"),
+      createHashlink(digest),
+    ),
+    false,
+  );
+});
+
+test("vocab-runtime gateway candidates on Workers", () => {
+  const hinted = parseIri(
+    `${portableId}?@gateway=https%3A%2F%2Fhint.example`,
+  );
+  deepStrictEqual(
+    getPortableGatewayCandidates(hinted, ["https://first.example"])
+      .map((url) => url.href),
+    ["https://first.example/"],
+  );
+  deepStrictEqual(
+    getPortableGatewayCandidates(hinted).map((url) => url.href),
+    ["https://hint.example/"],
+  );
+});

package/src/portable.ts

@@ -0,0 +1,180 @@
+import type { TracerProvider } from "@opentelemetry/api";
+import type { DocumentLoader } from "./docloader.ts";
+
+/**
+ * Options passed to a {@link PortableObjectVerifier}.
+ * @since 2.4.0
+ */
+export interface PortableObjectVerifierOptions {
+  /**
+   * The document loader for fetching remote documents, such as verification
+   * methods that are not `did:key` URLs.
+   */
+  readonly documentLoader?: DocumentLoader;
+
+  /**
+   * The document loader for fetching remote JSON-LD contexts.  During
+   * gateway dereferencing, this loader returns the same context documents
+   * that the vocabulary parser sees.
+   */
+  readonly contextLoader?: DocumentLoader;
+
+  /**
+   * The OpenTelemetry tracer provider.
+   */
+  readonly tracerProvider?: TracerProvider;
+
+  /**
+   * The URL the document was finally retrieved from, i.e., the `documentUrl`
+   * of the document loader's result, which may differ from the requested URL
+   * after redirects.  Trust decisions such as the [FEP-ef61] gateway trust
+   * policy for unsecured collections depend on it, so custom document loaders
+   * must report it truthfully.
+   *
+   * [FEP-ef61]: https://w3id.org/fep/ef61
+   * @since 2.4.0
+   */
+  readonly documentUrl?: URL;
+
+  /**
+   * The gateways that the caller explicitly passed to the accessor through
+   * its `gateways` option, in order.  It is `undefined` if the caller did not
+   * pass the option, and can be empty.
+   * @since 2.4.0
+   */
+  readonly gateways?: readonly URL[];
+
+  /**
+   * The gateways inferred from the reference, in order, when the caller did
+   * not pass the `gateways` option: the `@gateway` location hints of
+   * a portable IRI, the gateway named by an FEP-ef61 compatible identifier,
+   * or the WebFinger server of a portable actor.  They only tell where the
+   * document and related objects might be retrieved, and must not be
+   * trusted to act for the portable object's DID.
+   * @since 2.4.0
+   */
+  readonly gatewayHints?: readonly URL[];
+
+  /**
+   * The object whose property referred to the document, if the document was
+   * dereferenced through a property accessor.
+   * @since 2.4.0
+   */
+  readonly referrer?: PortableObjectReferrer;
+}
+
+/**
+ * An object whose property referred to a portable object being verified.
+ * Referrers form a chain: {@link PortableObjectReferrer.referrer} is the
+ * object through which this referrer itself was obtained, and so on.
+ * @since 2.4.0
+ */
+export interface PortableObjectReferrer {
+  /**
+   * The referring vocabulary object.
+   */
+  readonly object: unknown;
+
+  /**
+   * The `@id` of the referring object, if any.
+   */
+  readonly id: URL | null;
+
+  /**
+   * The expanded URI of the property through which the referring object
+   * referred to the next object in the chain, e.g.,
+   * `https://www.w3.org/ns/activitystreams#outbox`.
+   */
+  readonly property: string;
+
+  /**
+   * How the referring object itself was accepted by a
+   * {@link PortableObjectVerifier} when it was dereferenced through gateways:
+   *
+   * - `"verified"`: accepted as verified, e.g., with a valid integrity proof.
+   * - `"unsecured"`: accepted without an integrity proof, e.g., as an
+   *   unsecured collection served by a trusted gateway.
+   *
+   * It is `undefined` if the referring object was not dereferenced through
+   * gateways, e.g., if it was embedded in another object or constructed by
+   * the application.
+   */
+  readonly acceptance?: "verified" | "unsecured";
+
+  /**
+   * The opaque collection context that a {@link PortableObjectVerifier}
+   * attached to the referring object when it accepted it.  See
+   * {@link PortableObjectVerification}.
+   */
+  readonly collectionContext?: unknown;
+
+  /**
+   * The referrer of the referring object, if any.
+   */
+  readonly referrer?: PortableObjectReferrer;
+
+  /**
+   * Whether the chain was cut off here because it was too long.  If `true`,
+   * the referring object may have a referrer which is not included.
+   */
+  readonly truncated?: boolean;
+}
+
+/**
+ * The result of a {@link PortableObjectVerifier}.
+ * @since 2.4.0
+ */
+export type PortableObjectVerification =
+  | {
+    /** Whether the document is accepted. */
+    readonly verified: false;
+  }
+  | {
+    /** Whether the document is accepted. */
+    readonly verified: true;
+
+    /**
+     * Whether the document was accepted without an integrity proof, e.g., as
+     * an unsecured [FEP-ef61] collection served by a gateway that its owner
+     * lists.  Objects embedded in such a document are not trusted because of
+     * their origin; property accessors dereference and verify them one by
+     * one instead.
+     *
+     * [FEP-ef61]: https://w3id.org/fep/ef61
+     */
+    readonly unsecured?: boolean;
+
+    /**
+     * An opaque value that the verifier wants to receive again as
+     * {@link PortableObjectReferrer.collectionContext} when objects referred
+     * to by this document, such as collection pages, are verified.
+     */
+    readonly collectionContext?: unknown;
+  };
+
+/**
+ * A function that applies the [FEP-ef61] trust policy to a portable object
+ * fetched through a gateway.
+ *
+ * It receives the fetched JSON-LD document as is, and resolves to an object
+ * whose `verified` property tells whether the document is acceptable, e.g.,
+ * whether it carries a valid [FEP-8b32] Object Integrity Proof made by the
+ * DID in its portable ID.  `verifyPortableObject()` and
+ * `verifyPortableObjectProof()` from `@fedify/fedify` satisfy this type, so
+ * they can be passed as the `verifyPortableObject` option of generated
+ * vocabulary accessors such as `Activity.getObject()`.
+ *
+ * [FEP-ef61]: https://w3id.org/fep/ef61
+ * [FEP-8b32]: https://w3id.org/fep/8b32
+ *
+ * @param document The fetched JSON-LD document.
+ * @param options Loaders, tracing options, and where the document came from.
+ * @returns An object whose `verified` property is `true` if and only if the
+ *          document satisfies the policy.  Other properties, such as
+ *          a failure reason, are logged when verification fails.
+ * @since 2.4.0
+ */
+export type PortableObjectVerifier = (
+  document: unknown,
+  options: PortableObjectVerifierOptions,
+) => Promise<PortableObjectVerification>;

package/src/preprocessor.ts

@@ -1,5 +1,6 @@
 import type { DocumentLoader } from "./docloader.ts";
 import type { TracerProvider } from "@opentelemetry/api";
+import type { PortableObjectVerifier } from "./portable.ts";
 
 /**
  * JSON value shape passed to property preprocessors.
@@ -24,6 +25,12 @@ export interface PropertyPreprocessorContext {
   contextLoader?: DocumentLoader;
   /** OpenTelemetry tracer provider for instrumentation. */
   tracerProvider?: TracerProvider;
+  /**
+   * The default FEP-ef61 portable object verifier that objects returned by
+   * the preprocessor should use for their property accessors.
+   * @since 2.4.0
+   */
+  verifyPortableObject?: PortableObjectVerifier;
   /** Base URL for resolving relative references. */
   baseUrl?: URL;
 }

package/src/request.test.ts

@@ -2,7 +2,7 @@ import { deepStrictEqual } from "node:assert";
 import process from "node:process";
 import { test } from "node:test";
 import metadata from "../deno.json" with { type: "json" };
-import { getUserAgent } from "./request.ts";
+import { createActivityPubRequest, getUserAgent } from "./request.ts";
 
 test("getUserAgent()", () => {
   if ("Deno" in globalThis) {
@@ -91,3 +91,12 @@ test("getUserAgent()", () => {
     );
   }
 });
+
+test("createActivityPubRequest() asks for the ActivityStreams profile", () => {
+  const request = createActivityPubRequest("https://example.com/object");
+  deepStrictEqual(
+    request.headers.get("Accept"),
+    "application/activity+json, " +
+      'application/ld+json; profile="https://www.w3.org/ns/activitystreams"',
+  );
+});

package/src/request.ts

@@ -31,6 +31,14 @@ export class FetchError extends Error {
   }
 }
 
+/**
+ * The `Accept` header value for fetching ActivityPub objects.  ActivityPub
+ * and FEP-ef61 gateways require the ActivityStreams profile on the JSON-LD
+ * media type.
+ */
+const ACTIVITYPUB_ACCEPT =
+  'application/activity+json, application/ld+json; profile="https://www.w3.org/ns/activitystreams"';
+
 /**
  * Options for creating a request.
  * @internal
@@ -52,7 +60,7 @@ export function createActivityPubRequest(
 ): Request {
   return new Request(url, {
     headers: {
-      Accept: "application/activity+json, application/ld+json",
+      Accept: ACTIVITYPUB_ACCEPT,
       "User-Agent": typeof options.userAgent === "string"
         ? options.userAgent
         : getUserAgent(options.userAgent),

package/src/signed-representation.test.ts

@@ -0,0 +1,338 @@
+import { deepStrictEqual, ok, strictEqual, throws } from "node:assert";
+import { test } from "node:test";
+import {
+  enterSignedValueScope,
+  getRetainedSignedRepresentation,
+  isMarkerSafeContext,
+  isPlainJsonTree,
+  resolveSignedValues,
+  retainedSignedValueRef,
+  retainSignedRepresentation,
+  type SignedValueScope,
+} from "./internal/signed-representation.ts";
+
+const securedDocument = {
+  "@context": [
+    "https://www.w3.org/ns/activitystreams",
+    "https://w3id.org/security/data-integrity/v1",
+  ],
+  id: "ap://did:key:z6Mkabc/objects/1",
+  type: "Note",
+  content: "Hello",
+  proof: {
+    "@context": [
+      "https://www.w3.org/ns/activitystreams",
+      "https://w3id.org/security/data-integrity/v1",
+    ],
+    type: "DataIntegrityProof",
+    cryptosuite: "eddsa-jcs-2022",
+    created: "2023-02-24T23:36:38Z",
+    verificationMethod: "did:key:z6Mkabc#z6Mkabc",
+    proofPurpose: "assertionMethod",
+    proofValue: "z3FXQ",
+  },
+};
+
+function newScope(options: Record<string, unknown> = {}): SignedValueScope {
+  return enterSignedValueScope(options).scope;
+}
+
+function retainedSubject(): object {
+  const subject = {};
+  retainSignedRepresentation(subject, structuredClone(securedDocument));
+  return subject;
+}
+
+test("isPlainJsonTree() accepts plain JSON and rejects everything else", () => {
+  ok(isPlainJsonTree(securedDocument));
+  ok(isPlainJsonTree([1, "two", null, { three: true }]));
+  ok(isPlainJsonTree(Object.create(null)));
+
+  ok(!isPlainJsonTree(undefined));
+  ok(!isPlainJsonTree(Number.NaN));
+  ok(!isPlainJsonTree(Number.POSITIVE_INFINITY));
+  ok(!isPlainJsonTree(new Date()));
+  ok(!isPlainJsonTree(new URL("https://example.com/")));
+  ok(!isPlainJsonTree({ nested: { deeper: undefined } }));
+
+  const withSymbolKey: Record<string | symbol, unknown> = { a: 1 };
+  withSymbolKey[Symbol("b")] = 2;
+  ok(!isPlainJsonTree(withSymbolKey));
+
+  const withAccessor = {};
+  Object.defineProperty(withAccessor, "a", { get: () => 1, enumerable: true });
+  ok(!isPlainJsonTree(withAccessor));
+
+  const withHiddenProperty = {};
+  Object.defineProperty(withHiddenProperty, "a", {
+    value: 1,
+    enumerable: false,
+  });
+  ok(!isPlainJsonTree(withHiddenProperty));
+});
+
+test("retainSignedRepresentation() attaches a frozen, hidden snapshot", () => {
+  const subject: Record<string, unknown> = {};
+  retainSignedRepresentation(subject, structuredClone(securedDocument));
+  const retained = getRetainedSignedRepresentation(subject);
+
+  deepStrictEqual(retained, securedDocument);
+  ok(Object.isFrozen(retained));
+  ok(Object.isFrozen((retained as Record<string, unknown>).proof));
+  // The carrier must not show up in ordinary enumeration or serialization.
+  deepStrictEqual(Object.keys(subject), []);
+  strictEqual(JSON.stringify(subject), "{}");
+  // A fresh object, such as the one `clone()` builds, has no snapshot.
+  strictEqual(getRetainedSignedRepresentation({}), undefined);
+  strictEqual(getRetainedSignedRepresentation(null), undefined);
+  strictEqual(getRetainedSignedRepresentation("string"), undefined);
+});
+
+test("retainSignedRepresentation() rejects a value that is not plain JSON", () => {
+  throws(
+    () =>
+      retainSignedRepresentation({}, {
+        created: new Date(),
+      } as unknown as Record<string, unknown>),
+    TypeError,
+  );
+  throws(
+    () =>
+      retainSignedRepresentation(
+        {},
+        [1, 2] as unknown as Record<string, unknown>,
+      ),
+    TypeError,
+  );
+});
+
+test("isMarkerSafeContext() accepts contexts Fedify can vet offline", () => {
+  ok(isMarkerSafeContext(null));
+  ok(isMarkerSafeContext("https://www.w3.org/ns/activitystreams"));
+  ok(isMarkerSafeContext([
+    "https://www.w3.org/ns/activitystreams",
+    "https://w3id.org/security/data-integrity/v1",
+    "https://w3id.org/fep/ef61",
+  ]));
+  ok(isMarkerSafeContext([
+    "https://www.w3.org/ns/activitystreams",
+    { ex: "https://example.com/ns#" },
+  ]));
+});
+
+test("isMarkerSafeContext() rejects contexts that could hide a placeholder", () => {
+  // A context Fedify cannot resolve offline cannot be vetted at all.
+  ok(!isMarkerSafeContext("https://example.com/unknown-context"));
+  // An `@id` alias other than ActivityStreams' own `id`.
+  ok(!isMarkerSafeContext({ identifier: "@id" }));
+  ok(!isMarkerSafeContext({ identifier: { "@id": "@id" } }));
+  // An indirect alias: `i` resolves through `id`, which ActivityStreams maps
+  // to `@id`.  A target with no scheme separator is never an IRI.
+  ok(
+    !isMarkerSafeContext([
+      "https://www.w3.org/ns/activitystreams",
+      { i: "id" },
+    ]),
+  );
+  ok(!isMarkerSafeContext({ relative: { "@id": "ns#term" } }));
+  // `@nest` moves a property value into a wrapper map.
+  ok(!isMarkerSafeContext({ payload: "@nest" }));
+  ok(
+    !isMarkerSafeContext({
+      object: {
+        "@id": "https://www.w3.org/ns/activitystreams#object",
+        "@nest": "payload",
+      },
+    }),
+  );
+  // An id map or type map turns the identifier into a map key.
+  ok(
+    !isMarkerSafeContext({
+      object: {
+        "@id": "https://www.w3.org/ns/activitystreams#object",
+        "@container": "@id",
+      },
+    }),
+  );
+  ok(
+    !isMarkerSafeContext({
+      object: {
+        "@id": "https://www.w3.org/ns/activitystreams#object",
+        "@container": ["@set", "@type"],
+      },
+    }),
+  );
+  // A prefix, `@vocab` or `@base` covering the placeholder namespace lets
+  // compaction emit a shortened or relative marker.
+  ok(!isMarkerSafeContext({ urn: "urn:" }));
+  // A term named after the placeholder's scheme makes a JSON-LD processor
+  // read the marker as a compact IRI, whatever the term points at.
+  ok(!isMarkerSafeContext({ urn: "https://example.com/ns#" }));
+  ok(!isMarkerSafeContext({ urn: { "@id": "https://example.com/ns#urn" } }));
+  ok(!isMarkerSafeContext({ "@vocab": "urn:x-fedify-signed-value:" }));
+  ok(!isMarkerSafeContext({ "@base": "urn:" }));
+  ok(!isMarkerSafeContext({ everything: "" }));
+  // A scoped context is only as safe as its own definitions.
+  ok(isMarkerSafeContext({
+    Note: {
+      "@id": "https://www.w3.org/ns/activitystreams#Note",
+      "@context": { ex: "https://example.com/ns#" },
+    },
+  }));
+  ok(
+    !isMarkerSafeContext({
+      Note: {
+        "@id": "https://www.w3.org/ns/activitystreams#Note",
+        "@context": { identifier: "@id" },
+      },
+    }),
+  );
+});
+
+test("enterSignedValueScope() gives each call its own scope", () => {
+  const callerOptions = { format: "compact" as const };
+  const first = { ...callerOptions };
+  const second = { ...callerOptions };
+  const firstEntry = enterSignedValueScope(first);
+  const secondEntry = enterSignedValueScope(second);
+
+  ok(firstEntry.owner);
+  ok(secondEntry.owner);
+  ok(firstEntry.scope !== secondEntry.scope);
+  // The caller's own object is never touched.
+  deepStrictEqual(Object.getOwnPropertySymbols(callerOptions), []);
+
+  // A nested frame inherits the scope through the generated spread.
+  const nested = enterSignedValueScope({ ...first, format: "expand" });
+  ok(!nested.owner);
+  strictEqual(nested.scope, firstEntry.scope);
+});
+
+test("enterSignedValueScope() disables retention where it cannot apply", () => {
+  ok(enterSignedValueScope({}).scope.enabled);
+  ok(enterSignedValueScope({ format: "compact" }).scope.enabled);
+  // An expanded document has no compact representation to preserve.
+  ok(!enterSignedValueScope({ format: "expand" }).scope.enabled);
+  // A context that could hide a placeholder turns the whole mechanism off
+  // rather than risking a corrupted document.
+  ok(
+    !enterSignedValueScope({
+      format: "compact",
+      context: { identifier: "@id" } as unknown as Record<string, string>,
+    }).scope.enabled,
+  );
+});
+
+test("retainedSignedValueRef() mints one marker per instance", () => {
+  const scope = newScope();
+  const subject = retainedSubject();
+  const first = retainedSignedValueRef(subject, scope);
+  const second = retainedSignedValueRef(subject, scope);
+
+  ok(first != null);
+  deepStrictEqual(first, second);
+  ok(first["@id"].startsWith("urn:x-fedify-signed-value:"));
+  strictEqual(
+    scope.documents.get(first["@id"]),
+    scope.documents.get(second!["@id"]),
+  );
+  strictEqual(retainedSignedValueRef({}, scope), undefined);
+  strictEqual(retainedSignedValueRef(null, scope), undefined);
+  strictEqual(
+    retainedSignedValueRef(subject, newScope({ format: "expand" })),
+    undefined,
+  );
+});
+
+test("resolveSignedValues() restores every supported reference shape", () => {
+  const scope = newScope();
+  const subject = retainedSubject();
+  const marker = retainedSignedValueRef(subject, scope)!["@id"];
+  retainedSignedValueRef(subject, scope);
+  retainedSignedValueRef(subject, scope);
+
+  const resolved = resolveSignedValues({
+    "@context": ["https://www.w3.org/ns/activitystreams"],
+    object: marker,
+    attachment: [{ "@id": marker }],
+    tag: { id: marker },
+  }, scope) as Record<string, unknown>;
+
+  deepStrictEqual(resolved.object, securedDocument);
+  deepStrictEqual((resolved.attachment as unknown[])[0], securedDocument);
+  deepStrictEqual(resolved.tag, securedDocument);
+  // Each site gets its own copy.
+  ok(resolved.object !== resolved.tag);
+});
+
+test("resolveSignedValues() leaves a document without placeholders alone", () => {
+  const scope = newScope();
+  const document = { id: "https://example.com/notes/1" };
+  strictEqual(resolveSignedValues(document, scope), document);
+});
+
+test("resolveSignedValues() does not rewrite a context definition", () => {
+  const scope = newScope();
+  const subject = retainedSubject();
+  const marker = retainedSignedValueRef(subject, scope)!["@id"];
+  // A placeholder that only survives inside `@context` was never restored,
+  // so the accounting check has to reject the document.
+  throws(
+    () => resolveSignedValues({ "@context": { marker } }, scope),
+    TypeError,
+  );
+});
+
+test("resolveSignedValues() rejects a document that lost a placeholder", () => {
+  const scope = newScope();
+  const subject = retainedSubject();
+  retainedSignedValueRef(subject, scope);
+
+  throws(
+    () => resolveSignedValues({ id: "https://example.com/notes/1" }, scope),
+    TypeError,
+  );
+});
+
+test("resolveSignedValues() rejects a document that kept a placeholder trace", () => {
+  const scope = newScope();
+  const subject = retainedSubject();
+  const marker = retainedSignedValueRef(subject, scope)!["@id"];
+  const uuid = marker.slice("urn:x-fedify-signed-value:".length);
+
+  throws(
+    () => resolveSignedValues({ object: marker, note: `sv:${uuid}` }, scope),
+    TypeError,
+  );
+});
+
+test("resolveSignedValues() restores a placeholder only where it is a reference", () => {
+  const scope = newScope();
+  const subject = retainedSubject();
+  const marker = retainedSignedValueRef(subject, scope)!["@id"];
+
+  // A map with more than the identifier is a node of its own, not a
+  // reference, so only the string inside it is replaced.
+  const resolved = resolveSignedValues(
+    { object: { "@id": marker, type: "Note" } },
+    scope,
+  ) as Record<string, unknown>;
+  const object = resolved.object as Record<string, unknown>;
+  deepStrictEqual(object["@id"], securedDocument);
+  strictEqual(object.type, "Note");
+});
+
+test("resolveSignedValues() refuses a document too deep to walk", () => {
+  const scope = newScope();
+  const subject = retainedSubject();
+  const marker = retainedSignedValueRef(subject, scope)!["@id"];
+  // The shallow occurrence alone must not satisfy the check: a placeholder in
+  // an unvisited subtree would otherwise reach the wire.
+  let deep: unknown = { "@id": marker };
+  for (let i = 0; i < 300; i++) deep = { attachment: deep };
+
+  throws(
+    () => resolveSignedValues({ object: marker, tag: deep }, scope),
+    TypeError,
+  );
+});