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

package/dist/outbox-listener-delivery-required-DnljPdzy.cjs

@@ -1,1407 +0,0 @@
-require("./index.cjs");
-let _fxts_core = require("@fxts/core");
-//#region deno.json
-var name = "@fedify/lint";
-var version = "2.4.0-pr.936.41+59c7432c";
-//#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"
-		}
-	},
-	uploadMedia: {
-		name: "uploadMedia",
-		path: ["endpoints", "uploadMedia"],
-		getter: "getMediaUploaderUri",
-		setter: "setMediaUploader",
-		requiresIdentifier: true,
-		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",
-	actorUploadMediaPropertyRequired: "actor-upload-media-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",
-	actorUploadMediaPropertyMismatch: "actor-upload-media-property-mismatch",
-	collectionFilteringNotImplemented: "collection-filtering-not-implemented",
-	outboxListenerDeliveryRequired: "outbox-listener-delivery-required",
-	mediaUploaderObjectUriRequired: "media-uploader-object-uri-required",
-	mediaUploaderAuthorizationRequired: "media-uploader-authorization-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$25 = 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$24 = createMismatchRuleEslint(properties.featured);
-createRequiredRuleDeno(properties.featured);
-const eslint$23 = createRequiredRuleEslint(properties.featured);
-createMismatchRuleDeno(properties.featuredTags);
-const eslint$22 = createMismatchRuleEslint(properties.featuredTags);
-createRequiredRuleDeno(properties.featuredTags);
-const eslint$21 = createRequiredRuleEslint(properties.featuredTags);
-createMismatchRuleDeno(properties.followers);
-const eslint$20 = createMismatchRuleEslint(properties.followers);
-createRequiredRuleDeno(properties.followers);
-const eslint$19 = createRequiredRuleEslint(properties.followers);
-createMismatchRuleDeno(properties.following);
-const eslint$18 = createMismatchRuleEslint(properties.following);
-createRequiredRuleDeno(properties.following);
-const eslint$17 = createRequiredRuleEslint(properties.following);
-createMismatchRuleDeno(properties.id);
-const eslint$16 = createMismatchRuleEslint(properties.id);
-createRequiredRuleDeno(properties.id);
-const eslint$15 = createRequiredRuleEslint(properties.id);
-createMismatchRuleDeno(properties.inbox);
-const eslint$14 = createMismatchRuleEslint(properties.inbox);
-createRequiredRuleDeno(properties.inbox);
-const eslint$13 = createRequiredRuleEslint(properties.inbox);
-createMismatchRuleDeno(properties.liked);
-const eslint$12 = createMismatchRuleEslint(properties.liked);
-createRequiredRuleDeno(properties.liked);
-const eslint$11 = createRequiredRuleEslint(properties.liked);
-createMismatchRuleDeno(properties.outbox);
-const eslint$10 = createMismatchRuleEslint(properties.outbox);
-createRequiredRuleDeno(properties.outbox);
-const eslint$9 = createRequiredRuleEslint(properties.outbox);
-createRequiredRuleDeno(properties.publicKey);
-const eslint$8 = createRequiredRuleEslint(properties.publicKey);
-createMismatchRuleDeno(properties.sharedInbox);
-const eslint$7 = createMismatchRuleEslint(properties.sharedInbox);
-createRequiredRuleDeno(properties.sharedInbox);
-const eslint$6 = createRequiredRuleEslint(properties.sharedInbox);
-createMismatchRuleDeno(properties.uploadMedia);
-const eslint$5 = createMismatchRuleEslint(properties.uploadMedia);
-createRequiredRuleDeno(properties.uploadMedia);
-const eslint$4 = createRequiredRuleEslint(properties.uploadMedia);
-//#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$3 = {
-	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/media-uploader-authorization-required.ts
-const MESSAGE$2 = "setMediaUploader() should be protected with .authorize(); without it the endpoint accepts uploads from anyone who can reach the URL.  Add .authorize() unless a public upload endpoint is intended.";
-function getParent(node) {
-	if (node == null || typeof node !== "object") return null;
-	const parent = node.parent;
-	return isNode(parent) ? parent : null;
-}
-/**
-* Whether the given `setMediaUploader(...)` call is directly chained with
-* `.authorize(...)`, i.e. `federation.setMediaUploader(...).authorize(...)`.
-*/
-function isDirectlyAuthorized(callNode) {
-	const member = getParent(callNode);
-	if (member == null || member.type !== "MemberExpression" || member.computed === true) return false;
-	const property = member.property;
-	if (!isNode(property) || property.type !== "Identifier" || property.name !== "authorize") return false;
-	const call = getParent(member);
-	return call != null && call.type === "CallExpression" && call.callee === member;
-}
-function createRule$2(buildReport) {
-	return (context) => {
-		const federationTracker = trackFederationVariables();
-		const unchained = [];
-		const authorizedVars = /* @__PURE__ */ new Set();
-		return {
-			VariableDeclarator: federationTracker.VariableDeclarator,
-			CallExpression(node) {
-				if (hasMemberExpressionCallee(node) && hasIdentifierProperty(node) && hasMethodName("authorize")(node)) {
-					const object = node.callee.object;
-					if (isNode(object) && object.type === "Identifier") authorizedVars.add(object.name);
-					return;
-				}
-				if (!hasMemberExpressionCallee(node) || !hasIdentifierProperty(node) || !hasMethodName("setMediaUploader")(node) || !federationTracker.isFederationObject(node.callee.object)) return;
-				if (isDirectlyAuthorized(node)) return;
-				const parent = getParent(node);
-				let varName = null;
-				if (parent != null && parent.type === "VariableDeclarator") {
-					const id = parent.id;
-					if (isNode(id) && id.type === "Identifier") varName = id.name;
-				}
-				unchained.push({
-					node,
-					varName
-				});
-			},
-			"Program:exit"() {
-				for (const { node, varName } of unchained) {
-					if (varName != null && authorizedVars.has(varName)) continue;
-					context.report({
-						node,
-						...buildReport
-					});
-				}
-			}
-		};
-	};
-}
-const eslint$2 = {
-	meta: {
-		type: "suggestion",
-		docs: { description: "Warn when setMediaUploader() is registered without an authorize() hook" },
-		schema: [],
-		messages: { required: "{{ message }}" }
-	},
-	create: createRule$2({
-		messageId: "required",
-		data: { message: MESSAGE$2 }
-	})
-};
-//#endregion
-//#region src/rules/media-uploader-object-uri-required.ts
-const MESSAGE$1 = "setMediaUploader() callbacks should return a value derived from ctx.getObjectUri(): either return ctx.getObjectUri(...) directly, or an object whose id is ctx.getObjectUri(...).";
-const GETTER_NAME = "getObjectUri";
-const getMemberPropertyName$1 = (node) => {
-	if (node.type !== "MemberExpression") return null;
-	const property = node.property;
-	if (property.type === "Identifier") return property.name;
-	if (property.type === "Literal" && typeof property.value === "string") return property.value;
-	return null;
-};
-function unwrapAssignmentPattern(node) {
-	let current = node ?? null;
-	while (current?.type === "AssignmentPattern") current = current.left;
-	return current;
-}
-/**
-* Resolves the callback argument to a function node, following simple bindings
-* when the callback is passed by reference (identifier or object member).
-*/
-const resolveCallbackReference = (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 resolveCallbackReference(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$1(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;
-};
-/**
-* Returns the identifier name of the callback's context parameter, used to
-* require that `getObjectUri()` is called as a member of the context itself
-* (`ctx.getObjectUri(...)`), not on some other object.  Returns `null` when the
-* parameter is destructured: destructuring `getObjectUri` off the context
-* (`({ getObjectUri }) => getObjectUri(...)`) loses the method's receiver and
-* throws at runtime, so that form is intentionally not recognized as valid.
-*/
-function getContextParamName(callback) {
-	const contextParam = unwrapAssignmentPattern(callback.params[0]);
-	return contextParam?.type === "Identifier" ? contextParam.name : null;
-}
-const FUNCTION_NODE_TYPES = new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression"
-]);
-/**
-* Collects `const`/`let`/`var name = init` bindings declared inside the
-* callback body (excluding nested functions), so an identifier used in a
-* returned expression can be resolved back to the expression it was assigned.
-*/
-function collectLocalBindings(node, bindings) {
-	if (node == null || typeof node !== "object") return;
-	if (Array.isArray(node)) {
-		for (const child of node) collectLocalBindings(child, bindings);
-		return;
-	}
-	const n = node;
-	if (typeof n.type !== "string") return;
-	if (FUNCTION_NODE_TYPES.has(n.type)) return;
-	if (n.type === "VariableDeclarator") {
-		const id = n.id;
-		if (id != null && isNode(id) && id.type === "Identifier" && n.init != null) {
-			if (!bindings.has(id.name)) bindings.set(id.name, n.init);
-		}
-	}
-	for (const key in n) {
-		if (key === "parent") continue;
-		collectLocalBindings(n[key], bindings);
-	}
-}
-/**
-* Collects the returned expressions of the callback: the argument of every
-* `return` statement (excluding nested functions), or, for an
-* expression-bodied arrow, the body expression itself.  A bare `return;`
-* contributes `null`.
-*/
-function collectReturnedExpressions(callback) {
-	const body = callback.body;
-	if (body != null && isNode(body) && body.type !== "BlockStatement") return [body];
-	const result = [];
-	const walk = (node) => {
-		if (node == null || typeof node !== "object") return;
-		if (Array.isArray(node)) {
-			for (const child of node) walk(child);
-			return;
-		}
-		const n = node;
-		if (typeof n.type !== "string") return;
-		if (n.type === "ReturnStatement") {
-			result.push(n.argument ?? null);
-			return;
-		}
-		if (FUNCTION_NODE_TYPES.has(n.type)) return;
-		for (const key in n) {
-			if (key === "parent") continue;
-			walk(n[key]);
-		}
-	};
-	walk(body);
-	return result;
-}
-function toNode(value) {
-	if (value == null || typeof value !== "object" || Array.isArray(value)) return null;
-	const n = value;
-	return typeof n.type === "string" ? n : null;
-}
-/** Whether the node is a `Promise.resolve(x)` call. */
-function isPromiseResolveCall(expr) {
-	if (expr.type !== "CallExpression") return false;
-	const callee = toNode(expr.callee);
-	if (callee == null || callee.type !== "MemberExpression" || getMemberPropertyName$1(callee) !== "resolve") return false;
-	const object = toNode(callee.object);
-	return object != null && object.type === "Identifier" && object.name === "Promise";
-}
-/**
-* Strips wrapper expressions that do not change the underlying value: `await`,
-* parentheses, `as`/`<T>`/`!`/`satisfies` type assertions, and
-* `Promise.resolve(...)` (a synchronous callback may wrap its result in an
-* already-resolved promise, which `MediaUploaderCallback` permits).
-*/
-function unwrapExpression(value) {
-	let current = toNode(value);
-	while (current != null) if (current.type === "AwaitExpression") current = toNode(current.argument);
-	else if (current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "ParenthesizedExpression") current = toNode(current.expression);
-	else if (isPromiseResolveCall(current)) {
-		const args = current.arguments;
-		current = Array.isArray(args) && args.length === 1 ? toNode(args[0]) : null;
-	} else return current;
-	return null;
-}
-/**
-* Whether the expression is a member call `<ctx>.getObjectUri(...)` whose
-* receiver is the callback's context parameter.  A call on any other object
-* (e.g. `helper.getObjectUri(...)`), or a bare `getObjectUri(...)` from a
-* destructured parameter (which loses the receiver and throws at runtime),
-* does not count.
-*/
-function isGetObjectUriCall(expr, ctx) {
-	if (expr.type !== "CallExpression") return false;
-	if (ctx.ctxName == null) return false;
-	const callee = toNode(expr.callee);
-	if (callee == null || callee.type !== "MemberExpression" || getMemberPropertyName$1(callee) !== GETTER_NAME) return false;
-	const object = unwrapExpression(callee.object);
-	return object != null && object.type === "Identifier" && object.name === ctx.ctxName;
-}
-function isUrlConstructor(expr) {
-	const callee = toNode(expr.callee);
-	return callee != null && callee.type === "Identifier" && callee.name === "URL";
-}
-/** Finds the first `ObjectExpression` argument of a `NewExpression`. */
-function extractObjectArg(newExpr) {
-	const args = newExpr.arguments;
-	if (!Array.isArray(args)) return null;
-	for (const arg of args) {
-		const a = toNode(arg);
-		if (a != null && a.type === "ObjectExpression") return a;
-	}
-	return null;
-}
-/**
-* Whether a URL-valued expression is derived from `getObjectUri()`: a direct
-* call, an identifier whose local binding resolves to one
-* (`const uri = ctx.getObjectUri(...); return uri`), both branches of a
-* ternary, or `new URL(<derived>)`.
-*/
-function urlDerivesFromGetObjectUri(value, ctx, seen) {
-	const expr = unwrapExpression(value);
-	if (expr == null) return false;
-	if (isGetObjectUriCall(expr, ctx)) return true;
-	if (expr.type === "Identifier") {
-		const name = expr.name;
-		if (typeof name === "string" && ctx.bindings.has(name) && !seen.has(name)) return urlDerivesFromGetObjectUri(ctx.bindings.get(name), ctx, new Set(seen).add(name));
-		return false;
-	}
-	if (expr.type === "ConditionalExpression") return urlDerivesFromGetObjectUri(expr.consequent, ctx, seen) && urlDerivesFromGetObjectUri(expr.alternate, ctx, seen);
-	if (expr.type === "NewExpression" && isUrlConstructor(expr)) {
-		const args = expr.arguments;
-		return Array.isArray(args) && args.length > 0 && urlDerivesFromGetObjectUri(args[0], ctx, seen);
-	}
-	return false;
-}
-const SPREAD_TYPES = new Set([
-	"SpreadElement",
-	"SpreadProperty",
-	"ExperimentalSpreadProperty"
-]);
-/**
-* Whether an object literal's *effective* own `id` is derived from
-* `getObjectUri`.  Properties are evaluated in order so a later duplicate `id`
-* wins, and a spread or computed key appearing after the last static `id`
-* (which could override it) is treated as unsafe.  An object with no static
-* `id` property (its `id` might come from an unresolved spread) is also
-* unsafe.
-*/
-function objectIdDerivesFromGetObjectUri(objExpr, ctx, seen) {
-	const props = objExpr.properties;
-	if (!Array.isArray(props)) return false;
-	let idValue;
-	let idIsSet = false;
-	let overridableAfterId = false;
-	for (const prop of props) {
-		const p = toNode(prop);
-		if (p == null) return false;
-		if (SPREAD_TYPES.has(p.type) || p.type === "Property" && p.computed === true) {
-			if (idIsSet) overridableAfterId = true;
-			continue;
-		}
-		if (p.type !== "Property") continue;
-		const key = toNode(p.key);
-		if ((key == null ? null : key.type === "Identifier" && typeof key.name === "string" ? key.name : key.type === "Literal" && typeof key.value === "string" ? key.value : null) !== "id") continue;
-		idValue = p.value;
-		idIsSet = true;
-		overridableAfterId = false;
-	}
-	if (!idIsSet || overridableAfterId) return false;
-	return urlDerivesFromGetObjectUri(idValue, ctx, seen);
-}
-/**
-* Whether a single returned expression is valid: a URL derived from
-* `getObjectUri()`, or a vocab object (a `new X({...})` expression) whose own
-* `id` is derived from it.  The object is judged solely by its `id`, so
-* `getObjectUri()` appearing in another property (e.g. `url`) does not excuse a
-* hard-coded `id`.  A plain object literal is rejected: the handler calls
-* `toJsonLd()` on the result, so a bare `{ ... }` (which lacks it) is not a
-* valid return.
-*/
-function returnDerivesFromGetObjectUri(value, ctx, seen) {
-	const expr = unwrapExpression(value);
-	if (expr == null) return false;
-	if (expr.type === "Identifier") {
-		const name = expr.name;
-		if (typeof name === "string" && ctx.bindings.has(name) && !seen.has(name)) return returnDerivesFromGetObjectUri(ctx.bindings.get(name), ctx, new Set(seen).add(name));
-		return false;
-	}
-	if (expr.type === "ConditionalExpression") return returnDerivesFromGetObjectUri(expr.consequent, ctx, seen) && returnDerivesFromGetObjectUri(expr.alternate, ctx, seen);
-	if (expr.type === "NewExpression") {
-		if (isUrlConstructor(expr)) return urlDerivesFromGetObjectUri(expr, ctx, seen);
-		const objArg = extractObjectArg(expr);
-		if (objArg == null) return false;
-		return objectIdDerivesFromGetObjectUri(objArg, ctx, seen);
-	}
-	return urlDerivesFromGetObjectUri(expr, ctx, seen);
-}
-/**
-* Determines whether every returned value of the callback is derived from
-* `getObjectUri`.  Returns `false` when the callback has no return value or any
-* returned value is not derived from `getObjectUri`.
-*/
-function callbackDerivesFromGetObjectUri(callback) {
-	const returnedExpressions = collectReturnedExpressions(callback);
-	if (returnedExpressions.length < 1) return false;
-	const bindings = /* @__PURE__ */ new Map();
-	collectLocalBindings(callback.body, bindings);
-	const ctx = {
-		ctxName: getContextParamName(callback),
-		bindings
-	};
-	return returnedExpressions.every((expr) => returnDerivesFromGetObjectUri(expr, ctx, /* @__PURE__ */ new Set()));
-}
-function createRule$1(buildReport) {
-	return (context) => {
-		const federationTracker = trackFederationVariables();
-		const bindings = /* @__PURE__ */ new Map();
-		const pendingCalls = [];
-		const inspectCall = (node) => {
-			if (!hasMemberExpressionCallee(node) || !hasIdentifierProperty(node) || !hasMethodName("setMediaUploader")(node) || node.arguments.length < 2) return;
-			if (!federationTracker.isFederationObject(node.callee.object)) return;
-			const callbackArg = node.arguments[1];
-			const callback = isNode(callbackArg) && isFunction(callbackArg) ? callbackArg : isNode(callbackArg) ? resolveCallbackReference(callbackArg, bindings) : null;
-			if (callback == null) return;
-			if (callbackDerivesFromGetObjectUri(callback)) return;
-			context.report({
-				node: callback,
-				...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$1 = {
-	meta: {
-		type: "suggestion",
-		docs: { description: "Warn when a setMediaUploader() callback does not derive its return value from ctx.getObjectUri()" },
-		schema: [],
-		messages: { required: "{{ message }}" }
-	},
-	create: createRule$1({
-		messageId: "required",
-		data: { message: MESSAGE$1 }
-	})
-};
-//#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
-Object.defineProperty(exports, "RULE_IDS", {
-	enumerable: true,
-	get: function() {
-		return RULE_IDS;
-	}
-});
-Object.defineProperty(exports, "eslint", {
-	enumerable: true,
-	get: function() {
-		return eslint;
-	}
-});
-Object.defineProperty(exports, "eslint$1", {
-	enumerable: true,
-	get: function() {
-		return eslint$1;
-	}
-});
-Object.defineProperty(exports, "eslint$10", {
-	enumerable: true,
-	get: function() {
-		return eslint$10;
-	}
-});
-Object.defineProperty(exports, "eslint$11", {
-	enumerable: true,
-	get: function() {
-		return eslint$11;
-	}
-});
-Object.defineProperty(exports, "eslint$12", {
-	enumerable: true,
-	get: function() {
-		return eslint$12;
-	}
-});
-Object.defineProperty(exports, "eslint$13", {
-	enumerable: true,
-	get: function() {
-		return eslint$13;
-	}
-});
-Object.defineProperty(exports, "eslint$14", {
-	enumerable: true,
-	get: function() {
-		return eslint$14;
-	}
-});
-Object.defineProperty(exports, "eslint$15", {
-	enumerable: true,
-	get: function() {
-		return eslint$15;
-	}
-});
-Object.defineProperty(exports, "eslint$16", {
-	enumerable: true,
-	get: function() {
-		return eslint$16;
-	}
-});
-Object.defineProperty(exports, "eslint$17", {
-	enumerable: true,
-	get: function() {
-		return eslint$17;
-	}
-});
-Object.defineProperty(exports, "eslint$18", {
-	enumerable: true,
-	get: function() {
-		return eslint$18;
-	}
-});
-Object.defineProperty(exports, "eslint$19", {
-	enumerable: true,
-	get: function() {
-		return eslint$19;
-	}
-});
-Object.defineProperty(exports, "eslint$2", {
-	enumerable: true,
-	get: function() {
-		return eslint$2;
-	}
-});
-Object.defineProperty(exports, "eslint$20", {
-	enumerable: true,
-	get: function() {
-		return eslint$20;
-	}
-});
-Object.defineProperty(exports, "eslint$21", {
-	enumerable: true,
-	get: function() {
-		return eslint$21;
-	}
-});
-Object.defineProperty(exports, "eslint$22", {
-	enumerable: true,
-	get: function() {
-		return eslint$22;
-	}
-});
-Object.defineProperty(exports, "eslint$23", {
-	enumerable: true,
-	get: function() {
-		return eslint$23;
-	}
-});
-Object.defineProperty(exports, "eslint$24", {
-	enumerable: true,
-	get: function() {
-		return eslint$24;
-	}
-});
-Object.defineProperty(exports, "eslint$25", {
-	enumerable: true,
-	get: function() {
-		return eslint$25;
-	}
-});
-Object.defineProperty(exports, "eslint$3", {
-	enumerable: true,
-	get: function() {
-		return eslint$3;
-	}
-});
-Object.defineProperty(exports, "eslint$4", {
-	enumerable: true,
-	get: function() {
-		return eslint$4;
-	}
-});
-Object.defineProperty(exports, "eslint$5", {
-	enumerable: true,
-	get: function() {
-		return eslint$5;
-	}
-});
-Object.defineProperty(exports, "eslint$6", {
-	enumerable: true,
-	get: function() {
-		return eslint$6;
-	}
-});
-Object.defineProperty(exports, "eslint$7", {
-	enumerable: true,
-	get: function() {
-		return eslint$7;
-	}
-});
-Object.defineProperty(exports, "eslint$8", {
-	enumerable: true,
-	get: function() {
-		return eslint$8;
-	}
-});
-Object.defineProperty(exports, "eslint$9", {
-	enumerable: true,
-	get: function() {
-		return eslint$9;
-	}
-});
-Object.defineProperty(exports, "name", {
-	enumerable: true,
-	get: function() {
-		return name;
-	}
-});
-Object.defineProperty(exports, "version", {
-	enumerable: true,
-	get: function() {
-		return version;
-	}
-});