oxlint-plugin-effect 0.1.0 → 0.2.1

package/dist/rules/no-fromnullable-coalesce.js

@@ -0,0 +1,36 @@
+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-fromnullable-coalesce.ts
+const noFromNullableCoalesce = define({
+	name: "no-fromnullable-coalesce",
+	meta: meta({
+		type: "suggestion",
+		description: "Redundant nullish coalescing in Option.fromNullable. Pass the value directly."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const ce = node;
+			if (!(isCallOf(ce, "Option", "fromNullable") || isCallOf(ce, "Option", "fromNullishOr"))) 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 === "LogicalExpression" && "operator" in arg && arg.operator === "??") {
+					if ("right" in arg && arg.right != null && typeof arg.right === "object" && "type" in arg.right) {
+						const rhs = arg.right;
+						if (rhs.type === "Literal" && "value" in rhs && rhs.value === null || rhs.type === "Identifier" && "name" in rhs && rhs.name === "undefined") return ctx.report(make({
+							node,
+							message: "Redundant ?? null/undefined in Option.fromNullable. Pass the value directly."
+						}));
+					}
+				}
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noFromNullableCoalesce };

package/dist/rules/no-global-error-in-catch.d.ts

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

package/dist/rules/no-global-error-in-catch.js

@@ -0,0 +1,75 @@
+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-global-error-in-catch.ts
+const nativeErrors = new Set([
+	"Error",
+	"TypeError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"URIError",
+	"EvalError"
+]);
+const catchMethods = new Set([
+	"catch",
+	"catchAll",
+	"catchAllCause",
+	"catchIf",
+	"catchCauseIf",
+	"catchTag",
+	"catchTags",
+	"catchDefect"
+]);
+const isNativeErrorNew = (node) => {
+	if (node.type !== "NewExpression") return false;
+	const callee = node["callee"];
+	return callee.type === "Identifier" && "name" in callee && nativeErrors.has(callee.name);
+};
+/**
+* Check if a function body returns `new Error(...)`.
+*/
+const bodyReturnsNativeError = (fn) => {
+	const body = fn["body"];
+	if (body.type !== "BlockStatement") return isNativeErrorNew(body);
+	const stmts = body["body"];
+	if (!Array.isArray(stmts) || stmts.length !== 1) return false;
+	const stmt = stmts[0];
+	if (stmt.type !== "ReturnStatement") return false;
+	const arg = stmt["argument"];
+	return arg != null && typeof arg === "object" && isNativeErrorNew(arg);
+};
+const noGlobalErrorInCatch = define({
+	name: "no-global-error-in-catch",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid native Error in Effect catch handlers. Use Schema.TaggedErrorClass or Data.TaggedError."
+	}),
+	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 (!catchMethods.has(prop)) return Effect.void;
+			const args = call.arguments;
+			if (args.length === 0) return Effect.void;
+			const callback = args[args.length - 1];
+			if (callback === void 0) return Effect.void;
+			if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") return Effect.void;
+			if (bodyReturnsNativeError(callback)) return ctx.report(make({
+				node: callback,
+				message: "Avoid native Error in Effect catch handler. Use Schema.TaggedErrorClass or Data.TaggedError."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noGlobalErrorInCatch };

package/dist/rules/no-global-error-in-failure.d.ts

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

package/dist/rules/no-global-error-in-failure.js

@@ -0,0 +1,54 @@
+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-global-error-in-failure.ts
+const nativeErrors = new Set([
+	"Error",
+	"TypeError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"URIError",
+	"EvalError"
+]);
+const isNativeErrorNew = (node) => {
+	if (node.type !== "NewExpression") return false;
+	const callee = node["callee"];
+	return callee.type === "Identifier" && "name" in callee && nativeErrors.has(callee.name);
+};
+const noGlobalErrorInFailure = define({
+	name: "no-global-error-in-failure",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid native Error in Effect.fail(). Use Schema.TaggedErrorClass or Data.TaggedError."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			if (Option.isNone(matchCallOf(call, "Effect", "fail")) && Option.isNone(matchCallOf(call, "Effect", "failSync")) && Option.isNone(matchCallOf(call, "Effect", "failCause"))) return Effect.void;
+			const args = call.arguments;
+			if (args.length === 0) return Effect.void;
+			const arg = args[args.length - 1];
+			if (arg === void 0) return Effect.void;
+			if (isNativeErrorNew(arg)) return ctx.report(make({
+				node: arg,
+				message: "Avoid native Error in Effect.fail(). Use Schema.TaggedErrorClass or Data.TaggedError."
+			}));
+			if (arg.type === "ArrowFunctionExpression") {
+				const body = arg["body"];
+				if (body.type !== "BlockStatement" && isNativeErrorNew(body)) return ctx.report(make({
+					node: arg,
+					message: "Avoid native Error in Effect.failSync(). Use Schema.TaggedErrorClass or Data.TaggedError."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noGlobalErrorInFailure };

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

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

package/dist/rules/no-globals.js

@@ -0,0 +1,164 @@
+import { calleeName, matchMember, memberNames } 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 Option from "effect/Option";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/rules/no-globals.ts
+const memberBans = [
+	[
+		"console",
+		[
+			"log",
+			"warn",
+			"error",
+			"info",
+			"debug",
+			"trace"
+		],
+		"Avoid console.* inside Effect context. Use Effect.log / Effect.logWarning / Effect.logError."
+	],
+	[
+		"Date",
+		"now",
+		"Avoid Date.now() inside Effect context. Use Clock service from 'effect'."
+	],
+	[
+		"JSON",
+		["parse", "stringify"],
+		"Avoid JSON.parse/stringify inside Effect context. Use Schema.fromJsonString."
+	],
+	[
+		"Math",
+		"random",
+		"Avoid Math.random() inside Effect context. Use Random service from 'effect'."
+	],
+	[
+		"crypto",
+		["randomUUID", "getRandomValues"],
+		"Avoid crypto.randomUUID() inside Effect context. Use Random service from 'effect'."
+	]
+];
+const platformObjects = new Set([
+	"Bun",
+	"process",
+	"Deno"
+]);
+const alternatives = {
+	Bun: {
+		file: "Use FileSystem from 'effect'",
+		write: "Use FileSystem from 'effect'",
+		read: "Use FileSystem from 'effect'",
+		serve: "Use HttpServer from 'effect/unstable/http'",
+		env: "Use Config from 'effect'",
+		spawn: "Use Command from 'effect'",
+		sleep: "Use Effect.sleep",
+		stdin: "Use Terminal from 'effect'",
+		stdout: "Use Terminal from 'effect'",
+		stderr: "Use Terminal from 'effect'",
+		cwd: "Use Path from 'effect'",
+		which: "Use Command from 'effect'",
+		resolveSync: "Use Path from 'effect'",
+		pathToFileURL: "Use Path from 'effect'",
+		randomUUID: "Use Random service from 'effect'",
+		randomUUIDv7: "Use Random service from 'effect'"
+	},
+	process: {
+		env: "Use Config from 'effect'",
+		exit: "Use Effect.fail or Effect.die",
+		cwd: "Use Path from 'effect'",
+		argv: "Use Args/Command from 'effect/unstable/cli'",
+		stdin: "Use Terminal from 'effect'",
+		stdout: "Use Terminal from 'effect'",
+		stderr: "Use Terminal from 'effect'",
+		chdir: "Use Path from 'effect'",
+		kill: "Use Command from 'effect'",
+		on: "Use Effect.async or Stream.async",
+		platform: "Use PlatformInfo from 'effect'",
+		arch: "Use PlatformInfo from 'effect'",
+		execPath: "Use Command from 'effect'",
+		execArgv: "Use Args/Command from 'effect/unstable/cli'"
+	},
+	Deno: {
+		readFile: "Use FileSystem from 'effect'",
+		writeFile: "Use FileSystem from 'effect'",
+		readTextFile: "Use FileSystem from 'effect'",
+		writeTextFile: "Use FileSystem from 'effect'",
+		open: "Use FileSystem from 'effect'",
+		remove: "Use FileSystem from 'effect'",
+		mkdir: "Use FileSystem from 'effect'",
+		readDir: "Use FileSystem from 'effect'",
+		stat: "Use FileSystem from 'effect'",
+		cwd: "Use Path from 'effect'",
+		env: "Use Config from 'effect'",
+		exit: "Use Effect.fail or Effect.die",
+		serve: "Use HttpServer from 'effect/unstable/http'",
+		run: "Use Command from 'effect'",
+		args: "Use Args/Command from 'effect/unstable/cli'"
+	}
+};
+function getHint(obj, prop) {
+	const hint = alternatives[obj]?.[prop];
+	if (hint) return `. ${hint}`;
+	return ". Wrap in a service for testability";
+}
+const callBans = {
+	fetch: "Avoid fetch() inside Effect context. Use HttpClient from 'effect/unstable/http'.",
+	setTimeout: "Avoid setTimeout inside Effect context. Use Effect.sleep or Schedule.",
+	setInterval: "Avoid setInterval inside Effect context. Use Effect.sleep or Schedule."
+};
+const noGlobals = define({
+	name: "no-globals",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid global/platform APIs inside Effect.gen/fn. Use Effect platform services instead."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const [depth, tracker] = yield* makeEffectContextTracker;
+		return merge(tracker, {
+			MemberExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+				if (d <= 0) return Effect.void;
+				const memberNode = node;
+				for (const [obj, props, message] of memberBans) if (Option.isSome(matchMember(memberNode, obj, props))) return ctx.report(make({
+					node,
+					message
+				}));
+				const names = Option.getOrUndefined(memberNames(memberNode));
+				if (names !== void 0) {
+					const [obj, prop] = names;
+					if (platformObjects.has(obj)) return ctx.report(make({
+						node,
+						message: `Avoid ${obj}.${prop} inside Effect context${getHint(obj, prop)}.`
+					}));
+				}
+				return Effect.void;
+			}),
+			CallExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+				if (d <= 0) return Effect.void;
+				const name = Option.getOrUndefined(calleeName(node));
+				const message = name !== void 0 ? callBans[name] : void 0;
+				if (message !== void 0) return ctx.report(make({
+					node,
+					message
+				}));
+				return Effect.void;
+			}),
+			NewExpression: (node) => Effect.flatMap(Ref.get(depth), (d) => {
+				if (d <= 0) return Effect.void;
+				const callee = node["callee"];
+				if (callee.type === "Identifier" && "name" in callee && callee.name === "Date") return ctx.report(make({
+					node,
+					message: "Avoid new Date() inside Effect context. Use Clock service from 'effect'."
+				}));
+				return Effect.void;
+			})
+		});
+	}
+});
+//#endregion
+export { noGlobals };

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

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

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

@@ -0,0 +1,18 @@
+import { banStatement } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+//#region src/rules/no-if-statement.ts
+/**
+* Ban `if` statements in Effect codebases.
+*
+* Use `Option.match`, `Either.match`, `Match.value`, or data combinators.
+*
+* Source: biome-effect-linting-rules/no-if-statement
+*
+* Note: Very opinionated — recommended for strict functional presets only.
+*/
+const noIfStatement = banStatement("IfStatement", {
+	message: "Avoid if statements. Use Option.match, Either.match, Match.value, or Effect.if.",
+	meta: { type: "suggestion" }
+});
+//#endregion
+export { noIfStatement };

package/dist/rules/no-iife-wrapper.d.ts

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

package/dist/rules/no-iife-wrapper.js

@@ -0,0 +1,37 @@
+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-iife-wrapper.ts
+/**
+* Ban immediately-invoked function expressions (IIFEs).
+*
+* Use named const binding + flat pipeline.
+*
+* Source: biome-effect-linting-rules/no-iife-wrapper
+*/
+const noIifeWrapper = define({
+	name: "no-iife-wrapper",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid IIFEs. Use named const bindings + flat pipeline."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!("callee" in node)) return Effect.void;
+			const callee = node.callee;
+			if (callee == null || typeof callee !== "object" || !("type" in callee)) return Effect.void;
+			const isWrappedFn = callee.type === "ArrowFunctionExpression" || callee.type === "FunctionExpression";
+			const isParenWrapped = callee.type === "ParenthesizedExpression" && "expression" in callee && callee.expression != null && typeof callee.expression === "object" && "type" in callee.expression && (callee.expression.type === "ArrowFunctionExpression" || callee.expression.type === "FunctionExpression");
+			if (isWrappedFn || isParenWrapped) return ctx.report(make({
+				node,
+				message: "Avoid IIFEs. Use named const binding + flat pipeline."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noIifeWrapper };

package/dist/rules/no-inline-provide.d.ts

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

package/dist/rules/no-inline-provide.js

@@ -0,0 +1,31 @@
+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-inline-provide.ts
+const noInlineProvide = define({
+	name: "no-inline-provide",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect.provide inside Effect.gen/fn. Provide layers at the boundary."
+	}),
+	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;
+			if (!isCallOf(node, "Effect", "provide")) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: "Avoid Effect.provide inside Effect.gen/fn. Provide layers at the boundary."
+			}));
+		}) });
+	}
+});
+//#endregion
+export { noInlineProvide };

