@fedify/lint 2.4.0-pr.934.40 → 2.4.0

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

@@ -0,0 +1,2706 @@
+let _fxts_core = require("@fxts/core");
+//#region deno.json
+var name = "@fedify/lint";
+var version = "2.4.0";
+//#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",
+		portableGetter: "getPortableActorUri",
+		setter: "setActorDispatcher",
+		requiresIdentifier: true
+	},
+	following: {
+		name: "following",
+		path: ["following"],
+		getter: "getFollowingUri",
+		portableGetter: "getPortableFollowingUri",
+		setter: "setFollowingDispatcher",
+		requiresIdentifier: true
+	},
+	followers: {
+		name: "followers",
+		path: ["followers"],
+		getter: "getFollowersUri",
+		portableGetter: "getPortableFollowersUri",
+		setter: "setFollowersDispatcher",
+		requiresIdentifier: true
+	},
+	outbox: {
+		name: "outbox",
+		path: ["outbox"],
+		getter: "getOutboxUri",
+		portableGetter: "getPortableOutboxUri",
+		setter: "setOutboxDispatcher",
+		requiresIdentifier: true
+	},
+	inbox: {
+		name: "inbox",
+		path: ["inbox"],
+		getter: "getInboxUri",
+		portableGetter: "getPortableInboxUri",
+		setter: "setInboxListeners",
+		requiresIdentifier: true
+	},
+	liked: {
+		name: "liked",
+		path: ["liked"],
+		getter: "getLikedUri",
+		portableGetter: "getPortableLikedUri",
+		setter: "setLikedDispatcher",
+		requiresIdentifier: true
+	},
+	featured: {
+		name: "featured",
+		path: ["featured"],
+		getter: "getFeaturedUri",
+		portableGetter: "getPortableFeaturedUri",
+		setter: "setFeaturedDispatcher",
+		requiresIdentifier: true
+	},
+	featuredTags: {
+		name: "featuredTags",
+		path: ["featuredTags"],
+		getter: "getFeaturedTagsUri",
+		portableGetter: "getPortableFeaturedTagsUri",
+		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
+	},
+	preferredUsername: {
+		name: "preferredUsername",
+		path: ["preferredUsername"],
+		setter: "setActorDispatcher",
+		requiresIdentifier: false,
+		pluralName: "preferredUsernames"
+	}
+};
+/**
+* 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",
+	actorPreferredUsernameRequired: "actor-preferred-username-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",
+	outboxListenerDeliveryNotAwaited: "outbox-listener-delivery-not-awaited",
+	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 }) => {
+	const propertyPath = path.join(".");
+	return `When \`${setter}\` is configured, the \`${propertyPath}\` property is recommended. ${getter == null ? `Set the \`${propertyPath}\` property directly on the actor object.` : `Use \`${getExpectedCall({
+		ctxName: "Context",
+		methodName: getter,
+		idName: "identifier",
+		path: path.join("."),
+		requiresIdentifier
+	})}\` for the \`${propertyPath}\` 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 unwrapTypeScriptExpression = (node) => {
+	switch (node.type) {
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+		case "TSTypeAssertion": return unwrapTypeScriptExpression(node.expression);
+		default: return node;
+	}
+};
+const isNullLiteral = (node) => node.type === "Literal" && node.value === null;
+const isTombstoneExpression = (node) => node.type === "NewExpression" && node.callee.type === "Identifier" && node.callee.name === "Tombstone";
+const checkBranchWith = (propertyChecker) => (branch) => {
+	const expression = unwrapTypeScriptExpression(branch);
+	if (isNullLiteral(expression) || isTombstoneExpression(expression)) return true;
+	return (0, _fxts_core.pipe)(expression, 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":
+				if (isTombstoneExpression(node)) return true;
+				return (0, _fxts_core.pipe)(node, extractFirstObjectExpression, (0, _fxts_core.when)(_fxts_core.isObject, checkObjectExpression(propertyChecker)), Boolean);
+			default: return checkBranchWith(propertyChecker)(node);
+		}
+	};
+};
+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 propertyChecker = createPropertyChecker(Boolean)(config.path);
+		const pluralPropertyChecker = config.pluralName == null ? null : createPropertyChecker(Boolean)([...config.path.slice(0, -1), config.pluralName]);
+		const propertySearcher = createPropertySearcher(pluralPropertyChecker == null ? propertyChecker : (node) => propertyChecker(node) || pluralPropertyChecker(node));
+		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$27 = 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 }, identifierFirst = false) => (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);
+	if (identifierFirst) return node.arguments.length > 0 && isIdentifierWithName(idName)(node.arguments[0]);
+	return allOf((0, _fxts_core.negate)(_fxts_core.isEmpty), (0, _fxts_core.some)(isIdentifierWithName(idName)))(node.arguments);
+};
+/** Accepts an inline compatible ID built from the matching portable URI. */
+const isCompatiblePortableMethodCall = (context, portableGetter) => (node) => isNodeType("CallExpression")(node) && isIdentifierWithName("toCompatibleEf61Id")(node.callee) && node.arguments.length > 0 && isExpectedMethodCall({
+	...context,
+	methodName: portableGetter
+}, true)(node.arguments[0]);
+/**
+* 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((value) => isExpectedMethodCall(methodCallContext)(value) || config.portableGetter != null && (isExpectedMethodCall({
+					...methodCallContext,
+					methodName: config.portableGetter
+				}, true)(value) || isCompatiblePortableMethodCall(methodCallContext, config.portableGetter)(value)))(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$26 = createMismatchRuleEslint(properties.featured);
+createRequiredRuleDeno(properties.featured);
+const eslint$25 = createRequiredRuleEslint(properties.featured);
+createMismatchRuleDeno(properties.featuredTags);
+const eslint$24 = createMismatchRuleEslint(properties.featuredTags);
+createRequiredRuleDeno(properties.featuredTags);
+const eslint$23 = createRequiredRuleEslint(properties.featuredTags);
+createMismatchRuleDeno(properties.followers);
+const eslint$22 = createMismatchRuleEslint(properties.followers);
+createRequiredRuleDeno(properties.followers);
+const eslint$21 = createRequiredRuleEslint(properties.followers);
+createMismatchRuleDeno(properties.following);
+const eslint$20 = createMismatchRuleEslint(properties.following);
+createRequiredRuleDeno(properties.following);
+const eslint$19 = createRequiredRuleEslint(properties.following);
+createMismatchRuleDeno(properties.id);
+const eslint$18 = createMismatchRuleEslint(properties.id);
+createRequiredRuleDeno(properties.id);
+const eslint$17 = createRequiredRuleEslint(properties.id);
+createMismatchRuleDeno(properties.inbox);
+const eslint$16 = createMismatchRuleEslint(properties.inbox);
+createRequiredRuleDeno(properties.inbox);
+const eslint$15 = createRequiredRuleEslint(properties.inbox);
+createMismatchRuleDeno(properties.liked);
+const eslint$14 = createMismatchRuleEslint(properties.liked);
+createRequiredRuleDeno(properties.liked);
+const eslint$13 = createRequiredRuleEslint(properties.liked);
+createMismatchRuleDeno(properties.outbox);
+const eslint$12 = createMismatchRuleEslint(properties.outbox);
+createRequiredRuleDeno(properties.outbox);
+const eslint$11 = createRequiredRuleEslint(properties.outbox);
+createRequiredRuleDeno(properties.preferredUsername);
+const eslint$10 = createRequiredRuleEslint(properties.preferredUsername);
+createRequiredRuleDeno(properties.publicKey);
+const eslint$9 = createRequiredRuleEslint(properties.publicKey);
+createMismatchRuleDeno(properties.sharedInbox);
+const eslint$8 = createMismatchRuleEslint(properties.sharedInbox);
+createRequiredRuleDeno(properties.sharedInbox);
+const eslint$7 = createRequiredRuleEslint(properties.sharedInbox);
+createMismatchRuleDeno(properties.uploadMedia);
+const eslint$6 = createMismatchRuleEslint(properties.uploadMedia);
+createRequiredRuleDeno(properties.uploadMedia);
+const eslint$5 = 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$4 = {
+	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$3 = "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$1(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$1(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$1(member);
+	return call != null && call.type === "CallExpression" && call.callee === member;
+}
+function createRule$3(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$1(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$3 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Warn when setMediaUploader() is registered without an authorize() hook" },
+		schema: [],
+		messages: { required: "{{ message }}" }
+	},
+	create: createRule$3({
+		messageId: "required",
+		data: { message: MESSAGE$3 }
+	})
+};
+//#endregion
+//#region src/rules/media-uploader-object-uri-required.ts
+const MESSAGE$2 = "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$2 = (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$2(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$1 = /* @__PURE__ */ 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$1.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$1.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$2(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$2(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 = /* @__PURE__ */ 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$2(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$2 = {
+	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$2({
+		messageId: "required",
+		data: { message: MESSAGE$2 }
+	})
+};
+//#endregion
+//#region src/lib/outbox-listener.ts
+const DELIVERY_METHOD_NAMES$1 = /* @__PURE__ */ new Set(["sendActivity", "forwardActivity"]);
+const isChainedFromOutboxListeners$1 = (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$1(expr.callee.object, federationTracker);
+	return false;
+};
+const getMemberPropertyName$1 = (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$1(node) {
+	let current = node ?? null;
+	while (current?.type === "AssignmentPattern") current = current.left;
+	return current;
+}
+/**
+* Resolves an expression to the function it refers to: a direct function
+* literal, a local variable bound to one, or a property of a local object
+* literal bound to one (e.g. `handlers.deliver` where
+* `const handlers = { deliver() {} }`). Used to resolve a listener argument
+* (`.on(Activity, handler)`).
+*/
+const resolveFunctionBinding = (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 resolveFunctionBinding(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;
+};
+/**
+* Builds the visitor an outbox-listener rule registers: it follows
+* `federation.setOutboxListeners(...).on(Type, listener)` chains through the
+* file and, once the whole file has been seen, hands each listener, resolved
+* to its function, to `onListener`. The listener may be an inline function or
+* a name bound to one elsewhere in the file.
+*/
+function createOutboxListenerVisitor(onListener) {
+	const federationTracker = trackFederationVariables();
+	const bindings = /* @__PURE__ */ new Map();
+	const pendingCalls = [];
+	const inspectCall = (node) => {
+		if (!hasMemberExpressionCallee(node) || !hasIdentifierProperty(node) || !hasMethodName("on")(node) || node.arguments.length < 2) return;
+		if (!isChainedFromOutboxListeners$1(node.callee.object, federationTracker)) return;
+		const listener = node.arguments[1];
+		const resolvedListener = isNode(listener) && isFunction(listener) ? listener : isNode(listener) ? resolveFunctionBinding(listener, bindings) : null;
+		if (resolvedListener == null) return;
+		onListener(resolvedListener);
+	};
+	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);
+		}
+	};
+}
+//#endregion
+//#region src/lib/reachability.ts
+const FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+const isFunctionLikeNode = (node) => FUNCTION_NODE_TYPES.has(node.type);
+const isStaticallyFalsy = (test) => test.type === "Literal" && !test.value;
+const isStaticallyTruthy = (test) => test.type === "Literal" && Boolean(test.value);
+/**
+* Whether every path through this statement unconditionally returns or
+* throws, meaning anything textually after it in the same statement list
+* never runs. Deliberately conservative: when it can't prove that, it
+* answers `false`, which keeps the following code counted as reachable
+* (a missed dead-code case is safer than wrongly hiding live code).
+*/
+function alwaysExits(node) {
+	switch (node.type) {
+		case "ReturnStatement":
+		case "ThrowStatement":
+		case "BreakStatement":
+		case "ContinueStatement": return true;
+		case "BlockStatement": return node.body.some((statement) => alwaysExits(statement));
+		case "IfStatement": {
+			const test = node.test;
+			if (isStaticallyFalsy(test)) return node.alternate != null && alwaysExits(node.alternate);
+			if (isStaticallyTruthy(test)) return alwaysExits(node.consequent);
+			if (node.alternate == null) return false;
+			return alwaysExits(node.consequent) && alwaysExits(node.alternate);
+		}
+		case "TryStatement": return node.finalizer != null && alwaysExits(node.finalizer);
+		default: return false;
+	}
+}
+function collectBindingExpressions(node, out, bindings, declares = false) {
+	switch (node.type) {
+		case "VariableDeclaration":
+			for (const decl of node.declarations) {
+				const names = [];
+				collectBoundNames(decl.id, names);
+				if (node.kind === "var") for (const name of names) bindings?.declaredHere.add(name);
+				collectBindingExpressions(decl.id, out, bindings, true);
+			}
+			break;
+		case "ObjectPattern":
+			for (const prop of node.properties) if (prop.type === "Property") {
+				if (prop.computed) out.push(prop.key);
+				collectBindingExpressions(prop.value, out, bindings, declares);
+			} else if (prop.type === "RestElement") collectBindingExpressions(prop.argument, out, bindings, declares);
+			break;
+		case "ArrayPattern":
+			for (const elem of node.elements) if (elem != null) collectBindingExpressions(elem, out, bindings, declares);
+			break;
+		case "AssignmentPattern":
+			out.push(node);
+			if (declares) bindings?.declarationPatterns.add(node);
+			collectBindingExpressions(node.left, out, bindings, declares);
+			break;
+		case "RestElement":
+			collectBindingExpressions(node.argument, out, bindings, declares);
+			break;
+		case "MemberExpression": {
+			const object = node.object;
+			if (object.type !== "Identifier") out.push(object);
+			if (node.computed) out.push(node.property);
+			break;
+		}
+	}
+}
+function collectReachableStatements(node, out, bindings) {
+	switch (node.type) {
+		case "BlockStatement":
+			for (const [index, statement] of node.body.entries()) {
+				collectReachableStatements(statement, out, bindings);
+				if (alwaysExits(statement)) {
+					for (const rest of node.body.slice(index + 1)) if (rest.type === "FunctionDeclaration") out.push(rest);
+					return;
+				}
+			}
+			return;
+		case "IfStatement": {
+			const test = node.test;
+			out.push(test);
+			if (!isStaticallyFalsy(test)) collectReachableStatements(node.consequent, out, bindings);
+			if (node.alternate != null && !isStaticallyTruthy(test)) collectReachableStatements(node.alternate, out, bindings);
+			return;
+		}
+		case "TryStatement":
+			collectReachableStatements(node.block, out, bindings);
+			if (node.handler != null) collectReachableStatements(node.handler.body, out, bindings);
+			if (node.finalizer != null) collectReachableStatements(node.finalizer, out, bindings);
+			return;
+		case "SwitchStatement":
+			out.push(node.discriminant);
+			for (const switchCase of node.cases) {
+				if (switchCase.test != null) out.push(switchCase.test);
+				for (const statement of switchCase.consequent) {
+					collectReachableStatements(statement, out, bindings);
+					if (alwaysExits(statement)) break;
+				}
+			}
+			return;
+		case "WhileStatement":
+			out.push(node.test);
+			if (!isStaticallyFalsy(node.test)) collectReachableStatements(node.body, out, bindings);
+			return;
+		case "DoWhileStatement":
+			out.push(node.test);
+			collectReachableStatements(node.body, out, bindings);
+			return;
+		case "ForStatement":
+			if (node.init != null) out.push(node.init);
+			if (node.test != null) out.push(node.test);
+			if (node.test == null || !isStaticallyFalsy(node.test)) {
+				if (node.update != null) out.push(node.update);
+				collectReachableStatements(node.body, out, bindings);
+			}
+			return;
+		case "ForInStatement":
+		case "ForOfStatement":
+			collectBindingExpressions(node.left, out, bindings);
+			out.push(node.right);
+			collectReachableStatements(node.body, out, bindings);
+			return;
+		case "LabeledStatement":
+			collectReachableStatements(node.body, out, bindings);
+			return;
+		case "WithStatement":
+			out.push(node.object);
+			collectReachableStatements(node.body, out, bindings);
+			return;
+		default:
+			out.push(node);
+			return;
+	}
+}
+/**
+* Collects plain-value references to identifiers: `deliver()`,
+* `forEach(deliver)`, a shorthand `{ deliver }`, and so on. Skips positions
+* that name something rather than reference a value: a declaration's own
+* `id`/params, the non-computed `.property` of a member expression (so
+* `someService.deliver()` never counts as a reference to an unrelated local
+* `deliver`), and the target of an assignment, which writes to a name
+* instead of reading it.
+*/
+function collectReferencedNames(node, out, crossFunctions = false) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectReferencedNames(item, out, crossFunctions);
+		return;
+	}
+	if (!isNode(node)) return;
+	const n = node;
+	if (n.type === "Identifier") {
+		out.add(n.name);
+		return;
+	}
+	if (n.type === "MemberExpression" && !n.computed) {
+		collectReferencedNames(n.object, out, crossFunctions);
+		return;
+	}
+	if (n.type === "Property" && !n.computed) {
+		collectReferencedNames(n.value, out, crossFunctions);
+		return;
+	}
+	if (n.type === "VariableDeclarator") {
+		if (n.init != null) collectReferencedNames(n.init, out, crossFunctions);
+		return;
+	}
+	if (n.type === "ClassDeclaration" || n.type === "ClassExpression") {
+		collectReferencedNames(n.superClass, out, crossFunctions);
+		collectReferencedNames(n.body, out, crossFunctions);
+		return;
+	}
+	if ((n.type === "MethodDefinition" || n.type === "PropertyDefinition") && !n.computed) {
+		collectReferencedNames(n.value, out, crossFunctions);
+		return;
+	}
+	if (n.type === "AssignmentExpression" && n.operator === "=") {
+		if (getAssignmentTargetName(n.left) != null) {
+			collectReferencedNames(n.right, out, crossFunctions);
+			let current = n.left;
+			while (current.type === "MemberExpression") {
+				if (current.computed) collectReferencedNames(current.property, out, crossFunctions);
+				current = current.object;
+			}
+			return;
+		}
+	}
+	if (n.type === "AssignmentPattern") {
+		if (getAssignmentTargetName(n.left) != null) {
+			collectReferencedNames(n.right, out, crossFunctions);
+			let current = n.left;
+			while (current.type === "MemberExpression") {
+				if (current.computed) collectReferencedNames(current.property, out, crossFunctions);
+				current = current.object;
+			}
+			return;
+		}
+	}
+	if (isFunctionLikeNode(n)) {
+		if (crossFunctions) collectReferencedNames(n.body, out, crossFunctions);
+		return;
+	}
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectReferencedNames(record[key], out, crossFunctions);
+	}
+}
+/**
+* The name an assignment writes to: `x` for `x = ...`, and the root object
+* for `obj.a.b = ...`. `null` for anything more exotic.
+*/
+function getAssignmentTargetName(target) {
+	let current = target;
+	while (current.type === "MemberExpression") current = current.object;
+	return current.type === "Identifier" ? current.name : null;
+}
+/** Every identifier a declaration pattern binds (`a`, `{ a, b: c }`, `[a]`). */
+function collectBoundNames(pattern, out) {
+	if (pattern == null || typeof pattern !== "object" || !isNode(pattern)) return;
+	const p = pattern;
+	if (p.type === "TSParameterProperty") {
+		collectBoundNames(p.parameter, out);
+		return;
+	}
+	switch (p.type) {
+		case "Identifier":
+			out.push(p.name);
+			return;
+		case "AssignmentPattern":
+			collectBoundNames(p.left, out);
+			return;
+		case "RestElement":
+			collectBoundNames(p.argument, out);
+			return;
+		case "ArrayPattern":
+			for (const element of p.elements) collectBoundNames(element, out);
+			return;
+		case "ObjectPattern":
+			for (const prop of p.properties) collectBoundNames(prop.value ?? prop.argument, out);
+			return;
+	}
+}
+/**
+* Every name the function scope rooted at `root` binds or rebinds anywhere,
+* reachable or not: `fn`'s parameters and own name, any declaration (in a
+* block, a loop head, a `catch` clause, a class static block or a TypeScript
+* enum too), and any assignment or update of the name itself. Does not
+* descend into a nested function's body. Deliberately broad, since a name
+* outside this set is taken to be an enclosing scope's binding throughout
+* `root`.
+*/
+function collectScopeBoundNames(root, fn) {
+	const names = /* @__PURE__ */ new Set();
+	const add = (pattern) => {
+		const bound = [];
+		collectBoundNames(pattern, bound);
+		for (const name of bound) names.add(name);
+	};
+	const addAssigned = (target) => {
+		let current = target;
+		while (isNode(current) && TS_EXPRESSION_WRAPPERS.has(current.type)) current = current.expression;
+		add(current);
+	};
+	for (const param of fn?.params ?? []) add(param);
+	if (fn?.type === "FunctionExpression") add(fn.id);
+	const visit = (node) => {
+		if (node == null || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const item of node) visit(item);
+			return;
+		}
+		if (!isNode(node)) return;
+		const record = node;
+		switch (node.type) {
+			case "FunctionDeclaration":
+			case "TSDeclareFunction":
+				add(record.id);
+				return;
+			case "FunctionExpression":
+			case "ArrowFunctionExpression": return;
+			case "ClassDeclaration":
+			case "ClassExpression":
+			case "VariableDeclarator":
+			case "TSEnumDeclaration":
+			case "TSModuleDeclaration":
+			case "TSImportEqualsDeclaration":
+				add(record.id);
+				break;
+			case "TSEnumMember": {
+				const id = record.id;
+				if (id.type === "Identifier") names.add(id.name);
+				else if (id.type === "Literal" && typeof id.value === "string") names.add(id.value);
+				break;
+			}
+			case "CatchClause":
+				add(record.param);
+				break;
+			case "AssignmentExpression":
+				addAssigned(record.left);
+				break;
+			case "UpdateExpression":
+				addAssigned(record.argument);
+				break;
+			case "ForInStatement":
+			case "ForOfStatement":
+				addAssigned(record.left);
+				break;
+		}
+		for (const key in record) if (key !== "parent") visit(record[key]);
+	};
+	for (const param of fn?.params ?? []) visit(param);
+	visit(root);
+	return names;
+}
+const TS_EXPRESSION_WRAPPERS = /* @__PURE__ */ new Set([
+	"TSAsExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion"
+]);
+/**
+* Finds the function literals a value holds itself: the value is the
+* function, or it sits in an object or array literal, a conditional, or a
+* class body. Stops at a call, so a function handed to one as an argument,
+* or invoked by it, is not held by whatever the call's result is bound to.
+* Those count on their own wherever they appear.
+*/
+function collectHeldFunctions(node, out) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectHeldFunctions(item, out);
+		return;
+	}
+	if (!isNode(node)) return;
+	const n = node;
+	if (isFunctionLikeNode(n)) {
+		out.push(n);
+		return;
+	}
+	if (n.type === "CallExpression" || n.type === "NewExpression") return;
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectHeldFunctions(record[key], out);
+	}
+}
+/**
+* Collects the functions each name in `node`'s own scope holds: `function
+* name() {}`, `class Name {}`, and the value of `const name = ...` or a
+* later `name = ...` or `name.prop = ...`, including a function inside an
+* object or array literal (see `collectHeldFunctions`). A function held
+* under a name counts as used as soon as the name is mentioned, however it
+* is mentioned, so this never has to work out how the name reaches the
+* function. Does not descend into a found function's own body: a name bound
+* inside it is only found once that function is itself resolved as
+* reachable, so it can be layered on top of (and correctly shadow) the outer
+* scope's names. What goes into `augmentingAssignments` instead of `out`
+* extends the names' enclosing candidates rather than shadowing them: an
+* assignment-form loop default, and a property write through an object that
+* this scope inherits (a name not in `localNames`).
+*/
+function collectFunctionsByName(node, out, augmentingAssignments, declarationPatterns, declaredHere, scopeDeclarations, localNames) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectFunctionsByName(item, out, augmentingAssignments, declarationPatterns, declaredHere, scopeDeclarations, localNames);
+		return;
+	}
+	if (!isNode(node)) return;
+	const n = node;
+	const bindTo = (names, from, bindings = out) => {
+		const functions = [];
+		collectHeldFunctions(from, functions);
+		if (functions.length < 1) return;
+		for (const name of names) bindings.set(name, [...bindings.get(name) ?? [], ...functions]);
+	};
+	if (n.type === "FunctionDeclaration") {
+		if (n.id?.name != null) bindTo([n.id.name], n);
+		return;
+	}
+	if (n.type === "ClassDeclaration") {
+		if (n.id?.name != null) bindTo([n.id.name], n);
+		return;
+	}
+	if (isFunctionLikeNode(n)) return;
+	if (n.type === "StaticBlock") {
+		collectFunctionsByName(n.body, out, augmentingAssignments, declarationPatterns, /* @__PURE__ */ new Set(), scopeDeclarations, localNames);
+		return;
+	}
+	if (n.type === "VariableDeclaration") {
+		if (n.kind === "var" || scopeDeclarations.has(n)) for (const decl of n.declarations) {
+			const names = [];
+			collectBoundNames(decl.id, names);
+			for (const name of names) declaredHere.add(name);
+		}
+		for (const decl of n.declarations) collectFunctionsByName(decl, out, augmentingAssignments, declarationPatterns, declaredHere, scopeDeclarations, localNames);
+		return;
+	}
+	if (n.type === "VariableDeclarator") {
+		const decl = n;
+		const names = [];
+		collectBoundNames(decl.id, names);
+		if (decl.init != null) {
+			bindTo(names, decl.init);
+			collectFunctionsByName(decl.init, out, augmentingAssignments, declarationPatterns, declaredHere, scopeDeclarations, localNames);
+		}
+		return;
+	}
+	if (n.type === "AssignmentPattern") {
+		const names = [];
+		if (n.left.type === "MemberExpression") {
+			const name = getAssignmentTargetName(n.left);
+			if (name != null) names.push(name);
+		} else collectBoundNames(n.left, names);
+		bindTo(names, n.right, n.left.type === "MemberExpression" || !declarationPatterns.has(n) ? augmentingAssignments : out);
+		collectFunctionsByName(n.right, out, augmentingAssignments, declarationPatterns, declaredHere, scopeDeclarations, localNames);
+		return;
+	}
+	if (n.type === "AssignmentExpression") {
+		const name = getAssignmentTargetName(n.left);
+		if (name != null) bindTo([name], n.right, n.left.type === "MemberExpression" && !localNames.has(name) ? augmentingAssignments : out);
+		collectFunctionsByName(n.right, out, augmentingAssignments, declarationPatterns, declaredHere, scopeDeclarations, localNames);
+		return;
+	}
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectFunctionsByName(record[key], out, augmentingAssignments, declarationPatterns, declaredHere, scopeDeclarations, localNames);
+	}
+}
+/**
+* Finds function literals directly nested in a reachable statement, without
+* descending past them -- their own reachability is decided separately.
+*/
+function collectNestedFunctions(node, out) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectNestedFunctions(item, out);
+		return;
+	}
+	if (!isNode(node)) return;
+	const n = node;
+	if (isFunctionLikeNode(n)) {
+		out.push(n);
+		return;
+	}
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectNestedFunctions(record[key], out);
+	}
+}
+/**
+* Walks every scope that is actually reachable from `root`, calling `visit`
+* for each, and returns the set of function nodes found to be used: `root`
+* itself feeds a worklist, and each function it (or a function already on
+* the worklist) uses from *its own* reachable statements -- never from a
+* dead branch or some other not-yet-reached function's body -- gets queued in
+* turn. `outerFunctionsByName` is layered fresh for each scope, so a name
+* bound at an inner scope shadows a same-named one further out instead of
+* overwriting it globally, and a dead branch that merely mentions a name
+* never queues what it holds.
+*/
+function walkUsedScopes(root, visit) {
+	const used = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const processScope = (scopeRoot, scopeFn, outerFunctionsByName, outerStaleNames) => {
+		if (visited.has(scopeRoot)) return;
+		visited.add(scopeRoot);
+		const statements = [];
+		const declarationPatterns = /* @__PURE__ */ new Set();
+		const declaredHere = /* @__PURE__ */ new Set();
+		collectReachableStatements(scopeRoot, statements, {
+			declarationPatterns,
+			declaredHere
+		});
+		const functionsHere = /* @__PURE__ */ new Map();
+		const augmentingAssignmentsHere = /* @__PURE__ */ new Map();
+		for (const param of scopeFn?.params ?? []) {
+			const names = [];
+			collectBoundNames(param, names);
+			for (const name of names) functionsHere.set(name, []);
+		}
+		const scopeDeclarations = new Set(scopeRoot.type === "BlockStatement" ? scopeRoot.body : []);
+		const scopeBoundNames = collectScopeBoundNames(scopeRoot, scopeFn);
+		const localNames = /* @__PURE__ */ new Set([...scopeBoundNames, ...outerStaleNames]);
+		for (const statement of statements) collectFunctionsByName(statement, functionsHere, augmentingAssignmentsHere, declarationPatterns, declaredHere, scopeDeclarations, localNames);
+		const staleNames = new Set([...localNames].filter((name) => !functionsHere.has(name)));
+		const functionsByName = new Map(outerFunctionsByName);
+		for (const [name, functions] of functionsHere) functionsByName.set(name, functions);
+		for (const [name, functions] of augmentingAssignmentsHere) {
+			const base = declaredHere.has(name) ? functionsHere.get(name) ?? [] : functionsByName.get(name) ?? [];
+			functionsByName.set(name, [...base, ...functions]);
+		}
+		visit({
+			fn: scopeFn,
+			statements,
+			functionsByName
+		});
+		const referencedNames = /* @__PURE__ */ new Set();
+		for (const statement of statements) collectReferencedNames(statement, referencedNames);
+		const reached = /* @__PURE__ */ new Set();
+		for (const [name, functions] of functionsByName) {
+			if (!referencedNames.has(name)) continue;
+			for (const fn of functions) reached.add(fn);
+		}
+		const held = /* @__PURE__ */ new Set();
+		for (const bindings of [functionsHere, augmentingAssignmentsHere]) for (const functions of bindings.values()) for (const fn of functions) held.add(fn);
+		for (const statement of statements) {
+			const nested = [];
+			collectNestedFunctions(statement, nested);
+			for (const fn of nested) if (!held.has(fn)) reached.add(fn);
+		}
+		for (const reachedFn of reached) {
+			used.add(reachedFn);
+			processScope(reachedFn.body, reachedFn, functionsByName, staleNames);
+		}
+	};
+	processScope(root, null, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+	return used;
+}
+/**
+* The set of function nodes that are actually reachable from `root`. See
+* `walkUsedScopes`.
+*/
+function computeUsedFunctions(root) {
+	return walkUsedScopes(root, () => {});
+}
+/**
+* A node's `[start, end)` character offsets into the whole source file.
+* Both engines always populate this -- ESLint forces it on regardless of
+* parser options, and Deno.lint exposes it the same way as every other
+* child property (see the `for...in` note on why plain property access
+* still works even though it's not an own enumerable property).
+*/
+function getRange(node) {
+	return node.range;
+}
+//#endregion
+//#region src/rules/outbox-listener-delivery-not-awaited.ts
+const MESSAGE$1 = "Delivery is not awaited, so the activity may be lost once the handler returns (for example on Cloudflare Workers). Await it, return it, or pass it to waitUntil().";
+const HANDLED = {
+	fate: "handled",
+	owner: null
+};
+const DROPPED = {
+	fate: "dropped",
+	owner: null
+};
+/** Wrappers that pass a value through unchanged. */
+const TRANSPARENT_WRAPPERS = /* @__PURE__ */ new Set([
+	"ChainExpression",
+	"TSAsExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion",
+	"ParenthesizedExpression"
+]);
+/**
+* `Promise` methods that turn promises into one promise. `race()` and
+* `any()` settle as soon as one input does, which is accepted as a
+* deliberate choice to stop waiting, like `void`. A `race()` or `any()`
+* that is itself dropped is still reported.
+*/
+const PROMISE_COMBINATORS = /* @__PURE__ */ new Set([
+	"all",
+	"allSettled",
+	"race",
+	"any"
+]);
+/** Methods on a promise that return a new promise carrying the chain on. */
+const PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+const get = (node, key) => node == null ? void 0 : node[key];
+const asNode = (value) => isNode(value) ? value : null;
+const parentOf = (node) => asNode(get(node, "parent"));
+function unwrap(node) {
+	let current = node;
+	while (TRANSPARENT_WRAPPERS.has(current.type)) {
+		const inner = asNode(get(current, "expression"));
+		if (inner == null) break;
+		current = inner;
+	}
+	return current;
+}
+/** The name a member expression accesses, when it is spelled out plainly. */
+function memberName(node) {
+	if (node.type !== "MemberExpression") return null;
+	const property = asNode(get(node, "property"));
+	if (property == null) return null;
+	if (get(node, "computed") !== true) return property.type === "Identifier" ? property.name : null;
+	if (property.type === "Literal" && typeof property.value === "string") return property.value;
+	if (property.type === "TemplateLiteral") {
+		const quasis = get(property, "quasis");
+		if (get(property, "expressions").length === 0 && quasis.length === 1) return quasis[0].cooked ?? quasis[0].value?.cooked ?? null;
+	}
+	return null;
+}
+/** Visits every node in `node`, stopping at a nested function unless asked to cross it. */
+function visitAll(node, visitor, crossFunctions = true) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) visitAll(item, visitor, crossFunctions);
+		return;
+	}
+	if (!isNode(node)) return;
+	if (!crossFunctions && isFunctionLikeNode(node)) return;
+	visitor(node);
+	const record = node;
+	for (const key in record) if (key !== "parent") visitAll(record[key], visitor, crossFunctions);
+}
+/** Collects the calls in `node` that run in the same function, not in one nested in it. */
+function collectCalls(node, out) {
+	visitAll(node, (n) => {
+		if (n.type === "CallExpression") out.push(n);
+	}, false);
+}
+function enclosingFunction$1(node) {
+	for (let current = parentOf(node); current != null;) {
+		if (isFunctionLikeNode(current)) return current;
+		current = parentOf(current);
+	}
+	return null;
+}
+/** The names an object pattern binds the delivery methods to. */
+function deliveryAliasesOf(pattern, out) {
+	if (pattern.type !== "ObjectPattern") return;
+	for (const prop of get(pattern, "properties")) {
+		if (prop.type !== "Property") continue;
+		const key = asNode(get(prop, "key"));
+		const keyName = key?.type === "Identifier" ? key.name : key?.type === "Literal" && typeof key.value === "string" ? key.value : null;
+		if (keyName == null || !DELIVERY_METHOD_NAMES$1.has(keyName)) continue;
+		const value = asNode(get(prop, "value"));
+		if (value?.type === "Identifier") out.add(value.name);
+		else if (value?.type === "AssignmentPattern") {
+			const left = asNode(get(value, "left"));
+			if (left?.type === "Identifier") out.add(left.name);
+		}
+	}
+}
+/**
+* Works out how the listener refers to the delivery methods: through its
+* context parameter (`ctx.sendActivity`), or through a name bound to one of
+* them, either in the parameter (`{ sendActivity }`) or in code that can run
+* (`const { sendActivity } = ctx`, `const send = ctx.sendActivity`). A name
+* bound in a helper nothing uses, or in a dead branch, does not count.
+*/
+function findDeliveryTargets(listener, scopes) {
+	const aliases = /* @__PURE__ */ new Set();
+	const contextParam = unwrapContextParam$1(listener.params[0]);
+	const contextName = contextParam?.type === "Identifier" ? contextParam.name : null;
+	if (contextParam != null) deliveryAliasesOf(contextParam, aliases);
+	if (contextName != null) for (const scope of scopes) for (const statement of scope.statements) visitAll(statement, (node) => {
+		if (node.type !== "VariableDeclarator") return;
+		const id = asNode(get(node, "id"));
+		const init = asNode(get(node, "init"));
+		if (id == null || init == null) return;
+		const source = unwrap(init);
+		if (source.type === "Identifier" && source.name === contextName) {
+			deliveryAliasesOf(id, aliases);
+			return;
+		}
+		if (id.type !== "Identifier" || source.type !== "MemberExpression") return;
+		const object = unwrap(asNode(get(source, "object")) ?? source);
+		const name = memberName(source);
+		if (object.type === "Identifier" && object.name === contextName && name != null && DELIVERY_METHOD_NAMES$1.has(name)) aliases.add(id.name);
+	}, false);
+	return {
+		contextName,
+		aliases
+	};
+}
+/**
+* Where the value a callback returns goes, judged by the call that receives
+* the callback.
+*/
+function callbackResultOutcome(call, analysis) {
+	const name = memberName(unwrap(asNode(get(call, "callee")) ?? call));
+	if (name === "forEach") return DROPPED;
+	if (name === "map" || name === "flatMap") return fateOf(call, analysis, "promises");
+	if (name != null && PROMISE_CHAIN_METHODS.has(name)) return fateOf(call, analysis, "promise");
+	return HANDLED;
+}
+/** Where the promise a function returns goes, given who calls the function. */
+function returnedOutcome(fn, analysis) {
+	if (fn == null) return HANDLED;
+	if (fn === analysis.listener) return {
+		fate: "returned",
+		owner: fn
+	};
+	const parent = parentOf(fn);
+	if (parent?.type === "CallExpression") {
+		if (get(parent, "callee") === fn) return fateOf(parent, analysis, "promise");
+		if (get(parent, "arguments").includes(fn)) return callbackResultOutcome(parent, analysis);
+	}
+	return {
+		fate: "returned",
+		owner: fn
+	};
+}
+/**
+* Where an array of promises, or an object holding one, goes when it is
+* returned. The listener's caller does not wait for what is inside it. Any
+* other function hands it to its own callers, who may well pass it to
+* `Promise.all()` or read the promise back out of it.
+*/
+function returnedContainerOutcome(fn, analysis) {
+	return fn === analysis.listener ? DROPPED : HANDLED;
+}
+/** Follows the value of `expression` up through its parents to where it ends up. */
+function fateOf(expression, analysis, shape = "promise") {
+	let current = expression;
+	let currentShape = shape;
+	for (;;) {
+		const parent = parentOf(current);
+		if (parent == null) return HANDLED;
+		if (TRANSPARENT_WRAPPERS.has(parent.type)) {
+			current = parent;
+			continue;
+		}
+		switch (parent.type) {
+			case "AwaitExpression": return currentShape === "promise" ? {
+				fate: "awaited",
+				owner: enclosingFunction$1(parent)
+			} : DROPPED;
+			case "ReturnStatement": return currentShape === "promise" ? returnedOutcome(enclosingFunction$1(parent), analysis) : returnedContainerOutcome(enclosingFunction$1(parent), analysis);
+			case "ArrowFunctionExpression":
+				if (get(parent, "body") !== current) return HANDLED;
+				return currentShape === "promise" ? returnedOutcome(parent, analysis) : returnedContainerOutcome(parent, analysis);
+			case "ExpressionStatement": return DROPPED;
+			case "UnaryExpression": return get(parent, "operator") === "void" ? HANDLED : DROPPED;
+			case "SequenceExpression": {
+				const expressions = get(parent, "expressions");
+				if (expressions[expressions.length - 1] !== current) return DROPPED;
+				current = parent;
+				continue;
+			}
+			case "ConditionalExpression":
+				if (get(parent, "test") === current) return DROPPED;
+				current = parent;
+				continue;
+			case "IfStatement":
+			case "WhileStatement":
+			case "DoWhileStatement":
+			case "ForStatement": return DROPPED;
+			case "LogicalExpression":
+				if (get(parent, "operator") === "&&" && get(parent, "left") === current) return DROPPED;
+				current = parent;
+				continue;
+			case "Property":
+				if (get(parent, "computed") && get(parent, "key") === current) return DROPPED;
+				current = parent;
+				continue;
+			case "ObjectExpression":
+				if (currentShape === "promise") currentShape = "object";
+				current = parent;
+				continue;
+			case "ArrayExpression":
+				if (currentShape !== "promise") return HANDLED;
+				currentShape = "promises";
+				current = parent;
+				continue;
+			case "SpreadElement": {
+				const array = parentOf(parent);
+				if (currentShape !== "promises" || array?.type !== "ArrayExpression") return HANDLED;
+				current = array;
+				continue;
+			}
+			case "MemberExpression": {
+				if (get(parent, "computed") && get(parent, "property") === current) return DROPPED;
+				if (get(parent, "object") !== current) return HANDLED;
+				const call = parentOf(parent);
+				const name = memberName(parent);
+				if (currentShape === "promise" && call?.type === "CallExpression" && get(call, "callee") === parent && name != null && PROMISE_CHAIN_METHODS.has(name)) {
+					current = call;
+					continue;
+				}
+				return HANDLED;
+			}
+			case "CallExpression": {
+				if (get(parent, "callee") === current) return HANDLED;
+				const callee = unwrap(asNode(get(parent, "callee")) ?? parent);
+				const name = memberName(callee);
+				if (name === "waitUntil") return HANDLED;
+				const object = callee.type === "MemberExpression" ? unwrap(asNode(get(callee, "object")) ?? callee) : null;
+				if (object?.type === "Identifier" && object.name === "Promise" && name != null && PROMISE_COMBINATORS.has(name)) {
+					current = parent;
+					currentShape = "promise";
+					continue;
+				}
+				return HANDLED;
+			}
+			case "VariableDeclarator": {
+				const id = asNode(get(parent, "id"));
+				if (get(parent, "init") !== current || id?.type !== "Identifier") return HANDLED;
+				return analysis.mentioned.has(id.name) ? HANDLED : DROPPED;
+			}
+			case "AssignmentExpression": {
+				if (get(parent, "right") !== current) return HANDLED;
+				const name = getAssignmentTargetName(asNode(get(parent, "left")) ?? parent);
+				if (name == null) return HANDLED;
+				return analysis.mentioned.has(name) ? HANDLED : DROPPED;
+			}
+			case "AssignmentPattern": {
+				if (get(parent, "right") !== current) return HANDLED;
+				const name = getAssignmentTargetName(asNode(get(parent, "left")) ?? parent);
+				if (name == null) return HANDLED;
+				return analysis.mentioned.has(name) ? HANDLED : DROPPED;
+			}
+			default: return HANDLED;
+		}
+	}
+}
+/** Reports every place in `listener` where a delivery promise is dropped. */
+function checkListener(listener, report) {
+	const scopes = [];
+	walkUsedScopes(listener.body, (scope) => scopes.push(scope));
+	const targets = findDeliveryTargets(listener, scopes);
+	if (targets.contextName == null && targets.aliases.size === 0) return;
+	const isDeliveryCall = (call) => {
+		const callee = unwrap(call.callee);
+		if (callee.type === "MemberExpression") {
+			const name = memberName(callee);
+			if (name == null || !DELIVERY_METHOD_NAMES$1.has(name)) return false;
+			const object = unwrap(asNode(get(callee, "object")) ?? callee);
+			return object.type === "Identifier" && object.name === targets.contextName;
+		}
+		return callee.type === "Identifier" && targets.aliases.has(callee.name);
+	};
+	const mentioned = /* @__PURE__ */ new Set();
+	collectReferencedNames(listener.body, mentioned, true);
+	const analysis = {
+		listener,
+		mentioned
+	};
+	const callsByScope = scopes.map((scope) => {
+		const calls = [];
+		for (const statement of scope.statements) collectCalls(statement, calls);
+		return calls;
+	});
+	const carrying = /* @__PURE__ */ new Map();
+	const carriesDelivery = (call, scope) => {
+		if (isDeliveryCall(call)) return true;
+		const callee = unwrap(call.callee);
+		if (callee.type !== "Identifier") return false;
+		return scope.functionsByName.get(callee.name)?.some((helper) => carrying.has(helper)) ?? false;
+	};
+	const noteCarrying = ({ fate, owner }) => {
+		if (owner == null || owner === listener) return false;
+		if (fate !== "awaited" && fate !== "returned") return false;
+		const known = carrying.get(owner);
+		if (known === "awaited" || known === fate) return false;
+		carrying.set(owner, fate);
+		return true;
+	};
+	for (let changed = true; changed;) {
+		changed = false;
+		scopes.forEach((scope, index) => {
+			for (const call of callsByScope[index]) if (carriesDelivery(call, scope) && noteCarrying(fateOf(call, analysis))) changed = true;
+		});
+	}
+	const reported = /* @__PURE__ */ new Set();
+	const flag = (node) => {
+		if (reported.has(node)) return;
+		reported.add(node);
+		report(node);
+	};
+	scopes.forEach((scope, index) => {
+		for (const call of callsByScope[index]) {
+			if (!carriesDelivery(call, scope)) continue;
+			if (fateOf(call, analysis).fate === "dropped") flag(call);
+		}
+	});
+	for (const [fn, kind] of carrying) if (kind === "awaited" && returnedOutcome(fn, analysis).fate === "dropped") flag(fn);
+	scopes.forEach((scope, index) => {
+		for (const call of callsByScope[index]) for (const arg of call.arguments) {
+			if (arg.type !== "Identifier") continue;
+			const held = scope.functionsByName.get(arg.name);
+			if (held == null || !held.some((fn) => carrying.has(fn))) continue;
+			if (callbackResultOutcome(call, analysis).fate === "dropped") flag(arg);
+		}
+	});
+}
+function createRule$1(buildReport) {
+	return (context) => createOutboxListenerVisitor((listener) => checkListener(listener, (node) => {
+		context.report({
+			node,
+			...buildReport
+		});
+	}));
+}
+const eslint$1 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Warn when an outbox listener delivers an activity without awaiting it" },
+		schema: [],
+		messages: { notAwaited: "{{ message }}" }
+	},
+	create: createRule$1({
+		messageId: "notAwaited",
+		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 = /* @__PURE__ */ new Set(["sendActivity", "forwardActivity"]);
+const getMemberPropertyName = (expr) => {
+	if (expr.type !== "MemberExpression") return null;
+	const property = expr.property;
+	if (property.type === "Identifier" && !expr.computed) 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;
+}
+const getParent = (node) => node.parent ?? null;
+const isFunctionLike = (node) => node.type === "FunctionDeclaration" || isFunction(node);
+function bindPattern(node, bindings) {
+	switch (node.type) {
+		case "Identifier":
+			bindings.set(node.name, { value: null });
+			break;
+		case "AssignmentPattern":
+			bindPattern(node.left, bindings);
+			break;
+		case "RestElement":
+			bindPattern(node.argument, bindings);
+			break;
+		case "ObjectPattern":
+			for (const property of node.properties) bindPattern(property.type === "Property" ? property.value : property, bindings);
+			break;
+		case "ArrayPattern":
+			for (const element of node.elements) if (element != null) bindPattern(element, bindings);
+			break;
+	}
+}
+function createBindingIndex() {
+	const scopes = /* @__PURE__ */ new Map();
+	const scopeBindings = (scope) => {
+		let bindings = scopes.get(scope);
+		if (bindings == null) {
+			bindings = /* @__PURE__ */ new Map();
+			scopes.set(scope, bindings);
+			if (isFunctionLike(scope)) {
+				if (scope.type === "FunctionExpression" && scope.id != null) bindings.set(scope.id.name, { value: scope });
+				for (const param of scope.params) bindPattern(param, bindings);
+			}
+			if (scope.type === "ClassExpression" && scope.id != null) bindings.set(scope.id.name, { value: null });
+			if (scope.type === "CatchClause" && scope.param != null) bindPattern(scope.param, bindings);
+		}
+		return bindings;
+	};
+	const enclosingScope = (node, functionScope = false) => {
+		let scope = getParent(node);
+		while (scope.type !== "Program" && scope.type !== "StaticBlock" && scope.type !== "TSModuleBlock" && !isFunctionLike(scope) && (functionScope || ![
+			"BlockStatement",
+			"ForStatement",
+			"ForInStatement",
+			"ForOfStatement",
+			"SwitchStatement",
+			"CatchClause"
+		].includes(scope.type))) scope = getParent(scope);
+		return scope;
+	};
+	const lookup = (node, name) => {
+		for (let scope = node; scope != null; scope = getParent(scope)) {
+			const binding = scopeBindings(scope).get(name);
+			if (binding != null) return binding;
+		}
+		return null;
+	};
+	return {
+		lookup,
+		declare(node, pattern, value, hoisted = false) {
+			const bindings = scopeBindings(enclosingScope(node, hoisted));
+			if (pattern.type === "Identifier") {
+				if (hoisted && value == null && bindings.has(pattern.name)) return;
+				if (node.type === "FunctionDeclaration" && bindings.get(pattern.name)?.initializedVariable) return;
+				bindings.set(pattern.name, {
+					value,
+					initializedVariable: node.type === "VariableDeclarator" && value != null
+				});
+			} else bindPattern(pattern, bindings);
+		}
+	};
+}
+const position = (node) => node.range?.[0] ?? node.start ?? -1;
+const enclosingFunction = (node) => {
+	for (let parent = getParent(node); parent != null; parent = getParent(parent)) if (isFunctionLike(parent)) return parent;
+	return null;
+};
+const isInside = (node, ancestor) => {
+	for (let current = node; current != null; current = getParent(current)) if (current === ancestor) return true;
+	return false;
+};
+const isDirectStatement = (node, fn) => {
+	let current = node;
+	while (getParent(current) !== fn.body) {
+		const parent = getParent(current);
+		if (parent == null || ![
+			"AwaitExpression",
+			"ExpressionStatement",
+			"ReturnStatement",
+			"VariableDeclarator",
+			"VariableDeclaration",
+			"BlockStatement"
+		].includes(parent.type)) return false;
+		current = parent;
+	}
+	return [
+		"ExpressionStatement",
+		"ReturnStatement",
+		"VariableDeclaration",
+		"BlockStatement"
+	].includes(current.type);
+};
+const resolveBindingValue = (expr, bindings, seen = /* @__PURE__ */ new Set()) => {
+	if (expr.type !== "Identifier") return expr;
+	const binding = bindings.lookup(expr, expr.name);
+	if (binding == null || binding.value == null || seen.has(binding)) return null;
+	seen.add(binding);
+	return resolveBindingValue(binding.value, bindings, seen);
+};
+const resolveListenerReference = (expr, bindings) => {
+	const target = resolveBindingValue(expr, bindings);
+	if (target == null) return null;
+	if (isFunctionLike(target)) return target;
+	if (target.type !== "MemberExpression") return null;
+	const object = resolveBindingValue(target.object, bindings);
+	if (object?.type !== "ObjectExpression") return null;
+	const propertyName = getMemberPropertyName(target);
+	if (propertyName == null) return null;
+	for (const prop of object.properties) {
+		if (prop.type !== "Property") continue;
+		if ((prop.key.type === "Identifier" && !prop.computed ? prop.key.name : prop.key.type === "Literal" && typeof prop.key.value === "string" ? prop.key.value : null) !== propertyName) continue;
+		const value = resolveBindingValue(prop.value, bindings);
+		if (value != null && isFunctionLike(value)) return value;
+	}
+	return null;
+};
+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*\))`;
+}
+/**
+* Builds the source text to scan for a delivery call: the reachable
+* statements of `root`, with every nested function literal either folded
+* in (its own reachable text spliced in place, wherever that function's
+* own declaration happens to live) or blanked out, depending on whether
+* `used` (from `computeUsedFunctions`) says it is actually invoked.
+*
+* Splices each function by its own range rather than by matching its
+* source text, and applies the splices from the end of the statement
+* backward. That keeps two functions with byte-identical bodies (e.g. two
+* object-literal methods that both merely call `ctx.sendActivity(...)`)
+* from colliding: a text-based replacement would find and blank out both
+* occurrences the first time either one is processed, since it matches by
+* content everywhere in the statement rather than by which node is
+* actually being replaced. Replacing from the end backward also means a
+* later replacement's length change never shifts the still-unprocessed
+* offsets of an earlier one.
+*/
+function collectDeliveryScanCode(sourceCode, root, used, ignored, visited) {
+	if (visited.has(root)) return "";
+	visited.add(root);
+	const statements = [];
+	collectReachableStatements(root, statements);
+	return statements.map((statement) => {
+		const text = sourceCode.getText(statement);
+		const [statementStart] = getRange(statement);
+		const nested = [];
+		collectNestedFunctions(statement, nested);
+		const byDescendingStart = [...nested].sort((a, b) => getRange(b)[0] - getRange(a)[0]);
+		let result = text;
+		for (const fn of byDescendingStart) {
+			const [fnStart, fnEnd] = getRange(fn);
+			const replacement = used.has(fn) && !ignored.has(fn) ? collectDeliveryScanCode(sourceCode, fn.body, used, ignored, visited) : "";
+			result = result.slice(0, fnStart - statementStart) + `\n${replacement.length > 0 ? replacement : "()=>{}"}\n` + result.slice(fnEnd - statementStart);
+		}
+		return result;
+	}).join("\n");
+}
+function unwrapArgument(node) {
+	while (node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression") node = node.expression;
+	return node;
+}
+function ignoredLocalSetupFunctions(listener, bindings, calls, assignments) {
+	const ignored = [];
+	const directCalls = calls.filter((call) => enclosingFunction(call) === listener && isDirectStatement(call, listener));
+	for (const assignment of assignments) {
+		if (assignment.type !== "AssignmentExpression" || assignment.operator !== "=" || assignment.left.type !== "MemberExpression" || !isFunction(assignment.right)) continue;
+		const setup = enclosingFunction(assignment);
+		if (setup == null || setup === listener || !isInside(setup, listener)) continue;
+		const setupParent = getParent(setup);
+		const namedLocalSetup = enclosingFunction(setup) === listener && (setup.type === "FunctionDeclaration" || setupParent?.type === "VariableDeclarator" && setupParent.init === setup && setupParent.id.type === "Identifier");
+		const passedToCall = calls.some((call) => call.arguments.some((argument) => argument.type !== "SpreadElement" && resolveListenerReference(argument, bindings) === setup));
+		if (!namedLocalSetup || passedToCall) continue;
+		const installed = assignment.right;
+		if (!isDirectStatement(assignment, setup) || assignment.left.object.type !== "Identifier") {
+			ignored.push(installed);
+			continue;
+		}
+		const property = getMemberPropertyName(assignment.left);
+		if (property == null) continue;
+		const setupCalls = directCalls.filter((call) => resolveListenerReference(call.callee, bindings) === setup);
+		if (setupCalls.length === 0) {
+			const called = calls.some((call) => resolveListenerReference(call.callee, bindings) === setup);
+			ignored.push(called ? assignment.right : setup);
+			continue;
+		}
+		const objectBinding = bindings.lookup(assignment.left.object, assignment.left.object.name);
+		const deliveryCalls = directCalls.filter((call) => {
+			const callee = call.callee;
+			return callee.type === "MemberExpression" && callee.object.type === "Identifier" && getMemberPropertyName(callee) === property && bindings.lookup(callee.object, callee.object.name) === objectBinding;
+		});
+		if (!(objectBinding != null && setupCalls.some((setupCall) => deliveryCalls.some((deliveryCall) => position(setupCall) >= 0 && position(setupCall) < position(deliveryCall))))) ignored.push(installed);
+	}
+	return ignored;
+}
+function functionCallsDelivery(sourceCode, listener, bindings, calls, assignments, contextIndex = 0, visited = /* @__PURE__ */ new Map()) {
+	let indices = visited.get(listener);
+	if (indices?.has(contextIndex)) return false;
+	if (indices == null) visited.set(listener, indices = /* @__PURE__ */ new Set());
+	indices.add(contextIndex);
+	const ignored = ignoredLocalSetupFunctions(listener, bindings, calls, assignments);
+	if (listenerCallsDeliveryMethod(sourceCode, listener, contextIndex, ignored, bindings, calls, assignments)) return true;
+	const param = unwrapContextParam(listener.params[contextIndex]);
+	if (param?.type !== "Identifier") return false;
+	const contextBinding = bindings.lookup(listener, param.name);
+	const reachable = [];
+	collectReachableStatements(listener.body, reachable);
+	for (const call of calls) {
+		let child = call;
+		let owner = getParent(child);
+		while (owner != null && !isFunctionLike(owner)) {
+			const field = owner;
+			if ((field.type === "PropertyDefinition" || field.type === "AccessorProperty") && !field.static && field.value === child) break;
+			child = owner;
+			owner = getParent(owner);
+		}
+		if (owner !== listener) continue;
+		const [callStart, callEnd] = getRange(call);
+		if (!reachable.some((statement) => {
+			const [start, end] = getRange(statement);
+			return start <= callStart && callEnd <= end;
+		})) continue;
+		const helper = resolveListenerReference(call.callee, bindings);
+		if (helper == null || "generator" in helper && helper.generator) continue;
+		for (const [index, argument] of call.arguments.entries()) {
+			if (argument.type === "SpreadElement") break;
+			const arg = unwrapArgument(argument);
+			if (arg.type !== "Identifier" || arg.name !== param.name || bindings.lookup(arg, arg.name) !== contextBinding || helper.params[index]?.type === "RestElement") continue;
+			if (functionCallsDelivery(sourceCode, helper, bindings, calls, assignments, index, visited)) return true;
+		}
+	}
+	return false;
+}
+const listenerCallsDeliveryMethod = (sourceCode, listener, contextIndex, ignored, bindings, calls, assignments) => {
+	const used = computeUsedFunctions(listener.body);
+	const ignoredSet = new Set(ignored);
+	for (const assignment of assignments) {
+		if (assignment.type !== "AssignmentExpression" || assignment.left.type !== "MemberExpression" || assignment.left.object.type !== "Identifier" || !isFunction(assignment.right) || !isInside(assignment, listener)) continue;
+		const property = getMemberPropertyName(assignment.left);
+		const objectBinding = bindings.lookup(assignment.left.object, assignment.left.object.name);
+		if (property == null || objectBinding == null || !calls.some((call) => enclosingFunction(call) === listener && call.callee.type === "MemberExpression" && call.callee.object.type === "Identifier" && getMemberPropertyName(call.callee) === property && bindings.lookup(call.callee.object, call.callee.object.name) === objectBinding)) continue;
+		const installed = assignment.right;
+		if (ignoredSet.has(installed)) continue;
+		for (let fn = installed; fn != null && fn !== listener && !ignoredSet.has(fn); fn = enclosingFunction(fn)) used.add(fn);
+	}
+	const code = stripCommentsAndStrings(collectDeliveryScanCode(sourceCode, listener.body, used, ignoredSet, /* @__PURE__ */ new Set()));
+	const aliases = /* @__PURE__ */ new Set();
+	const contextParam = unwrapContextParam(listener.params[contextIndex]);
+	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 = createBindingIndex();
+		const pendingCalls = [];
+		const pendingAssignments = [];
+		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 (functionCallsDelivery(sourceCode, resolvedListener, bindings, pendingCalls, pendingAssignments)) return;
+			context.report({
+				node: resolvedListener,
+				...buildReport
+			});
+		};
+		return {
+			VariableDeclarator(node) {
+				federationTracker.VariableDeclarator(node);
+				const declaration = getParent(node);
+				bindings.declare(node, node.id, node.init, declaration?.kind === "var");
+			},
+			FunctionDeclaration(node) {
+				if (node.id == null) return;
+				const parent = getParent(node);
+				const owner = parent == null ? null : getParent(parent);
+				const inVarBody = parent?.type === "BlockStatement" && owner != null && (owner.type === "StaticBlock" || isFunctionLike(owner) && owner.body === parent);
+				bindings.declare(node, node.id, node, inVarBody);
+			},
+			ImportDeclaration(node) {
+				for (const specifier of node.specifiers) bindings.declare(node, specifier.local, null);
+			},
+			ClassDeclaration(node) {
+				if (node.id != null) bindings.declare(node, node.id, null);
+			},
+			CallExpression(node) {
+				pendingCalls.push(node);
+			},
+			AssignmentExpression(node) {
+				pendingAssignments.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$26", {
+	enumerable: true,
+	get: function() {
+		return eslint$26;
+	}
+});
+Object.defineProperty(exports, "eslint$27", {
+	enumerable: true,
+	get: function() {
+		return eslint$27;
+	}
+});
+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;
+	}
+});