@fedify/interaction-controls 2.4.0-dev.0

package/dist/mod.js

@@ -0,0 +1,892 @@
+import { Temporal } from "temporal-polyfill";
+import { Accept, Announce, AnnounceAuthorization, AnnounceRequest, Application, Article, ChatMessage, Create, Delete, FeatureAuthorization, FeatureRequest, FeaturedCollection, Group, Like, LikeAuthorization, LikeRequest, Mention, Note, Object as Object$1, Organization, PUBLIC_COLLECTION, Person, Question, QuoteAuthorization, QuoteRequest, Reject, ReplyAuthorization, ReplyRequest, Service, isActor } from "@fedify/vocab";
+import { getFe34Origin } from "@fedify/vocab-runtime";
+//#region src/control.ts
+function createInteractionControl(config) {
+	return {
+		name: config.name,
+		policyProperty: config.policyProperty,
+		requestTypeId: config.requestClass.typeId,
+		authorizationTypeId: config.authorizationClass.typeId,
+		verifyRequest: (context, options) => verifyRequest(context, options, config),
+		evaluatePolicy: (context, options) => evaluatePolicy(context, options, config),
+		createRequest: (options) => new config.requestClass({
+			id: options.id,
+			actor: options.actor,
+			object: options.object,
+			instrument: options.instrument,
+			...audience(options)
+		}),
+		createAuthorization: (options) => new config.authorizationClass({
+			id: options.id,
+			attribution: options.attributedTo,
+			interactingObject: getRequiredId(options.interactingObject, "interactingObject"),
+			interactionTarget: getRequiredId(options.interactionTarget, "interactionTarget")
+		}),
+		verifyAuthorization: (context, options) => verifyAuthorization(context, options, config),
+		createAccept: (options) => createAccept(options),
+		createReject: (options) => createReject(options),
+		createRevocation: (options) => new Delete({
+			id: options.id,
+			actor: options.actor,
+			object: getRequiredId(options.authorization, "authorization"),
+			...audience(options)
+		}),
+		recognizeImpolite: config.recognizeImpolite,
+		getInteractionKey: (input) => ({
+			interaction: config.name,
+			requester: input.requester,
+			interactingObjectId: getRequiredId(input.interactingObject, "interactingObject"),
+			interactionTargetId: getRequiredId(input.interactionTarget, "interactionTarget")
+		}),
+		getAuthorizationKey: (input) => ({
+			interaction: config.name,
+			authorizationId: getRequiredId(input.authorization, "authorization")
+		})
+	};
+}
+function audience(options) {
+	const to = options.to;
+	const cc = options.cc;
+	return {
+		...to == null ? {} : Array.isArray(to) ? { tos: to } : { to },
+		...cc == null ? {} : Array.isArray(cc) ? { ccs: cc } : { cc }
+	};
+}
+function getRequiredId(value, name) {
+	if (value instanceof URL) return value;
+	if (value.id == null) throw new TypeError(`The ${name} must have an id.`);
+	return value.id;
+}
+function getId(value) {
+	return value instanceof URL ? value : value.id;
+}
+function idsEqual(left, right) {
+	return left != null && right != null && left.href === right.href;
+}
+function getTypeId(object) {
+	return object.constructor.typeId;
+}
+async function verifyRequest(context, options, config) {
+	const documentLoader = options.documentLoader ?? context.documentLoader;
+	const expectedRequestId = options.request instanceof URL ? options.request : null;
+	const requestResult = await materialize(options.request, config.requestClass, documentLoader);
+	if (!requestResult.ok) return {
+		verified: false,
+		failure: requestResult.failure
+	};
+	const request = requestResult.object;
+	if (!(request instanceof config.requestClass)) return {
+		verified: false,
+		request,
+		requestId: request.id ?? void 0,
+		failure: {
+			category: "invalid",
+			type: "wrongType",
+			expectedType: config.requestClass.typeId,
+			actualTypes: [getTypeId(request)]
+		}
+	};
+	if (request.id == null) return {
+		verified: false,
+		request,
+		failure: {
+			category: "invalid",
+			type: "missingId"
+		}
+	};
+	if (expectedRequestId != null && !idsEqual(request.id, expectedRequestId)) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "idMismatch",
+			expected: expectedRequestId,
+			actual: request.id
+		}
+	};
+	const dereferenceOptions = {
+		documentLoader,
+		contextLoader: documentLoader,
+		suppressError: true
+	};
+	const interactionTarget = await config.getInteractionTarget(request, dereferenceOptions);
+	if (interactionTarget == null) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "missingObject"
+		}
+	};
+	if (config.isInteractionTarget != null && !config.isInteractionTarget(interactionTarget)) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "wrongObjectType",
+			expectedTypes: config.interactionTargetTypes ?? [],
+			actualTypes: [getTypeId(interactionTarget)]
+		}
+	};
+	const interactingObject = await config.getInteractingObject(request, dereferenceOptions);
+	if (interactingObject == null) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "missingInstrument"
+		}
+	};
+	if (config.isInteractingObject != null && !config.isInteractingObject(interactingObject)) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "wrongInstrumentType",
+			expectedTypes: config.interactingObjectTypes ?? [],
+			actualTypes: [getTypeId(interactingObject)]
+		}
+	};
+	const requester = request.actorId ?? config.getRequester?.(request, interactingObject, interactionTarget);
+	if (requester == null) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "missingActor"
+		}
+	};
+	const interactingObjectId = getId(interactingObject);
+	if (interactingObjectId == null) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "missingInstrumentId"
+		}
+	};
+	const interactionTargetId = getId(interactionTarget);
+	if (interactionTargetId == null) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: {
+			category: "invalid",
+			type: "missingObjectId"
+		}
+	};
+	const validation = config.validateRequest(request, interactingObject, interactionTarget, requester);
+	if (validation != null) return {
+		verified: false,
+		request,
+		requestId: request.id,
+		failure: validation.type === "requesterMismatch" ? {
+			category: "unauthorized",
+			type: validation.type,
+			expected: validation.expected,
+			actual: validation.actual
+		} : {
+			category: "invalid",
+			type: validation.type,
+			expected: validation.expected,
+			actual: validation.actual
+		}
+	};
+	return {
+		verified: true,
+		request,
+		requestId: request.id,
+		requester,
+		interactingObject,
+		interactingObjectId,
+		interactionTarget,
+		interactionTargetId
+	};
+}
+async function verifyAuthorization(context, options, config) {
+	const embeddedAuthorization = !(options.authorization instanceof URL);
+	const expectedAuthorizationId = options.authorization instanceof URL ? options.authorization : null;
+	const expectedAttribution = options.attributedTo ?? (!(options.interactionTarget instanceof URL) ? config.getSelfActor(options.interactionTarget) : null);
+	if (expectedAuthorizationId != null && expectedAttribution == null) return {
+		verified: false,
+		authorizationId: expectedAuthorizationId,
+		failure: {
+			category: "unauthorized",
+			type: "missingAttribution"
+		}
+	};
+	if (expectedAuthorizationId != null && expectedAttribution != null) {
+		const expectedOrigin = getAuthorizationOrigin(expectedAttribution);
+		const actualOrigin = getAuthorizationOrigin(expectedAuthorizationId);
+		if (expectedOrigin === "null" || actualOrigin === "null" || expectedOrigin !== actualOrigin) return {
+			verified: false,
+			authorizationId: expectedAuthorizationId,
+			failure: {
+				category: "unauthorized",
+				type: "originMismatch",
+				expectedOrigin,
+				actualOrigin
+			}
+		};
+	}
+	const authorizationResult = await materialize(options.authorization, config.authorizationClass, options.documentLoader ?? context.documentLoader);
+	if (!authorizationResult.ok) return {
+		verified: false,
+		failure: authorizationResult.failure
+	};
+	const authorization = authorizationResult.object;
+	if (!(authorization instanceof config.authorizationClass)) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id ?? void 0,
+		failure: {
+			category: "unauthorized",
+			type: "wrongType",
+			expectedType: config.authorizationClass.typeId,
+			actualTypes: [getTypeId(authorization)]
+		}
+	};
+	if (authorization.id == null) return {
+		verified: false,
+		authorization,
+		failure: {
+			category: "unauthorized",
+			type: "missingId"
+		}
+	};
+	if (expectedAuthorizationId != null && !idsEqual(authorization.id, expectedAuthorizationId)) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "idMismatch",
+			expected: expectedAuthorizationId,
+			actual: authorization.id
+		}
+	};
+	const revocation = await options.getRevocation?.(authorization.id, context);
+	if (revocation != null) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "revoked",
+			type: "deleted",
+			...revocation
+		}
+	};
+	const interactingObjectId = getId(options.interactingObject);
+	if (interactingObjectId == null) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "missingObjectId"
+		}
+	};
+	const interactionTargetId = getId(options.interactionTarget);
+	if (interactionTargetId == null) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "missingTargetId"
+		}
+	};
+	const actualInteractingId = authorization.interactingObjectId;
+	if (!idsEqual(actualInteractingId, interactingObjectId)) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "objectMismatch",
+			expected: interactingObjectId,
+			actual: actualInteractingId ?? void 0
+		}
+	};
+	const actualTargetId = authorization.interactionTargetId;
+	if (!idsEqual(actualTargetId, interactionTargetId)) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "targetMismatch",
+			expected: interactionTargetId,
+			actual: actualTargetId ?? void 0
+		}
+	};
+	if (expectedAttribution == null) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "missingAttribution"
+		}
+	};
+	if (config.authorizationAttribution !== "optional" && !idsEqual(authorization.attributionId, expectedAttribution)) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "attributionMismatch",
+			expected: expectedAttribution,
+			actual: authorization.attributionId ?? void 0
+		}
+	};
+	if (authorization.attributionId != null && !idsEqual(authorization.attributionId, expectedAttribution)) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "attributionMismatch",
+			expected: expectedAttribution,
+			actual: authorization.attributionId
+		}
+	};
+	const expectedOrigin = getAuthorizationOrigin(expectedAttribution);
+	const actualOrigin = getAuthorizationOrigin(authorization.id);
+	if (expectedOrigin === "null" || actualOrigin === "null" || expectedOrigin !== actualOrigin) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "originMismatch",
+			expectedOrigin,
+			actualOrigin
+		}
+	};
+	if (embeddedAuthorization && options.verifyAuthenticity == null) return {
+		verified: false,
+		authorization,
+		authorizationId: authorization.id,
+		failure: {
+			category: "unauthorized",
+			type: "notAuthentic",
+			detail: "Embedded authorizations require authenticity verification."
+		}
+	};
+	if (options.verifyAuthenticity != null) {
+		let authentic;
+		try {
+			authentic = await options.verifyAuthenticity(authorization, context);
+		} catch (cause) {
+			return {
+				verified: false,
+				authorization,
+				authorizationId: authorization.id,
+				failure: {
+					category: "unauthorized",
+					type: "notAuthentic",
+					cause
+				}
+			};
+		}
+		if (!authentic) return {
+			verified: false,
+			authorization,
+			authorizationId: authorization.id,
+			failure: {
+				category: "unauthorized",
+				type: "notAuthentic"
+			}
+		};
+	}
+	return {
+		verified: true,
+		authorization,
+		authorizationId: authorization.id
+	};
+}
+async function materialize(value, constructor, documentLoader) {
+	if (!(value instanceof URL)) return {
+		ok: true,
+		object: value
+	};
+	const loader = documentLoader;
+	if (loader == null) return {
+		ok: false,
+		failure: {
+			category: "unverifiable",
+			type: "notDereferenceable",
+			url: value
+		}
+	};
+	let remoteDocument;
+	try {
+		remoteDocument = await loader(value.href);
+	} catch (cause) {
+		return {
+			ok: false,
+			failure: {
+				category: "unverifiable",
+				type: "notDereferenceable",
+				url: value,
+				cause
+			}
+		};
+	}
+	if (remoteDocument == null) return {
+		ok: false,
+		failure: {
+			category: "unverifiable",
+			type: "notDereferenceable",
+			url: value
+		}
+	};
+	try {
+		return {
+			ok: true,
+			object: await constructor.fromJsonLd(remoteDocument.document, {
+				documentLoader: loader,
+				contextLoader: loader,
+				baseUrl: value
+			})
+		};
+	} catch (cause) {
+		return {
+			ok: false,
+			failure: {
+				category: "unverifiable",
+				type: "invalidJsonLd",
+				cause
+			}
+		};
+	}
+}
+async function evaluatePolicy(context, options, config) {
+	if (idsEqual(config.getSelfActor(options.subject), options.requester)) return {
+		result: "automatic",
+		reason: { type: "self" }
+	};
+	const implicitAutomatic = await matchImplicitAutomaticActors(options.subject, options.requester, {
+		documentLoader: options.documentLoader ?? context.documentLoader,
+		suppressError: true
+	}, config);
+	if (implicitAutomatic != null) return {
+		result: "automatic",
+		reason: implicitAutomatic
+	};
+	const policy = options.subject.interactionPolicy;
+	if (policy == null) return missingPolicyDecision(config);
+	const rule = policy[config.policyProperty];
+	if (rule == null) return missingRuleDecision(config);
+	const automaticApprovals = rule.automaticApprovals ?? [];
+	const manualApprovals = rule.manualApprovals ?? [];
+	if (automaticApprovals.length < 1 && manualApprovals.length < 1) return missingRuleDecision(config);
+	const automatic = await matchRule(automaticApprovals, options.requester, context, options.matchesApprovalCollection, { actorOnly: true });
+	if (automatic?.result === "matched") return {
+		result: "automatic",
+		reason: automatic.reason
+	};
+	const manual = await matchRule(manualApprovals, options.requester, context, options.matchesApprovalCollection, { actorOnly: true });
+	if (manual?.result === "matched") return {
+		result: "manual",
+		reason: manual.reason
+	};
+	const broadAutomatic = await matchRule(automaticApprovals, options.requester, context, options.matchesApprovalCollection);
+	const unverifiableAutomatic = broadAutomatic?.result === "unverifiableCollection" ? broadAutomatic.collection : null;
+	if (broadAutomatic?.result === "matched") return {
+		result: "automatic",
+		reason: broadAutomatic.reason
+	};
+	const broadManual = await matchRule(manualApprovals, options.requester, context, options.matchesApprovalCollection);
+	if (broadManual?.result === "unverifiableCollection") return deniedUnverifiableCollection(broadManual.collection);
+	else if (broadManual?.result === "matched") return {
+		result: "manual",
+		reason: broadManual.reason
+	};
+	if (unverifiableAutomatic != null) return deniedUnverifiableCollection(unverifiableAutomatic);
+	return {
+		result: "denied",
+		reason: { type: "noMatch" }
+	};
+}
+async function matchImplicitAutomaticActors(subject, requester, options, config) {
+	if (config.getImplicitAutomaticActors == null) return null;
+	for await (const actor of config.getImplicitAutomaticActors(subject, options)) if (idsEqual(actor, requester)) return {
+		type: "actor",
+		actor
+	};
+	return null;
+}
+function missingPolicyDecision(config) {
+	if (config.defaultMissingPolicy === "automatic") return {
+		result: "automatic",
+		reason: {
+			type: "default",
+			default: "publicAutomatic"
+		}
+	};
+	return {
+		result: "denied",
+		reason: { type: "missingPolicy" }
+	};
+}
+function missingRuleDecision(config) {
+	if (config.defaultMissingPolicy === "automatic") return {
+		result: "automatic",
+		reason: {
+			type: "default",
+			default: "publicAutomatic"
+		}
+	};
+	return {
+		result: "denied",
+		reason: { type: "missingRule" }
+	};
+}
+async function matchRule(entries, requester, context, matchesApprovalCollection, options = {}) {
+	for (const entry of entries) if (entry.href === requester.href) return {
+		result: "matched",
+		reason: {
+			type: "actor",
+			actor: entry
+		}
+	};
+	if (options.actorOnly) return null;
+	for (const entry of entries) if (entry.href === PUBLIC_COLLECTION.href) return {
+		result: "matched",
+		reason: { type: "public" }
+	};
+	if (matchesApprovalCollection != null) {
+		let unverifiableCollection = null;
+		for (const entry of entries) {
+			if (entry.href === PUBLIC_COLLECTION.href || entry.href === requester.href) continue;
+			let matched;
+			try {
+				matched = await matchesApprovalCollection(entry, requester, context);
+			} catch {
+				unverifiableCollection ??= entry;
+				continue;
+			}
+			if (matched) return {
+				result: "matched",
+				reason: {
+					type: "collection",
+					collection: entry
+				}
+			};
+		}
+		if (unverifiableCollection != null) return {
+			result: "unverifiableCollection",
+			collection: unverifiableCollection
+		};
+	}
+	return null;
+}
+function deniedUnverifiableCollection(collection) {
+	return {
+		result: "denied",
+		reason: {
+			type: "unverifiableCollection",
+			collection
+		}
+	};
+}
+function getAuthorizationOrigin(id) {
+	try {
+		return getFe34Origin(id);
+	} catch {
+		return id.origin;
+	}
+}
+function createAccept(options) {
+	if (options.mode === "polite") return new Accept({
+		id: options.id,
+		actor: options.actor,
+		object: options.request,
+		result: options.authorization,
+		...audience(options)
+	});
+	return new Accept({
+		id: options.id,
+		actor: options.actor,
+		object: getRequiredId(options.interactingObject, "interactingObject"),
+		target: getRequiredId(options.interactionTarget, "interactionTarget"),
+		result: getRequiredId(options.authorization, "authorization"),
+		...audience(options)
+	});
+}
+function createReject(options) {
+	if (options.mode === "polite") return new Reject({
+		id: options.id,
+		actor: options.actor,
+		object: options.request,
+		...audience(options)
+	});
+	return new Reject({
+		id: options.id,
+		actor: options.actor,
+		object: getRequiredId(options.interactingObject, "interactingObject"),
+		target: getRequiredId(options.interactionTarget, "interactionTarget"),
+		...audience(options)
+	});
+}
+function recognized(values) {
+	if (values.requester == null || values.interactionTargetId == null) return null;
+	const interactingObjectId = values.interactingObject.id;
+	if (interactingObjectId == null) return null;
+	return {
+		requester: values.requester,
+		interactingObject: values.interactingObject,
+		interactingObjectId,
+		interactionTarget: values.interactionTarget,
+		interactionTargetId: values.interactionTargetId,
+		source: values.source,
+		evidence: values.evidence
+	};
+}
+//#endregion
+//#region src/announce.ts
+const announceInteraction = createInteractionControl({
+	name: "announce",
+	policyProperty: "canAnnounce",
+	requestClass: AnnounceRequest,
+	authorizationClass: AnnounceAuthorization,
+	getInteractingObject: (request, options) => request.getInstrument(options),
+	isInteractingObject: (object) => object instanceof Announce,
+	interactingObjectTypes: [Announce.typeId],
+	getInteractionTarget: (request, options) => request.getObject(options),
+	validateRequest: (_request, announce, target, requester) => {
+		const targetId = getRequiredId(target, "interactionTarget");
+		if (!idsEqual(announce.objectId, targetId)) return {
+			type: "objectMismatch",
+			expected: targetId,
+			actual: announce.objectId ?? void 0
+		};
+		if (!idsEqual(announce.actorId, requester)) return {
+			type: "requesterMismatch",
+			expected: requester,
+			actual: announce.actorId ?? void 0
+		};
+		return null;
+	},
+	getSelfActor: (subject) => subject.attributionId,
+	defaultMissingPolicy: "automatic",
+	recognizeImpolite: (source) => recognized({
+		requester: source.actorId,
+		interactingObject: source,
+		interactionTarget: void 0,
+		interactionTargetId: source.objectId,
+		source,
+		evidence: {
+			type: "activity",
+			activityType: Announce.typeId
+		}
+	})
+});
+//#endregion
+//#region src/feature.ts
+const featureInteraction = createInteractionControl({
+	name: "feature",
+	policyProperty: "canFeature",
+	requestClass: FeatureRequest,
+	authorizationClass: FeatureAuthorization,
+	getInteractingObject: (request, options) => request.getInstrument(options),
+	isInteractingObject: (object) => object instanceof FeaturedCollection,
+	interactingObjectTypes: [FeaturedCollection.typeId],
+	getInteractionTarget: (request, options) => request.getObject(options),
+	isInteractionTarget: isActor,
+	interactionTargetTypes: [
+		Application.typeId,
+		Group.typeId,
+		Organization.typeId,
+		Person.typeId,
+		Service.typeId
+	],
+	getRequester: (_request, collection) => collection.attributionId,
+	validateRequest: (_request, collection, _target, requester) => {
+		if (!idsEqual(collection.attributionId, requester)) return {
+			type: "requesterMismatch",
+			expected: requester,
+			actual: collection.attributionId ?? void 0
+		};
+		return null;
+	},
+	authorizationAttribution: "optional",
+	getSelfActor: (subject) => subject.id,
+	defaultMissingPolicy: "denied",
+	recognizeImpolite: () => null
+});
+//#endregion
+//#region src/key.ts
+function formatInteractionKey(key) {
+	return JSON.stringify([
+		key.interaction,
+		key.requester.href,
+		key.interactingObjectId.href,
+		key.interactionTargetId.href
+	]);
+}
+function formatAuthorizationKey(key) {
+	return JSON.stringify([key.interaction, key.authorizationId.href]);
+}
+//#endregion
+//#region src/like.ts
+const likeInteraction = createInteractionControl({
+	name: "like",
+	policyProperty: "canLike",
+	requestClass: LikeRequest,
+	authorizationClass: LikeAuthorization,
+	getInteractingObject: (request, options) => request.getInstrument(options),
+	isInteractingObject: (object) => object instanceof Like,
+	interactingObjectTypes: [Like.typeId],
+	getInteractionTarget: (request, options) => request.getObject(options),
+	validateRequest: (_request, like, target, requester) => {
+		const targetId = getRequiredId(target, "interactionTarget");
+		if (!idsEqual(like.objectId, targetId)) return {
+			type: "objectMismatch",
+			expected: targetId,
+			actual: like.objectId ?? void 0
+		};
+		if (!idsEqual(like.actorId, requester)) return {
+			type: "requesterMismatch",
+			expected: requester,
+			actual: like.actorId ?? void 0
+		};
+		return null;
+	},
+	getSelfActor: (subject) => subject.attributionId,
+	defaultMissingPolicy: "automatic",
+	recognizeImpolite: (source) => recognized({
+		requester: source.actorId,
+		interactingObject: source,
+		interactionTarget: void 0,
+		interactionTargetId: source.objectId,
+		source,
+		evidence: {
+			type: "activity",
+			activityType: Like.typeId
+		}
+	})
+});
+//#endregion
+//#region src/quote.ts
+const QUOTE = new URL("https://w3id.org/fep/044f#quote");
+function getQuoteTargetId(quote) {
+	return quote.quoteId ?? quote.quoteUrl;
+}
+const quoteInteraction = createInteractionControl({
+	name: "quote",
+	policyProperty: "canQuote",
+	requestClass: QuoteRequest,
+	authorizationClass: QuoteAuthorization,
+	getInteractingObject: (request, options) => request.getInstrument(options),
+	isInteractingObject: (object) => object instanceof Note || object instanceof Article || object instanceof Question || object instanceof ChatMessage,
+	interactingObjectTypes: [
+		Note.typeId,
+		Article.typeId,
+		Question.typeId,
+		ChatMessage.typeId
+	],
+	getInteractionTarget: (request, options) => request.getObject(options),
+	validateRequest: (_request, quote, target, requester) => {
+		const targetId = getRequiredId(target, "interactionTarget");
+		if (quote.quoteId != null && quote.quoteUrl != null && !idsEqual(quote.quoteUrl, quote.quoteId)) return {
+			type: "objectMismatch",
+			expected: quote.quoteId,
+			actual: quote.quoteUrl
+		};
+		const quoteTargetId = getQuoteTargetId(quote);
+		if (!idsEqual(quoteTargetId, targetId)) return {
+			type: "objectMismatch",
+			expected: targetId,
+			actual: quoteTargetId ?? void 0
+		};
+		if (!idsEqual(quote.attributionId, requester)) return {
+			type: "requesterMismatch",
+			expected: requester,
+			actual: quote.attributionId ?? void 0
+		};
+		return null;
+	},
+	getSelfActor: (subject) => subject.attributionId,
+	defaultMissingPolicy: "denied",
+	recognizeImpolite: (source) => {
+		if (source instanceof Create) return null;
+		return recognized({
+			requester: source.attributionId,
+			interactingObject: source,
+			interactionTarget: void 0,
+			interactionTargetId: getQuoteTargetId(source),
+			source,
+			evidence: {
+				type: "property",
+				property: QUOTE
+			}
+		});
+	}
+});
+//#endregion
+//#region src/reply.ts
+const IN_REPLY_TO = new URL("https://www.w3.org/ns/activitystreams#inReplyTo");
+const replyInteraction = createInteractionControl({
+	name: "reply",
+	policyProperty: "canReply",
+	requestClass: ReplyRequest,
+	authorizationClass: ReplyAuthorization,
+	getInteractingObject: (request, options) => request.getInstrument(options),
+	isInteractingObject: (object) => object instanceof Note || object instanceof Article || object instanceof Question || object instanceof ChatMessage,
+	interactingObjectTypes: [
+		Note.typeId,
+		Article.typeId,
+		Question.typeId,
+		ChatMessage.typeId
+	],
+	getInteractionTarget: (request, options) => request.getObject(options),
+	validateRequest: (_request, reply, target, requester) => {
+		const targetId = getRequiredId(target, "interactionTarget");
+		if (!idsEqual(reply.replyTargetId, targetId)) return {
+			type: "objectMismatch",
+			expected: targetId,
+			actual: reply.replyTargetId ?? void 0
+		};
+		if (!idsEqual(reply.attributionId, requester)) return {
+			type: "requesterMismatch",
+			expected: requester,
+			actual: reply.attributionId ?? void 0
+		};
+		return null;
+	},
+	getSelfActor: (subject) => subject.attributionId,
+	getImplicitAutomaticActors: getReplyParticipants,
+	defaultMissingPolicy: "automatic",
+	recognizeImpolite: (source) => {
+		if (source instanceof Create) return null;
+		return recognized({
+			requester: source.attributionId,
+			interactingObject: source,
+			interactionTarget: void 0,
+			interactionTargetId: source.replyTargetId,
+			source,
+			evidence: {
+				type: "property",
+				property: IN_REPLY_TO
+			}
+		});
+	}
+});
+async function* getReplyParticipants(subject, options) {
+	const replyTarget = await subject.getReplyTarget(options);
+	if (replyTarget instanceof Object$1 && replyTarget.attributionId != null) yield replyTarget.attributionId;
+	for await (const tag of subject.getTags(options)) if (tag instanceof Mention && tag.href != null) yield tag.href;
+}
+//#endregion
+export { announceInteraction, featureInteraction, formatAuthorizationKey, formatInteractionKey, likeInteraction, quoteInteraction, replyInteraction };