package/dist/rules/no-instanceof-schema.d.ts

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

package/dist/rules/no-instanceof-schema.js

@@ -0,0 +1,35 @@
+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-instanceof-schema.ts
+/**
+* Ban `instanceof` checks against Schema-derived classes.
+*
+* Use `Schema.is(SchemaType)` instead.
+*
+* Source: language-service/instanceOfSchema
+*
+* Note: Without type information, we detect common Effect Schema class names
+* used in `instanceof` checks. This is a best-effort heuristic.
+*/
+const noInstanceofSchema = define({
+	name: "no-instanceof-schema",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid instanceof with Schema types. Use Schema.is(SchemaType) instead."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { BinaryExpression: (node) => {
+			if ("operator" in node && node.operator === "instanceof") return ctx.report(make({
+				node,
+				message: "Avoid instanceof. Add a static `is` field to your class: `static is = Schema.is(this)`, then use `MyClass.is(value)`. For tagged types, use `_tag` checks."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noInstanceofSchema };

package/dist/rules/no-manual-effect-channels.d.ts

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

package/dist/rules/no-manual-effect-channels.js

@@ -0,0 +1,40 @@
+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-manual-effect-channels.ts
+/**
+* Ban manual `Effect.Effect<A, E, R>` type annotations.
+*
+* Let return types infer from the Effect/Layer you return.
+*
+* Source: biome-effect-linting-rules/no-manual-effect-channels
+*/
+const noManualEffectChannels = define({
+	name: "no-manual-effect-channels",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid manual Effect.Effect<A, E, R> annotations. Let types infer from the returned Effect."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { TSTypeReference: (node) => {
+			if (!("typeName" in node) || node.typeName == null) return Effect.void;
+			const typeName = node.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" || left["name"] === "Layer") && right != null && right["type"] === "Identifier" && (right["name"] === "Effect" || right["name"] === "Layer")) {
+					if ("typeParameters" in node && node.typeParameters != null && typeof node.typeParameters === "object" && "params" in node.typeParameters && Array.isArray(node.typeParameters["params"]) && node.typeParameters["params"].length > 0) return ctx.report(make({
+						node,
+						message: "Avoid manual Effect/Layer channel annotations. Let types infer from the returned value."
+					}));
+				}
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noManualEffectChannels };

package/dist/rules/no-match-effect-branch.d.ts

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

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

@@ -0,0 +1,64 @@
+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-effect-branch.ts
+const sequencingMethods = new Set([
+	"flatMap",
+	"map",
+	"andThen",
+	"tap",
+	"zipRight",
+	"pipe"
+]);
+const containsEffectSequencing = (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") {
+			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" && sequencingMethods.has(prop["name"])) return true;
+		}
+		if ("arguments" in n && Array.isArray(n["arguments"])) {
+			for (const arg of n["arguments"]) if (containsEffectSequencing(arg)) return true;
+		}
+	}
+	if ("body" in n) {
+		if (Array.isArray(n["body"])) {
+			for (const child of n["body"]) if (containsEffectSequencing(child)) return true;
+		} else if (containsEffectSequencing(n["body"])) return true;
+	}
+	if ("argument" in n && containsEffectSequencing(n["argument"])) return true;
+	if ("expression" in n && containsEffectSequencing(n["expression"])) return true;
+	return false;
+};
+const noMatchEffectBranch = define({
+	name: "no-match-effect-branch",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid Effect sequencing inside Match branches. Select value in Match, run Effect outside."
+	}),
+	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;
+			const callbackIdx = isMatchWhen ? 1 : 0;
+			const callback = node.arguments[callbackIdx];
+			if (callback != null && containsEffectSequencing(callback)) return ctx.report(make({
+				node,
+				message: "Avoid Effect sequencing inside Match branches. Select value in Match, then run one Effect pipeline outside."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noMatchEffectBranch };

package/dist/rules/no-match-void-branch.d.ts

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