oxlint-plugin-effect 0.2.0 → 0.2.1

package/dist/rules/no-effect-map-void.js

@@ -0,0 +1,40 @@
+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-effect-map-void.ts
+const isVoidCallback = (arg) => {
+	if (arg == null || typeof arg !== "object" || !("type" in arg)) return false;
+	if (arg.type === "ArrowFunctionExpression" && "body" in arg) {
+		const body = arg.body;
+		if (body == null || typeof body !== "object" || !("type" in body)) return false;
+		if (body.type === "Identifier" && "name" in body && body.name === "undefined") return true;
+		if (body.type === "UnaryExpression" && "operator" in body && body.operator === "void") return true;
+		if (body.type === "BlockStatement" && "body" in body && Array.isArray(body.body) && body.body.length === 0) return true;
+	}
+	return false;
+};
+const noEffectMapVoid = define({
+	name: "no-effect-map-void",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect.map(() => undefined). Use Effect.asVoid instead."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "map")) return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments) && node.arguments.length >= 1) {
+				if (isVoidCallback(node.arguments.length === 2 ? node.arguments[1] : node.arguments[0])) return ctx.report(make({
+					node,
+					message: "Use Effect.asVoid instead of Effect.map(() => undefined)."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectMapVoid };

package/dist/rules/no-effect-never.d.ts

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

package/dist/rules/no-effect-never.js

@@ -0,0 +1,16 @@
+import { banMember } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+//#region src/rules/no-effect-never.ts
+/**
+* Ban `Effect.never`.
+*
+* Use `Stream` or explicit acquire/release lifecycles instead.
+*
+* Source: biome-effect-linting-rules/no-effect-never
+*/
+const noEffectNever = banMember("Effect", "never", {
+	message: "Avoid Effect.never. Use Stream or explicit acquire/release lifecycles.",
+	meta: { type: "suggestion" }
+});
+//#endregion
+export { noEffectNever };

package/dist/rules/no-effect-orElse-ladder.d.ts

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

package/dist/rules/no-effect-orElse-ladder.js

@@ -0,0 +1,53 @@
+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-effect-orElse-ladder.ts
+const sequencingCombinators = [
+	"flatMap",
+	"zipRight",
+	"as",
+	"tap",
+	"andThen"
+];
+const containsSequencing = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] === "CallExpression" && "callee" in n) {
+		const callee = n["callee"];
+		if (callee != null && callee["type"] === "MemberExpression" && "object" in callee && "property" in callee) {
+			const obj = callee["object"];
+			const prop = callee["property"];
+			if (obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" && prop != null && prop["type"] === "Identifier" && typeof prop["name"] === "string" && sequencingCombinators.includes(prop["name"])) return true;
+		}
+		if ("arguments" in n && Array.isArray(n["arguments"])) {
+			for (const arg of n["arguments"]) if (containsSequencing(arg)) return true;
+		}
+	}
+	if ("body" in n) return containsSequencing(n["body"]);
+	return false;
+};
+const noEffectOrElseLadder = define({
+	name: "no-effect-orElse-ladder",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect.orElse wrapping sequencing chains. Handle errors at a single terminal decision."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "orElse")) return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments)) {
+				for (const arg of node.arguments) if (containsSequencing(arg)) return ctx.report(make({
+					node,
+					message: "Effect.orElse wrapping sequencing chain. Move error handling to a terminal decision after the pipeline."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectOrElseLadder };

package/dist/rules/no-effect-succeed-string.d.ts

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

package/dist/rules/no-effect-succeed-string.js

@@ -0,0 +1,30 @@
+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-effect-succeed-string.ts
+const noEffectSucceedString = define({
+	name: "no-effect-succeed-string",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect.succeed with string literals. Return domain values (tagged unions, Option, Either)."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "succeed")) return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments) && node.arguments.length === 1) {
+				const arg = node.arguments[0];
+				if (arg != null && typeof arg === "object" && "type" in arg && arg.type === "Literal" && "value" in arg && typeof arg.value === "string") return ctx.report(make({
+					node,
+					message: "Avoid Effect.succeed with string literals. Use tagged unions, Option, or Either."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectSucceedString };

package/dist/rules/no-effect-succeed-variable.d.ts

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

package/dist/rules/no-effect-succeed-variable.js

@@ -0,0 +1,30 @@
+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-effect-succeed-variable.ts
+const noEffectSucceedVariable = define({
+	name: "no-effect-succeed-variable",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect.succeed with a plain variable. Select value with Option/Match, then run one Effect pipeline."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "succeed")) return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments) && node.arguments.length === 1) {
+				const arg = node.arguments[0];
+				if (arg != null && typeof arg === "object" && "type" in arg && arg.type === "Identifier") return ctx.report(make({
+					node,
+					message: "Avoid Effect.succeed(variable). Select value with Option/Match, then run one Effect pipeline."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectSucceedVariable };

package/dist/rules/no-effect-succeed-void.d.ts

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

package/dist/rules/no-effect-succeed-void.js

@@ -0,0 +1,33 @@
+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-effect-succeed-void.ts
+const isUndefinedLike = (node) => {
+	if (node == null || typeof node !== "object" || !("type" in node)) return false;
+	if (node.type === "Identifier" && "name" in node && node.name === "undefined") return true;
+	if (node.type === "UnaryExpression" && "operator" in node && node.operator === "void" && "argument" in node && node.argument != null && typeof node.argument === "object" && "type" in node.argument && node.argument.type === "Literal" && "value" in node.argument && node.argument.value === 0) return true;
+	return false;
+};
+const noEffectSucceedVoid = define({
+	name: "no-effect-succeed-void",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect.succeed(undefined). Use Effect.void instead."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "succeed")) return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments) && node.arguments.length === 1 && isUndefinedLike(node.arguments[0])) return ctx.report(make({
+				node,
+				message: "Use Effect.void instead of Effect.succeed(undefined)."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectSucceedVoid };

package/dist/rules/no-effect-sync-console.d.ts

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

package/dist/rules/no-effect-sync-console.js

@@ -0,0 +1,63 @@
+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-effect-sync-console.ts
+const consoleMethods = new Set([
+	"log",
+	"warn",
+	"error",
+	"info",
+	"debug",
+	"trace"
+]);
+const containsConsoleCall = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] === "CallExpression" && "callee" in n && n["callee"] != null && typeof n["callee"] === "object") {
+		const callee = n["callee"];
+		if (callee["type"] === "MemberExpression" && "object" in callee && "property" in callee) {
+			const obj = callee["object"];
+			const prop = callee["property"];
+			if (obj != null && obj["type"] === "Identifier" && obj["name"] === "console" && prop != null && prop["type"] === "Identifier" && typeof prop["name"] === "string" && consoleMethods.has(prop["name"])) return true;
+		}
+	}
+	if ("body" in n) {
+		if (Array.isArray(n["body"])) {
+			for (const child of n["body"]) if (containsConsoleCall(child)) return true;
+		} else if (containsConsoleCall(n["body"])) return true;
+	}
+	if ("argument" in n && containsConsoleCall(n["argument"])) return true;
+	if ("arguments" in n && Array.isArray(n["arguments"])) {
+		for (const arg of n["arguments"]) if (containsConsoleCall(arg)) return true;
+	}
+	if ("expression" in n && containsConsoleCall(n["expression"])) return true;
+	if ("expressions" in n && Array.isArray(n["expressions"])) {
+		for (const expr of n["expressions"]) if (containsConsoleCall(expr)) return true;
+	}
+	return false;
+};
+const noEffectSyncConsole = define({
+	name: "no-effect-sync-console",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid console.* inside Effect.sync. Use Effect.log* instead."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "sync")) return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments)) {
+				for (const arg of node.arguments) if (containsConsoleCall(arg)) return ctx.report(make({
+					node,
+					message: "Avoid console.* inside Effect.sync. Use Effect.log, Effect.logWarning, etc."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectSyncConsole };

package/dist/rules/no-effect-sync-wrapper.d.ts

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

package/dist/rules/no-effect-sync-wrapper.js

@@ -0,0 +1,37 @@
+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-effect-sync-wrapper.ts
+const noEffectSyncWrapper = define({
+	name: "no-effect-sync-wrapper",
+	meta: meta({
+		type: "suggestion",
+		description: "Effect.sync wrapping a plain call. Consider if Effect.sync is necessary."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isCallOf(node, "Effect", "sync")) 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 === "ArrowFunctionExpression" && "body" in arg) {
+				const body = arg.body;
+				if (body != null && typeof body === "object" && "type" in body && body.type === "CallExpression") {
+					const callee = body["callee"];
+					if (callee != null && typeof callee === "object" && "type" in callee && callee.type === "MemberExpression" && "object" in callee && callee.object != null && typeof callee.object === "object" && "name" in callee.object && callee.object.name === "console") return Effect.void;
+					return ctx.report(make({
+						node,
+						message: "Effect.sync wrapping a plain function call. Consider if Effect.sync is necessary."
+					}));
+				}
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectSyncWrapper };

package/dist/rules/no-effect-type-alias.d.ts

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

package/dist/rules/no-effect-type-alias.js

@@ -0,0 +1,52 @@
+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-effect-type-alias.ts
+/**
+* Ban `type X = Effect.Effect<...>` type aliases.
+*
+* Keep Effect types on service methods or inline at call site.
+*
+* Source: biome-effect-linting-rules/no-effect-type-alias
+*/
+const containsEffectType = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] === "TSTypeReference" && "typeName" in n && n["typeName"] != null && typeof n["typeName"] === "object") {
+		const typeName = n["typeName"];
+		if (typeName["type"] === "TSQualifiedName" && "left" in typeName && "right" in typeName) {
+			const left = typeName["left"];
+			const right = typeName["right"];
+			if (left != null && left["type"] === "Identifier" && left["name"] === "Effect" && right != null && right["type"] === "Identifier" && right["name"] === "Effect") return true;
+		}
+	}
+	if ("typeAnnotation" in n && containsEffectType(n["typeAnnotation"])) return true;
+	if ("typeParameters" in n && n["typeParameters"] != null && typeof n["typeParameters"] === "object") {
+		const tp = n["typeParameters"];
+		if ("params" in tp && Array.isArray(tp["params"])) {
+			for (const p of tp["params"]) if (containsEffectType(p)) return true;
+		}
+	}
+	return false;
+};
+const noEffectTypeAlias = define({
+	name: "no-effect-type-alias",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect type aliases. Keep Effect types on service methods or inline."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { TSTypeAliasDeclaration: (node) => {
+			if ("typeAnnotation" in node && containsEffectType(node.typeAnnotation)) return ctx.report(make({
+				node,
+				message: "Avoid type alias wrapping Effect.Effect. Let Effect types flow from service methods."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectTypeAlias };

package/dist/rules/no-effect-wrapper-alias.d.ts

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

package/dist/rules/no-effect-wrapper-alias.js

@@ -0,0 +1,69 @@
+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-effect-wrapper-alias.ts
+/**
+* Ban wrapper functions that just alias an Effect.fn or pipe(Effect.fn(...)).
+*
+* Inline the pipeline at the call site or define a real domain function.
+*
+* Source: biome-effect-linting-rules/no-effect-wrapper-alias
+*/
+const isEffectFnCall = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] !== "CallExpression") return false;
+	const callee = n["callee"];
+	if (callee == null || typeof callee !== "object") return false;
+	const c = callee;
+	if (c["type"] !== "MemberExpression") return false;
+	const obj = c["object"];
+	const prop = c["property"];
+	return obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" && prop != null && prop["type"] === "Identifier" && prop["name"] === "fn";
+};
+const isPipeWrappingEffectFn = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] !== "CallExpression") return false;
+	const callee = n["callee"];
+	if (callee == null || typeof callee !== "object") return false;
+	const c = callee;
+	if (!(c["type"] === "Identifier" && c["name"] === "pipe")) return false;
+	const args = n["arguments"];
+	if (!Array.isArray(args) || args.length === 0) return false;
+	return isEffectFnCall(args[0]);
+};
+const noEffectWrapperAlias = define({
+	name: "no-effect-wrapper-alias",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid wrapper functions aliasing Effect.fn. Inline or define a real domain function."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { VariableDeclarator: (node) => {
+			if (!("init" in node) || node.init == null) return Effect.void;
+			const init = node.init;
+			if (isEffectFnCall(init)) return ctx.report(make({
+				node,
+				message: "Avoid aliasing Effect.fn. Inline the pipeline or define a real domain function."
+			}));
+			if (isPipeWrappingEffectFn(init)) return ctx.report(make({
+				node,
+				message: "Avoid wrapping Effect.fn in pipe. Inline the pipeline or define a real domain function."
+			}));
+			if (typeof init === "object" && "type" in init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") && "body" in init) {
+				const body = init.body;
+				if (isEffectFnCall(body) || isPipeWrappingEffectFn(body)) return ctx.report(make({
+					node,
+					message: "Avoid wrapper function aliasing Effect.fn. Inline or define a real domain function."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectWrapperAlias };

package/dist/rules/no-extends-native-error.d.ts

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

package/dist/rules/no-extends-native-error.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-extends-native-error.ts
+/**
+* Ban `class Foo extends Error`.
+*
+* Use Schema.TaggedErrorClass or Data.TaggedError instead.
+*
+* Source: language-service/extendsNativeError
+*/
+const nativeErrors = new Set([
+	"Error",
+	"TypeError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"URIError",
+	"EvalError"
+]);
+const noExtendsNativeError = define({
+	name: "no-extends-native-error",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid extending native Error. Use Schema.TaggedErrorClass or Data.TaggedError."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { ClassDeclaration: (node) => {
+			if ("superClass" in node && node.superClass != null && typeof node.superClass === "object" && "type" in node.superClass && node.superClass.type === "Identifier" && "name" in node.superClass && typeof node.superClass.name === "string" && nativeErrors.has(node.superClass.name)) return ctx.report(make({
+				node,
+				message: "Avoid extending native Error. Use Schema.TaggedErrorClass or Data.TaggedError."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noExtendsNativeError };

package/dist/rules/no-flatmap-ladder.d.ts

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

package/dist/rules/no-flatmap-ladder.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 { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-flatmap-ladder.ts
+const isEffectFlatMap = (node) => isCallOf(node, "Effect", "flatMap");
+const containsEffectFlatMap = (node) => {
+	if (node == null || typeof node !== "object") return false;
+	const n = node;
+	if (n["type"] === "CallExpression" && "callee" in n && "arguments" in n) {
+		if (isEffectFlatMap(node)) return true;
+	}
+	if ("arguments" in n && Array.isArray(n["arguments"])) {
+		for (const arg of n["arguments"]) if (containsEffectFlatMap(arg)) return true;
+	}
+	if ("body" in n) return containsEffectFlatMap(n["body"]);
+	return false;
+};
+const noFlatmapLadder = define({
+	name: "no-flatmap-ladder",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid nested Effect.flatMap (flatMap ladder). Build context once with Effect.all and run a single flatMap."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const ce = node;
+			if (!isEffectFlatMap(ce)) return Effect.void;
+			if (!("arguments" in ce) || !Array.isArray(ce.arguments)) return Effect.void;
+			for (const arg of ce.arguments) if (arg != null && typeof arg === "object" && "type" in arg) {
+				if (arg.type === "CallExpression" && isEffectFlatMap(arg)) return ctx.report(make({
+					node,
+					message: "Nested Effect.flatMap detected. Build context with Effect.all, then single flatMap."
+				}));
+				if ((arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression") && "body" in arg && containsEffectFlatMap(arg.body)) return ctx.report(make({
+					node,
+					message: "Nested Effect.flatMap detected. Build context with Effect.all, then single flatMap."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noFlatmapLadder };

package/dist/rules/no-fromnullable-coalesce.d.ts

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