@fedify/fedify 1.3.0-dev.577 → 1.3.0

package/CHANGES.md

@@ -6,7 +6,7 @@ Fedify changelog
 Version 1.3.0
 -------------
 
-To be released.
+Released on November 30, 2024.
 
  -  `MessageQueue`s now can be differently configured for incoming and outgoing
     activities.
@@ -62,6 +62,16 @@ To be released.
  -  `Context.sendActivity()` and `InboxContext.forwardActivity()` methods now
     reject when they fail to enqueue the task.  [[#192]]
 
+ -  Fedify now allows you to manually route an `Activity` to the corresponding
+    inbox listener.  [[#193]]
+
+     -  Added `Context.routeActivity()` method.
+     -  Added `RouteActivityOptions` interface.
+
+ -  `Object.toJsonLd()` without any `format` option now returns its original
+    JSON-LD object even if it not created from `Object.fromJsonLd()` but it is
+    returned from another `Object`'s `get*()` method.
+
  -  Fedify now supports OpenTelemetry for tracing.  [[#170]]
 
      -  Added `Context.tracerProvider` property.
@@ -107,6 +117,7 @@ To be released.
 [#183]: https://github.com/dahlia/fedify/pull/183
 [#186]: https://github.com/dahlia/fedify/pull/186
 [#192]: https://github.com/dahlia/fedify/issues/192
+[#193]: https://github.com/dahlia/fedify/issues/193
 
 
 Version 1.2.8

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@fedify/fedify",
-    "version": "1.3.0-dev.577+bda6d57e",
+    "version": "1.3.0",
     "license": "MIT",
     "exports": {
         ".": "./mod.ts",
@@ -82,7 +82,7 @@ export default {
         "cache": "deno task codegen && deno cache mod.ts",
         "check": "deno task codegen && deno fmt --check && deno lint && deno check */*.ts",
         "codegen": "deno run --allow-read --allow-write --check codegen/main.ts vocab/ ../runtime/ > vocab/vocab.ts && deno fmt vocab/vocab.ts && deno cache vocab/vocab.ts && deno check vocab/vocab.ts",
-        "test-without-codegen": "deno test --check --doc --allow-read --allow-write --allow-env --unstable-kv --trace-leaks",
+        "test-without-codegen": "deno test --check --doc --allow-read --allow-write --allow-env --unstable-kv --trace-leaks --parallel",
         "test": "deno task codegen && deno task test-without-codegen",
         "coverage": "rm -rf coverage/ && deno task test --coverage && deno coverage --html coverage",
         "bench": "deno task codegen && deno bench --allow-read --allow-write --allow-net --allow-env --allow-run --unstable-kv",

package/esm/federation/handler.js

@@ -1,6 +1,5 @@
-import * as dntShim from "../_dnt.shims.js";
 import { getLogger } from "@logtape/logtape";
-import { context, propagation, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { accepts } from "../deps/jsr.io/@std/http/1.0.11/negotiation.js";
 import metadata from "../deno.js";
 import { verifyRequest } from "../sig/http.js";
@@ -8,7 +7,9 @@ import { detachSignature, verifyJsonLd } from "../sig/ld.js";
 import { doesActorOwnKey } from "../sig/owner.js";
 import { verifyObject } from "../sig/proof.js";
 import { getTypeId } from "../vocab/type.js";
-import { Activity, CryptographicKey, Link, Multikey, Object, OrderedCollection, OrderedCollectionPage, } from "../vocab/vocab.js";
+import { Activity, Link, Object, OrderedCollection, OrderedCollectionPage, } from "../vocab/vocab.js";
+import { routeActivity } from "./inbox.js";
+import { KvKeyCache } from "./keycache.js";
 export function acceptsJsonLd(request) {
     const types = accepts(request);
     if (types == null)
@@ -317,42 +318,7 @@ async function handleInboxInternal(request, { recipient, context: ctx, inboxCont
             headers: { "Content-Type": "text/plain; charset=utf-8" },
         });
     }
-    const keyCache = {
-        nullKeys: new Set(),
-        async get(keyId) {
-            if (this.nullKeys.has(keyId.href))
-                return null;
-            const serialized = await kv.get([
-                ...kvPrefixes.publicKey,
-                keyId.href,
-            ]);
-            if (serialized == null)
-                return undefined;
-            let object;
-            try {
-                object = await Object.fromJsonLd(serialized, ctx);
-            }
-            catch {
-                await kv.delete([...kvPrefixes.publicKey, keyId.href]);
-                return undefined;
-            }
-            if (object instanceof CryptographicKey || object instanceof Multikey) {
-                return object;
-            }
-            await kv.delete([...kvPrefixes.publicKey, keyId.href]);
-            return undefined;
-        },
-        async set(keyId, key) {
-            if (key == null) {
-                this.nullKeys.add(keyId.href);
-                await kv.delete([...kvPrefixes.publicKey, keyId.href]);
-                return;
-            }
-            this.nullKeys.delete(keyId.href);
-            const serialized = await key.toJsonLd(ctx);
-            await kv.set([...kvPrefixes.publicKey, keyId.href], serialized);
-        },
-    };
+    const keyCache = new KvKeyCache(kv, kvPrefixes.publicKey, ctx);
     const ldSigVerified = await verifyJsonLd(json, {
         contextLoader: ctx.contextLoader,
         documentLoader: ctx.documentLoader,
@@ -436,143 +402,73 @@ async function handleInboxInternal(request, { recipient, context: ctx, inboxCont
         span.setAttribute("activitypub.activity.id", activity.id.href);
     }
     span.setAttribute("activitypub.activity.type", getTypeId(activity).href);
-    const cacheKey = activity.id == null
-        ? null
-        : [...kvPrefixes.activityIdempotence, activity.id.href];
-    if (cacheKey != null) {
-        const cached = await kv.get(cacheKey);
-        if (cached === true) {
-            logger.debug("Activity {activityId} has already been processed.", {
-                activityId: activity.id?.href,
-                activity: json,
-                recipient,
-            });
-            span.setStatus({
-                code: SpanStatusCode.UNSET,
-                message: `Activity ${activity.id?.href} has already been processed.`,
-            });
-            return new Response(`Activity <${activity.id}> has already been processed.`, {
-                status: 202,
-                headers: { "Content-Type": "text/plain; charset=utf-8" },
-            });
-        }
-    }
-    if (activity.actorId == null) {
-        logger.error("Missing actor.", { activity: json });
-        span.setStatus({ code: SpanStatusCode.ERROR, message: "Missing actor." });
-        return new Response("Missing actor.", {
-            status: 400,
-            headers: { "Content-Type": "text/plain; charset=utf-8" },
-        });
-    }
-    span.setAttribute("activitypub.actor.id", activity.actorId.href);
+    const routeResult = await routeActivity({
+        context: ctx,
+        json,
+        activity,
+        recipient,
+        inboxListeners,
+        inboxContextFactory,
+        inboxErrorHandler,
+        kv,
+        kvPrefixes,
+        queue,
+        span,
+        tracerProvider,
+    });
     if (httpSigKey != null && !await doesActorOwnKey(activity, httpSigKey, ctx)) {
         logger.error("The signer ({keyId}) and the actor ({actorId}) do not match.", {
             activity: json,
             recipient,
             keyId: httpSigKey.id?.href,
-            actorId: activity.actorId.href,
+            actorId: activity.actorId?.href,
         });
         span.setStatus({
             code: SpanStatusCode.ERROR,
             message: `The signer (${httpSigKey.id?.href}) and ` +
-                `the actor (${activity.actorId.href}) do not match.`,
+                `the actor (${activity.actorId?.href}) do not match.`,
         });
         return new Response("The signer and the actor do not match.", {
             status: 401,
             headers: { "Content-Type": "text/plain; charset=utf-8" },
         });
     }
-    if (queue != null) {
-        const carrier = {};
-        propagation.inject(context.active(), carrier);
-        try {
-            await queue.enqueue({
-                type: "inbox",
-                id: dntShim.crypto.randomUUID(),
-                baseUrl: request.url,
-                activity: json,
-                identifier: recipient,
-                attempt: 0,
-                started: new Date().toISOString(),
-                traceContext: carrier,
-            });
-        }
-        catch (error) {
-            logger.error("Failed to enqueue the incoming activity {activityId}:\n{error}", { error, activityId: activity.id?.href, activity: json, recipient });
-            span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: `Failed to enqueue the incoming activity ${activity.id?.href}.`,
-            });
-            throw error;
-        }
-        logger.info("Activity {activityId} is enqueued.", { activityId: activity.id?.href, activity: json, recipient });
+    if (routeResult === "alreadyProcessed") {
+        return new Response(`Activity <${activity.id}> has already been processed.`, {
+            status: 202,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
+    }
+    else if (routeResult === "missingActor") {
+        return new Response("Missing actor.", {
+            status: 400,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
+    }
+    else if (routeResult === "enqueued") {
         return new Response("Activity is enqueued.", {
             status: 202,
             headers: { "Content-Type": "text/plain; charset=utf-8" },
         });
     }
-    tracerProvider = tracerProvider ?? trace.getTracerProvider();
-    const tracer = tracerProvider.getTracer(metadata.name, metadata.version);
-    const response = await tracer.startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
-        const dispatched = inboxListeners?.dispatchWithClass(activity);
-        if (dispatched == null) {
-            logger.error("Unsupported activity type:\n{activity}", { activity: json, recipient });
-            span.setStatus({
-                code: SpanStatusCode.UNSET,
-                message: `Unsupported activity type: ${getTypeId(activity).href}`,
-            });
-            span.end();
-            return new Response("", {
-                status: 202,
-                headers: { "Content-Type": "text/plain; charset=utf-8" },
-            });
-        }
-        const { class: cls, listener } = dispatched;
-        span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
-        try {
-            await listener(inboxContextFactory(recipient, json, activity?.id?.href, getTypeId(activity).href), activity);
-        }
-        catch (error) {
-            try {
-                await inboxErrorHandler?.(ctx, error);
-            }
-            catch (error) {
-                logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
-                    error,
-                    activityId: activity.id?.href,
-                    activity: json,
-                    recipient,
-                });
-            }
-            logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
-                error,
-                activityId: activity.id?.href,
-                activity: json,
-                recipient,
-            });
-            span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
-            span.end();
-            return new Response("Internal server error.", {
-                status: 500,
-                headers: { "Content-Type": "text/plain; charset=utf-8" },
-            });
-        }
-        if (cacheKey != null) {
-            await kv.set(cacheKey, true, {
-                ttl: dntShim.Temporal.Duration.from({ days: 1 }),
-            });
-        }
-        logger.info("Activity {activityId} has been processed.", { activityId: activity.id?.href, activity: json, recipient });
-        span.end();
+    else if (routeResult === "unsupportedActivity") {
         return new Response("", {
             status: 202,
             headers: { "Content-Type": "text/plain; charset=utf-8" },
         });
-    });
-    if (response.status >= 500)
-        span.setStatus({ code: SpanStatusCode.ERROR });
-    return response;
+    }
+    else if (routeResult === "error") {
+        return new Response("Internal server error.", {
+            status: 500,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
+    }
+    else {
+        return new Response("", {
+            status: 202,
+            headers: { "Content-Type": "text/plain; charset=utf-8" },
+        });
+    }
 }
 /**
  * Responds with the given object in JSON-LD format.

package/esm/federation/inbox.js

@@ -1,3 +1,8 @@
+import * as dntShim from "../_dnt.shims.js";
+import { getLogger } from "@logtape/logtape";
+import { context, propagation, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
+import metadata from "../deno.js";
+import { getTypeId } from "../vocab/type.js";
 import { Activity } from "../vocab/vocab.js";
 export class InboxListenerSet {
     #listeners;
@@ -35,3 +40,106 @@ export class InboxListenerSet {
         return this.dispatchWithClass(activity)?.listener ?? null;
     }
 }
+export async function routeActivity({ context: ctx, json, activity, recipient, inboxListeners, inboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, tracerProvider, }) {
+    const logger = getLogger(["fedify", "federation", "inbox"]);
+    const cacheKey = activity.id == null ? null : [
+        ...kvPrefixes.activityIdempotence,
+        activity.id.href,
+    ];
+    if (cacheKey != null) {
+        const cached = await kv.get(cacheKey);
+        if (cached === true) {
+            logger.debug("Activity {activityId} has already been processed.", {
+                activityId: activity.id?.href,
+                activity: json,
+                recipient,
+            });
+            span.setStatus({
+                code: SpanStatusCode.UNSET,
+                message: `Activity ${activity.id?.href} has already been processed.`,
+            });
+            return "alreadyProcessed";
+        }
+    }
+    if (activity.actorId == null) {
+        logger.error("Missing actor.", { activity: json });
+        span.setStatus({ code: SpanStatusCode.ERROR, message: "Missing actor." });
+        return "missingActor";
+    }
+    span.setAttribute("activitypub.actor.id", activity.actorId.href);
+    if (queue != null) {
+        const carrier = {};
+        propagation.inject(context.active(), carrier);
+        try {
+            await queue.enqueue({
+                type: "inbox",
+                id: dntShim.crypto.randomUUID(),
+                baseUrl: ctx.origin,
+                activity: json,
+                identifier: recipient,
+                attempt: 0,
+                started: new Date().toISOString(),
+                traceContext: carrier,
+            });
+        }
+        catch (error) {
+            logger.error("Failed to enqueue the incoming activity {activityId}:\n{error}", { error, activityId: activity.id?.href, activity: json, recipient });
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: `Failed to enqueue the incoming activity ${activity.id?.href}.`,
+            });
+            throw error;
+        }
+        logger.info("Activity {activityId} is enqueued.", { activityId: activity.id?.href, activity: json, recipient });
+        return "enqueued";
+    }
+    tracerProvider = tracerProvider ?? trace.getTracerProvider();
+    const tracer = tracerProvider.getTracer(metadata.name, metadata.version);
+    return await tracer.startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
+        const dispatched = inboxListeners?.dispatchWithClass(activity);
+        if (dispatched == null) {
+            logger.error("Unsupported activity type:\n{activity}", { activity: json, recipient });
+            span.setStatus({
+                code: SpanStatusCode.UNSET,
+                message: `Unsupported activity type: ${getTypeId(activity).href}`,
+            });
+            span.end();
+            return "unsupportedActivity";
+        }
+        const { class: cls, listener } = dispatched;
+        span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
+        try {
+            await listener(inboxContextFactory(recipient, json, activity?.id?.href, getTypeId(activity).href), activity);
+        }
+        catch (error) {
+            try {
+                await inboxErrorHandler?.(ctx, error);
+            }
+            catch (error) {
+                logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
+                    error,
+                    activityId: activity.id?.href,
+                    activity: json,
+                    recipient,
+                });
+            }
+            logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
+                error,
+                activityId: activity.id?.href,
+                activity: json,
+                recipient,
+            });
+            span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+            span.end();
+            return "error";
+        }
+        if (cacheKey != null) {
+            await kv.set(cacheKey, true, {
+                ttl: dntShim.Temporal.Duration.from({ days: 1 }),
+            });
+        }
+        logger.info("Activity {activityId} has been processed.", { activityId: activity.id?.href, activity: json, recipient });
+        span.end();
+        return "success";
+    });
+}

package/esm/federation/keycache.js

@@ -0,0 +1,42 @@
+import { CryptographicKey, Multikey } from "../vocab/vocab.js";
+export class KvKeyCache {
+    kv;
+    prefix;
+    options;
+    nullKeys;
+    constructor(kv, prefix, options = {}) {
+        this.kv = kv;
+        this.prefix = prefix;
+        this.nullKeys = new Set();
+        this.options = options;
+    }
+    async get(keyId) {
+        if (this.nullKeys.has(keyId.href))
+            return null;
+        const serialized = await this.kv.get([...this.prefix, keyId.href]);
+        if (serialized == null)
+            return undefined;
+        try {
+            return await CryptographicKey.fromJsonLd(serialized, this.options);
+        }
+        catch {
+            try {
+                return await Multikey.fromJsonLd(serialized, this.options);
+            }
+            catch {
+                await this.kv.delete([...this.prefix, keyId.href]);
+                return undefined;
+            }
+        }
+    }
+    async set(keyId, key) {
+        if (key == null) {
+            this.nullKeys.add(keyId.href);
+            await this.kv.delete([...this.prefix, keyId.href]);
+            return;
+        }
+        this.nullKeys.delete(keyId.href);
+        const serialized = await key.toJsonLd(this.options);
+        await this.kv.set([...this.prefix, keyId.href], serialized);
+    }
+}

package/esm/federation/middleware.js

@@ -1,4 +1,5 @@
 import * as dntShim from "../_dnt.shims.js";
+import { verifyObject } from "../mod.js";
 import { getLogger, withContext } from "@logtape/logtape";
 import { context, propagation, SpanKind, SpanStatusCode, trace, } from "@opentelemetry/api";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_URL_FULL, } from "@opentelemetry/semantic-conventions";
@@ -16,7 +17,8 @@ import { Activity, CryptographicKey, Multikey, } from "../vocab/vocab.js";
 import { handleWebFinger } from "../webfinger/handler.js";
 import { buildCollectionSynchronizationHeader } from "./collection.js";
 import { handleActor, handleCollection, handleInbox, handleObject, } from "./handler.js";
-import { InboxListenerSet } from "./inbox.js";
+import { InboxListenerSet, routeActivity } from "./inbox.js";
+import { KvKeyCache } from "./keycache.js";
 import { createExponentialBackoffPolicy } from "./retry.js";
 import { Router, RouterError } from "./router.js";
 import { extractInboxes, sendActivity } from "./send.js";
@@ -1946,6 +1948,118 @@ export class ContextImpl {
             cursor = result.nextCursor ?? null;
         }
     }
+    routeActivity(recipient, activity, options = {}) {
+        const tracerProvider = this.tracerProvider ?? this.tracerProvider;
+        const tracer = tracerProvider.getTracer(metadata.name, metadata.version);
+        return tracer.startActiveSpan("activitypub.inbox", {
+            kind: this.federation.inboxQueue == null || options.immediate
+                ? SpanKind.INTERNAL
+                : SpanKind.PRODUCER,
+            attributes: {
+                "activitypub.activity.type": getTypeId(activity).href,
+            },
+        }, async (span) => {
+            if (activity.id != null) {
+                span.setAttribute("activitypub.activity.id", activity.id.href);
+            }
+            if (activity.toIds.length > 0) {
+                span.setAttribute("activitypub.activity.to", activity.toIds.map((to) => to.href));
+            }
+            if (activity.ccIds.length > 0) {
+                span.setAttribute("activitypub.activity.cc", activity.ccIds.map((cc) => cc.href));
+            }
+            if (activity.btoIds.length > 0) {
+                span.setAttribute("activitypub.activity.bto", activity.btoIds.map((bto) => bto.href));
+            }
+            if (activity.bccIds.length > 0) {
+                span.setAttribute("activitypub.activity.bcc", activity.bccIds.map((bcc) => bcc.href));
+            }
+            try {
+                const ok = await this.routeActivityInternal(recipient, activity, options, span);
+                if (ok) {
+                    span.setAttribute("activitypub.shared_inbox", recipient == null);
+                    if (recipient != null) {
+                        span.setAttribute("fedify.inbox.recipient", recipient);
+                    }
+                }
+                else {
+                    span.setStatus({ code: SpanStatusCode.ERROR });
+                }
+                return ok;
+            }
+            catch (e) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(e) });
+                throw e;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    async routeActivityInternal(recipient, activity, options = {}, span) {
+        const logger = getLogger(["fedify", "federation", "inbox"]);
+        const contextLoader = options.contextLoader ?? this.contextLoader;
+        const json = await activity.toJsonLd({ contextLoader });
+        const keyCache = new KvKeyCache(this.federation.kv, this.federation.kvPrefixes.publicKey, this);
+        const verified = await verifyObject(Activity, json, {
+            contextLoader,
+            documentLoader: options.documentLoader ?? this.documentLoader,
+            tracerProvider: options.tracerProvider ?? this.tracerProvider,
+            keyCache,
+        });
+        if (verified == null) {
+            logger.debug("Object Integrity Proofs are not verified.", { recipient, activity: json });
+            if (activity.id == null) {
+                logger.debug("Activity is missing an ID; unable to fetch.", { recipient, activity: json });
+                return false;
+            }
+            const fetched = await this.lookupObject(activity.id, options);
+            if (fetched == null) {
+                logger.debug("Failed to fetch the remote activity object {activityId}.", { recipient, activity: json, activityId: activity.id.href });
+                return false;
+            }
+            else if (!(fetched instanceof Activity)) {
+                logger.debug("Fetched object is not an Activity.", { recipient, activity: await fetched.toJsonLd({ contextLoader }) });
+                return false;
+            }
+            else if (fetched.id?.href !== activity.id.href) {
+                logger.debug("Fetched activity object has a different ID; failed to verify.", { recipient, activity: await fetched.toJsonLd({ contextLoader }) });
+                return false;
+            }
+            else if (fetched.actorIds.length < 1) {
+                logger.debug("Fetched activity object is missing an actor; unable to verify.", { recipient, activity: await fetched.toJsonLd({ contextLoader }) });
+                return false;
+            }
+            const activityId = fetched.id;
+            if (!fetched.actorIds.every((actor) => actor.origin === activityId.origin)) {
+                logger.debug("Fetched activity object has actors from different origins; " +
+                    "unable to verify.", { recipient, activity: await fetched.toJsonLd({ contextLoader }) });
+                return false;
+            }
+            logger.debug("Successfully fetched the remote activity object {activityId}; " +
+                "ignore the original activity and use the fetched one, which is trustworthy.");
+            activity = fetched;
+        }
+        else {
+            logger.debug("Object Integrity Proofs are verified.", { recipient, activity: json });
+        }
+        const routeResult = await routeActivity({
+            context: this,
+            json,
+            activity,
+            recipient,
+            inboxListeners: this.federation.inboxListeners,
+            inboxContextFactory: this.toInboxContext.bind(this),
+            inboxErrorHandler: this.federation.inboxErrorHandler,
+            kv: this.federation.kv,
+            kvPrefixes: this.federation.kvPrefixes,
+            queue: this.federation.inboxQueue,
+            span,
+            tracerProvider: options.tracerProvider ?? this.tracerProvider,
+        });
+        return routeResult === "alreadyProcessed" || routeResult === "enqueued" ||
+            routeResult === "unsupportedActivity" || routeResult === "success";
+    }
 }
 class RequestContextImpl extends ContextImpl {
     #invokedFromActorDispatcher;

package/esm/testing/fixtures/example.com/create

@@ -0,0 +1,6 @@
+{
+  "@context": "https://www.w3.org/ns/activitystreams",
+  "type": "Create",
+  "id": "https://example.com/create",
+  "actor": "https://example.com/person"
+}

package/esm/testing/fixtures/example.com/cross-origin-actor

@@ -0,0 +1,6 @@
+{
+  "@context": "https://www.w3.org/ns/activitystreams",
+  "type": "Create",
+  "id": "https://example.com/cross-origin-actor",
+  "actor": "https://cross-origin.com/actor"
+}

package/esm/testing/fixtures/example.com/invite

@@ -0,0 +1,7 @@
+{
+  "@context": "https://www.w3.org/ns/activitystreams",
+  "type": "Invite",
+  "id": "https://example.com/invite",
+  "actor": "https://example.com/person",
+  "object": "https://example.com/object"
+}