oxlint-plugin-effect 0.2.0 → 0.2.2

package/dist/rules/no-redundant-schema-tag-identifier.js

@@ -0,0 +1,46 @@
+import { matchCallOf } from "../vendor/effect-oxlint/AST.js";
+import { make } 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 * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-redundant-schema-tag-identifier.ts
+const isTagKey = (key) => {
+	if (key.type === "Identifier" && "name" in key && key.name === "_tag") return true;
+	if (key.type === "Literal" && "value" in key && key.value === "_tag") return true;
+	return false;
+};
+const noRedundantSchemaTagIdentifier = define({
+	name: "no-redundant-schema-tag-identifier",
+	meta: meta({
+		type: "suggestion",
+		description: "Redundant _tag in TaggedStruct. TaggedStruct already provides _tag automatically."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			if (Option.isNone(matchCallOf(call, "Schema", "TaggedStruct"))) return Effect.void;
+			const args = call.arguments;
+			if (args.length < 2) return Effect.void;
+			const fieldsArg = args[1];
+			if (fieldsArg === void 0) return Effect.void;
+			if (fieldsArg.type !== "ObjectExpression") return Effect.void;
+			const props = fieldsArg["properties"];
+			if (!Array.isArray(props)) return Effect.void;
+			for (const prop of props) {
+				const p = prop;
+				if (p.type !== "Property") continue;
+				const key = p["key"];
+				if (isTagKey(key)) return ctx.report(make({
+					node: p,
+					message: "Redundant _tag property. Schema.TaggedStruct already provides _tag automatically."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noRedundantSchemaTagIdentifier };

package/dist/rules/no-return-in-arrow.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-return-in-arrow.d.ts
+declare const noReturnInArrow: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noReturnInArrow };

package/dist/rules/no-return-in-arrow.js

@@ -0,0 +1,41 @@
+import { make } 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 * as Effect from "effect/Effect";
+//#region src/rules/no-return-in-arrow.ts
+/**
+* Ban explicit `return` in arrow function callbacks (info severity).
+*
+* Use expression-only callbacks + pipeline logic.
+* Excludes Schema.filter callbacks where return is required.
+*
+* Source: biome-effect-linting-rules/no-return-in-arrow
+*/
+const noReturnInArrow = define({
+	name: "no-return-in-arrow",
+	meta: meta({
+		type: "suggestion",
+		description: "Prefer expression-only arrow callbacks. Avoid explicit return in arrow functions."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { ArrowFunctionExpression: (node) => {
+			if ("body" in node && node.body != null && typeof node.body === "object" && "type" in node.body && node.body.type === "BlockStatement" && "body" in node.body && Array.isArray(node.body.body)) {
+				for (const stmt of node.body.body) if (stmt != null && typeof stmt === "object" && "type" in stmt && stmt.type === "ReturnStatement") {
+					if ("parent" in node && node.parent != null && typeof node.parent === "object" && "type" in node.parent && node.parent.type === "CallExpression" && "callee" in node.parent) {
+						const callee = node.parent.callee;
+						if (callee != null && typeof callee === "object" && "type" in callee && callee.type === "MemberExpression" && "property" in callee && callee.property != null && typeof callee.property === "object" && "name" in callee.property && (callee.property.name === "filter" || callee.property.name === "check")) return Effect.void;
+					}
+					return ctx.report(make({
+						node: stmt,
+						message: "Prefer expression-only arrow callbacks over explicit return."
+					}));
+				}
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noReturnInArrow };

package/dist/rules/no-return-nullish.d.ts

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

package/dist/rules/no-return-nullish.js

@@ -0,0 +1,47 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { merge } from "../vendor/effect-oxlint/Visitor.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { makeEffectContextTracker } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/rules/no-return-nullish.ts
+/**
+* Ban `return null`, `return undefined`, `return void 0`. Context-aware messaging.
+*
+* Inside Effect.gen/fn: "Use Option.none() or Effect.void"
+* Outside: "Use Option.none() — convert nullish at system boundaries with Option.fromNullable"
+*
+* Source: biome-effect-linting-rules/no-return-null (extended)
+*/
+const noReturnNullish = define({
+	name: "no-return-nullish",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid returning null/undefined. Use Option.none() for absence or Effect.void for void effects."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const [depth, tracker] = yield* makeEffectContextTracker;
+		return merge(tracker, { ReturnStatement: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+			if (node.type !== "ReturnStatement" || !("argument" in node) || node.argument === null || node.argument === void 0) return Effect.void;
+			const arg = node.argument;
+			if (arg["type"] === "Literal" && arg["value"] === null) return ctx.report(make({
+				node,
+				message: d > 0 ? "Avoid returning null inside Effect.gen/fn. Use Option.none() for absence, or yield* Effect.fail(new MyError()) for errors." : "Avoid returning null. Use Option.none() for absence — convert nullish values at system boundaries with Option.fromNullable()."
+			}));
+			if (arg["type"] === "Identifier" && arg["name"] === "undefined") return ctx.report(make({
+				node,
+				message: d > 0 ? "Avoid returning undefined inside Effect.gen/fn. Use Effect.void for void effects, or Option.none() for absence." : "Avoid returning undefined. Use Option.none() for absence, or restructure as an Effect returning void."
+			}));
+			if (arg["type"] === "UnaryExpression" && arg["operator"] === "void") return ctx.report(make({
+				node,
+				message: d > 0 ? "Avoid returning void inside Effect.gen/fn. Use Effect.void for void effects." : "Avoid returning void expression. Use Option.none() for absence."
+			}));
+			return Effect.void;
+		}) });
+	}
+});
+//#endregion
+export { noReturnNullish };

package/dist/rules/no-run-in-effect-gen.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-run-in-effect-gen.d.ts
+declare const noRunInEffectGen: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noRunInEffectGen };

package/dist/rules/no-run-in-effect-gen.js

@@ -0,0 +1,48 @@
+import { isCallOf } from "../vendor/effect-oxlint/AST.js";
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { merge } from "../vendor/effect-oxlint/Visitor.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { makeEffectContextTracker } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/rules/no-run-in-effect-gen.ts
+const effectRunMethods = [
+	"runSync",
+	"runPromise",
+	"runFork",
+	"runCallback"
+];
+const runtimeRunMethods = [
+	"runSync",
+	"runPromise",
+	"runFork",
+	"runCallback"
+];
+const noRunInEffectGen = define({
+	name: "no-run-in-effect-gen",
+	meta: meta({
+		type: "problem",
+		description: "Running effects inside Effect.gen/fn drops the ambient context. Use yield* instead."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const [depth, tracker] = yield* makeEffectContextTracker;
+		return merge(tracker, { CallExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+			if (d <= 0) return Effect.void;
+			const call = node;
+			if (isCallOf(call, "Effect", effectRunMethods)) return ctx.report(make({
+				node,
+				message: "Avoid Effect.run* inside Effect.gen/fn. `yield*` the child effect, or use Effect.fork for concurrency."
+			}));
+			if (isCallOf(call, "Runtime", runtimeRunMethods)) return ctx.report(make({
+				node,
+				message: "Avoid Runtime.run* inside Effect.gen/fn. The ambient context already has your services — `yield*` the child effect."
+			}));
+			return Effect.void;
+		}) });
+	}
+});
+//#endregion
+export { noRunInEffectGen };

package/dist/rules/no-runtime-run-fork.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-runtime-run-fork.d.ts
+declare const noRuntimeRunFork: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noRuntimeRunFork };

package/dist/rules/no-runtime-run-fork.js

@@ -0,0 +1,19 @@
+import { banMember } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+//#region src/rules/no-runtime-run-fork.ts
+/**
+* Ban `Runtime.runFork`.
+*
+* Use `forkScoped`, `Stream`, or runtime-provided layers.
+*
+* Source: biome-effect-linting-rules/no-runtime-runfork
+*/
+const noRuntimeRunFork = banMember("Runtime", "runFork", {
+	message: "Avoid Runtime.runFork. Use forkScoped, Stream, or runtime-provided layers.",
+	meta: {
+		type: "problem",
+		effectVersion: "v3"
+	}
+});
+//#endregion
+export { noRuntimeRunFork };

package/dist/rules/no-schema-struct-with-tag.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-schema-struct-with-tag.d.ts
+declare const noSchemaStructWithTag: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noSchemaStructWithTag };

package/dist/rules/no-schema-struct-with-tag.js

@@ -0,0 +1,48 @@
+import { matchCallOf } from "../vendor/effect-oxlint/AST.js";
+import { make } 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 * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-schema-struct-with-tag.ts
+const isTagKey = (key) => {
+	if (key.type === "Identifier" && "name" in key && key.name === "_tag") return true;
+	if (key.type === "Literal" && "value" in key && key.value === "_tag") return true;
+	return false;
+};
+const noSchemaStructWithTag = define({
+	name: "no-schema-struct-with-tag",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Schema.TaggedStruct(\"Tag\", { ... }) instead of Schema.Struct({ _tag: Schema.Literal(\"Tag\"), ... })."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			if (Option.isNone(matchCallOf(call, "Schema", "Struct"))) return Effect.void;
+			const args = call.arguments;
+			if (args.length !== 1) return Effect.void;
+			const arg = args[0];
+			if (arg === void 0) return Effect.void;
+			if (arg.type !== "ObjectExpression") return Effect.void;
+			const props = arg["properties"];
+			if (!Array.isArray(props)) return Effect.void;
+			for (const prop of props) {
+				const p = prop;
+				if (p.type !== "Property") continue;
+				const key = p["key"];
+				if (!isTagKey(key)) continue;
+				const value = p["value"];
+				if (value.type === "CallExpression" && Option.isSome(matchCallOf(value, "Schema", "Literal"))) return ctx.report(make({
+					node,
+					message: "Use Schema.TaggedStruct(\"Tag\", { ... }) instead of Schema.Struct({ _tag: Schema.Literal(...), ... })."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noSchemaStructWithTag };

package/dist/rules/no-schema-union-of-literals.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-schema-union-of-literals.d.ts
+declare const noSchemaUnionOfLiterals: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noSchemaUnionOfLiterals };

package/dist/rules/no-schema-union-of-literals.js

@@ -0,0 +1,35 @@
+import { matchCallOf } from "../vendor/effect-oxlint/AST.js";
+import { make } 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 * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-schema-union-of-literals.ts
+const isSchemaLiteral = (node) => {
+	if (node.type !== "CallExpression") return false;
+	return Option.isSome(matchCallOf(node, "Schema", "Literal"));
+};
+const noSchemaUnionOfLiterals = define({
+	name: "no-schema-union-of-literals",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Schema.Literal('a', 'b') instead of Schema.Union(Schema.Literal('a'), Schema.Literal('b'))."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			if (Option.isNone(matchCallOf(call, "Schema", "Union"))) return Effect.void;
+			const args = call.arguments;
+			if (args.length < 2) return Effect.void;
+			if (!args.every((arg) => isSchemaLiteral(arg))) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: "Use Schema.Literal('a', 'b') instead of Schema.Union(Schema.Literal('a'), Schema.Literal('b'))."
+			}));
+		} };
+	}
+});
+//#endregion
+export { noSchemaUnionOfLiterals };

package/dist/rules/no-string-sentinel-const.d.ts

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

package/dist/rules/no-string-sentinel-const.js

@@ -0,0 +1,38 @@
+import { make } 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 * as Effect from "effect/Effect";
+//#region src/rules/no-string-sentinel-const.ts
+/**
+* Ban `const x = "some-string"` string literal const declarations.
+*
+* Use tagged unions, Option, or meaningful domain values.
+*
+* Source: biome-effect-linting-rules/no-string-sentinel-const
+*
+* Note: Very aggressive — should probably be off by default or in a strict preset only.
+*/
+const noStringSentinelConst = define({
+	name: "no-string-sentinel-const",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid string literal const declarations. Use tagged unions or domain values."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { VariableDeclarator: (node) => {
+			if (!("init" in node) || node.init == null) return Effect.void;
+			const init = node.init;
+			if (init["type"] === "Literal" && typeof init["value"] === "string") {
+				if ("parent" in node && node.parent != null && typeof node.parent === "object" && "type" in node.parent && node.parent.type === "VariableDeclaration" && "kind" in node.parent && node.parent.kind === "const") return ctx.report(make({
+					node,
+					message: "Avoid string literal const. Use tagged unions, Option, or domain values."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noStringSentinelConst };

package/dist/rules/no-switch-statement.d.ts

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

package/dist/rules/no-switch-statement.js

@@ -0,0 +1,16 @@
+import { banStatement } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+//#region src/rules/no-switch-statement.ts
+/**
+* Ban `switch` statements.
+*
+* Use `Match.value`, `Option.match`, `Either.match` instead.
+*
+* Source: biome-effect-linting-rules/no-switch-statement
+*/
+const noSwitchStatement = banStatement("SwitchStatement", {
+	message: "Avoid switch statements. Use Match.value, Option.match, or Either.match.",
+	meta: { type: "suggestion" }
+});
+//#endregion
+export { noSwitchStatement };

package/dist/rules/no-ternary.d.ts

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

package/dist/rules/no-ternary.js

@@ -0,0 +1,30 @@
+import { make } 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";
+//#region src/rules/no-ternary.ts
+/**
+* Ban ternary expressions in Effect codebases.
+*
+* Use `Option.match`, `Either.match`, `Match.value` instead.
+*
+* Source: biome-effect-linting-rules/no-ternary
+*
+* Note: Very opinionated — recommended for strict functional presets only.
+*/
+const noTernary = define({
+	name: "no-ternary",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid ternary expressions. Use Option.match, Either.match, or Match.value."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { ConditionalExpression: (node) => ctx.report(make({
+			node,
+			message: "Avoid ternary expressions. Use Option.match, Either.match, or Match.value."
+		})) };
+	}
+});
+//#endregion
+export { noTernary };

package/dist/rules/no-throw-statement.d.ts

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

package/dist/rules/no-throw-statement.js

@@ -0,0 +1,34 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { merge } from "../vendor/effect-oxlint/Visitor.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { makeEffectContextTracker } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/rules/no-throw-statement.ts
+/**
+* Ban `throw` statements. Context-aware messaging.
+*
+* Inside Effect.gen/fn: "Use yield* Effect.fail() or yield* new MyError()"
+* Outside: "Model errors with Effect.fail() — wrap this function with Effect.fn"
+*
+* Source: effect convention — errors should be in the type system
+*/
+const noThrowStatement = define({
+	name: "no-throw-statement",
+	meta: meta({
+		type: "problem",
+		description: "Avoid throw. Use Effect.fail with tagged errors."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const [depth, tracker] = yield* makeEffectContextTracker;
+		return merge(tracker, { ThrowStatement: (node) => Effect.flatMap(Ref.get(depth), (d) => ctx.report(make({
+			node,
+			message: d > 0 ? "Avoid throw inside Effect.gen/fn. Use yield* Effect.fail(new MyError()) or yield* new MyError() for yieldable errors." : "Avoid throw. Model errors with Effect — wrap this function with Effect.fn and use Effect.fail with tagged errors."
+		}))) });
+	}
+});
+//#endregion
+export { noThrowStatement };

package/dist/rules/no-try-catch.d.ts

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

package/dist/rules/no-try-catch.js

@@ -0,0 +1,34 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { merge } from "../vendor/effect-oxlint/Visitor.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { makeEffectContextTracker } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/rules/no-try-catch.ts
+/**
+* Ban `try/catch` statements. Context-aware messaging.
+*
+* Inside Effect.gen/fn: "Use Effect.try or Effect.tryPromise"
+* Outside: "Wrap with Effect.fn and use Effect.try for error handling"
+*
+* Source: biome-effect-linting-rules/no-try-catch, language-service/tryCatchInEffectGen
+*/
+const noTryCatch = define({
+	name: "no-try-catch",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid try/catch. Use Effect.try or Effect.tryPromise."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const [depth, tracker] = yield* makeEffectContextTracker;
+		return merge(tracker, { TryStatement: (node) => Effect.flatMap(Ref.get(depth), (d) => ctx.report(make({
+			node,
+			message: d > 0 ? "Avoid try/catch inside Effect.gen/fn. Use Effect.try({ try: () => ..., catch: (e) => new MyError({ cause: e }) })." : "Avoid try/catch. Wrap this function with Effect.fn and use Effect.try or Effect.tryPromise for error handling."
+		}))) });
+	}
+});
+//#endregion
+export { noTryCatch };

package/dist/rules/no-unnecessary-arrow-block.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unnecessary-arrow-block.d.ts
+declare const noUnnecessaryArrowBlock: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnnecessaryArrowBlock };

package/dist/rules/no-unnecessary-arrow-block.js

@@ -0,0 +1,34 @@
+import { make } 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 * as Effect from "effect/Effect";
+//#region src/rules/no-unnecessary-arrow-block.ts
+/**
+* Ban `() => { return x }` — use `() => x` instead.
+*
+* Source: language-service/unnecessaryArrowBlock
+*/
+const noUnnecessaryArrowBlock = define({
+	name: "no-unnecessary-arrow-block",
+	meta: meta({
+		type: "suggestion",
+		description: "Unnecessary arrow block body. Use concise arrow `() => expr`.",
+		fixable: "code"
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { ArrowFunctionExpression: (node) => {
+			if ("body" in node && node.body != null && typeof node.body === "object" && "type" in node.body && node.body.type === "BlockStatement" && "body" in node.body && Array.isArray(node.body.body) && node.body.body.length === 1) {
+				const stmt = node.body.body[0];
+				if (stmt != null && typeof stmt === "object" && "type" in stmt && stmt.type === "ReturnStatement" && "argument" in stmt && stmt.argument != null) return ctx.report(make({
+					node,
+					message: "Unnecessary arrow block body. Use `() => expr` instead of `() => { return expr }`."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noUnnecessaryArrowBlock };

package/dist/rules/no-unnecessary-effect-gen.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unnecessary-effect-gen.d.ts
+declare const noUnnecessaryEffectGen: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnnecessaryEffectGen };

package/dist/rules/no-unnecessary-effect-gen.js

@@ -0,0 +1,35 @@
+import { isCallOf } from "../vendor/effect-oxlint/AST.js";
+import { make } 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 * as Effect from "effect/Effect";
+//#region src/rules/no-unnecessary-effect-gen.ts
+const noUnnecessaryEffectGen = define({
+	name: "no-unnecessary-effect-gen",
+	meta: meta({
+		type: "suggestion",
+		description: "Unnecessary Effect.gen — single yield can be replaced with the yielded effect directly.",
+		fixable: "code"
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "gen")) return Effect.void;
+			if (!("arguments" in node) || !Array.isArray(node.arguments) || node.arguments.length !== 1) return Effect.void;
+			const arg = node.arguments[0];
+			if (arg == null || typeof arg !== "object" || !("type" in arg)) return Effect.void;
+			if (arg.type !== "FunctionExpression" || !("generator" in arg) || !arg.generator) return Effect.void;
+			if (!("body" in arg) || arg.body == null || typeof arg.body !== "object" || !("type" in arg.body) || arg.body.type !== "BlockStatement" || !("body" in arg.body) || !Array.isArray(arg.body.body) || arg.body.body.length !== 1) return Effect.void;
+			const stmt = arg.body.body[0];
+			if (stmt == null || typeof stmt !== "object" || !("type" in stmt)) return Effect.void;
+			if (stmt.type === "ReturnStatement" && "argument" in stmt && stmt.argument != null && typeof stmt.argument === "object" && "type" in stmt.argument && stmt.argument.type === "YieldExpression" && "delegate" in stmt.argument && stmt.argument.delegate === true) return ctx.report(make({
+				node,
+				message: "Unnecessary Effect.gen — single yield*. Replace with the yielded effect directly."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noUnnecessaryEffectGen };

package/dist/rules/no-unnecessary-pipe-chain.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unnecessary-pipe-chain.d.ts
+declare const noUnnecessaryPipeChain: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnnecessaryPipeChain };