@fedify/lint 2.4.0-dev.1995 → 2.4.0-dev.2010

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/lint",
-  "version": "2.4.0-dev.1995+618fd4e7",
+  "version": "2.4.0-dev.2010+498229f4",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/index.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_outbox_listener_delivery_required = require("./outbox-listener-delivery-required-DDinWqeF.cjs");
+const require_outbox_listener_delivery_required = require("./outbox-listener-delivery-required-glWw7_mh.cjs");
 let _fxts_core = require("@fxts/core");
 let _typescript_eslint_parser = require("@typescript-eslint/parser");
 _typescript_eslint_parser = __toESM(_typescript_eslint_parser, 1);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as version, C as eslint$12, D as eslint$21, E as eslint$11, O as RULE_IDS, S as eslint$5, T as eslint$10, _ as eslint$1, a as eslint$18, b as eslint$3, c as eslint$17, d as eslint$6, f as eslint$7, g as eslint$15, h as eslint$14, i as eslint$23, k as name, l as eslint$20, m as eslint$9, n as eslint$25, o as eslint$19, p as eslint$8, r as eslint$26, s as eslint$16, t as eslint$24, u as eslint$22, v as eslint, w as eslint$13, x as eslint$4, y as eslint$2 } from "./outbox-listener-delivery-required-TTZ3Jc4b.js";
+import { A as version, C as eslint$12, D as eslint$21, E as eslint$11, O as RULE_IDS, S as eslint$5, T as eslint$10, _ as eslint$1, a as eslint$18, b as eslint$3, c as eslint$17, d as eslint$6, f as eslint$7, g as eslint$15, h as eslint$14, i as eslint$23, k as name, l as eslint$20, m as eslint$9, n as eslint$25, o as eslint$19, p as eslint$8, r as eslint$26, s as eslint$16, t as eslint$24, u as eslint$22, v as eslint, w as eslint$13, x as eslint$4, y as eslint$2 } from "./outbox-listener-delivery-required-DzoYEMe6.js";
 import { fromEntries, keys, map, pipe } from "@fxts/core";
 import parser from "@typescript-eslint/parser";
 //#region src/index.ts

package/dist/{outbox-listener-delivery-required-TTZ3Jc4b.js → outbox-listener-delivery-required-DzoYEMe6.js}

@@ -1,7 +1,7 @@
 import { always, every, head, isEmpty, isObject, negate, pipe, pipeLazy, prop, some, toArray, unless, when } from "@fxts/core";
 //#region deno.json
 var name = "@fedify/lint";
-var version = "2.4.0-dev.1995+618fd4e7";
+var version = "2.4.0-dev.2010+498229f4";
 //#endregion
 //#region src/lib/const.ts
 /**
@@ -744,7 +744,7 @@ function getContextParamName(callback) {
 	const contextParam = unwrapAssignmentPattern(callback.params[0]);
 	return contextParam?.type === "Identifier" ? contextParam.name : null;
 }
-const FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
+const FUNCTION_NODE_TYPES$1 = /* @__PURE__ */ new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -762,7 +762,7 @@ function collectLocalBindings(node, bindings) {
 	}
 	const n = node;
 	if (typeof n.type !== "string") return;
