oxlint-plugin-effect 0.10.0 → 0.12.0

package/README.md

@@ -21,31 +21,42 @@ export default {
 };
 ```
 
-If the project uses JSON configuration, copy the exported rule map into `rules`; every recommended rule has `error` severity.
+If the project uses JSON configuration, copy the exported rule map into `rules`; every recommended rule has `error` severity. The complexity rules carry their limit as an option, `["error", { "max": 21 }]`.
 
 ## Recommended Rules
 
-| Rule                               | Contract                                                                                  |
-| ---------------------------------- | ----------------------------------------------------------------------------------------- |
-| `effect/noAs`                      | Bans TypeScript `as` assertions; use `satisfies`                                          |
-| `effect/noAsyncFunction`           | Bans async functions and await expressions                                                |
-| `effect/noTryCatch`                | Bans every try/catch/finally statement                                                    |
-| `effect/noTestLifecycleHooks`      | Bans `beforeEach`, `afterEach`, `beforeAll`, and `afterAll`; use Effect scopes instead    |
-| `effect/noThrowStatement`          | Bans every throw statement                                                                |
-| `effect/noNewPromise`              | Bans new Promise, Promise calls, and Promise static APIs                                  |
-| `effect/noNewError`                | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
-| `effect/noNullish`                 | Bans null and undefined; use Option or a domain enum for richer state                     |
-| `effect/noModuleMocks`             | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
-| `effect/noTernary`                 | Bans conditional expressions while allowing ordinary if statements                        |
-| `effect/noDynamicImports`          | Allows import() only behind a named lazy-loading boundary; bans require()                 |
-| `effect/noEffectDo`                | Bans Effect.Do                                                                            |
-| `effect/noEffectBind`              | Bans Effect.bind                                                                          |
-| `effect/preferCatchTag`            | Replaces manual `_tag` predicates in `Effect.catchIf` with tagged recovery                |
-| `effect/preferEffectFn`            | Requires `Effect.fn` for a generator operation that adds a span                           |
-| `effect/preferMatchTagsExhaustive` | Requires exhaustive `Match` for return-only `_tag` switches                               |
-| `effect/preferPredicateIsTagged`   | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
-| `effect/noGlobals`                 | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
-| `effect/noNodeBuiltinImport`       | Bans fully replaced Node modules and replaced operations from partial modules             |
+| Rule                                   | Contract                                                                                  |
+| -------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `effect/noAs`                          | Bans TypeScript `as` assertions; use `satisfies`                                          |
+| `effect/noAsyncFunction`               | Bans async functions and await expressions                                                |
+| `effect/noTryCatch`                    | Bans every try/catch/finally statement                                                    |
+| `effect/noTestLifecycleHooks`          | Bans `beforeEach`, `afterEach`, `beforeAll`, and `afterAll`; use Effect scopes instead    |
+| `effect/noThrowStatement`              | Bans every throw statement                                                                |
+| `effect/noNewPromise`                  | Bans new Promise, Promise calls, and Promise static APIs                                  |
+| `effect/noNewError`                    | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
+| `effect/noNullish`                     | Bans null and undefined; use Option or a domain enum for richer state                     |
+| `effect/noModuleMocks`                 | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
+| `effect/noTernary`                     | Bans conditional expressions while allowing ordinary if statements                        |
+| `effect/noManagedRuntimeInEffect`      | Keeps ManagedRuntime construction at non-Effect host boundaries                           |
+| `effect/noInlineProvide`               | Keeps dependency provisioning at explicit composition boundaries                          |
+| `effect/noNestedEffectGen`             | Flattens directly yielded nested generators                                               |
+| `effect/noPerCallCacheConstruction`    | Constructs shared caches once in their owning layer                                       |
+| `effect/noRunCollectOnUnboundedStream` | Requires termination before collecting a clearly unbounded Stream                         |
+| `effect/noSequentialEffectAll`         | Uses explicit sequencing when serial aggregation discards its result                      |
+| `effect/noSilentCatchAll`              | Keeps swallowed failures visible or recovers them truthfully                              |
+| `effect/noUnboundedConcurrency`        | Requires finite concurrency for collections that can grow                                 |
+| `effect/noUnboundedRetry`              | Requires an attempt or duration bound on retry schedules                                  |
+| `effect/noDynamicImports`              | Allows import() only behind a named lazy-loading boundary; bans require()                 |
+| `effect/noEffectDo`                    | Bans Effect.Do                                                                            |
+| `effect/noEffectBind`                  | Bans Effect.bind                                                                          |
+| `effect/preferCatchTag`                | Replaces manual `_tag` predicates and `catchAll` dispatch with tagged recovery            |
+| `effect/preferEffectFn`                | Requires `Effect.fn` for a generator operation that adds a span                           |
+| `effect/preferMatchTagsExhaustive`     | Requires exhaustive `Match` for return-only `_tag` switches and if chains                 |
+| `effect/preferPredicateIsTagged`       | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
+| `effect/preferServiceOf`               | Checks inline Layer implementations through `Service.of`                                  |
+| `effect/requireNamedEffectFn`          | Requires stable names for `Effect.fn` operations                                          |
+| `effect/noGlobals`                     | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
+| `effect/noNodeBuiltinImport`           | Bans fully replaced Node modules and replaced operations from partial modules             |
 
 ## Anti-Slop Rules
 
@@ -69,6 +80,31 @@ See `THIRD_PARTY_NOTICES.md` for the source revision and license.
 
 The preset intentionally allows `Effect.as`, `Option.as`, `Effect.never`, `Effect.async`, simple `_tag` guards, partial or stateful `switch` statements, and runtime runners at explicit application boundaries.
 
+## Complexity Rules
+
+The recommended preset caps three complexity metrics for every function. Each nested function is measured as its own unit, so a heavy `Effect.gen` body is reported on the generator, not on the surrounding pipeline.
+
+| Rule                            | Metric                                     | Limit |
+| ------------------------------- | ------------------------------------------ | ----- |
+| `complexity` (native oxlint)    | Cyclomatic complexity                      | 21    |
+| `effect/maxCognitiveComplexity` | Cognitive complexity (SonarSource)         | 21    |
+| `effect/maxHalsteadDifficulty`  | Halstead difficulty `(η1 / 2) × (N2 / η2)` | 79    |
+
+Cognitive complexity charges one for every `if`, loop, `switch`, `catch`, and ternary, plus one for each level of nesting the structure sits in. `else` and `else if` charge one without nesting. Each run of like logical operators (`&&`, `||`, `??`) charges one, and so does a labelled `break` or `continue`.
+
+Halstead difficulty treats every name and literal as an operand and every piece of syntax that acts on them as an operator: calls, member access, keywords, declarations, and arithmetic, logical, and assignment operators. Type annotations and type-only declarations never count.
+
+Tighten or relax a limit per project or per file by passing a different `max`:
+
+```json
+{
+  "rules": {
+    "effect/maxCognitiveComplexity": ["error", { "max": 15 }],
+    "effect/maxHalsteadDifficulty": ["error", { "max": 60 }]
+  }
+}
+```
+
 ## Platform Boundaries
 
 Application code should use Effect services for time, randomness, crypto randomness and supported digests, configuration, files, paths, child processes, stdio, HTTP, sockets, workers, streams, logging, JSON boundaries, encoding, and key-value storage.

package/dist/presets/recommended.d.ts

@@ -5,6 +5,15 @@
  * AUTO-GENERATED by scripts/codegen.ts — do not edit manually.
  */
 declare const recommended: {
+  readonly complexity: readonly ["error", {
+    readonly max: 21;
+  }];
+  readonly "effect/maxCognitiveComplexity": readonly ["error", {
+    readonly max: 21;
+  }];
+  readonly "effect/maxHalsteadDifficulty": readonly ["error", {
+    readonly max: 79;
+  }];
   readonly "effect/noAs": "error";
   readonly "effect/noAsyncFunction": "error";
   readonly "effect/noChainedTypeAssertions": "error";
@@ -13,19 +22,28 @@ declare const recommended: {
   readonly "effect/noEffectBind": "error";
   readonly "effect/noEffectDo": "error";
   readonly "effect/noGlobals": "error";
+  readonly "effect/noInlineProvide": "error";
   readonly "effect/noKnownValueWidening": "error";
+  readonly "effect/noManagedRuntimeInEffect": "error";
   readonly "effect/noModuleMocks": "error";
+  readonly "effect/noNestedEffectGen": "error";
   readonly "effect/noNewError": "error";
   readonly "effect/noNewPromise": "error";
   readonly "effect/noNodeBuiltinImport": "error";
   readonly "effect/noNullish": "error";
   readonly "effect/noObjectParameters": "error";
+  readonly "effect/noPerCallCacheConstruction": "error";
+  readonly "effect/noRunCollectOnUnboundedStream": "error";
   readonly "effect/noRuntimeTypeof": "error";
+  readonly "effect/noSequentialEffectAll": "error";
   readonly "effect/noShapeInSymbolNames": "error";
+  readonly "effect/noSilentCatchAll": "error";
   readonly "effect/noTernary": "error";
   readonly "effect/noTestLifecycleHooks": "error";
   readonly "effect/noThrowStatement": "error";
   readonly "effect/noTryCatch": "error";
+  readonly "effect/noUnboundedConcurrency": "error";
+  readonly "effect/noUnboundedRetry": "error";
   readonly "effect/noUnknownParameters": "error";
   readonly "effect/noUnknownTypeAliases": "error";
   readonly "effect/noUnsafeDictionaryType": "error";
@@ -34,6 +52,8 @@ declare const recommended: {
   readonly "effect/preferEffectFn": "error";
   readonly "effect/preferMatchTagsExhaustive": "error";
   readonly "effect/preferPredicateIsTagged": "error";
+  readonly "effect/preferServiceOf": "error";
+  readonly "effect/requireNamedEffectFn": "error";
 };
 //#endregion
 export { recommended };

package/dist/presets/recommended.js

@@ -5,6 +5,9 @@
 * AUTO-GENERATED by scripts/codegen.ts — do not edit manually.
 */
 const recommended = {
+	complexity: ["error", { max: 21 }],
+	"effect/maxCognitiveComplexity": ["error", { max: 21 }],
+	"effect/maxHalsteadDifficulty": ["error", { max: 79 }],
 	"effect/noAs": "error",
 	"effect/noAsyncFunction": "error",
 	"effect/noChainedTypeAssertions": "error",
@@ -13,19 +16,28 @@ const recommended = {
 	"effect/noEffectBind": "error",
 	"effect/noEffectDo": "error",
 	"effect/noGlobals": "error",
+	"effect/noInlineProvide": "error",
 	"effect/noKnownValueWidening": "error",
+	"effect/noManagedRuntimeInEffect": "error",
 	"effect/noModuleMocks": "error",
+	"effect/noNestedEffectGen": "error",
 	"effect/noNewError": "error",
 	"effect/noNewPromise": "error",
 	"effect/noNodeBuiltinImport": "error",
 	"effect/noNullish": "error",
 	"effect/noObjectParameters": "error",
+	"effect/noPerCallCacheConstruction": "error",
+	"effect/noRunCollectOnUnboundedStream": "error",
 	"effect/noRuntimeTypeof": "error",
+	"effect/noSequentialEffectAll": "error",
 	"effect/noShapeInSymbolNames": "error",
+	"effect/noSilentCatchAll": "error",
 	"effect/noTernary": "error",
 	"effect/noTestLifecycleHooks": "error",
 	"effect/noThrowStatement": "error",
 	"effect/noTryCatch": "error",
+	"effect/noUnboundedConcurrency": "error",
+	"effect/noUnboundedRetry": "error",
 	"effect/noUnknownParameters": "error",
 	"effect/noUnknownTypeAliases": "error",
 	"effect/noUnsafeDictionaryType": "error",
@@ -33,7 +45,9 @@ const recommended = {
 	"effect/preferCatchTag": "error",
 	"effect/preferEffectFn": "error",
 	"effect/preferMatchTagsExhaustive": "error",
-	"effect/preferPredicateIsTagged": "error"
+	"effect/preferPredicateIsTagged": "error",
+	"effect/preferServiceOf": "error",
+	"effect/requireNamedEffectFn": "error"
 };
 //#endregion
 export { recommended };

package/dist/rules/_effect-context.js

@@ -0,0 +1,27 @@
+import { isStaticCall, isStaticMember } from "./_effect-namespaces.js";
+//#region src/rules/_effect-context.ts
+const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const effectProgramKind = (node, effectNamespaces) => {
+	const parent = node.parent;
+	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return void 0;
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "gen")) return "gen";
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fn")) return "fn";
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
+	if (parent.callee.type !== "CallExpression") return void 0;
+	if (isStaticCall(parent.callee, effectNamespaces, "fn")) return "fn";
+	if (isStaticCall(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
+};
+const enclosingEffectProgram = (node, effectNamespaces) => {
+	let current = node.parent;
+	while (current !== void 0 && current !== null) {
+		if (isFunction(current)) {
+			const kind = effectProgramKind(current, effectNamespaces);
+			if (kind === void 0) return void 0;
+			return [current, kind];
+		}
+		current = current.parent;
+	}
+};
+const isInsideEffectProgram = (node, effectNamespaces) => enclosingEffectProgram(node, effectNamespaces) !== void 0;
+//#endregion
+export { enclosingEffectProgram, isInsideEffectProgram };

package/dist/rules/_effect-namespaces.js

@@ -0,0 +1,25 @@
+import { findVariableUp } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+//#region src/rules/_effect-namespaces.ts
+const importedNamespaces = (node, exportName, directModule) => {
+	const source = node.source.value;
+	if (source !== "effect" && source !== directModule) return [];
+	const namespaces = [];
+	for (const specifier of node.specifiers) {
+		if (specifier.type === "ImportNamespaceSpecifier" && source === directModule) {
+			namespaces.push(specifier.local.name);
+			continue;
+		}
+		if (specifier.type === "ImportSpecifier" && source === "effect" && specifier.imported.type === "Identifier" && specifier.imported.name === exportName) namespaces.push(specifier.local.name);
+	}
+	return namespaces;
+};
+const visibleNamespaces = (ctx, node, namespaces) => new Set([...namespaces].filter((namespace) => Option.match(findVariableUp(ctx.sourceCode.getScope(node), namespace), {
+	onNone: () => true,
+	onSome: (variable) => variable.defs.some((definition) => definition.type === "ImportBinding")
+})));
+const isStaticMember = (node, namespaces, property) => node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && namespaces.has(node.object.name) && node.property.type === "Identifier" && node.property.name === property;
+const isStaticCall = (node, namespaces, property) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, namespaces, property);
+//#endregion
+export { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces };

package/dist/rules/_function-metrics.js

@@ -0,0 +1,283 @@
+//#region src/rules/_function-metrics.ts
+const isNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const isFunctionType = (type) => type === "ArrowFunctionExpression" || type === "FunctionDeclaration" || type === "FunctionExpression";
+const isFunctionNode = (node) => isFunctionType(node.type);
+/** Slots that hold the parent link, source positions, or type-level syntax. */
+const structuralKeys = new Set([
+	"parent",
+	"loc",
+	"range",
+	"start",
+	"end",
+	"typeAnnotation",
+	"returnType",
+	"typeParameters",
+	"typeArguments",
+	"superTypeArguments",
+	"implements",
+	"decorators"
+]);
+/** TypeScript expression wrappers whose `expression` slot is runtime code. */
+const transparentTypeWrappers = new Set([
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSNonNullExpression",
+	"TSTypeAssertion",
+	"TSInstantiationExpression"
+]);
+const isTypeOnly = (node) => node.type.startsWith("TS") && !transparentTypeWrappers.has(node.type);
+const slot = (node, key) => {
+	const value = node[key];
+	if (isNode(value)) return [value];
+	if (Array.isArray(value)) return value.filter(isNode);
+	return [];
+};
+/** Runtime child nodes of `node`, in source order of their slots. */
+const children = (node) => {
+	if (transparentTypeWrappers.has(node.type)) return slot(node, "expression");
+	const found = [];
+	for (const key of Object.keys(node)) {
+		if (structuralKeys.has(key)) continue;
+		for (const child of slot(node, key)) if (!isTypeOnly(child)) found.push(child);
+	}
+	return found;
+};
+/** The nodes that form the body of a function unit: its parameters and its body. */
+const unitRoots = (fn) => {
+	const node = fn;
+	return [...slot(node, "params"), ...slot(node, "body")];
+};
+/**
+* Flatten a logical expression tree into its operator sequence, left to right.
+* `a && b || c` yields `["&&", "||"]`.
+*/
+const logicalOperators = (node, into) => {
+	if (node.type !== "LogicalExpression") return;
+	for (const side of slot(node, "left")) logicalOperators(side, into);
+	into.push(String(node.operator));
+	for (const side of slot(node, "right")) logicalOperators(side, into);
+};
+/** Leaf operands of a logical expression tree, in source order. */
+const logicalLeaves = (node, into) => {
+	if (node.type !== "LogicalExpression") {
+		into.push(node);
+		return;
+	}
+	for (const side of slot(node, "left")) logicalLeaves(side, into);
+	for (const side of slot(node, "right")) logicalLeaves(side, into);
+};
+/**
+* Cognitive complexity of one function, excluding nested functions.
+*
+* - `if`, loops, `switch`, `catch`, and `?:` cost one plus the current nesting level.
+* - `else` and `else if` cost one and never pay for nesting.
+* - A labelled `break` or `continue` costs one.
+* - Each run of like logical operators (`&&`, `||`, `??`) costs one.
+* - The bodies of nesting structures raise the nesting level by one.
+*/
+const cognitiveComplexity = (fn) => {
+	let total = 0;
+	const visitSlot = (node, key, nesting) => {
+		for (const child of slot(node, key)) visit(child, nesting);
+	};
+	const visitIf = (node, nesting, isElseIf) => {
+		total += isElseIf ? 1 : 1 + nesting;
+		visitSlot(node, "test", nesting);
+		visitSlot(node, "consequent", nesting + 1);
+		for (const alternate of slot(node, "alternate")) if (alternate.type === "IfStatement") visitIf(alternate, nesting, true);
+		else {
+			total += 1;
+			visit(alternate, nesting + 1);
+		}
+	};
+	const visitNesting = (node, nesting, headerKeys, bodyKeys) => {
+		total += 1 + nesting;
+		for (const key of headerKeys) visitSlot(node, key, nesting);
+		for (const key of bodyKeys) visitSlot(node, key, nesting + 1);
+	};
+	const visit = (node, nesting) => {
+		if (isTypeOnly(node)) return;
+		switch (node.type) {
+			case "ArrowFunctionExpression":
+			case "FunctionDeclaration":
+			case "FunctionExpression": return;
+			case "IfStatement": return visitIf(node, nesting, false);
+			case "ConditionalExpression": return visitNesting(node, nesting, ["test"], ["consequent", "alternate"]);
+			case "SwitchStatement": return visitNesting(node, nesting, ["discriminant"], ["cases"]);
+			case "ForStatement": return visitNesting(node, nesting, [
+				"init",
+				"test",
+				"update"
+			], ["body"]);
+			case "ForInStatement":
+			case "ForOfStatement": return visitNesting(node, nesting, ["left", "right"], ["body"]);
+			case "WhileStatement":
+			case "DoWhileStatement": return visitNesting(node, nesting, ["test"], ["body"]);
+			case "CatchClause": return visitNesting(node, nesting, ["param"], ["body"]);
+			case "BreakStatement":
+			case "ContinueStatement":
+				if (isNode(node.label)) total += 1;
+				return;
+			case "LogicalExpression": {
+				const operators = [];
+				logicalOperators(node, operators);
+				total += operators.filter((operator, index) => operator !== operators[index - 1]).length;
+				const leaves = [];
+				logicalLeaves(node, leaves);
+				for (const leaf of leaves) visit(leaf, nesting);
+				return;
+			}
+			default: for (const child of children(node)) visit(child, nesting);
+		}
+	};
+	for (const root of unitRoots(fn)) visit(root, 0);
+	return total;
+};
+/** Halstead difficulty: `(η1 / 2) × (N2 / η2)`. Zero when the unit has no operands. */
+const halsteadDifficulty = (counts) => {
+	if (counts.distinctOperands === 0) return 0;
+	return counts.distinctOperators / 2 * (counts.totalOperands / counts.distinctOperands);
+};
+const functionOperator = (node) => {
+	if (node.type === "ArrowFunctionExpression") return "=>";
+	return node.generator === true ? "function*" : "function";
+};
+const literalOperand = (node) => {
+	if (typeof node.raw === "string") return node.raw;
+	if (typeof node.bigint === "string") return `${node.bigint}n`;
+	return String(node.value);
+};
+const templateOperand = (node) => {
+	const value = node.value;
+	if (typeof value !== "object" || value === null) return null;
+	const raw = value.raw;
+	return typeof raw === "string" && raw.length > 0 ? raw : null;
+};
+/** Node types that always stand for the same operator tokens. */
+const fixedOperators = {
+	ForStatement: ["for"],
+	ForInStatement: ["for-in"],
+	WhileStatement: ["while"],
+	DoWhileStatement: ["do-while"],
+	SwitchStatement: ["switch"],
+	ReturnStatement: ["return"],
+	ThrowStatement: ["throw"],
+	CatchClause: ["catch"],
+	BreakStatement: ["break"],
+	ContinueStatement: ["continue"],
+	LabeledStatement: [":"],
+	DebuggerStatement: ["debugger"],
+	WithStatement: ["with"],
+	AssignmentPattern: ["="],
+	NewExpression: ["new"],
+	ArrayExpression: ["[]"],
+	ArrayPattern: ["[]"],
+	ObjectExpression: ["{}"],
+	ObjectPattern: ["{}"],
+	SpreadElement: ["..."],
+	RestElement: ["..."],
+	ConditionalExpression: ["?:"],
+	SequenceExpression: [","],
+	AwaitExpression: ["await"],
+	ImportExpression: ["import()"],
+	TemplateLiteral: ["`"],
+	JSXElement: ["<>"],
+	JSXFragment: ["<>"]
+};
+/** Node types whose operator token carries the operator itself. */
+const operatorCarriers = new Set([
+	"BinaryExpression",
+	"LogicalExpression",
+	"AssignmentExpression",
+	"UnaryExpression",
+	"UpdateExpression"
+]);
+/** Statement-level nodes whose operator tokens depend on the node's shape. */
+const statementOperators = (node) => {
+	switch (node.type) {
+		case "IfStatement": return isNode(node.alternate) ? ["if", "else"] : ["if"];
+		case "ForOfStatement": return node.await === true ? ["for-await-of"] : ["for-of"];
+		case "SwitchCase": return isNode(node.test) ? ["case"] : ["default"];
+		case "TryStatement": return isNode(node.finalizer) ? ["try", "finally"] : ["try"];
+		case "VariableDeclaration": return [String(node.kind)];
+		case "VariableDeclarator": return isNode(node.init) ? ["="] : [];
+		case "ClassDeclaration":
+		case "ClassExpression": return isNode(node.superClass) ? ["class", "extends"] : ["class"];
+		case "PropertyDefinition": return isNode(node.value) ? ["="] : [];
+		default: return [];
+	}
+};
+/** Expression-level nodes whose operator tokens depend on the node's shape. */
+const expressionOperators = (node) => {
+	if (operatorCarriers.has(node.type)) return [String(node.operator)];
+	switch (node.type) {
+		case "CallExpression": return node.optional === true ? ["?.()"] : ["()"];
+		case "MemberExpression": {
+			const access = node.computed === true ? "[]" : ".";
+			return node.optional === true ? [`?${access}`] : [access];
+		}
+		case "Property":
+			if (node.kind === "get" || node.kind === "set") return [String(node.kind)];
+			return node.shorthand === true || node.method === true ? [] : [":"];
+		case "YieldExpression": return node.delegate === true ? ["yield*"] : ["yield"];
+		case "JSXAttribute": return isNode(node.value) ? ["="] : [];
+		case "ArrowFunctionExpression":
+		case "FunctionDeclaration":
+		case "FunctionExpression": return node.async === true ? ["async", functionOperator(node)] : [functionOperator(node)];
+		default: return [];
+	}
+};
+/** Every operator token a node stands for. */
+const operatorsOf = (node) => [
+	...fixedOperators[node.type] ?? [],
+	...statementOperators(node),
+	...expressionOperators(node)
+];
+/** The operand a leaf node contributes, if any. */
+const operandOf = (node) => {
+	switch (node.type) {
+		case "Identifier":
+		case "JSXIdentifier": return String(node.name);
+		case "PrivateIdentifier": return `#${String(node.name)}`;
+		case "Literal": return literalOperand(node);
+		case "TemplateElement": return templateOperand(node);
+		case "ThisExpression": return "this";
+		case "Super": return "super";
+		case "MetaProperty": return `${isNode(node.meta) ? String(node.meta.name) : ""}.${isNode(node.property) ? String(node.property.name) : ""}`;
+		case "JSXText": {
+			const text = String(node.value).trim();
+			return text.length > 0 ? text : null;
+		}
+		default: return null;
+	}
+};
+/**
+* Halstead operator and operand counts of one function, excluding nested
+* functions. A nested function contributes only its own `function` or `=>`
+* operator to the enclosing unit.
+*/
+const halstead = (fn) => {
+	const operators = /* @__PURE__ */ new Map();
+	const operands = /* @__PURE__ */ new Map();
+	const tally = (into, token) => {
+		into.set(token, (into.get(token) ?? 0) + 1);
+	};
+	const visit = (node) => {
+		if (isTypeOnly(node)) return;
+		for (const operator of operatorsOf(node)) tally(operators, operator);
+		const operand = operandOf(node);
+		if (operand !== null) tally(operands, operand);
+		if (isFunctionType(node.type) || node.type === "MetaProperty") return;
+		for (const child of children(node)) visit(child);
+	};
+	for (const root of unitRoots(fn)) visit(root);
+	const total = (counts) => Array.from(counts.values()).reduce((sum, count) => sum + count, 0);
+	return {
+		distinctOperators: operators.size,
+		totalOperators: total(operators),
+		distinctOperands: operands.size,
+		totalOperands: total(operands)
+	};
+};
+//#endregion
+export { cognitiveComplexity, halstead, halsteadDifficulty, isFunctionNode };

