oxlint-plugin-effect 0.13.0 → 0.15.0

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

@@ -3,7 +3,9 @@ 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 Arr from "effect/Array";
 import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-node-builtin-import.ts
 const replacedModules = new Map([
@@ -39,30 +41,47 @@ const processOperations = new Set([
 	"stdout"
 ]);
 const moduleBase = (source) => {
-	const withoutPrefix = source.startsWith("node:") ? source.slice(5) : source;
-	return withoutPrefix.split("/")[0] ?? withoutPrefix;
+	let withoutPrefix = source;
+	if (source.startsWith("node:")) withoutPrefix = source.slice(5);
+	return Option.getOrElse(Arr.head(withoutPrefix.split("/")), () => withoutPrefix);
+};
+const importedName = (specifier) => {
+	if (specifier.imported.type === "Identifier") return specifier.imported.name;
+	return specifier.imported.value;
 };
-const importedName = (specifier) => specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
 const memberPath = (node) => {
-	if (node.computed || node.property.type !== "Identifier") return void 0;
-	if (node.object.type === "Identifier") return [node.object.name, node.property.name];
-	if (node.object.type !== "MemberExpression") return void 0;
-	const parentPath = memberPath(node.object);
-	return parentPath === void 0 ? void 0 : [...parentPath, node.property.name];
+	if (node.computed || node.property.type !== "Identifier") return Option.none();
+	const property = node.property.name;
+	if (node.object.type === "Identifier") return Option.some([node.object.name, property]);
+	if (node.object.type !== "MemberExpression") return Option.none();
+	return Option.map(memberPath(node.object), (parentPath) => [...parentPath, property]);
+};
+/** Whether the segment before the operation in `path` is `name`. */
+const followsSegment = (path, name) => Option.contains(Arr.get(path, path.length - 2), name);
+const isDigestUnder = (operation, path, name) => operation === "digest" && followsSegment(path, name);
+const cryptoReplacement = (operation, path) => {
+	if (cryptoOperations.has(operation) && path.length === 2) return Option.some("Crypto");
+	if (followsSegment(path, "webcrypto") && cryptoOperations.has(operation)) return Option.some("Crypto");
+	if (isDigestUnder(operation, path, "subtle")) return Option.some("Crypto.digest");
+	return Option.none();
 };
-const partialReplacement = (module, path) => {
-	const operation = path.at(-1);
-	if (operation === void 0) return void 0;
-	if (module === "process") return processOperations.has(operation) && path.length === 2 ? "Config, Stdio, Clock, or Effect scheduling" : void 0;
-	if (module === "subtle") return operation === "digest" && path.length === 2 ? "Crypto.digest" : void 0;
+const replacementFor = (module, operation, path) => {
+	if (module === "process") {
+		if (processOperations.has(operation) && path.length === 2) return Option.some("Config, Stdio, Clock, or Effect scheduling");
+		return Option.none();
+	}
+	if (module === "subtle") {
+		if (operation === "digest" && path.length === 2) return Option.some("Crypto.digest");
+		return Option.none();
+	}
 	if (module === "webcrypto") {
-		if (cryptoOperations.has(operation) && path.length === 2) return "Crypto";
-		return operation === "digest" && path.at(-2) === "subtle" ? "Crypto.digest" : void 0;
+		if (cryptoOperations.has(operation) && path.length === 2) return Option.some("Crypto");
+		if (isDigestUnder(operation, path, "subtle")) return Option.some("Crypto.digest");
+		return Option.none();
 	}
-	if (cryptoOperations.has(operation) && path.length === 2) return "Crypto";
-	if (path.at(-2) === "webcrypto" && cryptoOperations.has(operation)) return "Crypto";
-	return operation === "digest" && path.at(-2) === "subtle" ? "Crypto.digest" : void 0;
+	return cryptoReplacement(operation, path);
 };
+const partialReplacement = (module, path) => Option.flatMap(Arr.last(path), (operation) => replacementFor(module, operation, path));
 const noNodeBuiltinImport = define({
 	name: "no-node-builtin-import",
 	meta: meta({
@@ -76,14 +95,17 @@ const noNodeBuiltinImport = define({
 			node,
 			message: `Avoid ${used}. Use ${alternative}; platform adapters may disable this rule explicitly.`
 		}));
+		/** The partially replaced module a member path starts from, if its root is an alias. */
+		const aliasedModule = (path) => Option.flatMap(Arr.head(path), (alias) => Option.fromUndefinedOr(partialModuleByAlias.get(alias)));
 		return {
 			ImportDeclaration: (node) => {
-				const declaration = Option.getOrUndefined(narrow(node, "ImportDeclaration"));
-				if (declaration === void 0) return Effect.void;
+				const narrowed = narrow(node, "ImportDeclaration");
+				if (Option.isNone(narrowed)) return Effect.void;
+				const declaration = narrowed.value;
 				const source = importSource(declaration);
 				const module = moduleBase(source);
 				const alternative = replacedModules.get(module);
-				if (alternative !== void 0) return report(declaration, `importing '${source}'`, alternative);
+				if (Predicate.isNotUndefined(alternative)) return report(declaration, `importing '${source}'`, alternative);
 				if (module !== "crypto" && module !== "process") return Effect.void;
 				const diagnostics = [];
 				for (const specifier of declaration.specifiers) {
@@ -99,18 +121,19 @@ const noNodeBuiltinImport = define({
 				}
 				return Effect.all(diagnostics, { discard: true });
 			},
-			MemberExpression: (node) => {
-				const member = Option.getOrUndefined(narrow(node, "MemberExpression"));
-				if (member === void 0) return Effect.void;
-				const path = memberPath(member);
-				if (path === void 0) return Effect.void;
-				const alias = path[0];
-				if (alias === void 0) return Effect.void;
-				const module = partialModuleByAlias.get(alias);
-				if (module === void 0) return Effect.void;
-				const alternative = partialReplacement(module, path);
-				return alternative === void 0 ? Effect.void : report(member, `${path.join(".")}`, alternative);
-			}
+			MemberExpression: (node) => Option.match(narrow(node, "MemberExpression"), {
+				onNone: () => Effect.void,
+				onSome: (member) => {
+					const replacement = Option.flatMap(memberPath(member), (path) => Option.map(Option.flatMap(aliasedModule(path), (module) => partialReplacement(module, path)), (alternative) => ({
+						path,
+						alternative
+					})));
+					return Option.match(replacement, {
+						onNone: () => Effect.void,
+						onSome: ({ path, alternative }) => report(member, `${path.join(".")}`, alternative)
+					});
+				}
+			})
 		};
 	}
 });

package/dist/rules/no-nullish.js

@@ -5,6 +5,7 @@ import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import { isGlobalReference } from "../vendor/effect-oxlint/SourceCode.js";
 import "../vendor/effect-oxlint/index.js";
 import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-nullish.ts
 const message = "Avoid null and undefined. Use Option for presence or absence. Use a domain enum when the state has more than two cases.";
@@ -37,7 +38,10 @@ const noNullish = define({
 			}),
 			Literal: (node) => Option.match(narrow(node, "Literal"), {
 				onNone: () => Effect.void,
-				onSome: (literal) => literal.value === null && !("regex" in literal) && !isNullPrototypeArgument(literal) ? report(literal) : Effect.void
+				onSome: (literal) => {
+					if (!Predicate.isNull(literal.value) || "regex" in literal || isNullPrototypeArgument(literal)) return Effect.void;
+					return report(literal);
+				}
 			}),
 			TSNullKeyword: (node) => Option.match(narrow(node, "TSNullKeyword"), {
 				onNone: () => Effect.void,

package/dist/rules/no-object-parameters.js

@@ -2,17 +2,11 @@ import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import { createTypeAliasEnvironment, resolvedTypeMatches } from "./_anti-slop-type-alias-resolution.js";
+import { functionParameterBindingName, functionParameterTypeAnnotation } from "./_anti-slop-function-parameters.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-object-parameters.ts
-function parameterAnnotation(parameter) {
-	if (parameter.type === "TSParameterProperty") return parameterAnnotation(parameter.parameter);
-	if (parameter.type === "RestElement") return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
-	if (parameter.type === "AssignmentPattern") return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
-	return parameter.typeAnnotation;
-}
-function parameterName(parameter, sourceCode) {
-	return parameter.type === "Identifier" ? parameter.name : sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "");
-}
 /** Ban the broad object type on function inputs, including local aliases to object. */
 const noObjectParameters = define({
 	name: "no-object-parameters",
@@ -23,34 +17,26 @@ const noObjectParameters = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const aliases = /* @__PURE__ */ new Map();
-		const resolvesToObject = (type, visited = /* @__PURE__ */ new Set()) => {
-			if (type.type === "TSObjectKeyword") return true;
-			if (type.type === "TSParenthesizedType") return resolvesToObject(type.typeAnnotation, visited);
-			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToObject(member, visited));
-			if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || type.typeArguments !== null && type.typeArguments !== void 0 && type.typeArguments.params.length > 0 || visited.has(type.typeName.name)) return false;
-			const alias = aliases.get(type.typeName.name);
-			if (alias === void 0) return false;
-			const nextVisited = new Set(visited);
-			nextVisited.add(type.typeName.name);
-			return resolvesToObject(alias, nextVisited);
-		};
+		let environment = Option.none();
+		const resolvesToObject = (type) => Option.exists(environment, (present) => resolvedTypeMatches(type, present, (resolved, matches) => {
+			if (resolved.type === "TSObjectKeyword") return true;
+			if (resolved.type === "TSParenthesizedType") return matches(resolved.typeAnnotation);
+			return resolved.type === "TSUnionType" && resolved.types.some(matches);
+		}));
 		const checkParameters = (node) => Effect.forEach(node.params, (parameter) => {
-			const annotation = parameterAnnotation(parameter);
-			if (annotation === null || annotation === void 0) return Effect.void;
-			if (!resolvesToObject(annotation.typeAnnotation)) return Effect.void;
+			const annotation = functionParameterTypeAnnotation(parameter);
+			if (Option.isNone(annotation)) return Effect.void;
+			const type = annotation.value.typeAnnotation;
+			if (!resolvesToObject(type)) return Effect.void;
 			return context.report(fromId({
-				node: annotation.typeAnnotation,
+				node: type,
 				messageId: "objectParameter",
-				data: { parameter: parameterName(parameter, context.sourceCode) }
+				data: { parameter: functionParameterBindingName(parameter, context.sourceCode) }
 			}));
 		}, { discard: true });
 		return {
 			Program: (node) => {
-				for (const statement of node.body) {
-					const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-					if (declaration?.type === "TSTypeAliasDeclaration" && (declaration.typeParameters === null || declaration.typeParameters === void 0)) aliases.set(declaration.id.name, declaration.typeAnnotation);
-				}
+				environment = Option.some(createTypeAliasEnvironment(node, context.sourceCode.visitorKeys));
 				return Effect.void;
 			},
 			ArrowFunctionExpression: checkParameters,

package/dist/rules/no-per-call-cache-construction.js

@@ -4,6 +4,7 @@ import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
 import { enclosingEffectProgram } from "./_effect-context.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-per-call-cache-construction.ts
 const cachedEffectOperations = new Set([
@@ -36,8 +37,7 @@ const noPerCallCacheConstruction = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
 				const effects = visibleNamespaces(ctx, node, effectNamespaces);
-				const program = enclosingEffectProgram(node, effects);
-				if (program === void 0 || program[1] === "gen") return Effect.void;
+				if (!Option.exists(enclosingEffectProgram(node, effects), ([, kind]) => kind !== "gen")) return Effect.void;
 				const caches = visibleNamespaces(ctx, node, cacheNamespaces);
 				if (!(isOperation(node.callee, effects, cachedEffectOperations) || isOperation(node.callee, caches, cacheConstructors))) return Effect.void;
 				return ctx.report(make({

package/dist/rules/no-reduce-accumulator-copy.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-reduce-accumulator-copy.d.ts
+/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
+declare const noReduceAccumulatorCopy: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noReduceAccumulatorCopy };

package/dist/rules/no-reduce-accumulator-copy.js

@@ -0,0 +1,106 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { arrayMethodTarget, constInitializer, isKnownArrayExpression, resolveArrayBinding, unwrapArrayExpression } from "./_anti-slop-array-method.js";
+import { ancestors } from "./_ast-ancestors.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-reduce-accumulator-copy.ts
+const arrayCopyMethods = new Set([
+	"concat",
+	"slice",
+	"toSpliced",
+	"toSorted",
+	"toReversed",
+	"with"
+]);
+const isCallback = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+const parameterBinding = (parameter) => {
+	if (parameter.type === "AssignmentPattern") return parameter.left;
+	return parameter;
+};
+const isReduceCall = (owner, callback) => Option.exists(arrayMethodTarget(owner.callee), (method) => method.name === "reduce" || method.name === "reduceRight") && owner.arguments.length <= 2 && Option.exists(Arr.head(owner.arguments), (firstArgument) => unwrapArrayExpression(firstArgument) === callback);
+function reducerForCallback(callback) {
+	const owner = Arr.findFirst(ancestors(callback), (node) => unwrapArrayExpression(node) !== callback);
+	return Option.flatMap(owner, (call) => {
+		if (call.type !== "CallExpression" || !isReduceCall(call, callback)) return Option.none();
+		return Option.flatMap(Arr.head(callback.params), (firstParameter) => {
+			const accumulator = parameterBinding(firstParameter);
+			if (accumulator.type !== "Identifier") return Option.none();
+			return Option.some({
+				callback,
+				accumulator,
+				initialValue: Arr.get(call.arguments, 1)
+			});
+		});
+	});
+}
+function enclosingReducer(node) {
+	const boundary = Arr.findFirst(ancestors(node), (parent) => parent.type === "FunctionDeclaration" || isCallback(parent));
+	return Option.flatMap(boundary, (parent) => {
+		if (!isCallback(parent)) return Option.none();
+		return reducerForCallback(parent);
+	});
+}
+function referencesAccumulator(sourceCode, node, accumulator, visited = /* @__PURE__ */ new Set()) {
+	return Option.exists(resolveArrayBinding(sourceCode, node), (variable) => {
+		if (visited.has(variable)) return false;
+		if (variable === accumulator) return true;
+		visited.add(variable);
+		if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
+		return Option.exists(constInitializer(variable), (init) => referencesAccumulator(sourceCode, init, accumulator, visited));
+	});
+}
+function isGlobalCopyOwner(sourceCode, node, name) {
+	const owner = unwrapArrayExpression(node);
+	if (owner.type !== "Identifier" || owner.name !== name) return false;
+	return Option.match(resolveArrayBinding(sourceCode, owner), {
+		onNone: () => true,
+		onSome: (variable) => variable.defs.length === 0
+	});
+}
+function accumulatorCopyCandidate(sourceCode, node) {
+	const lookups = Option.all({
+		method: arrayMethodTarget(node.callee),
+		reducer: enclosingReducer(node)
+	});
+	return Option.flatMap(lookups, ({ method, reducer }) => {
+		const accumulator = Arr.findFirst(sourceCode.getDeclaredVariables(reducer.callback), (variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
+		return Option.map(accumulator, (variable) => ({
+			method,
+			reducer,
+			accumulator: variable
+		}));
+	});
+}
+/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
+const noReduceAccumulatorCopy = define({
+	name: "no-reduce-accumulator-copy",
+	meta: meta({
+		type: "problem",
+		description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods.",
+		messages: { accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const { sourceCode } = context;
+		const copiesAccumulator = (node, { method, reducer, accumulator }) => {
+			const isAccumulator = (expression) => referencesAccumulator(sourceCode, expression, accumulator);
+			if (method.name === "assign" && isGlobalCopyOwner(sourceCode, method.object, "Object")) return Option.exists(Arr.head(node.arguments), (target) => unwrapArrayExpression(target).type === "ObjectExpression") && node.arguments.slice(1).some(isAccumulator);
+			if (method.name === "from" && isGlobalCopyOwner(sourceCode, method.object, "Array")) return Option.exists(Arr.head(node.arguments), isAccumulator);
+			if (!arrayCopyMethods.has(method.name)) return false;
+			return Option.exists(reducer.initialValue, (initialValue) => isKnownArrayExpression(sourceCode, initialValue)) && isAccumulator(method.object);
+		};
+		return { CallExpression: (node) => {
+			if (!Option.exists(accumulatorCopyCandidate(sourceCode, node), (candidate) => copiesAccumulator(node, candidate))) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "accumulatorCopy"
+			}));
+		} };
+	}
+});
+//#endregion
+export { noReduceAccumulatorCopy };

package/dist/rules/no-reflect-apply.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-reflect-apply.d.ts
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+declare const noReflectApply: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noReflectApply };

package/dist/rules/no-reflect-apply.js

@@ -0,0 +1,28 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { isGlobalReflectMethodCall } from "./_anti-slop-reflect-method.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-reflect-apply.ts
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+const noReflectApply = define({
+	name: "no-reflect-apply",
+	meta: meta({
+		type: "problem",
+		description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface.",
+		messages: { reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (node.callee.type === "Super" || !isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "reflectApply"
+			}));
+		} };
+	}
+});
+//#endregion
+export { noReflectApply };

package/dist/rules/no-reflect-get.d.ts

@@ -0,0 +1,7 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-reflect-get.d.ts
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+declare const noReflectGet: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noReflectGet };

package/dist/rules/no-reflect-get.js

@@ -0,0 +1,28 @@
+import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import { isGlobalReflectMethodCall } from "./_anti-slop-reflect-method.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-reflect-get.ts
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+const noReflectGet = define({
+	name: "no-reflect-get",
+	meta: meta({
+		type: "problem",
+		description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type.",
+		messages: { reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (node.callee.type === "Super" || !isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "reflectGet"
+			}));
+		} };
+	}
+});
+//#endregion
+export { noReflectGet };

package/dist/rules/no-run-collect-on-unbounded-stream.js

@@ -2,7 +2,9 @@ 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 { expressionArgument } from "./_call-arguments.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Option from "effect/Option";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-run-collect-on-unbounded-stream.ts
 const unboundedSources = new Set([
@@ -23,29 +25,25 @@ const terminatingOperations = new Set([
 ]);
 const staticOperation = (node, streamNamespaces, operations) => {
 	if (node.type === "SpreadElement") return false;
-	const candidate = node.type === "CallExpression" && node.callee.type !== "Super" ? node.callee : node;
+	let candidate = node;
+	if (node.type === "CallExpression" && node.callee.type !== "Super") candidate = node.callee;
 	for (const operation of operations) if (isStaticMember(candidate, streamNamespaces, operation)) return true;
 	return false;
 };
+const isPipeMember = (node) => node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier" && node.property.name === "pipe";
+const pipesTerminatingOperation = (node, streamNamespaces) => node.arguments.some((operation) => staticOperation(operation, streamNamespaces, terminatingOperations));
 const unboundedRoot = (node, streamNamespaces) => {
-	if (node.type !== "CallExpression" || node.callee.type === "Super") return void 0;
-	for (const source of unboundedSources) if (isStaticMember(node.callee, streamNamespaces, source)) return node;
-	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
-	const root = unboundedRoot(node.callee.object, streamNamespaces);
-	if (root === void 0) return void 0;
-	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
-	return root;
+	if (node.type !== "CallExpression" || node.callee.type === "Super") return Option.none();
+	for (const source of unboundedSources) if (isStaticMember(node.callee, streamNamespaces, source)) return Option.some(node);
+	if (!isPipeMember(node.callee)) return Option.none();
+	return Option.filter(unboundedRoot(node.callee.object, streamNamespaces), () => !pipesTerminatingOperation(node, streamNamespaces));
 };
 const collectedSource = (node, streamNamespaces) => {
-	if (node.callee.type === "Super") return void 0;
-	if (isStaticMember(node.callee, streamNamespaces, "runCollect")) {
-		const source = node.arguments[0];
-		if (source !== void 0 && source.type !== "SpreadElement") return source;
-		return;
-	}
-	if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "pipe") return;
-	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, terminatingOperations)) return void 0;
-	for (const operation of node.arguments) if (staticOperation(operation, streamNamespaces, collectOperations)) return node.callee.object;
+	if (node.callee.type === "Super") return Option.none();
+	if (isStaticMember(node.callee, streamNamespaces, "runCollect")) return expressionArgument(node, 0);
+	if (!isPipeMember(node.callee) || pipesTerminatingOperation(node, streamNamespaces)) return Option.none();
+	if (!node.arguments.some((operation) => staticOperation(operation, streamNamespaces, collectOperations))) return Option.none();
+	return Option.some(node.callee.object);
 };
 const noRunCollectOnUnboundedStream = define({
 	name: "no-run-collect-on-unbounded-stream",
@@ -65,14 +63,14 @@ const noRunCollectOnUnboundedStream = define({
 			CallExpression: (node) => {
 				if (node.type !== "CallExpression") return Effect.void;
 				const namespaces = visibleNamespaces(ctx, node, streamNamespaces);
-				const source = collectedSource(node, namespaces);
-				if (source === void 0) return Effect.void;
-				const root = unboundedRoot(source, namespaces);
-				if (root === void 0) return Effect.void;
-				return ctx.report(make({
-					node: root,
-					message: "Do not collect a clearly unbounded Stream. Add a terminating operation or consume it with runForEach or runDrain."
-				}));
+				const root = Option.flatMap(collectedSource(node, namespaces), (source) => unboundedRoot(source, namespaces));
+				return Option.match(root, {
+					onNone: () => Effect.void,
+					onSome: (stream) => ctx.report(make({
+						node: stream,
+						message: "Do not collect a clearly unbounded Stream. Add a terminating operation or consume it with runForEach or runDrain."
+					}))
+				});
 			}
 		};
 	}

package/dist/rules/no-runtime-typeof.js

@@ -4,6 +4,20 @@ 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-runtime-typeof.ts
+/** Whether `typeof` probes for a possibly absent binding, which only `typeof` can do safely. */
+function isExistenceProbe(node) {
+	const parent = node.parent;
+	if (parent?.type !== "BinaryExpression") return false;
+	if (![
+		"===",
+		"!==",
+		"==",
+		"!="
+	].includes(parent.operator)) return false;
+	let other = parent.left;
+	if (parent.left === node) other = parent.right;
+	return other.type === "Literal" && other.value === "undefined";
+}
 /** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
 const noRuntimeTypeof = define({
 	name: "no-runtime-typeof",
@@ -14,10 +28,13 @@ const noRuntimeTypeof = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		return { UnaryExpression: (node) => node.operator === "typeof" ? context.report(fromId({
-			node,
-			messageId: "runtimeTypeof"
-		})) : Effect.void };
+		return { UnaryExpression: (node) => {
+			if (node.operator !== "typeof" || isExistenceProbe(node)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "runtimeTypeof"
+			}));
+		} };
 	}
 });
 //#endregion

package/dist/rules/no-sequential-effect-all.js

@@ -2,19 +2,26 @@ 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 { expressionArgument, staticProperties } from "./_call-arguments.js";
 import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-sequential-effect-all.ts
+const primitiveLiteral = (node) => {
+	if (node.type !== "Literal") return Option.none();
+	const value = node.value;
+	if (Predicate.isNull(value) || Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) return Option.some(node);
+	return Option.none();
+};
+/** The first primitive literal given for `name` in an options object literal. */
 const propertyLiteral = (node, name) => {
-	if (node?.type !== "ObjectExpression") return void 0;
-	for (const property of node.properties) {
-		if (property.type !== "Property" || property.computed) continue;
-		if ((property.key.type === "Identifier" && property.key.name === name || property.key.type === "Literal" && property.key.value === name) && property.value.type === "Literal") {
-			const value = property.value.value;
-			if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-		}
-	}
+	if (node.type !== "ObjectExpression") return Option.none();
+	return Arr.findFirst(staticProperties(node, name), (property) => primitiveLiteral(property.value));
 };
+/** Whether the options set `name` to the literal `expected`. */
+const hasLiteralOption = (options, name, expected) => Option.exists(Option.flatMap(options, (node) => propertyLiteral(node, name)), (literal) => literal.value === expected);
 const pipedToAsVoid = (node, effectNamespaces) => {
 	const member = node.parent;
 	if (member?.type !== "MemberExpression" || member.object !== node || member.computed || member.property.type !== "Identifier" || member.property.name !== "pipe") return false;
@@ -46,9 +53,9 @@ const noSequentialEffectAll = define({
 				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
 				if (!isStaticMember(node.callee, namespaces, "all")) return Effect.void;
 				if (node.arguments[0]?.type !== "ArrayExpression") return Effect.void;
-				const options = node.arguments[1];
-				if (propertyLiteral(options, "concurrency") !== 1) return Effect.void;
-				if (!(propertyLiteral(options, "discard") === true || pipedToAsVoid(node, namespaces))) return Effect.void;
+				const options = expressionArgument(node, 1);
+				if (!hasLiteralOption(options, "concurrency", 1)) return Effect.void;
+				if (!(hasLiteralOption(options, "discard", true) || pipedToAsVoid(node, namespaces))) return Effect.void;
 				return ctx.report(make({
 					node,
 					message: "Use Effect.andThen or one flat generator for sequential steps. Reserve Effect.all for value aggregation or real concurrency."

package/dist/rules/no-shape-in-symbol-names.js

@@ -2,12 +2,19 @@ import { fromId } from "../vendor/effect-oxlint/Diagnostic.js";
 import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
 import { define, meta } from "../vendor/effect-oxlint/Rule.js";
 import "../vendor/effect-oxlint/index.js";
+import * as Predicate from "effect/Predicate";
 import * as Effect from "effect/Effect";
 //#region src/rules/no-shape-in-symbol-names.ts
 const forbiddenSymbolName = "shape";
 function containsForbiddenSymbolName(name) {
 	return name.toLowerCase().includes(forbiddenSymbolName);
 }
+/** Return whether an identifier names a statically accessed member owned by another value. */
+function isBorrowedMemberName(node) {
+	const parent = node.parent;
+	if (Predicate.isNull(parent) || parent.type !== "MemberExpression") return false;
+	return parent.property === node && !parent.computed;
+}
 /** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
 const noShapeInSymbolNames = define({
 	name: "no-shape-in-symbol-names",
@@ -18,11 +25,14 @@ const noShapeInSymbolNames = define({
 	}),
 	create: function* () {
 		const context = yield* RuleContext;
-		const reportForbiddenSymbolName = (node) => containsForbiddenSymbolName(node.name) ? context.report(fromId({
-			node,
-			messageId: "forbiddenSymbolName",
-			data: { name: node.name }
-		})) : Effect.void;
+		const reportForbiddenSymbolName = (node) => {
+			if (!containsForbiddenSymbolName(node.name) || isBorrowedMemberName(node)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "forbiddenSymbolName",
+				data: { name: node.name }
+			}));
+		};
 		return {
 			Identifier: reportForbiddenSymbolName,
 			PrivateIdentifier: reportForbiddenSymbolName,