@fedify/lint 2.3.0-pr.809.39 → 2.3.0

package/dist/index.cjs

@@ -24,865 +24,46 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
+const require_outbox_listener_delivery_required = require("./outbox-listener-delivery-required-DWbQtz5p.cjs");
 let _fxts_core = require("@fxts/core");
 let _typescript_eslint_parser = require("@typescript-eslint/parser");
 _typescript_eslint_parser = __toESM(_typescript_eslint_parser, 1);
-//#region deno.json
-var name = "@fedify/lint";
-var version = "2.3.0-pr.809.39+f65f60c0";
-//#endregion
-//#region src/lib/const.ts
-/**
-* Mapping of actor property names to their corresponding Context method names
-* and dispatcher methods.
-* Used by lint rules to validate property existence and correct method usage.
-*/
-const properties = {
-	id: {
-		name: "id",
-		path: ["id"],
-		getter: "getActorUri",
-		setter: "setActorDispatcher",
-		requiresIdentifier: true
-	},
-	following: {
-		name: "following",
-		path: ["following"],
-		getter: "getFollowingUri",
-		setter: "setFollowingDispatcher",
-		requiresIdentifier: true
-	},
-	followers: {
-		name: "followers",
-		path: ["followers"],
-		getter: "getFollowersUri",
-		setter: "setFollowersDispatcher",
-		requiresIdentifier: true
-	},
-	outbox: {
-		name: "outbox",
-		path: ["outbox"],
-		getter: "getOutboxUri",
-		setter: "setOutboxDispatcher",
-		requiresIdentifier: true
-	},
-	inbox: {
-		name: "inbox",
-		path: ["inbox"],
-		getter: "getInboxUri",
-		setter: "setInboxListeners",
-		requiresIdentifier: true
-	},
-	liked: {
-		name: "liked",
-		path: ["liked"],
-		getter: "getLikedUri",
-		setter: "setLikedDispatcher",
-		requiresIdentifier: true
-	},
-	featured: {
-		name: "featured",
-		path: ["featured"],
-		getter: "getFeaturedUri",
-		setter: "setFeaturedDispatcher",
-		requiresIdentifier: true
-	},
-	featuredTags: {
-		name: "featuredTags",
-		path: ["featuredTags"],
-		getter: "getFeaturedTagsUri",
-		setter: "setFeaturedTagsDispatcher",
-		requiresIdentifier: true
-	},
-	sharedInbox: {
-		name: "sharedInbox",
-		path: ["endpoints", "sharedInbox"],
-		getter: "getInboxUri",
-		setter: "setInboxListeners",
-		requiresIdentifier: false,
-		nested: {
-			parent: "endpoints",
-			wrapper: "Endpoints"
-		}
-	},
-	publicKey: {
-		name: "publicKey",
-		path: ["publicKey"],
-		getter: "getActorKeyPairs",
-		setter: "setKeyPairsDispatcher",
-		requiresIdentifier: true,
-		isKeyProperty: true
-	},
-	assertionMethod: {
-		name: "assertionMethod",
-		path: ["assertionMethod"],
-		getter: "getActorKeyPairs",
-		setter: "setKeyPairsDispatcher",
-		requiresIdentifier: true,
-		isKeyProperty: true
-	}
-};
-/**
-* Rule IDs for all Fedify lint rules
-*/
-const RULE_IDS = {
-	actorIdRequired: "actor-id-required",
-	actorFollowingPropertyRequired: "actor-following-property-required",
-	actorFollowersPropertyRequired: "actor-followers-property-required",
-	actorOutboxPropertyRequired: "actor-outbox-property-required",
-	actorLikedPropertyRequired: "actor-liked-property-required",
-	actorFeaturedPropertyRequired: "actor-featured-property-required",
-	actorFeaturedTagsPropertyRequired: "actor-featured-tags-property-required",
-	actorInboxPropertyRequired: "actor-inbox-property-required",
-	actorSharedInboxPropertyRequired: "actor-shared-inbox-property-required",
-	actorPublicKeyRequired: "actor-public-key-required",
-	actorAssertionMethodRequired: "actor-assertion-method-required",
-	actorIdMismatch: "actor-id-mismatch",
-	actorFollowingPropertyMismatch: "actor-following-property-mismatch",
-	actorFollowersPropertyMismatch: "actor-followers-property-mismatch",
-	actorOutboxPropertyMismatch: "actor-outbox-property-mismatch",
-	actorLikedPropertyMismatch: "actor-liked-property-mismatch",
-	actorFeaturedPropertyMismatch: "actor-featured-property-mismatch",
-	actorFeaturedTagsPropertyMismatch: "actor-featured-tags-property-mismatch",
-	actorInboxPropertyMismatch: "actor-inbox-property-mismatch",
-	actorSharedInboxPropertyMismatch: "actor-shared-inbox-property-mismatch",
-	collectionFilteringNotImplemented: "collection-filtering-not-implemented",
-	outboxListenerDeliveryRequired: "outbox-listener-delivery-required"
-};
-//#endregion
-//#region src/lib/messages.ts
-/**
-* Generates error message for *-required rules.
-* Used when a property is missing from the actor dispatcher return value.
-*
-* @param name - The property name (e.g., "id", "inbox", "following")
-*/
-const actorPropertyRequired = ({ setter, path, getter, requiresIdentifier = true }) => `When \`${setter}\` is configured, the \`${path.join(".")}\` property is recommended. Use \`${getExpectedCall({
-	ctxName: "Context",
-	methodName: getter,
-	idName: "identifier",
-	path: path.join("."),
-	requiresIdentifier
-})}\` for the \`${path.join(".")}\` property URI.`;
-/**
-* Generates error message for *-mismatch rules.
-* Used when a property exists but uses the wrong context method.
-*
-* @param propertyName - The property name or path
-*                       (e.g., "id", "endpoints.sharedInbox")
-* @param expectedCall - The expected method call
-*                       (e.g., "ctx.getActorUri(identifier)")
-*/
-const actorPropertyMismatch = (context) => `Actor's \`${context.path}\` property must match \`${getExpectedCall(context)}\`. \
-Ensure you're using the correct context method.`;
-const getExpectedCall = ({ ctxName, methodName, requiresIdentifier, idName }) => requiresIdentifier ? `${ctxName}.${methodName}(${idName})` : `${ctxName}.${methodName}()`;
-/**
-* Error message for collection filtering not implemented.
-*/
-const COLLECTION_FILTERING_NOT_IMPLEMENTED_ERROR = "Collection dispatcher should implement filtering to avoid large response payloads. Add a fourth parameter (filter) to handle filtering. See: https://fedify.dev/manual/collections#filtering-by-server";
-//#endregion
-//#region src/lib/utils.ts
-const eq = (value) => (other) => value === other;
-function cases(pred, ifTrue, ifFalse) {
-	return (value) => pred(value) ? ifTrue(value) : ifFalse(value);
-}
-//#endregion
-//#region src/lib/pred.ts
-function allOf(...predicates) {
-	return (value) => predicates.every((predicate) => predicate(value));
-}
-const anyOf = (...predicates) => (value) => predicates.some((predicate) => predicate(value));
-const isNode = (obj) => (0, _fxts_core.isObject)(obj) && "type" in obj;
-/**
-* Checks if a node is of a specific type.
-*/
-const isNodeType = (type) => (node) => (0, _fxts_core.pipe)(node, (0, _fxts_core.prop)("type"), eq(type));
-/**
-* Checks if a node is of a specific name.
-*/
-const isNodeName = (name) => (node) => (0, _fxts_core.pipe)(node, (0, _fxts_core.prop)("name"), eq(name));
-/**
-* Checks if a node's callee is a MemberExpression.
-*/
-const hasMemberExpressionCallee = (node) => node.callee.type === "MemberExpression";
-/**
-* Checks if a node's callee property is an Identifier.
-*/
-const hasIdentifierProperty = (node) => "callee" in node && "property" in node.callee && "type" in node.callee.property && node.callee.property.type === "Identifier";
-/**
-* Checks if a node's callee property name matches the given method name.
-*/
-const hasMethodName = (methodName) => (node) => "callee" in node && "property" in node.callee && "name" in node.callee.property && node.callee.property.name === methodName;
-/**
-* Checks if a CallExpression has minimum required arguments.
-*/
-const hasMinArguments = (min) => (node) => node.arguments.length >= min;
-/**
-* Checks if an expression is a function (arrow or regular).
-*/
-const isFunction = (expr) => anyOf(isNodeType("ArrowFunctionExpression"), isNodeType("FunctionExpression"))(expr);
-/**
-* Checks if a CallExpression is a setActorDispatcher call with
-* proper structure.
-*/
-const isSetActorDispatcherCall = (node) => allOf(hasMemberExpressionCallee, hasIdentifierProperty, hasMethodName("setActorDispatcher"), hasMinArguments(2))(node);
-/**
-* Checks if a function has at least n parameters.
-*/
-const hasMinParams = (min) => (fn) => fn.params.length >= min;
-//#endregion
-//#region src/lib/property-checker.ts
-/**
-* Checks if a node has a key with a specific name.
-*/
-const hasKeyName = (propertyName) => (node) => (0, _fxts_core.pipe)(node, (0, _fxts_core.prop)("key"), allOf(isNodeType("Identifier"), (0, _fxts_core.pipeLazy)((0, _fxts_core.prop)("name"), eq(propertyName))));
-/**
-* Checks if a node is a Property with an Identifier key of a specific name.
-*/
-const isPropertyWithName = (propertyName) => (node) => allOf(isNodeType("Property"), hasKeyName(propertyName))(node);
-/**
-* Creates a predicate function that checks if a nested property exists.
-* @param path Array of property names forming the path
-*             (e.g., ["endpoints", "sharedInbox"])
-* @returns A predicate function that checks if the nested property exists
-*/
-function createPropertyChecker(checker) {
-	const inner = ([first, ...rest]) => (node) => {
-		if (!isPropertyWithName(first)(node)) return false;
-		if ((0, _fxts_core.isEmpty)(rest)) return checker(node.value);
-		if (isNodeType("NewExpression")(node.value)) {
-			if (node.value.arguments.length === 0) return false;
-			const firstArg = node.value.arguments[0];
-			if (!isNodeType("ObjectExpression")(firstArg)) return false;
-			return firstArg.properties.some(inner(rest));
-		}
-		return false;
-	};
-	return inner;
-}
-/**
-* Checks if an ObjectExpression node contains a property.
-* @param propertyChecker The predicate function to check properties
-* @returns A function that checks the ObjectExpression
-*/
-const checkObjectExpression = (propertyChecker) => (obj) => obj.properties.some(propertyChecker);
-/**
-* Checks if a ConditionalExpression (ternary operator) has the property in
-* both branches.
-* @param propertyChecker The predicate function to check properties
-* @returns A function that checks the ConditionalExpression
-*/
-const checkConditionalExpression = (propertyChecker) => (node) => [node.consequent, node.alternate].every(checkBranchWith(propertyChecker));
-const checkBranchWith = (propertyChecker) => (branch) => (0, _fxts_core.pipe)(branch, cases(isNodeType("ConditionalExpression"), checkConditionalExpression(propertyChecker), (0, _fxts_core.pipeLazy)(extractObjectExpression, cases(_fxts_core.isObject, checkObjectExpression(propertyChecker), (0, _fxts_core.always)(false)))));
-/**
-* Extracts the first argument if it's an ObjectExpression.
-*/
-const extractFirstObjectExpression = (node) => (0, _fxts_core.pipe)(node, (0, _fxts_core.prop)("arguments"), _fxts_core.head, (0, _fxts_core.unless)(isNodeType("ObjectExpression"), (0, _fxts_core.always)(null)));
-/**
-* Extracts ObjectExpression from NewExpression.
-*/
-const extractObjectExpression = cases(isNodeType("NewExpression"), extractFirstObjectExpression, (0, _fxts_core.always)(null));
-/**
-* Checks if a ReturnStatement node contains a property.
-* @param propertyChecker The predicate function to check properties
-* @returns A function that checks the ReturnStatement
-*/
-const checkReturnStatement = (propertyChecker) => (node) => (0, _fxts_core.pipe)(node, (0, _fxts_core.prop)("argument"), cases(_fxts_core.isObject, checkBranchWith(propertyChecker), (0, _fxts_core.always)(false)));
-/**
-* Creates a function that recursively checks for a property in an AST node.
-* @param propertyChecker The predicate function to check properties
-* @returns A recursive function that checks the AST node
-*/
-const createPropertySearcher = (propertyChecker) => {
-	return (node) => {
-		switch (node.type) {
-			case "ReturnStatement": return checkReturnStatement(propertyChecker)(node);
-			case "BlockStatement": return checkAllReturnPaths(propertyChecker)(node);
-			case "NewExpression": return (0, _fxts_core.pipe)(node, extractFirstObjectExpression, (0, _fxts_core.when)(_fxts_core.isObject, checkObjectExpression(propertyChecker)), Boolean);
-			default: return false;
-		}
-	};
-};
-const checkAllReturnPaths = (propertyChecker) => (node) => (0, _fxts_core.pipe)(node, collectReturnPaths, cases(_fxts_core.isEmpty, (0, _fxts_core.always)(false), (0, _fxts_core.every)(checkReturnStatement(propertyChecker))));
-/**
-* Collects all return statements from a node, traversing control flow.
-* This handles if/else branches, loops, etc.
-*/
-const collectReturnPaths = (node) => (0, _fxts_core.pipe)(node, flatten, _fxts_core.toArray);
-function* flatten(node) {
-	switch (node.type) {
-		case "ReturnStatement":
-			yield node;
-			return;
-		case "IfStatement":
-			if (node.consequent) yield* flatten(node.consequent);
-			if (node.alternate) yield* flatten(node.alternate);
-			return;
-		case "BlockStatement":
-			for (const statement of node.body) yield* flatten(statement);
-			return;
-		case "SwitchStatement":
-			for (const switchCase of node.cases) for (const statement of switchCase.consequent) yield* flatten(statement);
-			return;
-		case "TryStatement":
-			yield* flatten(node.block);
-			if (node.handler) yield* flatten(node.handler.body);
-			if (node.finalizer) yield* flatten(node.finalizer);
-			return;
-		case "WhileStatement":
-		case "DoWhileStatement":
-		case "ForStatement":
-		case "ForInStatement":
-		case "ForOfStatement":
-			yield* flatten(node.body);
-			return;
-		case "LabeledStatement":
-			yield* flatten(node.body);
-			return;
-		case "WithStatement":
-			yield* flatten(node.body);
-			return;
-		default: return;
-	}
-}
-//#endregion
-//#region src/lib/tracker.ts
-/**
-* Helper to track variable names that store the result of createFederation() or createFederationBuilder() calls
-*/
-function trackFederationVariables() {
-	const federationVariables = /* @__PURE__ */ new Set();
-	const isFederationObject = (obj) => {
-		switch (obj.type) {
-			case "Identifier": return federationVariables.has(obj.name);
-			case "CallExpression":
-				if (isCreateFederation(obj)) return true;
-				if (obj.callee.type === "MemberExpression") return isFederationObject(obj.callee.object);
-				return false;
-			case "MemberExpression": return isFederationObject(obj.object);
-		}
-		return false;
-	};
-	return {
-		VariableDeclarator(node) {
-			const init = node.init;
-			const id = node.id;
-			if (init?.type === "CallExpression") {
-				if (isCreateFederation(init) && id.type === "Identifier") federationVariables.add(id.name);
-			}
-		},
-		isFederationVariable(name) {
-			return federationVariables.has(name);
-		},
-		isFederationObject
-	};
-}
-const isCreateFederation = (node) => node.callee.type === "Identifier" && /^create(Federation|FederationBuilder)$/i.test(node.callee.name);
-//#endregion
-//#region src/lib/required.ts
-/**
-* Checks if a CallExpression is a specific dispatcher method call.
-*/
-const isDispatcherMethodCall = (methodName) => (node) => allOf(hasMemberExpressionCallee, hasIdentifierProperty, hasMethodName(methodName))(node);
-/**
-* Tracks dispatcher method calls on federation objects.
-*/
-const createDispatcherTracker = (dispatcherMethod, federationTracker) => {
-	let dispatcherConfigured = false;
-	return {
-		isDispatcherConfigured: () => dispatcherConfigured,
-		checkDispatcherCall: (node) => {
-			if (isDispatcherMethodCall(dispatcherMethod)(node) && federationTracker.isFederationObject(node.callee.object)) dispatcherConfigured = true;
-		}
-	};
-};
-function createRequiredRule(config, description) {
-	return (context) => {
-		const federationTracker = trackFederationVariables();
-		const dispatcherTracker = createDispatcherTracker(config.setter, federationTracker);
-		const actorDispatchers = [];
-		const propertySearcher = createPropertySearcher(createPropertyChecker(Boolean)(config.path));
-		return {
-			VariableDeclarator: federationTracker.VariableDeclarator,
-			CallExpression(node) {
-				dispatcherTracker.checkDispatcherCall(node);
-				if (!isSetActorDispatcherCall(node)) return;
-				if (!federationTracker.isFederationObject(node.callee.object)) return;
-				const dispatcher = node.arguments[1];
-				if (isFunction(dispatcher)) actorDispatchers.push(dispatcher);
-			},
-			"Program:exit"() {
-				if (!dispatcherTracker.isDispatcherConfigured()) return;
-				for (const dispatcher of actorDispatchers) if (!propertySearcher(dispatcher.body)) context.report({
-					node: dispatcher,
-					...description
-				});
-			}
-		};
-	};
-}
-/**
-* Creates a required rule with the given property configuration.
-*/
-function createRequiredRuleDeno(config) {
-	return { create: createRequiredRule(config, { message: actorPropertyRequired(config) }) };
-}
-/**
-* Creates a required ESLint rule with the given property configuration.
-*/
-function createRequiredRuleEslint(config) {
-	return {
-		meta: {
-			type: "suggestion",
-			docs: { description: `Ensure actor dispatcher returns ${config.path.join(".")} property.` },
-			schema: [],
-			messages: { required: "{{ message }}" }
-		},
-		create: createRequiredRule(config, {
-			messageId: "required",
-			data: { message: actorPropertyRequired(config) }
-		})
-	};
-}
-createRequiredRuleDeno(properties.assertionMethod);
-const eslint$21 = createRequiredRuleEslint(properties.assertionMethod);
-//#endregion
-//#region src/lib/mismatch.ts
-const isIdentifierWithName = (name) => (node) => allOf(isNodeType("Identifier"), isNodeName(name))(node);
-/**
-* Checks if a node is a CallExpression calling the expected context method.
-*/
-const isExpectedMethodCall = ({ ctxName, idName, methodName, requiresIdentifier }) => (node) => {
-	if (!isNodeType("CallExpression")(node) || !hasMemberExpressionCallee(node) || !isIdentifierWithName(ctxName)(node.callee.object) || !isIdentifierWithName(methodName)(node.callee.property)) return false;
-	if (!requiresIdentifier) return (0, _fxts_core.isEmpty)(node.arguments);
-	return allOf((0, _fxts_core.negate)(_fxts_core.isEmpty), (0, _fxts_core.some)(isIdentifierWithName(idName)))(node.arguments);
-};
-/**
-* Extracts parameter names from a function.
-*/
-const extractParams = (fn) => {
-	const params = fn.params;
-	if (params.length < 2) return [null, null];
-	return params.slice(0, 2).map(getNameIfIdentifier);
-};
-const getNameIfIdentifier = (node) => node?.type === "Identifier" ? node.name : null;
-function createMismatchRule(config, describe) {
-	return (context) => {
-		const tracker = trackFederationVariables();
-		return {
-			VariableDeclarator: tracker.VariableDeclarator,
-			CallExpression(node) {
-				if (!isSetActorDispatcherCall(node) || !hasMemberExpressionCallee(node) || !tracker.isFederationObject(node.callee.object)) return;
-				const dispatcherArg = node.arguments[1];
-				if (!isFunction(dispatcherArg)) return;
-				const [ctxName, idName] = extractParams(dispatcherArg);
-				if (!ctxName || !idName) return;
-				const methodCallContext = {
-					path: config.path.join("."),
-					ctxName,
-					idName,
-					methodName: config.getter,
-					requiresIdentifier: config.requiresIdentifier
-				};
-				if (!createPropertySearcher(createPropertyChecker(Boolean)(config.path))(dispatcherArg.body)) return;
-				if (!createPropertySearcher(createPropertyChecker(isExpectedMethodCall(methodCallContext))(config.path))(dispatcherArg.body)) context.report({
-					node: dispatcherArg,
-					...describe(methodCallContext)
-				});
-			}
-		};
-	};
-}
-/**
-* Creates a lint rule that checks if a property uses
-* the correct context method.
-*
-* @param config Property configuration containing name, getter, setter, and
-*               nested info
-* @returns A Deno lint rule
-*/
-const createMismatchRuleDeno = (config) => ({ create: createMismatchRule(config, (context) => ({ message: actorPropertyMismatch(context) })) });
-const createMismatchRuleEslint = (config) => ({
-	meta: {
-		type: "problem",
-		docs: { description: `Ensure actor's ${config.path.join(".")} property uses correct context method` },
-		schema: [],
-		messages: { mismatch: "{{ message }}" }
-	},
-	create: createMismatchRule(config, (context) => ({
-		messageId: "mismatch",
-		data: { message: actorPropertyMismatch(context) }
-	}))
-});
-createMismatchRuleDeno(properties.featured);
-const eslint$20 = createMismatchRuleEslint(properties.featured);
-createRequiredRuleDeno(properties.featured);
-const eslint$19 = createRequiredRuleEslint(properties.featured);
-createMismatchRuleDeno(properties.featuredTags);
-const eslint$18 = createMismatchRuleEslint(properties.featuredTags);
-createRequiredRuleDeno(properties.featuredTags);
-const eslint$17 = createRequiredRuleEslint(properties.featuredTags);
-createMismatchRuleDeno(properties.followers);
-const eslint$16 = createMismatchRuleEslint(properties.followers);
-createRequiredRuleDeno(properties.followers);
-const eslint$15 = createRequiredRuleEslint(properties.followers);
-createMismatchRuleDeno(properties.following);
-const eslint$14 = createMismatchRuleEslint(properties.following);
-createRequiredRuleDeno(properties.following);
-const eslint$13 = createRequiredRuleEslint(properties.following);
-createMismatchRuleDeno(properties.id);
-const eslint$12 = createMismatchRuleEslint(properties.id);
-createRequiredRuleDeno(properties.id);
-const eslint$11 = createRequiredRuleEslint(properties.id);
-createMismatchRuleDeno(properties.inbox);
-const eslint$10 = createMismatchRuleEslint(properties.inbox);
-createRequiredRuleDeno(properties.inbox);
-const eslint$9 = createRequiredRuleEslint(properties.inbox);
-createMismatchRuleDeno(properties.liked);
-const eslint$8 = createMismatchRuleEslint(properties.liked);
-createRequiredRuleDeno(properties.liked);
-const eslint$7 = createRequiredRuleEslint(properties.liked);
-createMismatchRuleDeno(properties.outbox);
-const eslint$6 = createMismatchRuleEslint(properties.outbox);
-createRequiredRuleDeno(properties.outbox);
-const eslint$5 = createRequiredRuleEslint(properties.outbox);
-createRequiredRuleDeno(properties.publicKey);
-const eslint$4 = createRequiredRuleEslint(properties.publicKey);
-createMismatchRuleDeno(properties.sharedInbox);
-const eslint$3 = createMismatchRuleEslint(properties.sharedInbox);
-createRequiredRuleDeno(properties.sharedInbox);
-const eslint$2 = createRequiredRuleEslint(properties.sharedInbox);
-//#endregion
-//#region src/rules/collection-filtering-not-implemented.ts
-/**
-* The followers dispatcher method that supports filtering.
-* Only setFollowersDispatcher uses the filter parameter for
-* followers collection synchronization.
-* See: https://fedify.dev/manual/collections#filtering-by-server
-*/
-const FILTER_NEEDED = ["setFollowersDispatcher"];
-/**
-* Checks if a node is a setFollowersDispatcher call.
-*/
-const isFollowersDispatcherCall = (node) => "callee" in node && node.callee && node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && FILTER_NEEDED.includes(node.callee.property.name);
-/**
-* Checks if a function node has the filter parameter (4th parameter).
-* CollectionDispatcher signature: (context, identifier, cursor, filter?) => ...
-*/
-const hasFilterParameter = hasMinParams(4);
-const eslint$1 = {
-	meta: {
-		type: "suggestion",
-		docs: { description: "Ensure followers dispatcher implements filtering" },
-		schema: [],
-		messages: { filterRequired: COLLECTION_FILTERING_NOT_IMPLEMENTED_ERROR }
-	},
-	create(context) {
-		const federationTracker = trackFederationVariables();
-		return {
-			VariableDeclarator: federationTracker.VariableDeclarator,
-			CallExpression(node) {
-				if (!isFollowersDispatcherCall(node)) return;
-				if (!federationTracker.isFederationObject(node.callee.object)) return;
-				const dispatcherArg = node.arguments[1];
-				if (!isFunction(dispatcherArg)) return;
-				if (!hasFilterParameter(dispatcherArg)) context.report({
-					node: dispatcherArg,
-					messageId: "filterRequired"
-				});
-			}
-		};
-	}
-};
-//#endregion
-//#region src/rules/outbox-listener-delivery-required.ts
-const MESSAGE = "Outbox listeners should deliver posted activities explicitly with ctx.sendActivity() or ctx.forwardActivity().";
-const isChainedFromOutboxListeners = (expr, federationTracker) => {
-	if (expr.type !== "CallExpression") return false;
-	if (!hasMemberExpressionCallee(expr) || !hasIdentifierProperty(expr)) return false;
-	const methodName = expr.callee.property.name;
-	if (methodName === "setOutboxListeners") return federationTracker.isFederationObject(expr.callee.object);
-	if (methodName === "authorize" || methodName === "onError" || methodName === "on") return isChainedFromOutboxListeners(expr.callee.object, federationTracker);
-	return false;
-};
-const DELIVERY_METHOD_NAMES = new Set(["sendActivity", "forwardActivity"]);
-const getMemberPropertyName = (expr) => {
-	if (expr.type !== "MemberExpression") return null;
-	const property = expr.property;
-	if (property.type === "Identifier") return property.name;
-	if (property.type === "Literal" && typeof property.value === "string") return property.value;
-	return null;
-};
-function unwrapContextParam(node) {
-	let current = node ?? null;
-	while (current?.type === "AssignmentPattern") current = current.left;
-	return current;
-}
-function escapeRegExp(value) {
-	return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function stripCommentsAndStrings(code) {
-	let result = "";
-	let index = 0;
-	const skipQuotedString = (quote) => {
-		const start = index;
-		index += 1;
-		while (index < code.length) {
-			const char = code[index];
-			if (char === "\\") {
-				index += 2;
-				continue;
-			}
-			index += 1;
-			if (char === quote) break;
-		}
-		const literal = code.slice(start, index);
-		const value = literal.slice(1, -1);
-		result += DELIVERY_METHOD_NAMES.has(value) ? literal : `${quote}${quote}`;
-	};
-	const stripTemplateLiteral = () => {
-		const start = index;
-		index += 1;
-		let raw = "";
-		let hasExpression = false;
-		while (index < code.length) {
-			const char = code[index];
-			if (char === "\\") {
-				raw += char;
-				raw += code[index + 1] ?? "";
-				index += 2;
-				continue;
-			}
-			if (char === "`") {
-				index += 1;
-				if (!hasExpression && DELIVERY_METHOD_NAMES.has(raw)) result += code.slice(start, index);
-				else result += "``";
-				return;
-			}
-			if (char === "$" && code[index + 1] === "{") {
-				hasExpression = true;
-				result += "`${";
-				index += 2;
-				let depth = 1;
-				while (index < code.length && depth > 0) {
-					const exprChar = code[index];
-					const next = code[index + 1];
-					if (exprChar === "'" || exprChar === "\"") {
-						skipQuotedString(exprChar);
-						continue;
-					}
-					if (exprChar === "`") {
-						stripTemplateLiteral();
-						continue;
-					}
-					if (exprChar === "/" && next === "*") {
-						index += 2;
-						while (index < code.length) {
-							if (code[index] === "*" && code[index + 1] === "/") {
-								index += 2;
-								break;
-							}
-							index += 1;
-						}
-						continue;
-					}
-					if (exprChar === "/" && next === "/") {
-						index += 2;
-						while (index < code.length && code[index] !== "\n") index += 1;
-						continue;
-					}
-					result += exprChar;
-					index += 1;
-					if (exprChar === "{") depth += 1;
-					else if (exprChar === "}") depth -= 1;
-				}
-				continue;
-			}
-			raw += char;
-			index += 1;
-		}
-		result += "``";
-	};
-	while (index < code.length) {
-		const char = code[index];
-		const next = code[index + 1];
-		if (char === "/" && next === "*") {
-			index += 2;
-			while (index < code.length) {
-				if (code[index] === "*" && code[index + 1] === "/") {
-					index += 2;
-					break;
-				}
-				index += 1;
-			}
-			continue;
-		}
-		if (char === "/" && next === "/") {
-			index += 2;
-			while (index < code.length && code[index] !== "\n") index += 1;
-			continue;
-		}
-		if (char === "'" || char === "\"") {
-			skipQuotedString(char);
-			continue;
-		}
-		if (char === "`") {
-			stripTemplateLiteral();
-			continue;
-		}
-		result += char;
-		index += 1;
-	}
-	return result;
-}
-function getDeliveryAliasName(node) {
-	if (node.type === "Identifier") return node.name;
-	if (node.type === "AssignmentPattern" && node.left.type === "Identifier") return node.left.name;
-	return null;
-}
-function buildContextExpressionPattern(contextName) {
-	const name = escapeRegExp(contextName);
-	const boundedName = String.raw`(?<![\w$])${name}(?![\w$])`;
-	return String.raw`(?:${boundedName}|\(\s*${boundedName}(?:\s+as\s+[^)]+)?\s*\))`;
-}
-const resolveListenerReference = (expr, bindings, seen = /* @__PURE__ */ new Set()) => {
-	if (isFunction(expr)) return expr;
-	if (expr.type === "Identifier") {
-		if (seen.has(expr.name)) return null;
-		seen.add(expr.name);
-		const binding = bindings.get(expr.name);
-		if (binding == null || !isNode(binding)) return null;
-		if (isFunction(binding) || binding.type === "FunctionDeclaration") return binding;
-		if (binding.type === "Identifier") return resolveListenerReference(binding, bindings, seen);
-		return null;
-	}
-	if (expr.type === "MemberExpression" && expr.object.type === "Identifier" && !expr.computed) {
-		const binding = bindings.get(expr.object.name);
-		if (binding == null || !isNode(binding) || binding.type !== "ObjectExpression") return null;
-		const propertyName = getMemberPropertyName(expr);
-		if (propertyName == null) return null;
-		for (const prop of binding.properties) {
-			if (!isNode(prop) || prop.type !== "Property") continue;
-			if ((prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" && typeof prop.key.value === "string" ? prop.key.value : null) !== propertyName || !isNode(prop.value)) continue;
-			const value = prop.value;
-			if (isFunction(value) || value.type === "FunctionDeclaration") return value;
-		}
-	}
-	return null;
-};
-const listenerCallsDeliveryMethod = (sourceCode, listener) => {
-	const code = stripCommentsAndStrings(sourceCode.getText(listener));
-	const aliases = /* @__PURE__ */ new Set();
-	const contextParam = unwrapContextParam(listener.params[0]);
-	const contextName = contextParam?.type === "Identifier" ? contextParam.name : null;
-	if (contextParam?.type === "ObjectPattern") for (const prop of contextParam.properties) {
-		if (!isNode(prop) || prop.type !== "Property") continue;
-		const keyName = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" && typeof prop.key.value === "string" ? prop.key.value : null;
-		if (keyName == null || !DELIVERY_METHOD_NAMES.has(keyName)) continue;
-		const alias = getDeliveryAliasName(prop.value);
-		if (alias != null) aliases.add(alias);
-	}
-	if (contextName != null) {
-		const contextExpr = buildContextExpressionPattern(contextName);
-		if (new RegExp(String.raw`${contextExpr}\s*(?:\?\s*\.\s*(?:sendActivity|forwardActivity)|\.\s*(?:sendActivity|forwardActivity)|\?\s*\.\s*\[\s*["'\`](?:sendActivity|forwardActivity)["'\`]\s*\]|\[\s*["'\`](?:sendActivity|forwardActivity)["'\`]\s*\])\s*\(`).test(code)) return true;
-		const destructuringPattern = new RegExp(String.raw`(?:const|let|var)\s*{([^}]*)}\s*=\s*${contextExpr}`, "g");
-		for (const match of code.matchAll(destructuringPattern)) {
-			const fields = match[1].split(",").map((field) => field.trim()).filter(Boolean);
-			for (const field of fields) {
-				const [sourceName, aliasName] = field.split(":").map((part) => part.trim());
-				if (!DELIVERY_METHOD_NAMES.has(sourceName)) continue;
-				aliases.add(aliasName ?? sourceName);
-			}
-		}
-		const aliasPattern = new RegExp(String.raw`(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*${contextExpr}\s*(?:\?\s*\.\s*(sendActivity|forwardActivity)|\.\s*(sendActivity|forwardActivity)|\?\s*\.\s*\[\s*["'\`](sendActivity|forwardActivity)["'\`]\s*\]|\[\s*["'\`](sendActivity|forwardActivity)["'\`]\s*\])`, "g");
-		for (const match of code.matchAll(aliasPattern)) aliases.add(match[1]);
-	}
-	return globalThis.Array.from(aliases).some((alias) => new RegExp(String.raw`\b${escapeRegExp(alias)}\s*\(`).test(code));
-};
-function createRule(buildReport) {
-	return (context) => {
-		const federationTracker = trackFederationVariables();
-		const bindings = /* @__PURE__ */ new Map();
-		const pendingCalls = [];
-		const sourceCode = context.sourceCode;
-		const inspectCall = (node) => {
-			if (!hasMemberExpressionCallee(node) || !hasIdentifierProperty(node) || !hasMethodName("on")(node) || node.arguments.length < 2) return;
-			if (!isChainedFromOutboxListeners(node.callee.object, federationTracker)) return;
-			const listener = node.arguments[1];
-			const resolvedListener = isNode(listener) && isFunction(listener) ? listener : isNode(listener) ? resolveListenerReference(listener, bindings) : null;
-			if (resolvedListener == null) return;
-			if (listenerCallsDeliveryMethod(sourceCode, resolvedListener)) return;
-			context.report({
-				node: resolvedListener,
-				...buildReport
-			});
-		};
-		return {
-			VariableDeclarator(node) {
-				federationTracker.VariableDeclarator(node);
-				if (node.id.type === "Identifier" && node.init != null) bindings.set(node.id.name, node.init);
-			},
-			FunctionDeclaration(node) {
-				if (node.id != null) bindings.set(node.id.name, node);
-			},
-			CallExpression(node) {
-				pendingCalls.push(node);
-			},
-			"Program:exit"() {
-				for (const node of pendingCalls) inspectCall(node);
-			}
-		};
-	};
-}
-const eslint = {
-	meta: {
-		type: "suggestion",
-		docs: { description: "Warn when an outbox listener omits explicit delivery methods" },
-		schema: [],
-		messages: { required: "{{ message }}" }
-	},
-	create: createRule({
-		messageId: "required",
-		data: { message: MESSAGE }
-	})
-};
-//#endregion
 //#region src/index.ts
 /**
 * ESLint plugin for Fedify.
 * Provides lint rules for validating Fedify federation code.
 */
 const rules = {
-	[RULE_IDS.actorIdMismatch]: eslint$12,
-	[RULE_IDS.actorIdRequired]: eslint$11,
-	[RULE_IDS.actorFollowingPropertyRequired]: eslint$13,
-	[RULE_IDS.actorFollowingPropertyMismatch]: eslint$14,
-	[RULE_IDS.actorFollowersPropertyRequired]: eslint$15,
-	[RULE_IDS.actorFollowersPropertyMismatch]: eslint$16,
-	[RULE_IDS.actorOutboxPropertyRequired]: eslint$5,
-	[RULE_IDS.actorOutboxPropertyMismatch]: eslint$6,
-	[RULE_IDS.actorLikedPropertyRequired]: eslint$7,
-	[RULE_IDS.actorLikedPropertyMismatch]: eslint$8,
-	[RULE_IDS.actorFeaturedPropertyRequired]: eslint$19,
-	[RULE_IDS.actorFeaturedPropertyMismatch]: eslint$20,
-	[RULE_IDS.actorFeaturedTagsPropertyRequired]: eslint$17,
-	[RULE_IDS.actorFeaturedTagsPropertyMismatch]: eslint$18,
-	[RULE_IDS.actorInboxPropertyRequired]: eslint$9,
-	[RULE_IDS.actorInboxPropertyMismatch]: eslint$10,
-	[RULE_IDS.actorSharedInboxPropertyRequired]: eslint$2,
-	[RULE_IDS.actorSharedInboxPropertyMismatch]: eslint$3,
-	[RULE_IDS.actorPublicKeyRequired]: eslint$4,
-	[RULE_IDS.actorAssertionMethodRequired]: eslint$21,
-	[RULE_IDS.collectionFilteringNotImplemented]: eslint$1,
-	[RULE_IDS.outboxListenerDeliveryRequired]: eslint
-};
-const recommendedRuleIds = [RULE_IDS.actorIdMismatch, RULE_IDS.actorIdRequired];
+	[require_outbox_listener_delivery_required.RULE_IDS.actorIdMismatch]: require_outbox_listener_delivery_required.eslint$12,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorIdRequired]: require_outbox_listener_delivery_required.eslint$11,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFollowingPropertyRequired]: require_outbox_listener_delivery_required.eslint$13,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFollowingPropertyMismatch]: require_outbox_listener_delivery_required.eslint$14,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFollowersPropertyRequired]: require_outbox_listener_delivery_required.eslint$15,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFollowersPropertyMismatch]: require_outbox_listener_delivery_required.eslint$16,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorOutboxPropertyRequired]: require_outbox_listener_delivery_required.eslint$5,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorOutboxPropertyMismatch]: require_outbox_listener_delivery_required.eslint$6,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorLikedPropertyRequired]: require_outbox_listener_delivery_required.eslint$7,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorLikedPropertyMismatch]: require_outbox_listener_delivery_required.eslint$8,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFeaturedPropertyRequired]: require_outbox_listener_delivery_required.eslint$19,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFeaturedPropertyMismatch]: require_outbox_listener_delivery_required.eslint$20,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFeaturedTagsPropertyRequired]: require_outbox_listener_delivery_required.eslint$17,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorFeaturedTagsPropertyMismatch]: require_outbox_listener_delivery_required.eslint$18,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorInboxPropertyRequired]: require_outbox_listener_delivery_required.eslint$9,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorInboxPropertyMismatch]: require_outbox_listener_delivery_required.eslint$10,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorSharedInboxPropertyRequired]: require_outbox_listener_delivery_required.eslint$2,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorSharedInboxPropertyMismatch]: require_outbox_listener_delivery_required.eslint$3,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorPublicKeyRequired]: require_outbox_listener_delivery_required.eslint$4,
+	[require_outbox_listener_delivery_required.RULE_IDS.actorAssertionMethodRequired]: require_outbox_listener_delivery_required.eslint$21,
+	[require_outbox_listener_delivery_required.RULE_IDS.collectionFilteringNotImplemented]: require_outbox_listener_delivery_required.eslint$1,
+	[require_outbox_listener_delivery_required.RULE_IDS.outboxListenerDeliveryRequired]: require_outbox_listener_delivery_required.eslint
+};
+const recommendedRuleIds = [require_outbox_listener_delivery_required.RULE_IDS.actorIdMismatch, require_outbox_listener_delivery_required.RULE_IDS.actorIdRequired];
 /**
 * Recommended configuration - enables all rules as warnings
 */
 const recommendedRules = (0, _fxts_core.pipe)(rules, _fxts_core.keys, (0, _fxts_core.map)((key) => [`@fedify/lint/${key}`, recommendedRuleIds.includes(key) ? "error" : "warn"]), _fxts_core.fromEntries);
-const pluginName = name;
-const pluginVersion = version;
+const pluginName = require_outbox_listener_delivery_required.name;
+const pluginVersion = require_outbox_listener_delivery_required.version;
 /**
 * Strict configuration - enables all rules as errors
 */
@@ -912,5 +93,6 @@ const recommendedConfig = {
 	rules: recommendedRules
 };
 //#endregion
+exports.__toESM = __toESM;
 exports.default = recommendedConfig;
 exports.plugin = plugin;