package/dist/rules/_max-option.js

@@ -0,0 +1,19 @@
+import * as Schema from "effect/Schema";
+//#region src/rules/_max-option.ts
+const MaxOptions = Schema.UndefinedOr(Schema.Struct({ max: Schema.optionalKey(Schema.Number) }));
+const maxOptionsMeta = (defaultMax) => ({
+	schema: [{
+		type: "object",
+		properties: { max: {
+			type: "integer",
+			minimum: 0
+		} },
+		additionalProperties: false
+	}],
+	defaultOptions: [{ max: defaultMax }],
+	recommendedOptions: { max: defaultMax }
+});
+/** The configured limit, or the rule default when the harness supplies no options. */
+const resolveMax = (options, defaultMax) => options?.max ?? defaultMax;
+//#endregion
+export { MaxOptions, maxOptionsMeta, resolveMax };

package/dist/rules/_tagged-control-flow.js

@@ -76,4 +76,4 @@ const isInsideCatchAllHandler = (node) => {
 };
 const taggedSwitchSubject = (node) => taggedSubject(node.discriminant);
 //#endregion
-export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparisonsInOr, taggedSwitchSubject };
+export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparison, tagComparisonsInOr, taggedSwitchSubject };

package/dist/rules/index.d.ts

@@ -1,24 +1,35 @@
 import { noEffectBind } from "./no-effect-bind.js";
 import { noEffectDo } from "./no-effect-do.js";
