oxlint-plugin-effect 0.2.0 → 0.2.1

package/dist/rules/no-match-void-branch.js

@@ -0,0 +1,50 @@
+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-match-void-branch.ts
+const isEffectVoid = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] !== "MemberExpression") return false;
+	const obj = n["object"];
+	const prop = n["property"];
+	return obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" && prop != null && prop["type"] === "Identifier" && prop["name"] === "void";
+};
+const isVoidCallback = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] !== "ArrowFunctionExpression" && n["type"] !== "FunctionExpression") return false;
+	if (!("body" in n)) return false;
+	return isEffectVoid(n["body"]);
+};
+const noMatchVoidBranch = define({
+	name: "no-match-void-branch",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid no-op Match branches returning Effect.void. Remove the branch or restructure."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const ce = node;
+			const isMatchWhen = isCallOf(ce, "Match", "when");
+			const isMatchOrElse = isCallOf(ce, "Match", "orElse");
+			if (!isMatchWhen && !isMatchOrElse) return Effect.void;
+			if (!("arguments" in node) || !Array.isArray(node.arguments)) return Effect.void;
+			if (isMatchOrElse && node.arguments.length >= 1 && isVoidCallback(node.arguments[0])) return ctx.report(make({
+				node,
+				message: "Match.orElse returning Effect.void is a no-op. Remove the branch or restructure."
+			}));
+			if (isMatchWhen && node.arguments.length >= 2 && isVoidCallback(node.arguments[1])) return ctx.report(make({
+				node,
+				message: "Match.when branch returning Effect.void is a no-op. Remove the branch or restructure."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noMatchVoidBranch };

package/dist/rules/no-multiple-effect-provide.d.ts

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

package/dist/rules/no-multiple-effect-provide.js

@@ -0,0 +1,45 @@
+import { calleeName, 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-multiple-effect-provide.ts
+const isEffectProvide = (node) => {
+	if (node.type !== "CallExpression") return false;
+	return Option.isSome(matchCallOf(node, "Effect", "provide"));
+};
+const countProvides = (args) => {
+	let count = 0;
+	for (const arg of args) if (isEffectProvide(arg)) count++;
+	return count;
+};
+const noMultipleEffectProvide = define({
+	name: "no-multiple-effect-provide",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid consecutive Effect.provide() calls. Merge into Effect.provide(Layer.mergeAll(...))."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			const args = call.arguments;
+			if (args.length < 3) return Effect.void;
+			const calleeName$1 = Option.getOrUndefined(calleeName(call));
+			const callee = call.callee;
+			if (!(calleeName$1 === "pipe" || callee.type === "MemberExpression" && "property" in callee && callee["computed"] !== true && (() => {
+				const prop = callee["property"];
+				return prop != null && typeof prop === "object" && "name" in prop && prop.name === "pipe";
+			})())) return Effect.void;
+			if (countProvides(args) >= 2) return ctx.report(make({
+				node,
+				message: "Multiple Effect.provide() in pipe. Merge into Effect.provide(Layer.mergeAll(...))."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noMultipleEffectProvide };

package/dist/rules/no-nested-effect-call.d.ts

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

package/dist/rules/no-nested-effect-call.js

@@ -0,0 +1,97 @@
+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-nested-effect-call.ts
+const pipelineCombinators = new Set([
+	"flatMap",
+	"map",
+	"mapBoth",
+	"mapError",
+	"andThen",
+	"tap",
+	"tapError",
+	"tapBoth",
+	"zipRight",
+	"zipLeft",
+	"zip",
+	"as",
+	"asVoid",
+	"catchAll",
+	"catchAllCause",
+	"catch",
+	"catchCause",
+	"catchTag",
+	"catchTags"
+]);
+const effectAcceptingCombinators = new Set([
+	"andThen",
+	"tap",
+	"zipRight",
+	"zipLeft"
+]);
+const effectProducers = new Set([
+	"gen",
+	"fn",
+	"succeed",
+	"fail",
+	"failCause",
+	"sync",
+	"promise",
+	"tryPromise",
+	"try",
+	"async",
+	"void",
+	"die",
+	"dieMessage"
+]);
+const getEffectMethodName = (node) => {
+	if (node == null || typeof node !== "object") return void 0;
+	const n = node;
+	if (n["type"] !== "CallExpression") return void 0;
+	const callee = n["callee"];
+	if (callee == null || typeof callee !== "object") return void 0;
+	const c = callee;
+	if (c["type"] !== "MemberExpression") return void 0;
+	const obj = c["object"];
+	const prop = c["property"];
+	if (obj == null || typeof obj !== "object") return void 0;
+	if (prop == null || typeof prop !== "object") return void 0;
+	const o = obj;
+	const p = prop;
+	if (o["type"] !== "Identifier" || o["name"] !== "Effect") return void 0;
+	if (p["type"] !== "Identifier" || typeof p["name"] !== "string") return void 0;
+	return p["name"];
+};
+const noNestedEffectCall = define({
+	name: "no-nested-effect-call",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid nested Effect pipeline calls. Compose with .pipe() instead of nesting."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const outerName = getEffectMethodName(node);
+			if (outerName === void 0 || !pipelineCombinators.has(outerName)) return Effect.void;
+			const ce = node;
+			if (!("arguments" in ce) || !Array.isArray(ce.arguments)) return Effect.void;
+			if (ce.arguments.length < 2) return Effect.void;
+			const outerTakesEffect = effectAcceptingCombinators.has(outerName);
+			for (const arg of ce.arguments) {
+				const innerName = getEffectMethodName(arg);
+				if (innerName === void 0) continue;
+				const isCallTower = pipelineCombinators.has(innerName);
+				const isProducerArg = outerTakesEffect && effectProducers.has(innerName);
+				if (isCallTower || isProducerArg) return ctx.report(make({
+					node,
+					message: `Nested Effect.${outerName}(Effect.${innerName}(...)). Use .pipe(Effect.${innerName}(...), Effect.${outerName}(...)) instead.`
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noNestedEffectCall };

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

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

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

@@ -0,0 +1,46 @@
+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, tracked } from "../vendor/effect-oxlint/Visitor.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/rules/no-nested-effect-gen.ts
+const parentOf = (node) => node.parent;
+const isDirectlyNestedGen = (node) => {
+	const yieldExpr = parentOf(node);
+	if (yieldExpr?.type !== "YieldExpression") return false;
+	if (yieldExpr.delegate !== true) return false;
+	const stmt = parentOf(yieldExpr);
+	if (stmt?.type !== "ExpressionStatement") return false;
+	const block = parentOf(stmt);
+	if (block?.type !== "BlockStatement") return false;
+	const fn = parentOf(block);
+	if (fn?.type !== "FunctionExpression" && fn?.type !== "ArrowFunctionExpression") return false;
+	const call = parentOf(fn);
+	if (call?.type !== "CallExpression") return false;
+	return isCallOf(call, "Effect", "gen") || isCallOf(call, "Effect", "fn");
+};
+const noNestedEffectGen = define({
+	name: "no-nested-effect-gen",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid nested Effect.gen. Flatten to a single Effect.gen per method."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const depth = yield* Ref.make(0);
+		return merge(tracked("CallExpression", (node) => isCallOf(node, "Effect", "gen"), depth), { CallExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+			if (d <= 1) return Effect.void;
+			if (!isCallOf(node, "Effect", "gen")) return Effect.void;
+			if (!isDirectlyNestedGen(node)) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: "Nested Effect.gen detected. Flatten to a single Effect.gen."
+			}));
+		}) });
+	}
+});
+//#endregion
+export { noNestedEffectGen };

package/dist/rules/no-nested-pipe.d.ts

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

package/dist/rules/no-nested-pipe.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-nested-pipe.ts
+const isPipeCall = (node) => {
+	if (node.type === "CallExpression" && "callee" in node) {
+		const callee = node["callee"];
+		if (callee != null && typeof callee === "object" && "type" in callee) {
+			if (callee.type === "Identifier" && "name" in callee && callee.name === "pipe") return true;
+			if (callee.type === "MemberExpression" && "property" in callee && callee.property != null && typeof callee.property === "object" && "type" in callee.property && callee.property.type === "Identifier" && "name" in callee.property && callee.property.name === "pipe") return true;
+		}
+	}
+	return false;
+};
+const noNestedPipe = define({
+	name: "no-nested-pipe",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid nested pipe() calls. Flatten into a single pipeline."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isPipeCall(node)) return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments)) {
+				for (const arg of node.arguments) if (arg != null && typeof arg === "object" && "type" in arg && isPipeCall(arg)) return ctx.report(make({
+					node: arg,
+					message: "Nested pipe() detected. Flatten into a single pipeline."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noNestedPipe };

package/dist/rules/no-new-error.d.ts

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

package/dist/rules/no-new-error.js

@@ -0,0 +1,39 @@
+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-new-error.ts
+const nativeErrors = new Set([
+	"Error",
+	"TypeError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"URIError",
+	"EvalError"
+]);
+const noNewError = define({
+	name: "no-new-error",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid native Error constructors. Use Schema.TaggedErrorClass."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const [depth, tracker] = yield* makeEffectContextTracker;
+		return merge(tracker, { NewExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+			const callee = node["callee"];
+			if (callee.type === "Identifier" && "name" in callee && nativeErrors.has(callee.name)) return ctx.report(make({
+				node,
+				message: d > 0 ? "Avoid native Error inside Effect.gen/fn. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { ... }) {} — then yield* new MyError()." : "Avoid native Error constructors. Define: class MyError extends Schema.TaggedErrorClass<MyError>()(\"MyError\", { message: Schema.String }) {}"
+			}));
+			return Effect.void;
+		}) });
+	}
+});
+//#endregion
+export { noNewError };

package/dist/rules/no-new-promise.d.ts

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

package/dist/rules/no-new-promise.js

@@ -0,0 +1,38 @@
+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-new-promise.ts
+/**
+* Ban `new Promise()`. Context-aware messaging.
+*
+* Inside Effect.gen/fn: "Use Effect.tryPromise or Effect.async"
+* Outside: "Use Effect.tryPromise or wrap with Effect.fn"
+*
+* Source: language-service/newPromise
+*/
+const noNewPromise = define({
+	name: "no-new-promise",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid new Promise(). Use Effect.async or Effect.tryPromise."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const [depth, tracker] = yield* makeEffectContextTracker;
+		return merge(tracker, { NewExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+			const callee = node["callee"];
+			if (callee != null && typeof callee === "object" && "type" in callee && callee.type === "Identifier" && "name" in callee && callee.name === "Promise") return ctx.report(make({
+				node,
+				message: d > 0 ? "Avoid new Promise() inside Effect.gen/fn. Use Effect.async for callback APIs, Effect.tryPromise for existing promises, or Effect.promise for infallible promises." : "Avoid new Promise(). Use Effect.async for callback APIs, Effect.tryPromise for existing promises — wrap this function with Effect.fn."
+			}));
+			return Effect.void;
+		}) });
+	}
+});
+//#endregion
+export { noNewPromise };

package/dist/rules/no-node-builtin-import.d.ts

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

package/dist/rules/no-node-builtin-import.js

@@ -0,0 +1,61 @@
+import { importSource, narrow } 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-node-builtin-import.ts
+/**
+* Ban Node.js builtin imports.
+*
+* Use Effect platform services: FileSystem, Path, HttpClient, Command.
+*
+* Source: language-service/nodeBuiltinImport
+*/
+const hints = {
+	fs: "Use FileSystem from 'effect'",
+	path: "Use Path from 'effect'",
+	http: "Use HttpClient from 'effect/unstable/http'",
+	https: "Use HttpClient from 'effect/unstable/http'",
+	child_process: "Use Command from 'effect'",
+	crypto: "Use a service wrapper",
+	os: "Use PlatformInfo from 'effect'",
+	net: "Use HttpServer from 'effect/unstable/http'",
+	dns: "Use a service wrapper",
+	tls: "Use a service wrapper",
+	dgram: "Use a service wrapper",
+	stream: "Use Stream from 'effect'",
+	zlib: "Use a service wrapper",
+	readline: "Use Terminal from 'effect'",
+	cluster: "Use a service wrapper",
+	worker_threads: "Use a service wrapper"
+};
+const nodeBuiltins = new Set(Object.keys(hints));
+const resolveModule = (source) => {
+	const base = (source.startsWith("node:") ? source.slice(5) : source).split("/")[0];
+	return base !== void 0 && nodeBuiltins.has(base) ? base : void 0;
+};
+const noNodeBuiltinImport = define({
+	name: "no-node-builtin-import",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Node.js builtin imports. Use Effect platform services."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { ImportDeclaration: (node) => {
+			const source = Option.getOrUndefined(narrow(node, "ImportDeclaration").pipe(Option.map(importSource)));
+			if (source === void 0) return Effect.void;
+			const mod = resolveModule(source);
+			if (mod === void 0) return Effect.void;
+			const hint = hints[mod] ?? "Use an Effect service wrapper";
+			return ctx.report(make({
+				node,
+				message: `Avoid importing '${source}'. ${hint}.`
+			}));
+		} };
+	}
+});
+//#endregion
+export { noNodeBuiltinImport };

package/dist/rules/no-option-as.d.ts

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

package/dist/rules/no-option-as.js

@@ -0,0 +1,16 @@
+import { banMember } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+//#region src/rules/no-option-as.ts
+/**
+* Ban `Option.as`.
+*
+* Use `Option.map` or `Option.match` with explicit value return.
+*
+* Source: biome-effect-linting-rules/no-option-as
+*/
+const noOptionAs = banMember("Option", "as", {
+	message: "Avoid Option.as. Use Option.map or Option.match instead.",
+	meta: { type: "suggestion" }
+});
+//#endregion
+export { noOptionAs };

package/dist/rules/no-option-boolean-normalization.d.ts

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

package/dist/rules/no-option-boolean-normalization.js

@@ -0,0 +1,50 @@
+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-option-boolean-normalization.ts
+const noOptionBooleanNormalization = define({
+	name: "no-option-boolean-normalization",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Option.match for boolean normalization. Normalize at schema boundary."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Option", "match")) return Effect.void;
+			if (!("arguments" in node) || !Array.isArray(node.arguments) || node.arguments.length < 2) return Effect.void;
+			const opts = node.arguments[1];
+			if (opts == null || typeof opts !== "object" || !("type" in opts)) return Effect.void;
+			if (opts.type !== "ObjectExpression" || !("properties" in opts) || !Array.isArray(opts.properties)) return Effect.void;
+			let hasTripleEqualTrue = false;
+			let hasReturnFalse = false;
+			for (const prop of opts.properties) {
+				if (prop == null || typeof prop !== "object" || !("type" in prop) || prop.type !== "Property") continue;
+				const key = prop["key"];
+				const value = prop["value"];
+				if (key == null || value == null) continue;
+				if (key["type"] === "Identifier" && key["name"] === "onSome" && value["type"] === "ArrowFunctionExpression" && "body" in value) {
+					const body = value["body"];
+					if (body != null && body["type"] === "BinaryExpression" && body["operator"] === "===" && "right" in body) {
+						const right = body["right"];
+						if (right != null && right["type"] === "Literal" && right["value"] === true) hasTripleEqualTrue = true;
+					}
+				}
+				if (key["type"] === "Identifier" && key["name"] === "onNone" && value["type"] === "ArrowFunctionExpression" && "body" in value) {
+					const body = value["body"];
+					if (body != null && body["type"] === "Literal" && body["value"] === false) hasReturnFalse = true;
+				}
+			}
+			if (hasTripleEqualTrue && hasReturnFalse) return ctx.report(make({
+				node,
+				message: "Avoid Option.match for boolean normalization. Normalize at schema boundary instead."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noOptionBooleanNormalization };

package/dist/rules/no-positional-log-error.d.ts

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

package/dist/rules/no-positional-log-error.js

@@ -0,0 +1,52 @@
+import { memberNames } 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-positional-log-error.ts
+const logMethods = new Set([
+	"log",
+	"logDebug",
+	"logInfo",
+	"logWarning",
+	"logError",
+	"logFatal",
+	"logTrace"
+]);
+const noPositionalLogError = define({
+	name: "no-positional-log-error",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid passing errors as positional arguments to Effect.log*. Use Effect.annotateLogs instead."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			const names = Option.getOrUndefined(memberNames(call.callee));
+			if (names === void 0) return Effect.void;
+			const [obj, prop] = names;
+			if (obj !== "Effect") return Effect.void;
+			if (!logMethods.has(prop)) return Effect.void;
+			const args = call.arguments;
+			if (args.length < 2) return Effect.void;
+			const secondArg = args[1];
+			if (secondArg === void 0) return Effect.void;
+			if (secondArg.type === "CallExpression") {
+				const secondNames = Option.getOrUndefined(memberNames(secondArg.callee));
+				if (secondNames !== void 0) {
+					const [sObj] = secondNames;
+					if (sObj === "Cause") return Effect.void;
+				}
+			}
+			return ctx.report(make({
+				node: secondArg,
+				message: `Avoid passing errors as positional args to Effect.${prop}. Use .pipe(Effect.annotateLogs({ error: String(err) })) or pass a Cause.`
+			}));
+		} };
+	}
+});
+//#endregion
+export { noPositionalLogError };

package/dist/rules/no-redundant-schema-tag-identifier.d.ts

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