oxlint-plugin-effect 0.11.0 → 0.12.0

package/README.md

@@ -21,7 +21,7 @@ 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
 
@@ -80,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";

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",

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/index.d.ts

@@ -1,5 +1,7 @@
 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";
@@ -41,7 +43,7 @@ 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, 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 };
+  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 };

package/dist/rules/index.js

@@ -1,6 +1,8 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 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";
@@ -41,6 +43,8 @@ import { preferServiceOf } from "./prefer-service-of.js";
 import { requireNamedEffectFn } from "./require-named-effect-fn.js";
 //#region src/rules/index.ts
 var rules_exports = /* @__PURE__ */ __exportAll({
+	maxCognitiveComplexity: () => maxCognitiveComplexity,
+	maxHalsteadDifficulty: () => maxHalsteadDifficulty,
 	noAs: () => noAs,
 	noAsyncFunction: () => noAsyncFunction,
 	noChainedTypeAssertions: () => noChainedTypeAssertions,

package/dist/rules/max-cognitive-complexity.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/max-cognitive-complexity.d.ts
+declare const maxCognitiveComplexity: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { maxCognitiveComplexity };

package/dist/rules/max-cognitive-complexity.js

@@ -0,0 +1,43 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { cognitiveComplexity, isFunctionNode } from "./_function-metrics.js";
+import { MaxOptions, maxOptionsMeta, resolveMax } from "./_max-option.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/max-cognitive-complexity.ts
+const DEFAULT_MAX = 21;
+const maxCognitiveComplexity = define({
+	name: "max-cognitive-complexity",
+	meta: meta({
+		type: "suggestion",
+		description: "Keep every function below the cognitive complexity limit.",
+		messages: { tooComplex: "Function has a cognitive complexity of {{value}}. Maximum allowed is {{max}}. Split it into named operations." },
+		...maxOptionsMeta(DEFAULT_MAX)
+	}),
+	options: MaxOptions,
+	create: function* (options) {
+		const context = yield* RuleContext;
+		const max = resolveMax(options, DEFAULT_MAX);
+		const check = (node) => {
+			if (!isFunctionNode(node)) return Effect.void;
+			const value = cognitiveComplexity(node);
+			if (value <= max) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "tooComplex",
+				data: {
+					value: String(value),
+					max: String(max)
+				}
+			}));
+		};
+		return {
+			ArrowFunctionExpression: check,
+			FunctionDeclaration: check,
+			FunctionExpression: check
+		};
+	}
+});
+//#endregion
+export { maxCognitiveComplexity };

package/dist/rules/max-halstead-difficulty.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/max-halstead-difficulty.d.ts
+declare const maxHalsteadDifficulty: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { maxHalsteadDifficulty };

package/dist/rules/max-halstead-difficulty.js

@@ -0,0 +1,44 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { halstead, halsteadDifficulty, isFunctionNode } from "./_function-metrics.js";
+import { MaxOptions, maxOptionsMeta, resolveMax } from "./_max-option.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/max-halstead-difficulty.ts
+const DEFAULT_MAX = 79;
+const formatDifficulty = (value) => String(Math.round(value * 10) / 10);
+const maxHalsteadDifficulty = define({
+	name: "max-halstead-difficulty",
+	meta: meta({
+		type: "suggestion",
+		description: "Keep every function below the Halstead difficulty limit.",
+		messages: { tooDifficult: "Function has a Halstead difficulty of {{value}}. Maximum allowed is {{max}}. Extract repeated expressions into named values." },
+		...maxOptionsMeta(DEFAULT_MAX)
+	}),
+	options: MaxOptions,
+	create: function* (options) {
+		const context = yield* RuleContext;
+		const max = resolveMax(options, DEFAULT_MAX);
+		const check = (node) => {
+			if (!isFunctionNode(node)) return Effect.void;
+			const value = halsteadDifficulty(halstead(node));
+			if (value <= max) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "tooDifficult",
+				data: {
+					value: formatDifficulty(value),
+					max: String(max)
+				}
+			}));
+		};
+		return {
+			ArrowFunctionExpression: check,
+			FunctionDeclaration: check,
+			FunctionExpression: check
+		};
+	}
+});
+//#endregion
+export { maxHalsteadDifficulty };

package/dist/vendor/effect-oxlint/Rule.d.ts

@@ -71,7 +71,17 @@ declare const meta: (opts: {
   readonly hasSuggestions?: boolean | undefined;
   readonly messages?: Record<string, string> | undefined;
   readonly docs?: RuleDocs | undefined;
-  readonly effectVersion?: EffectVersion | undefined;
+  readonly effectVersion?: EffectVersion | undefined; /** JSON schema for the rule options. Oxlint rejects options on rules without one. */
+  readonly schema?: RuleMeta["schema"] | undefined; /** Options oxlint merges underneath the user's configuration. */
+  readonly defaultOptions?: RuleMeta["defaultOptions"] | undefined;
+  /**
+   * Options the recommended preset passes to this rule.
+   *
+   * Stored on `meta.docs.recommendedOptions`. The preset generator emits
+   * `["error", recommendedOptions]` instead of a bare `"error"` entry, so
+   * the rule's default threshold and the published preset stay in sync.
+   */
+  readonly recommendedOptions?: Record<string, unknown> | undefined;
 }) => RuleMeta;
 /**
  * Create a rule that bans `obj.prop` member expression access.

package/dist/vendor/effect-oxlint/Rule.js

@@ -66,9 +66,12 @@ const meta = (opts) => ({
 	...opts.fixable !== void 0 ? { fixable: opts.fixable } : {},
 	...opts.hasSuggestions !== void 0 ? { hasSuggestions: opts.hasSuggestions } : {},
 	...opts.messages !== void 0 ? { messages: opts.messages } : {},
+	...opts.schema !== void 0 ? { schema: opts.schema } : {},
+	...opts.defaultOptions !== void 0 ? { defaultOptions: opts.defaultOptions } : {},
 	docs: {
 		description: opts.description,
 		effectVersion: opts.effectVersion ?? "both",
+		...opts.recommendedOptions !== void 0 ? { recommendedOptions: opts.recommendedOptions } : {},
 		...opts.docs
 	}
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
   "repository": {