@fedify/lint 2.4.0-dev.2030 → 2.4.0-dev.2035

package/dist/{outbox-listener-delivery-required-BTQdF7iz.cjs → outbox-listener-delivery-required-BRGnlbDc.cjs}

@@ -1,7 +1,7 @@
 let _fxts_core = require("@fxts/core");
 //#region deno.json
 var name = "@fedify/lint";
-var version = "2.4.0-dev.2030+e6b3de3d";
+var version = "2.4.0-dev.2035+d1f8f8e2";
 //#endregion
 //#region src/lib/const.ts
 /**
@@ -141,6 +141,7 @@ const RULE_IDS = {
 	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"
 };
@@ -462,7 +463,7 @@ function createRequiredRuleEslint(config) {
 	};
 }
 createRequiredRuleDeno(properties.assertionMethod);
-const eslint$26 = createRequiredRuleEslint(properties.assertionMethod);
+const eslint$27 = createRequiredRuleEslint(properties.assertionMethod);
 //#endregion
 //#region src/lib/mismatch.ts
 const isIdentifierWithName = (name) => (node) => allOf(isNodeType("Identifier"), isNodeName(name))(node);
@@ -532,49 +533,49 @@ const createMismatchRuleEslint = (config) => ({
 	}))
 });
 createMismatchRuleDeno(properties.featured);
-const eslint$25 = createMismatchRuleEslint(properties.featured);
+const eslint$26 = createMismatchRuleEslint(properties.featured);
 createRequiredRuleDeno(properties.featured);
-const eslint$24 = createRequiredRuleEslint(properties.featured);
+const eslint$25 = createRequiredRuleEslint(properties.featured);
 createMismatchRuleDeno(properties.featuredTags);
-const eslint$23 = createMismatchRuleEslint(properties.featuredTags);
+const eslint$24 = createMismatchRuleEslint(properties.featuredTags);
 createRequiredRuleDeno(properties.featuredTags);
-const eslint$22 = createRequiredRuleEslint(properties.featuredTags);
+const eslint$23 = createRequiredRuleEslint(properties.featuredTags);
 createMismatchRuleDeno(properties.followers);
-const eslint$21 = createMismatchRuleEslint(properties.followers);
+const eslint$22 = createMismatchRuleEslint(properties.followers);
 createRequiredRuleDeno(properties.followers);
-const eslint$20 = createRequiredRuleEslint(properties.followers);
+const eslint$21 = createRequiredRuleEslint(properties.followers);
 createMismatchRuleDeno(properties.following);
-const eslint$19 = createMismatchRuleEslint(properties.following);
+const eslint$20 = createMismatchRuleEslint(properties.following);
 createRequiredRuleDeno(properties.following);
-const eslint$18 = createRequiredRuleEslint(properties.following);
+const eslint$19 = createRequiredRuleEslint(properties.following);
 createMismatchRuleDeno(properties.id);
-const eslint$17 = createMismatchRuleEslint(properties.id);
+const eslint$18 = createMismatchRuleEslint(properties.id);
 createRequiredRuleDeno(properties.id);
-const eslint$16 = createRequiredRuleEslint(properties.id);
+const eslint$17 = createRequiredRuleEslint(properties.id);
 createMismatchRuleDeno(properties.inbox);
-const eslint$15 = createMismatchRuleEslint(properties.inbox);
+const eslint$16 = createMismatchRuleEslint(properties.inbox);
 createRequiredRuleDeno(properties.inbox);
-const eslint$14 = createRequiredRuleEslint(properties.inbox);
+const eslint$15 = createRequiredRuleEslint(properties.inbox);
 createMismatchRuleDeno(properties.liked);
-const eslint$13 = createMismatchRuleEslint(properties.liked);
+const eslint$14 = createMismatchRuleEslint(properties.liked);
 createRequiredRuleDeno(properties.liked);
-const eslint$12 = createRequiredRuleEslint(properties.liked);
+const eslint$13 = createRequiredRuleEslint(properties.liked);
 createMismatchRuleDeno(properties.outbox);
-const eslint$11 = createMismatchRuleEslint(properties.outbox);
+const eslint$12 = createMismatchRuleEslint(properties.outbox);
 createRequiredRuleDeno(properties.outbox);
-const eslint$10 = createRequiredRuleEslint(properties.outbox);
+const eslint$11 = createRequiredRuleEslint(properties.outbox);
 createRequiredRuleDeno(properties.preferredUsername);
-const eslint$9 = createRequiredRuleEslint(properties.preferredUsername);
+const eslint$10 = createRequiredRuleEslint(properties.preferredUsername);
 createRequiredRuleDeno(properties.publicKey);
-const eslint$8 = createRequiredRuleEslint(properties.publicKey);
+const eslint$9 = createRequiredRuleEslint(properties.publicKey);
 createMismatchRuleDeno(properties.sharedInbox);
-const eslint$7 = createMismatchRuleEslint(properties.sharedInbox);
+const eslint$8 = createMismatchRuleEslint(properties.sharedInbox);
 createRequiredRuleDeno(properties.sharedInbox);
-const eslint$6 = createRequiredRuleEslint(properties.sharedInbox);
+const eslint$7 = createRequiredRuleEslint(properties.sharedInbox);
 createMismatchRuleDeno(properties.uploadMedia);
-const eslint$5 = createMismatchRuleEslint(properties.uploadMedia);
+const eslint$6 = createMismatchRuleEslint(properties.uploadMedia);
 createRequiredRuleDeno(properties.uploadMedia);
-const eslint$4 = createRequiredRuleEslint(properties.uploadMedia);
+const eslint$5 = createRequiredRuleEslint(properties.uploadMedia);
 //#endregion
 //#region src/rules/collection-filtering-not-implemented.ts
 /**
@@ -593,7 +594,7 @@ const isFollowersDispatcherCall = (node) => "callee" in node && node.callee && n
 * CollectionDispatcher signature: (context, identifier, cursor, filter?) => ...
 */
 const hasFilterParameter = hasMinParams(4);