-	if (FUNCTION_NODE_TYPES.has(n.type)) 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) {
@@ -796,7 +796,7 @@ function collectReturnedExpressions(callback) {
 			result.push(n.argument ?? null);
 			return;
 		}
-		if (FUNCTION_NODE_TYPES.has(n.type)) return;
+		if (FUNCTION_NODE_TYPES$1.has(n.type)) return;
 		for (const key in n) {
 			if (key === "parent") continue;
 			walk(n[key]);
@@ -1021,6 +1021,12 @@ const isChainedFromOutboxListeners = (expr, 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;
@@ -1160,7 +1166,14 @@ function buildContextExpressionPattern(contextName) {
 	const boundedName = String.raw`(?<![\w$])${name}(?![\w$])`;
 	return String.raw`(?:${boundedName}|\(\s*${boundedName}(?:\s+as\s+[^)]+)?\s*\))`;
 }
-const resolveListenerReference = (expr, bindings, seen = /* @__PURE__ */ new Set()) => {
+/**
+* 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;
@@ -1168,7 +1181,7 @@ const resolveListenerReference = (expr, bindings, seen = /* @__PURE__ */ new Set
 		const binding = bindings.get(expr.name);
 		if (binding == null || !isNode(binding)) return null;
 		if (isFunction(binding) || binding.type === "FunctionDeclaration") return binding;
-		if (binding.type === "Identifier") return resolveListenerReference(binding, bindings, seen);
+		if (binding.type === "Identifier") return resolveFunctionBinding(binding, bindings, seen);
 		return null;
 	}
 	if (expr.type === "MemberExpression" && expr.object.type === "Identifier" && !expr.computed) {
@@ -1185,8 +1198,382 @@ const resolveListenerReference = (expr, bindings, seen = /* @__PURE__ */ new Set
 	}
 	return null;
 };
+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 collectReachableStatements(node, out) {
+	switch (node.type) {
+		case "BlockStatement":
+			for (const [index, statement] of node.body.entries()) {
+				collectReachableStatements(statement, out);
+				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);
+			if (node.alternate != null && !isStaticallyTruthy(test)) collectReachableStatements(node.alternate, out);
+			return;
+		}
+		case "TryStatement":
+			collectReachableStatements(node.block, out);
+			if (node.handler != null) collectReachableStatements(node.handler.body, out);
+			if (node.finalizer != null) collectReachableStatements(node.finalizer, out);
+			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);
+					if (alwaysExits(statement)) break;
+				}
+			}
+			return;
+		case "WhileStatement":
+		case "DoWhileStatement":
+			out.push(node.test);
+			collectReachableStatements(node.body, out);
+			return;
+		case "ForStatement":
+			for (const head of [
+				node.init,
+				node.test,
+				node.update
+			]) if (head != null) out.push(head);
+			collectReachableStatements(node.body, out);
+			return;
+		case "ForInStatement":
+		case "ForOfStatement":
+			out.push(node.right);
+			collectReachableStatements(node.body, out);
+			return;
+		case "LabeledStatement":
+			collectReachableStatements(node.body, out);
+			return;
+		case "WithStatement":
+			out.push(node.object);
+			collectReachableStatements(node.body, out);
+			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) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectReferencedNames(item, out);
+		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);
+		return;
+	}
+	if (n.type === "Property" && !n.computed) {
+		collectReferencedNames(n.value, out);
+		return;
+	}
+	if (n.type === "VariableDeclarator") {
+		if (n.init != null) collectReferencedNames(n.init, out);
+		return;
+	}
+	if (n.type === "ClassDeclaration" || n.type === "ClassExpression") {
+		collectReferencedNames(n.superClass, out);
+		collectReferencedNames(n.body, out);
+		return;
+	}
+	if ((n.type === "MethodDefinition" || n.type === "PropertyDefinition") && !n.computed) {
+		collectReferencedNames(n.value, out);
+		return;
+	}
+	if (n.type === "AssignmentExpression" && n.operator === "=") {
+		if (getAssignmentTargetName(n.left) != null) {
+			collectReferencedNames(n.right, out);
+			return;
+		}
+	}
+	if (isFunctionLikeNode(n)) return;
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectReferencedNames(record[key], out);
+	}
+}
+/**
+* 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;
+	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;
+	}
+}
+/**
+* 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.
+*/
+function collectFunctionsByName(node, out) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectFunctionsByName(item, out);
+		return;
+	}
+	if (!isNode(node)) return;
+	const n = node;
+	const bindTo = (names, from) => {
+		const functions = [];
+		collectHeldFunctions(from, functions);
+		if (functions.length < 1) return;
+		for (const name of names) out.set(name, [...out.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 === "VariableDeclarator") {
+		const decl = n;
+		if (decl.init != null) {
+			const names = [];
+			collectBoundNames(decl.id, names);
+			bindTo(names, decl.init);
+			collectFunctionsByName(decl.init, out);
+		}
+		return;
+	}
+	if (n.type === "AssignmentExpression") {
+		const name = getAssignmentTargetName(n.left);
+		if (name != null) bindTo([name], n.right);
+		collectFunctionsByName(n.right, out);
+		return;
+	}
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectFunctionsByName(record[key], out);
+	}
+}
+/**
+* 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);
+	}
+}
+/**
+* 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.
+*/
+function computeUsedFunctions(root) {
+	const used = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const processScope = (scopeRoot, outerFunctionsByName) => {
+		if (visited.has(scopeRoot)) return;
+		visited.add(scopeRoot);
+		const statements = [];
+		collectReachableStatements(scopeRoot, statements);
+		const functionsHere = /* @__PURE__ */ new Map();
+		for (const statement of statements) collectFunctionsByName(statement, functionsHere);
+		const functionsByName = new Map(outerFunctionsByName);
+		for (const [name, functions] of functionsHere) functionsByName.set(name, functions);
+		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 functions of functionsHere.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 fn of reached) {
+			used.add(fn);
+			processScope(fn.body, functionsByName);
+		}
+	};
+	processScope(root, /* @__PURE__ */ new Map());
+	return used;
+}
+/**
+* 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;
+}
+/**
+* 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, 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) ? collectDeliveryScanCode(sourceCode, fn.body, used, visited) : "";
+			result = result.slice(0, fnStart - statementStart) + (replacement.length > 0 ? replacement : "()=>{}") + result.slice(fnEnd - statementStart);
+		}
+		return result;
+	}).join("\n");
+}
 const listenerCallsDeliveryMethod = (sourceCode, listener) => {
-	const code = stripCommentsAndStrings(sourceCode.getText(listener));
+	const used = computeUsedFunctions(listener.body);
+	const code = stripCommentsAndStrings(collectDeliveryScanCode(sourceCode, listener.body, used, /* @__PURE__ */ new Set()));
 	const aliases = /* @__PURE__ */ new Set();
 	const contextParam = unwrapContextParam(listener.params[0]);
 	const contextName = contextParam?.type === "Identifier" ? contextParam.name : null;
