@fedify/lint 2.0.0-dev.1

package/dist/index.js

@@ -0,0 +1,726 @@
+import { always, every, fromEntries, head, isEmpty, isObject, keys, map, negate, pipe, pipeLazy, prop, some, toArray, unless, when } from "@fxts/core";
+import parser from "@typescript-eslint/parser";
+
+//#region deno.json
+var name = "@fedify/lint";
+var version = "2.0.0";
+var license = "MIT";
+var exports = { ".": "./src/mod.ts" };
+var imports = {
+	"eslint": "npm:eslint@^9.0.0",
+	"estree": "npm:@types/estree@^1.0.8"
+};
+var tasks = { "test": "deno test --allow-env" };
+var deno_default = {
+	name,
+	version,
+	license,
+	exports,
+	imports,
+	tasks
+};
+
+//#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"
+};
+
+//#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));
+/**
+* Checks if a node is of a specific type.
+*/
+const isNodeType = (type) => (node) => pipe(node, prop("type"), eq(type));
+/**
+* Checks if a node is of a specific name.
+*/
+const isNodeName = (name$1) => (node) => pipe(node, prop("name"), eq(name$1));
+/**
+* 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) => pipe(node, prop("key"), allOf(isNodeType("Identifier"), pipeLazy(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 (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) => pipe(branch, cases(isNodeType("ConditionalExpression"), checkConditionalExpression(propertyChecker), pipeLazy(extractObjectExpression, cases(isObject, checkObjectExpression(propertyChecker), always(false)))));
+/**
+* Extracts the first argument if it's an ObjectExpression.
+*/
+const extractFirstObjectExpression = (node) => pipe(node, prop("arguments"), head, unless(isNodeType("ObjectExpression"), always(null)));
+/**
+* Extracts ObjectExpression from NewExpression.
+*/
+const extractObjectExpression = cases(isNodeType("NewExpression"), extractFirstObjectExpression, 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) => pipe(node, prop("argument"), cases(isObject, checkBranchWith(propertyChecker), 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 pipe(node, extractFirstObjectExpression, when(isObject, checkObjectExpression(propertyChecker)), Boolean);
+			default: return false;
+		}
+	};
+};
+const checkAllReturnPaths = (propertyChecker) => (node) => pipe(node, collectReturnPaths, cases(isEmpty, always(false), every(checkReturnStatement(propertyChecker))));
+/**
+* Collects all return statements from a node, traversing control flow.
+* This handles if/else branches, loops, etc.
+*/
+const collectReturnPaths = (node) => pipe(node, flatten, 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$1) {
+			return federationVariables.has(name$1);
+		},
+		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 propertyChecker = createPropertyChecker(Boolean)(config.path);
+		const propertySearcher = createPropertySearcher(propertyChecker);
+		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) }
+		})
+	};
+}
+
+//#endregion
+//#region src/rules/actor-assertion-method-required.ts
+const deno$19 = createRequiredRuleDeno(properties.assertionMethod);
+const eslint = createRequiredRuleEslint(properties.assertionMethod);
+
+//#endregion
+//#region src/lib/mismatch.ts
+const isIdentifierWithName = (name$1) => (node) => allOf(isNodeType("Identifier"), isNodeName(name$1))(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 isEmpty(node.arguments);
+	return allOf(negate(isEmpty), 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
+				};
+				const existenceChecker = createPropertyChecker(Boolean)(config.path);
+				const hasProperty = createPropertySearcher(existenceChecker)(dispatcherArg.body);
+				if (!hasProperty) return;
+				const propertyChecker = createPropertyChecker(isExpectedMethodCall(methodCallContext))(config.path);
+				const propertySearcher = createPropertySearcher(propertyChecker);
+				if (!propertySearcher(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) }
+	}))
+});
+
+//#endregion
+//#region src/rules/actor-featured-property-mismatch.ts
+const deno$18 = createMismatchRuleDeno(properties.featured);
+const eslint$1 = createMismatchRuleEslint(properties.featured);
+
+//#endregion
+//#region src/rules/actor-featured-property-required.ts
+const deno$17 = createRequiredRuleDeno(properties.featured);
+const eslint$2 = createRequiredRuleEslint(properties.featured);
+
+//#endregion
+//#region src/rules/actor-featured-tags-property-mismatch.ts
+const deno$16 = createMismatchRuleDeno(properties.featuredTags);
+const eslint$3 = createMismatchRuleEslint(properties.featuredTags);
+
+//#endregion
+//#region src/rules/actor-featured-tags-property-required.ts
+const deno$15 = createRequiredRuleDeno(properties.featuredTags);
+const eslint$4 = createRequiredRuleEslint(properties.featuredTags);
+
+//#endregion
+//#region src/rules/actor-followers-property-mismatch.ts
+const deno$14 = createMismatchRuleDeno(properties.followers);
+const eslint$5 = createMismatchRuleEslint(properties.followers);
+
+//#endregion
+//#region src/rules/actor-followers-property-required.ts
+const deno$13 = createRequiredRuleDeno(properties.followers);
+const eslint$6 = createRequiredRuleEslint(properties.followers);
+
+//#endregion
+//#region src/rules/actor-following-property-mismatch.ts
+const deno$12 = createMismatchRuleDeno(properties.following);
+const eslint$7 = createMismatchRuleEslint(properties.following);
+
+//#endregion
+//#region src/rules/actor-following-property-required.ts
+const deno$11 = createRequiredRuleDeno(properties.following);
+const eslint$8 = createRequiredRuleEslint(properties.following);
+
+//#endregion
+//#region src/rules/actor-id-mismatch.ts
+const deno$10 = createMismatchRuleDeno(properties.id);
+const eslint$9 = createMismatchRuleEslint(properties.id);
+
+//#endregion
+//#region src/rules/actor-id-required.ts
+const deno$9 = createRequiredRuleDeno(properties.id);
+const eslint$10 = createRequiredRuleEslint(properties.id);
+
+//#endregion
+//#region src/rules/actor-inbox-property-mismatch.ts
+const deno$8 = createMismatchRuleDeno(properties.inbox);
+const eslint$11 = createMismatchRuleEslint(properties.inbox);
+
+//#endregion
+//#region src/rules/actor-inbox-property-required.ts
+const deno$7 = createRequiredRuleDeno(properties.inbox);
+const eslint$12 = createRequiredRuleEslint(properties.inbox);
+
+//#endregion
+//#region src/rules/actor-liked-property-mismatch.ts
+const deno$6 = createMismatchRuleDeno(properties.liked);
+const eslint$13 = createMismatchRuleEslint(properties.liked);
+
+//#endregion
+//#region src/rules/actor-liked-property-required.ts
+const deno$5 = createRequiredRuleDeno(properties.liked);
+const eslint$14 = createRequiredRuleEslint(properties.liked);
+
+//#endregion
+//#region src/rules/actor-outbox-property-mismatch.ts
+const deno$4 = createMismatchRuleDeno(properties.outbox);
+const eslint$15 = createMismatchRuleEslint(properties.outbox);
+
+//#endregion
+//#region src/rules/actor-outbox-property-required.ts
+const deno$3 = createRequiredRuleDeno(properties.outbox);
+const eslint$16 = createRequiredRuleEslint(properties.outbox);
+
+//#endregion
+//#region src/rules/actor-public-key-required.ts
+const deno$2 = createRequiredRuleDeno(properties.publicKey);
+const eslint$17 = createRequiredRuleEslint(properties.publicKey);
+
+//#endregion
+//#region src/rules/actor-shared-inbox-property-mismatch.ts
+const deno$1 = createMismatchRuleDeno(properties.sharedInbox);
+const eslint$18 = createMismatchRuleEslint(properties.sharedInbox);
+
+//#endregion
+//#region src/rules/actor-shared-inbox-property-required.ts
+const deno = createRequiredRuleDeno(properties.sharedInbox);
+const eslint$19 = 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$20 = {
+	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/index.ts
+const rules = {
+	[RULE_IDS.actorIdMismatch]: eslint$9,
+	[RULE_IDS.actorIdRequired]: eslint$10,
+	[RULE_IDS.actorFollowingPropertyRequired]: eslint$8,
+	[RULE_IDS.actorFollowingPropertyMismatch]: eslint$7,
+	[RULE_IDS.actorFollowersPropertyRequired]: eslint$6,
+	[RULE_IDS.actorFollowersPropertyMismatch]: eslint$5,
+	[RULE_IDS.actorOutboxPropertyRequired]: eslint$16,
+	[RULE_IDS.actorOutboxPropertyMismatch]: eslint$15,
+	[RULE_IDS.actorLikedPropertyRequired]: eslint$14,
+	[RULE_IDS.actorLikedPropertyMismatch]: eslint$13,
+	[RULE_IDS.actorFeaturedPropertyRequired]: eslint$2,
+	[RULE_IDS.actorFeaturedPropertyMismatch]: eslint$1,
+	[RULE_IDS.actorFeaturedTagsPropertyRequired]: eslint$4,
+	[RULE_IDS.actorFeaturedTagsPropertyMismatch]: eslint$3,
+	[RULE_IDS.actorInboxPropertyRequired]: eslint$12,
+	[RULE_IDS.actorInboxPropertyMismatch]: eslint$11,
+	[RULE_IDS.actorSharedInboxPropertyRequired]: eslint$19,
+	[RULE_IDS.actorSharedInboxPropertyMismatch]: eslint$18,
+	[RULE_IDS.actorPublicKeyRequired]: eslint$17,
+	[RULE_IDS.actorAssertionMethodRequired]: eslint,
+	[RULE_IDS.collectionFilteringNotImplemented]: eslint$20
+};
+const recommendedRuleIds = [RULE_IDS.actorIdMismatch, RULE_IDS.actorIdRequired];
+/**
+* Recommended configuration - enables all rules as warnings
+*/
+const recommendedRules = pipe(rules, keys, map((key) => [`@fedify/lint/${key}`, recommendedRuleIds.includes(key) ? "error" : "warn"]), fromEntries);
+/**
+* Strict configuration - enables all rules as errors
+*/
+const strictRules = pipe(rules, keys, map((key) => [`${deno_default.name}/${key}`, "error"]), fromEntries);
+const plugin = {
+	meta: {
+		name: deno_default.name,
+		version: deno_default.version
+	},
+	rules,
+	configs: {
+		recommended: {
+			plugins: [deno_default.name],
+			rules: recommendedRules
+		},
+		strict: {
+			plugins: [deno_default.name],
+			rules: strictRules
+		}
+	}
+};
+const recommendedConfig = {
+	files: ["federation", "federation/*"].map((filename) => [
+		filename + ".ts",
+		filename + ".tsx",
+		filename + ".js",
+		filename + ".jsx",
+		filename + ".mjs",
+		filename + ".cjs"
+	]).flat(),
+	languageOptions: { parser },
+	plugins: { [deno_default.name]: plugin },
+	rules: recommendedRules
+};
+var src_default = recommendedConfig;
+
+//#endregion
+export { src_default as default, plugin };