-const eslint$3 = {
+const eslint$4 = {
 	meta: {
 		type: "suggestion",
 		docs: { description: "Ensure followers dispatcher implements filtering" },
@@ -619,7 +620,7 @@ const eslint$3 = {
 };
 //#endregion
 //#region src/rules/media-uploader-authorization-required.ts
-const MESSAGE$2 = "setMediaUploader() should be protected with .authorize(); without it the endpoint accepts uploads from anyone who can reach the URL.  Add .authorize() unless a public upload endpoint is intended.";
+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(node) {
 	if (node == null || typeof node !== "object") return null;
 	const parent = node.parent;
@@ -637,7 +638,7 @@ function isDirectlyAuthorized(callNode) {
 	const call = getParent(member);
 	return call != null && call.type === "CallExpression" && call.callee === member;
 }
-function createRule$2(buildReport) {
+function createRule$3(buildReport) {
 	return (context) => {
 		const federationTracker = trackFederationVariables();
 		const unchained = [];
@@ -675,21 +676,21 @@ function createRule$2(buildReport) {
 		};
 	};
 }
-const eslint$2 = {
+const eslint$3 = {
 	meta: {
 		type: "suggestion",
 		docs: { description: "Warn when setMediaUploader() is registered without an authorize() hook" },
 		schema: [],
 		messages: { required: "{{ message }}" }
 	},
-	create: createRule$2({
+	create: createRule$3({
 		messageId: "required",
-		data: { message: MESSAGE$2 }
+		data: { message: MESSAGE$3 }
 	})
 };
 //#endregion
 //#region src/rules/media-uploader-object-uri-required.ts
-const MESSAGE$1 = "setMediaUploader() callbacks should return a value derived from ctx.getObjectUri(): either return ctx.getObjectUri(...) directly, or an object whose id is ctx.getObjectUri(...).";
+const 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$1 = (node) => {
 	if (node.type !== "MemberExpression") return null;
@@ -963,7 +964,7 @@ function callbackDerivesFromGetObjectUri(callback) {
 	};
 	return returnedExpressions.every((expr) => returnDerivesFromGetObjectUri(expr, ctx, /* @__PURE__ */ new Set()));
 }
-function createRule$1(buildReport) {
+function createRule$2(buildReport) {
 	return (context) => {
 		const federationTracker = trackFederationVariables();
 		const bindings = /* @__PURE__ */ new Map();
@@ -997,21 +998,21 @@ function createRule$1(buildReport) {
 		};
 	};
 }
-const eslint$1 = {
+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$1({
+	create: createRule$2({
 		messageId: "required",
-		data: { message: MESSAGE$1 }
+		data: { message: MESSAGE$2 }
 	})
 };
 //#endregion
-//#region src/rules/outbox-listener-delivery-required.ts
-const MESSAGE = "Outbox listeners should deliver posted activities explicitly with ctx.sendActivity() or ctx.forwardActivity().";
+//#region src/lib/outbox-listener.ts
+const DELIVERY_METHOD_NAMES = /* @__PURE__ */ new Set(["sendActivity", "forwardActivity"]);
 const isChainedFromOutboxListeners = (expr, federationTracker) => {
 	if (expr.type !== "CallExpression") return false;
 	if (!hasMemberExpressionCallee(expr) || !hasIdentifierProperty(expr)) return false;
@@ -1020,13 +1021,6 @@ const isChainedFromOutboxListeners = (expr, federationTracker) => {
 	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 FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression"
-]);
-const isFunctionLikeNode = (node) => FUNCTION_NODE_TYPES.has(node.type);
 const getMemberPropertyName = (expr) => {
 	if (expr.type !== "MemberExpression") return null;
 	const property = expr.property;
@@ -1039,133 +1033,6 @@ function unwrapContextParam(node) {
 	while (current?.type === "AssignmentPattern") current = current.left;
 	return current;
 }
-function escapeRegExp(value) {
-	return value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function stripCommentsAndStrings(code) {
-	let result = "";
-	let index = 0;
-	const skipQuotedString = (quote) => {
-		const start = index;
-		index += 1;
-		while (index < code.length) {
-			const char = code[index];
-			if (char === "\\") {
-				index += 2;
-				continue;
-			}
-			index += 1;
-			if (char === quote) break;
-		}
-		const literal = code.slice(start, index);
-		const value = literal.slice(1, -1);
-		result += DELIVERY_METHOD_NAMES.has(value) ? literal : `${quote}${quote}`;
-	};
-	const stripTemplateLiteral = () => {
-		const start = index;
-		index += 1;
-		let raw = "";
-		let hasExpression = false;
-		while (index < code.length) {
-			const char = code[index];
-			if (char === "\\") {
-				raw += char;
-				raw += code[index + 1] ?? "";
-				index += 2;
-				continue;
-			}
-			if (char === "`") {
-				index += 1;
-				if (!hasExpression && DELIVERY_METHOD_NAMES.has(raw)) result += code.slice(start, index);
-				else result += "``";
-				return;
-			}
-			if (char === "$" && code[index + 1] === "{") {
-				hasExpression = true;
-				result += "`${";
-				index += 2;
-				let depth = 1;
-				while (index < code.length && depth > 0) {
-					const exprChar = code[index];
-					const next = code[index + 1];
-					if (exprChar === "'" || exprChar === "\"") {
-						skipQuotedString(exprChar);
-						continue;
-					}
-					if (exprChar === "`") {
-						stripTemplateLiteral();
-						continue;
-					}
-					if (exprChar === "/" && next === "*") {
-						index += 2;
-						while (index < code.length) {
-							if (code[index] === "*" && code[index + 1] === "/") {
-								index += 2;
-								break;
-							}
-							index += 1;
-						}
-						continue;
-					}
-					if (exprChar === "/" && next === "/") {
-						index += 2;
-						while (index < code.length && code[index] !== "\n") index += 1;
-						continue;
-					}
-					result += exprChar;
-					index += 1;
-					if (exprChar === "{") depth += 1;
-					else if (exprChar === "}") depth -= 1;
-				}
-				continue;
-			}
-			raw += char;
-			index += 1;
-		}
-		result += "``";
-	};
-	while (index < code.length) {
-		const char = code[index];
-		const next = code[index + 1];
-		if (char === "/" && next === "*") {
-			index += 2;
-			while (index < code.length) {
-				if (code[index] === "*" && code[index + 1] === "/") {
-					index += 2;
-					break;
-				}
-				index += 1;
-			}
-			continue;
-		}
-		if (char === "/" && next === "/") {
-			index += 2;
-			while (index < code.length && code[index] !== "\n") index += 1;
-			continue;
-		}
-		if (char === "'" || char === "\"") {
-			skipQuotedString(char);
-			continue;
-		}
-		if (char === "`") {
-			stripTemplateLiteral();
-			continue;
-		}
-		result += char;
-		index += 1;
-	}
-	return result;
-}
-function getDeliveryAliasName(node) {
-	if (node.type === "Identifier") return node.name;
-	if (node.type === "AssignmentPattern" && node.left.type === "Identifier") return node.left.name;
-	return null;
-}
-function buildContextExpressionPattern(contextName) {
-	const name = escapeRegExp(contextName);
-	const boundedName = String.raw`(?<![\w$])${name}(?![\w$])`;
-	return String.raw`(?:${boundedName}|\(\s*${boundedName}(?:\s+as\s+[^)]+)?\s*\))`;
-}
 /**
 * 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
@@ -1198,6 +1065,49 @@ const resolveFunctionBinding = (expr, bindings, seen = /* @__PURE__ */ new Set()
 	}
 	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(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);
 /**
@@ -1297,10 +1207,10 @@ function collectReachableStatements(node, out) {
 * `deliver`), and the target of an assignment, which writes to a name
 * instead of reading it.
 */
-function collectReferencedNames(node, out) {
+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);
+		for (const item of node) collectReferencedNames(item, out, crossFunctions);
 		return;
 	}
 	if (!isNode(node)) return;
@@ -1310,37 +1220,40 @@ function collectReferencedNames(node, out) {
 		return;
 	}
 	if (n.type === "MemberExpression" && !n.computed) {
-		collectReferencedNames(n.object, out);
+		collectReferencedNames(n.object, out, crossFunctions);
 		return;
 	}
 	if (n.type === "Property" && !n.computed) {
-		collectReferencedNames(n.value, out);
+		collectReferencedNames(n.value, out, crossFunctions);
 		return;
 	}
 	if (n.type === "VariableDeclarator") {
-		if (n.init != null) collectReferencedNames(n.init, out);
+		if (n.init != null) collectReferencedNames(n.init, out, crossFunctions);
 		return;
 	}
 	if (n.type === "ClassDeclaration" || n.type === "ClassExpression") {
-		collectReferencedNames(n.superClass, out);
-		collectReferencedNames(n.body, out);
+		collectReferencedNames(n.superClass, out, crossFunctions);
+		collectReferencedNames(n.body, out, crossFunctions);
 		return;
 	}
 	if ((n.type === "MethodDefinition" || n.type === "PropertyDefinition") && !n.computed) {
-		collectReferencedNames(n.value, out);
+		collectReferencedNames(n.value, out, crossFunctions);
 		return;
 	}
 	if (n.type === "AssignmentExpression" && n.operator === "=") {
 		if (getAssignmentTargetName(n.left) != null) {
-			collectReferencedNames(n.right, out);
+			collectReferencedNames(n.right, out, crossFunctions);
 			return;
 		}
 	}
-	if (isFunctionLikeNode(n)) 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);
+		collectReferencedNames(record[key], out, crossFunctions);
 	}
 }
 /**
@@ -1480,19 +1393,20 @@ function collectNestedFunctions(node, out) {
 	}
 }
 /**
-* Computes the full set of function nodes that are actually reachable from
-* `root`: `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.
+* 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 computeUsedFunctions(root) {
+function walkUsedScopes(root, visit) {
 	const used = /* @__PURE__ */ new Set();
 	const visited = /* @__PURE__ */ new Set();
-	const processScope = (scopeRoot, outerFunctionsByName) => {
+	const processScope = (scopeRoot, scopeFn, outerFunctionsByName) => {
 		if (visited.has(scopeRoot)) return;
 		visited.add(scopeRoot);
 		const statements = [];
@@ -1501,6 +1415,11 @@ function computeUsedFunctions(root) {
 		for (const statement of statements) collectFunctionsByName(statement, functionsHere);
 		const functionsByName = new Map(outerFunctionsByName);
 		for (const [name, functions] of functionsHere) functionsByName.set(name, functions);
+		visit({
+			fn: scopeFn,
+			statements,
+			functionsByName
+		});
 		const referencedNames = /* @__PURE__ */ new Set();
 		for (const statement of statements) collectReferencedNames(statement, referencedNames);
 		const reached = /* @__PURE__ */ new Set();
@@ -1515,15 +1434,22 @@ function computeUsedFunctions(root) {
 			collectNestedFunctions(statement, nested);
 			for (const fn of nested) if (!held.has(fn)) reached.add(fn);
 		}
-		for (const fn of reached) {
-			used.add(fn);
-			processScope(fn.body, functionsByName);
+		for (const reachedFn of reached) {
+			used.add(reachedFn);
+			processScope(reachedFn.body, reachedFn, functionsByName);
 		}
 	};
-	processScope(root, /* @__PURE__ */ new Map());
+	processScope(root, null, /* @__PURE__ */ new Map());
 	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
@@ -1533,6 +1459,493 @@ function computeUsedFunctions(root) {
 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(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.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(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.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(parent)
+			} : DROPPED;
+			case "ReturnStatement": return currentShape === "promise" ? returnedOutcome(enclosingFunction(parent), analysis) : returnedContainerOutcome(enclosingFunction(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":
+			case "Property":
+				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, "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;
+			}
+			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.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().";
+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
@@ -1566,7 +1979,7 @@ function collectDeliveryScanCode(sourceCode, root, used, visited) {
 		for (const fn of byDescendingStart) {
 			const [fnStart, fnEnd] = getRange(fn);
 			const replacement = used.has(fn) ? collectDeliveryScanCode(sourceCode, fn.body, used, visited) : "";
-			result = result.slice(0, fnStart - statementStart) + (replacement.length > 0 ? replacement : "()=>{}") + result.slice(fnEnd - statementStart);
+			result = result.slice(0, fnStart - statementStart) + `\n${replacement.length > 0 ? replacement : "()=>{}"}\n` + result.slice(fnEnd - statementStart);
 		}
 		return result;
 	}).join("\n");
@@ -1603,37 +2016,14 @@ const listenerCallsDeliveryMethod = (sourceCode, listener) => {
 };
 function createRule(buildReport) {
 	return (context) => {
-		const federationTracker = trackFederationVariables();
-		const bindings = /* @__PURE__ */ new Map();
-		const pendingCalls = [];
 		const sourceCode = context.sourceCode;
-		const inspectCall = (node) => {
-			if (!hasMemberExpressionCallee(node) || !hasIdentifierProperty(node) || !hasMethodName("on")(node) || node.arguments.length < 2) return;
-			if (!isChainedFromOutboxListeners(node.callee.object, federationTracker)) return;
-			const listener = node.arguments[1];
-			const resolvedListener = isNode(listener) && isFunction(listener) ? listener : isNode(listener) ? resolveFunctionBinding(listener, bindings) : null;
-			if (resolvedListener == null) return;
-			if (listenerCallsDeliveryMethod(sourceCode, resolvedListener)) return;
+		return createOutboxListenerVisitor((listener) => {
+			if (listenerCallsDeliveryMethod(sourceCode, listener)) return;
 			context.report({
-				node: resolvedListener,
+				node: listener,
 				...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 = {
@@ -1775,6 +2165,12 @@ Object.defineProperty(exports, "eslint$26", {
 		return eslint$26;
 	}
 });
+Object.defineProperty(exports, "eslint$27", {
+	enumerable: true,
+	get: function() {
+		return eslint$27;
+	}
+});
 Object.defineProperty(exports, "eslint$3", {
 	enumerable: true,
 	get: function() {