@@ -1224,7 +1611,7 @@ function createRule(buildReport) {
 			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;
+			const resolvedListener = isNode(listener) && isFunction(listener) ? listener : isNode(listener) ? resolveFunctionBinding(listener, bindings) : null;
 			if (resolvedListener == null) return;
 			if (listenerCallsDeliveryMethod(sourceCode, resolvedListener)) return;
 			context.report({

package/dist/{outbox-listener-delivery-required-DDinWqeF.cjs → outbox-listener-delivery-required-glWw7_mh.cjs}

@@ -1,7 +1,7 @@
 let _fxts_core = require("@fxts/core");
 //#region deno.json
 var name = "@fedify/lint";
-var version = "2.4.0-dev.1995+618fd4e7";
+var version = "2.4.0-dev.2010+498229f4";
 //#endregion
 //#region src/lib/const.ts
 /**
@@ -744,7 +744,7 @@ function getContextParamName(callback) {
 	const contextParam = unwrapAssignmentPattern(callback.params[0]);
 	return contextParam?.type === "Identifier" ? contextParam.name : null;
 }
-const FUNCTION_NODE_TYPES = /* @__PURE__ */ new Set([
+const FUNCTION_NODE_TYPES$1 = /* @__PURE__ */ new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -762,7 +762,7 @@ function collectLocalBindings(node, bindings) {
 	}
 	const n = node;
 	if (typeof n.type !== "string") return;
-	if (FUNCTION_NODE_TYPES.has(n.type)) 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) {
@@ -796,7 +796,7 @@ function collectReturnedExpressions(callback) {
 			result.push(n.argument ?? null);
 			return;
 		}
-		if (FUNCTION_NODE_TYPES.has(n.type)) return;
+		if (FUNCTION_NODE_TYPES$1.has(n.type)) return;
 		for (const key in n) {
 			if (key === "parent") continue;
 			walk(n[key]);
@@ -1021,6 +1021,12 @@ const isChainedFromOutboxListeners = (expr, 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;
@@ -1160,7 +1166,14 @@ function buildContextExpressionPattern(contextName) {
 	const boundedName = String.raw`(?<![\w$])${name}(?![\w$])`;
 	return String.raw`(?:${boundedName}|\(\s*${boundedName}(?:\s+as\s+[^)]+)?\s*\))`;
 }
-const resolveListenerReference = (expr, bindings, seen = /* @__PURE__ */ new Set()) => {
+/**
+* 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;
@@ -1168,7 +1181,7 @@ const resolveListenerReference = (expr, bindings, seen = /* @__PURE__ */ new Set
 		const binding = bindings.get(expr.name);
 		if (binding == null || !isNode(binding)) return null;
 		if (isFunction(binding) || binding.type === "FunctionDeclaration") return binding;
-		if (binding.type === "Identifier") return resolveListenerReference(binding, bindings, seen);
+		if (binding.type === "Identifier") return resolveFunctionBinding(binding, bindings, seen);
 		return null;
 	}
 	if (expr.type === "MemberExpression" && expr.object.type === "Identifier" && !expr.computed) {
@@ -1185,8 +1198,382 @@ const resolveListenerReference = (expr, bindings, seen = /* @__PURE__ */ new Set
 	}
 	return null;
 };
+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 collectReachableStatements(node, out) {
+	switch (node.type) {
+		case "BlockStatement":
+			for (const [index, statement] of node.body.entries()) {
+				collectReachableStatements(statement, out);
+				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);
+			if (node.alternate != null && !isStaticallyTruthy(test)) collectReachableStatements(node.alternate, out);
+			return;
+		}
+		case "TryStatement":
+			collectReachableStatements(node.block, out);
+			if (node.handler != null) collectReachableStatements(node.handler.body, out);
+			if (node.finalizer != null) collectReachableStatements(node.finalizer, out);
+			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);
+					if (alwaysExits(statement)) break;
+				}
+			}
+			return;
+		case "WhileStatement":
+		case "DoWhileStatement":
+			out.push(node.test);
+			collectReachableStatements(node.body, out);
+			return;
+		case "ForStatement":
+			for (const head of [
+				node.init,
+				node.test,
+				node.update
+			]) if (head != null) out.push(head);
+			collectReachableStatements(node.body, out);
+			return;
+		case "ForInStatement":
+		case "ForOfStatement":
+			out.push(node.right);
+			collectReachableStatements(node.body, out);
+			return;
+		case "LabeledStatement":
+			collectReachableStatements(node.body, out);
+			return;
+		case "WithStatement":
+			out.push(node.object);
+			collectReachableStatements(node.body, out);
+			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) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectReferencedNames(item, out);
+		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);
+		return;
+	}
+	if (n.type === "Property" && !n.computed) {
+		collectReferencedNames(n.value, out);
+		return;
+	}
+	if (n.type === "VariableDeclarator") {
+		if (n.init != null) collectReferencedNames(n.init, out);
+		return;
+	}
+	if (n.type === "ClassDeclaration" || n.type === "ClassExpression") {
+		collectReferencedNames(n.superClass, out);
+		collectReferencedNames(n.body, out);
+		return;
+	}
+	if ((n.type === "MethodDefinition" || n.type === "PropertyDefinition") && !n.computed) {
+		collectReferencedNames(n.value, out);
+		return;
+	}
+	if (n.type === "AssignmentExpression" && n.operator === "=") {
+		if (getAssignmentTargetName(n.left) != null) {
+			collectReferencedNames(n.right, out);
+			return;
+		}
+	}
+	if (isFunctionLikeNode(n)) return;
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectReferencedNames(record[key], out);
+	}
+}
+/**
+* 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;
+	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;
+	}
+}
+/**
+* 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.
+*/
+function collectFunctionsByName(node, out) {
+	if (node == null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) collectFunctionsByName(item, out);
+		return;
+	}
+	if (!isNode(node)) return;
+	const n = node;
+	const bindTo = (names, from) => {
+		const functions = [];
+		collectHeldFunctions(from, functions);
+		if (functions.length < 1) return;
+		for (const name of names) out.set(name, [...out.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 === "VariableDeclarator") {
+		const decl = n;
+		if (decl.init != null) {
+			const names = [];
+			collectBoundNames(decl.id, names);
+			bindTo(names, decl.init);
+			collectFunctionsByName(decl.init, out);
+		}
+		return;
+	}
+	if (n.type === "AssignmentExpression") {
+		const name = getAssignmentTargetName(n.left);
+		if (name != null) bindTo([name], n.right);
+		collectFunctionsByName(n.right, out);
+		return;
+	}
+	const record = n;
+	for (const key in record) {
+		if (key === "parent") continue;
+		collectFunctionsByName(record[key], out);
+	}
+}
+/**
+* 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);
+	}
+}
+/**
+* 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.
+*/
+function computeUsedFunctions(root) {
+	const used = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const processScope = (scopeRoot, outerFunctionsByName) => {
+		if (visited.has(scopeRoot)) return;
+		visited.add(scopeRoot);
+		const statements = [];
+		collectReachableStatements(scopeRoot, statements);
+		const functionsHere = /* @__PURE__ */ new Map();
+		for (const statement of statements) collectFunctionsByName(statement, functionsHere);
+		const functionsByName = new Map(outerFunctionsByName);
+		for (const [name, functions] of functionsHere) functionsByName.set(name, functions);
+		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 functions of functionsHere.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 fn of reached) {
+			used.add(fn);
+			processScope(fn.body, functionsByName);
+		}
+	};
+	processScope(root, /* @__PURE__ */ new Map());
+	return used;
+}
+/**
+* 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;
+}
+/**
+* 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, 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) ? collectDeliveryScanCode(sourceCode, fn.body, used, visited) : "";
+			result = result.slice(0, fnStart - statementStart) + (replacement.length > 0 ? replacement : "()=>{}") + result.slice(fnEnd - statementStart);
+		}
+		return result;
+	}).join("\n");
+}
 const listenerCallsDeliveryMethod = (sourceCode, listener) => {
-	const code = stripCommentsAndStrings(sourceCode.getText(listener));
+	const used = computeUsedFunctions(listener.body);
+	const code = stripCommentsAndStrings(collectDeliveryScanCode(sourceCode, listener.body, used, /* @__PURE__ */ new Set()));
 	const aliases = /* @__PURE__ */ new Set();
 	const contextParam = unwrapContextParam(listener.params[0]);
 	const contextName = contextParam?.type === "Identifier" ? contextParam.name : null;