+import { maxCognitiveComplexity } from "./max-cognitive-complexity.js";
+import { maxHalsteadDifficulty } from "./max-halstead-difficulty.js";
 import { noAs } from "./no-as.js";
 import { noAsyncFunction } from "./no-async-function.js";
 import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
 import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
+import { noInlineProvide } from "./no-inline-provide.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
+import { noManagedRuntimeInEffect } from "./no-managed-runtime-in-effect.js";
 import { noModuleMocks } from "./no-module-mocks.js";
+import { noNestedEffectGen } from "./no-nested-effect-gen.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
 import { noObjectParameters } from "./no-object-parameters.js";
+import { noPerCallCacheConstruction } from "./no-per-call-cache-construction.js";
+import { noRunCollectOnUnboundedStream } from "./no-run-collect-on-unbounded-stream.js";
 import { noRuntimeTypeof } from "./no-runtime-typeof.js";
+import { noSequentialEffectAll } from "./no-sequential-effect-all.js";
 import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
+import { noSilentCatchAll } from "./no-silent-catch-all.js";
 import { noTernary } from "./no-ternary.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
+import { noUnboundedConcurrency } from "./no-unbounded-concurrency.js";
+import { noUnboundedRetry } from "./no-unbounded-retry.js";
 import { noUnknownParameters } from "./no-unknown-parameters.js";
 import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
 import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
@@ -27,10 +38,12 @@ import { preferCatchTag } from "./prefer-catch-tag.js";
 import { preferEffectFn } from "./prefer-effect-fn.js";
 import { preferMatchTagsExhaustive } from "./prefer-match-tags-exhaustive.js";
 import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
+import { preferServiceOf } from "./prefer-service-of.js";
+import { requireNamedEffectFn } from "./require-named-effect-fn.js";
 
 //#region src/rules/index.d.ts
 declare namespace index_d_exports {
-  export { noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noKnownValueWidening, noModuleMocks, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noRuntimeTypeof, noShapeInSymbolNames, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged };
+  export { maxCognitiveComplexity, maxHalsteadDifficulty, noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noInlineProvide, noKnownValueWidening, noManagedRuntimeInEffect, noModuleMocks, noNestedEffectGen, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noPerCallCacheConstruction, noRunCollectOnUnboundedStream, noRuntimeTypeof, noSequentialEffectAll, noShapeInSymbolNames, noSilentCatchAll, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnboundedConcurrency, noUnboundedRetry, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged, preferServiceOf, requireNamedEffectFn };
 }
 //#endregion
 export { index_d_exports };