@@ -1224,7 +1611,7 @@ function createRule(buildReport) {
 			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;
+			const resolvedListener = isNode(listener) && isFunction(listener) ? listener : isNode(listener) ? resolveFunctionBinding(listener, bindings) : null;
 			if (resolvedListener == null) return;
 			if (listenerCallsDeliveryMethod(sourceCode, resolvedListener)) return;
 			context.report({

package/dist/oxlint.cjs

@@ -1,4 +1,4 @@
-const require_outbox_listener_delivery_required = require("./outbox-listener-delivery-required-DDinWqeF.cjs");
+const require_outbox_listener_delivery_required = require("./outbox-listener-delivery-required-glWw7_mh.cjs");
 //#region src/oxlint.ts
 const rules = {
 	[require_outbox_listener_delivery_required.RULE_IDS.actorIdMismatch]: require_outbox_listener_delivery_required.eslint$17,

package/dist/oxlint.js

@@ -1,4 +1,4 @@
-import { A as version, C as eslint$12, D as eslint$21, E as eslint$11, O as RULE_IDS, S as eslint$5, T as eslint$10, _ as eslint$1, a as eslint$18, b as eslint$3, c as eslint$17, d as eslint$6, f as eslint$7, g as eslint$15, h as eslint$14, i as eslint$23, k as name, l as eslint$20, m as eslint$9, n as eslint$25, o as eslint$19, p as eslint$8, r as eslint$26, s as eslint$16, t as eslint$24, u as eslint$22, v as eslint, w as eslint$13, x as eslint$4, y as eslint$2 } from "./outbox-listener-delivery-required-TTZ3Jc4b.js";
+import { A as version, C as eslint$12, D as eslint$21, E as eslint$11, O as RULE_IDS, S as eslint$5, T as eslint$10, _ as eslint$1, a as eslint$18, b as eslint$3, c as eslint$17, d as eslint$6, f as eslint$7, g as eslint$15, h as eslint$14, i as eslint$23, k as name, l as eslint$20, m as eslint$9, n as eslint$25, o as eslint$19, p as eslint$8, r as eslint$26, s as eslint$16, t as eslint$24, u as eslint$22, v as eslint, w as eslint$13, x as eslint$4, y as eslint$2 } from "./outbox-listener-delivery-required-DzoYEMe6.js";
 //#region src/oxlint.ts
 const rules = {
 	[RULE_IDS.actorIdMismatch]: eslint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/lint",
-  "version": "2.4.0-dev.1995+618fd4e7",
+  "version": "2.4.0-dev.2010+498229f4",
   "description": "Fedify linting rules and plugins",
   "keywords": [
     "Fedify",
@@ -51,7 +51,7 @@
   ],
   "peerDependencies": {
     "eslint": ">=9.0.0",
-    "@fedify/fedify": "^2.4.0-dev.1995+618fd4e7"
+    "@fedify/fedify": "^2.4.0-dev.2010+498229f4"
   },
   "peerDependenciesMeta": {
     "eslint": {
@@ -71,7 +71,7 @@
     "tsdown": "^0.22.0",
     "typescript": "^6.0.0",
     "@fedify/fixture": "2.0.0",
-    "@fedify/vocab": "2.4.0-dev.1995+618fd4e7"
+    "@fedify/vocab": "2.4.0-dev.2010+498229f4"
   },
   "scripts": {
     "build:self": "tsdown",