@deslop/coding-standards 0.1.1076 → 0.1.1079

package/dist/oxlint.js

@@ -1,5 +1,5 @@
-import { $ as values, $n as symbol$1, C as filterMap, D as flatMap$1, Dt as orElse, Et as none, F as isArrayNonEmpty, Gn as combine, Hn as equals, J as take, Jn as optimize, K as some$1, Kn as hash, M as getSomes, N as head, Nn as NodeInspectSymbol, O as flatten, Or as pipe, Ot as some, P as isArrayEmpty, Q as remove, R as join, S as filter$1, St as isSome, T as findFirstIndex, Tt as match$1, U as of, Un as symbol, V as map$1, Vn as byReferenceUnsafe, W as prepend, X as get$2, Xn as string, Y as fromEntries, _ as dedupe, _t as fromNullishOr, a as includes, b as ensure, c as startsWith, dt as contains, er as hasProperty, f as TaggedError, ft as exists, g as contains$1, gt as flatten$1, h as appendAll, hr as isString, ht as flatMap, i as Order, j as get$1, jr as pipeArguments, k as forEach, kt as zipWith, l as trim, lr as isNullish$1, m as append, mr as isReadonlyObject, mt as firstSomeOf, n as make$2, nr as isBoolean, nt as fromOption, o as match, or as isNotNull, pt as filter, q as sort, qn as number, r as update, s as split, sr as isNotNullish, t as get$3, ur as isNumber, ut as all, v as dropRight, vt as fromUndefinedOr, w as findFirst, wr as dual, wt as map, x as every, y as empty, yt as getOrElse, z as last } from "./MutableRef-KfyWrSvW.mjs";
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/graph.js
+import { $ as prepend, $t as strictEqual, A as filter$1, Ar as isString, At as getOrUndefined, B as getSomes, Bt as zipWith, C as contains$1, Cr as isNullish$1, Ct as filter, D as empty, Dt as fromNullishOr, E as dedupeWith, Et as flatten$1, F as flatMap$1, Ft as match, Gn as NodeInspectSymbol, H as isArrayEmpty, I as flatten, It as none, K as join, Kr as pipeArguments, L as forEach, Lr as constVoid, Lt as orElse, M as findFirst, Mt as isSome, N as findFirstIndex, O as ensure, Or as isReadonlyObject, Ot as fromUndefinedOr, Pr as constFalse, Pt as map, Q as of, Rt as some, S as appendAll, St as exists, T as dedupe, Tt as flatMap, U as isArrayNonEmpty, Ur as pipe, V as head, Y as map$1, Z as matchRight, at as get$2, bt as all, c as make$3, cr as number, ct as remove, d as includes, f as match$1, ft as fromOption, g as trim, gr as isBoolean, h as startsWith, ir as symbol, it as fromEntries, j as filterMap, k as every, kr as isRegExp, kt as getOrElse, l as update, lr as optimize, lt as values, m as split, mr as hasProperty, nr as byReferenceUnsafe, nt as sort, o as toArray, or as combine, p as replaceAll, pr as symbol$1, q as last, r as make$2, rr as equals, rt as take, s as get$3, sr as hash, t as append$1, tt as some$1, u as Order, ur as string, w as containsWith, wr as isNumber, wt as firstSomeOf, x as append, xr as isNotNullish, xt as contains, y as TaggedError, z as get$1, zr as dual, zt as toArray$1 } from "./MutableList-BCF17jPH.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/graph.js
 /** @internal */
 const TypeId = "~effect/Graph";
 /** @internal */
@@ -94,7 +94,7 @@ const finalize = (source) => {
 	return graph;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/graphCsr.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/graphCsr.js
 const cache = /*#__PURE__*/ new WeakMap();
 const makeAdjacency = (csr, incoming) => {
 	const impl = toImpl(csr.graph);
@@ -168,7 +168,7 @@ const get = (graph) => {
 	return result;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Graph.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Graph.js
 /**
 * Models relationships between indexed nodes and edges.
 *
@@ -621,7 +621,7 @@ Object.freeze({
 	}
 });
 //#endregion
-//#region ../../node_modules/.pnpm/oxlint@1.88.0_oxlint-tsgolint@7.0.2004_vite-plus@1.2.0_@opentelemetry+api@1.9.1_@types+_05cbd3a08eae06c0731a5b89848c76f6/node_modules/oxlint/dist/index.js
+//#region ../../node_modules/.pnpm/oxlint@1.88.0_oxlint-tsgolint@7.0.2004_vite-plus@1.2.0_@opentelemetry+api@1.9.1_@types+_d0d0d8af4627f12721655e70fc027515/node_modules/oxlint/dist/index.js
 /**
 * Define an Oxlint configuration with type inference.
 *
@@ -650,20 +650,35 @@ function variableFor(context, node) {
 function isImportBinding(input) {
 	return pipe(variableFor(input.context, input.node), exists((variable) => some$1(variable.defs, (definition) => {
 		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") return false;
-		const source = definition.parent.source.value;
-		if (isString(input.source) ? source !== input.source : !input.source.test(source)) return false;
+		if (isString(input.source) && definition.parent.source.value !== input.source) return false;
+		if (isRegExp(input.source) && !input.source.test(definition.parent.source.value)) return false;
 		return input.importedName === void 0 || definition.node.type === "ImportSpecifier" && definition.node.imported.type === "Identifier" && definition.node.imported.name === input.importedName;
 	})));
 }
 function isNamespaceImport(input) {
 	return pipe(variableFor(input.context, input.node), exists((variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" && definition.node.type === "ImportNamespaceSpecifier" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === input.source)));
 }
+function typeWrapped(node) {
+	if (node.type === "TSAsExpression" || node.type === "TSInstantiationExpression" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion") return some(node.expression);
+	return none();
+}
+function outermost(node) {
+	return pipe(fromNullishOr(node.parent), filter((parent) => isSome(typeWrapped(parent))), match({
+		onNone: () => node,
+		onSome: outermost
+	}));
+}
 function returnedExpression(node) {
 	if (node.body === null) return;
 	if (node.body.type !== "BlockStatement") return node.body;
 	if (node.body.body.length !== 1 || node.body.body[0]?.type !== "ReturnStatement") return;
 	return node.body.body[0].argument;
 }
+function rootName(node) {
+	if (node.type === "Identifier") return some(node.name);
+	if (node.type === "MemberExpression" && !node.computed && !node.optional) return rootName(node.object);
+	return none();
+}
 function memberName(node) {
 	if (!node.computed && node.property.type === "Identifier") return some(node.property.name);
 	if (node.computed && node.property.type === "Literal" && isString(node.property.value)) return some(node.property.value);
@@ -678,11 +693,9 @@ function importedMember(input) {
 	}) && (input.propertyName === void 0 || contains(memberName(input.node), input.propertyName));
 }
 function matches(regExp) {
-	return (text) => isSome(pipe(text, match(regExp)));
-}
-function isSchemaOperationName(name) {
-	return matches(/^(?:(?:decode|encode)(?:Unknown)?(?:Effect|Exit|Option|Promise|Result|Sync)|asserts|is)$/u)(name);
+	return (text) => isSome(pipe(text, match$1(regExp)));
 }
+const isSchemaOperationName = matches(/^(?:(?:decode|encode)(?:Unknown)?(?:Effect|Exit|Option|Promise|Result|Sync)|asserts|is)$/u);
 function isSchemaOperationCall(input) {
 	if (input.node.callee.type !== "MemberExpression" || !importedMember({
 		context: input.context,
@@ -705,11 +718,13 @@ function isReactUseState(input) {
 	});
 }
 function statementDeclaration(statement) {
-	return statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+	if (statement.type === "ExportNamedDeclaration") return statement.declaration;
+	return statement;
 }
 function typeAlias(statement) {
 	const declaration = statementDeclaration(statement);
-	return declaration?.type === "TSTypeAliasDeclaration" ? some(declaration) : none();
+	if (declaration?.type !== "TSTypeAliasDeclaration") return none();
+	return some(declaration);
 }
 function isInferredType(input) {
 	return input.node.type === "TSTypeQuery" && input.node.exprName.type === "TSQualifiedName" && input.node.exprName.left.type === "Identifier" && input.node.exprName.left.name === input.name && input.node.exprName.right.name === "Type";
@@ -738,7 +753,10 @@ function isSchemaCodecType(input) {
 }
 function typeArgumentName(node) {
 	if (node.type !== "TSTypeReference" || node.typeArguments === null) return none();
-	return pipe(get$1(node.typeArguments.params, 0), flatMap((parameter) => parameter.type === "TSTypeReference" && parameter.typeName.type === "Identifier" ? some(parameter.typeName.name) : none()));
+	return pipe(get$1(node.typeArguments.params, 0), flatMap((parameter) => {
+		if (parameter.type !== "TSTypeReference" || parameter.typeName.type !== "Identifier") return none();
+		return some(parameter.typeName.name);
+	}));
 }
 function suspendedTypeName(input) {
 	if (input.node.callee.type === "Super" || !importedMember({
@@ -747,7 +765,10 @@ function suspendedTypeName(input) {
 		node: input.node.callee,
 		propertyName: "suspend"
 	})) return none();
-	return pipe(get$1(input.node.arguments, 0), flatMap((argument) => argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression" ? fromNullishOr(argument.returnType) : none()), filter((returnType) => isSchemaCodecType({
+	return pipe(get$1(input.node.arguments, 0), flatMap((argument) => {
+		if (argument.type !== "ArrowFunctionExpression" && argument.type !== "FunctionExpression") return none();
+		return fromNullishOr(argument.returnType);
+	}), filter((returnType) => isSchemaCodecType({
 		context: input.context,
 		node: returnType.typeAnnotation
 	})), flatMap((returnType) => typeArgumentName(returnType.typeAnnotation)));
@@ -755,7 +776,8 @@ function suspendedTypeName(input) {
 function referencedTypeNames(node) {
 	if (node.type === "TSTypeReference") {
 		const argumentNames = pipe(fromNullishOr(node.typeArguments), map((typeArguments) => pipe(typeArguments.params, flatMap$1(referencedTypeNames))), getOrElse(() => empty()));
-		return node.typeName.type === "Identifier" ? prepend(argumentNames, node.typeName.name) : argumentNames;
+		if (node.typeName.type !== "Identifier") return argumentNames;
+		return prepend(argumentNames, node.typeName.name);
 	}
 	if (node.type === "TSArrayType") return referencedTypeNames(node.elementType);
 	if (node.type === "TSUnionType" || node.type === "TSIntersectionType") return pipe(node.types, flatMap$1(referencedTypeNames));
@@ -779,9 +801,13 @@ function referencedTypeNames(node) {
 	if (node.type === "TSTypeLiteral") return pipe(node.members, flatMap$1(memberTypeNames));
 	return empty();
 }
+function annotationTypeNames(annotation) {
+	return pipe(fromNullishOr(annotation), map((present) => referencedTypeNames(present.typeAnnotation)), getOrElse(() => empty()));
+}
 function memberTypeNames(member) {
 	if (member.type === "TSIndexSignature") return referencedTypeNames(member.typeAnnotation.typeAnnotation);
-	return pipe(fromNullishOr(member.type === "TSPropertySignature" ? member.typeAnnotation : member.returnType), map((annotation) => referencedTypeNames(annotation.typeAnnotation)), getOrElse(() => empty()));
+	if (member.type === "TSPropertySignature") return annotationTypeNames(member.typeAnnotation);
+	return annotationTypeNames(member.returnType);
 }
 function isNode(value) {
 	return hasProperty(value, "type") && isString(value.type);
@@ -799,24 +825,28 @@ function suspendSeeds(input) {
 	return pipe(suspendedTypeName({
 		context: input.context,
 		node: input.node
-	}), match$1({
+	}), match({
 		onNone: () => seeds,
 		onSome: (name) => prepend(seeds, name)
 	}));
 }
 function referenceNames(node) {
 	const nested = pipe(childNodes(node), filter$1((child) => !(node.type === "Property" && !node.computed && child === node.key) && !(node.type === "MemberExpression" && !node.computed && child === node.property)), flatMap$1(referenceNames));
-	return node.type === "Identifier" ? prepend(nested, node.name) : nested;
+	if (node.type !== "Identifier") return nested;
+	return prepend(nested, node.name);
 }
 function schemaEdges(statement) {
 	const declaration = statementDeclaration(statement);
-	if (declaration?.type === "TSTypeAliasDeclaration") return isInferredType({
-		name: declaration.id.name,
-		node: declaration.typeAnnotation
-	}) ? empty() : [{
-		name: declaration.id.name,
-		targets: referencedTypeNames(declaration.typeAnnotation)
-	}];
+	if (declaration?.type === "TSTypeAliasDeclaration") {
+		if (isInferredType({
+			name: declaration.id.name,
+			node: declaration.typeAnnotation
+		})) return empty();
+		return [{
+			name: declaration.id.name,
+			targets: referencedTypeNames(declaration.typeAnnotation)
+		}];
+	}
 	if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") return empty();
 	return flatMap$1(declaration.declarations, (declarator) => {
 		if (declarator.id.type !== "Identifier" || declarator.init === null) return empty();
@@ -873,15 +903,27 @@ function isSingletonArray(input) {
 	if (isNullish$1(element) || element.type === "SpreadElement") return false;
 	return input.context.sourceCode.getText(element) === input.context.sourceCode.getText(input.value);
 }
-function restatesArrayEnsure(input) {
-	const test = input.node.test.type === "UnaryExpression" && input.node.test.operator === "!" ? input.node.test.argument : input.node.test;
-	const negated = test !== input.node.test;
-	return exists(testedValue(test), (value) => input.context.sourceCode.getText(negated ? input.node.alternate : input.node.consequent) === input.context.sourceCode.getText(value) && isSingletonArray({
+function wrapsTestedValue(input) {
+	return exists(testedValue(input.test), (value) => input.context.sourceCode.getText(input.kept) === input.context.sourceCode.getText(value) && isSingletonArray({
 		context: input.context,
-		node: negated ? input.node.consequent : input.node.alternate,
+		node: input.wrapped,
 		value
 	}));
 }
+function restatesArrayEnsure(input) {
+	if (input.node.test.type === "UnaryExpression" && input.node.test.operator === "!") return wrapsTestedValue({
+		context: input.context,
+		kept: input.node.alternate,
+		test: input.node.test.argument,
+		wrapped: input.node.consequent
+	});
+	return wrapsTestedValue({
+		context: input.context,
+		kept: input.node.consequent,
+		test: input.node.test,
+		wrapped: input.node.alternate
+	});
+}
 const noArrayWrapTernary = defineRule({
 	create: (context) => ({ ConditionalExpression: (node) => {
 		if (restatesArrayEnsure({
@@ -949,7 +991,9 @@ function enclosingPipes(context, node) {
 		"FunctionDeclaration",
 		"FunctionExpression"
 	], node.type)) return 0;
-	return enclosingPipes(context, node.parent) + (isPipeCall(context, node.parent) && some$1(node.parent.arguments, (argument) => argument === node) ? 1 : 0);
+	const depth = enclosingPipes(context, node.parent);
+	if (isPipeCall(context, node.parent) && some$1(node.parent.arguments, (argument) => argument === node)) return depth + 1;
+	return depth;
 }
 const noDeepPipe = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -980,22 +1024,28 @@ function namedTuple(input) {
 		seen: append(input.seen, input.node)
 	}))));
 }
+function componentName(node) {
+	if (node.type !== "ArrowFunctionExpression" && node.id !== null) return some(node.id.name);
+	return bindingName(node);
+}
 function component(node) {
-	const name = (node.type === "ArrowFunctionExpression" ? void 0 : node.id) ?? (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier" ? node.parent.id : void 0);
-	if (name === void 0 || !matches(/^[A-Z]/u)(name.name) || node.params.length !== 1 || node.body === null) return false;
+	if (!exists(componentName(node), matches(/^[A-Z]/u)) || node.params.length !== 1 || node.body === null) return false;
 	if (node.body.type === "JSXElement" || node.body.type === "JSXFragment") return true;
 	return node.body.type === "BlockStatement" && some$1(node.body.body, (statement) => statement.type === "ReturnStatement" && (statement.argument?.type === "JSXElement" || statement.argument?.type === "JSXFragment"));
 }
 function isPattern(input) {
-	const target = input.node.type === "AssignmentPattern" ? input.node.left : input.node;
-	if (target.type === "ArrayPattern") return !exists(fromNullishOr(target.typeAnnotation), (annotation) => namedTuple({
+	if (input.node.type === "AssignmentPattern") return isPattern({
+		...input,
+		node: input.node.left
+	});
+	if (input.node.type === "ArrayPattern") return !exists(fromNullishOr(input.node.typeAnnotation), (annotation) => namedTuple({
 		context: input.context,
 		node: annotation.typeAnnotation,
 		seen: []
 	}));
-	if (target.type !== "ObjectPattern") return false;
-	const named = filter$1(target.properties, (property) => property.type === "Property");
-	return !(input.component && named.length === 1 && named[0]?.key.type === "Identifier" && named[0].key.name === "ref" && some$1(target.properties, (property) => property.type === "RestElement"));
+	if (input.node.type !== "ObjectPattern") return false;
+	const named = filter$1(input.node.properties, (property) => property.type === "Property");
+	return !(input.component && named.length === 1 && named[0]?.key.type === "Identifier" && named[0].key.name === "ref" && some$1(input.node.properties, (property) => property.type === "RestElement"));
 }
 const noDestructuredParameter = defineRule({
 	create: (context) => {
@@ -1054,8 +1104,19 @@ const noDiscardedFailure = defineRule({
 //#region src/rules/no-double-nullish-check.ts
 function nullishOperand(node) {
 	if (node.type === "Literal" && node.value === null) return some("null");
-	return node.type === "Identifier" && node.name === "undefined" ? some("undefined") : none();
+	if (node.type === "Identifier" && node.name === "undefined") return some("undefined");
+	return none();
 }
+const variants = {
+	"&&": {
+		comparison: "!==",
+		message: "Use Predicate.isNotNullish."
+	},
+	"||": {
+		comparison: "===",
+		message: "Use Predicate.isNullish."
+	}
+};
 function operands(input) {
 	if (input.node.type !== "LogicalExpression" || input.node.operator !== input.operator) return [input.node];
 	return appendAll(operands({
@@ -1078,17 +1139,17 @@ const noDoubleNullishCheck = defineRule({
 	create: (context) => ({ LogicalExpression: (node) => {
 		if (node.operator === "??") return;
 		if (node.parent.type === "LogicalExpression" && node.parent.operator === node.operator) return;
-		const comparison = node.operator === "&&" ? "!==" : "===";
+		const variant = variants[node.operator];
 		const checks = pipe(operands({
 			node,
 			operator: node.operator
 		}), filterMap((operand) => fromOption(comparedNullish({
 			context,
 			node: operand,
-			operator: comparison
+			operator: variant.comparison
 		}), () => void 0)));
 		if (some$1(checks, (check) => some$1(checks, (other) => other.subject === check.subject && other.nullish !== check.nullish))) context.report({
-			message: comparison === "!==" ? "Use Predicate.isNotNullish." : "Use Predicate.isNullish.",
+			message: variant.message,
 			node
 		});
 	} }),
@@ -1099,11 +1160,10 @@ const noDoubleNullishCheck = defineRule({
 const noEffectPropertyArrow = defineRule({
 	create: (context) => ({ Property: (node) => {
 		if (node.value.type !== "ArrowFunctionExpression" || isArrayEmpty(node.value.params) || node.value.body.type !== "CallExpression") return;
-		const callee = node.value.body.callee;
-		if (callee.type === "Identifier" && isImportBinding({
+		if (node.value.body.callee.type === "Identifier" && isImportBinding({
 			context,
 			importedName: "pipe",
-			node: callee,
+			node: node.value.body.callee,
 			source: "effect"
 		}) && some$1(node.value.body.arguments, (argument) => argument.type !== "SpreadElement" && importedMember({
 			context,
@@ -1113,10 +1173,10 @@ const noEffectPropertyArrow = defineRule({
 			context,
 			importedName: "Effect",
 			node: argument.callee
-		})) || callee.type === "MemberExpression" && importedMember({
+		})) || node.value.body.callee.type === "MemberExpression" && importedMember({
 			context,
 			importedName: "Effect",
-			node: callee,
+			node: node.value.body.callee,
 			propertyName: "tryPromise"
 		})) context.report({
 			message: "Define this property with Effect.fn or Effect.fnUntraced instead of an arrow.",
@@ -1129,14 +1189,18 @@ const noEffectPropertyArrow = defineRule({
 //#region src/rules/no-error-message-assertion.ts
 function receiverName(node) {
 	if (node.type === "Identifier") return some(node.name);
-	return node.type === "MemberExpression" ? memberName(node) : none();
+	if (node.type !== "MemberExpression") return none();
+	return memberName(node);
 }
 function isErrorMessage(node) {
 	return node?.type === "MemberExpression" && contains(memberName(node), "message") && exists(receiverName(node.object), matches(/^(?:e|err|error|failure|cause|exception)$|Error$/iu));
 }
+function expectsErrorMessage(node) {
+	return node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "expect" && isErrorMessage(node.arguments[0]);
+}
 function expectsMessage(node) {
-	const subject = node.object.type === "MemberExpression" && contains(memberName(node.object), "not") ? node.object.object : node.object;
-	return subject.type === "CallExpression" && subject.callee.type === "Identifier" && subject.callee.name === "expect" && isErrorMessage(subject.arguments[0]);
+	if (node.object.type === "MemberExpression" && contains(memberName(node.object), "not")) return expectsErrorMessage(node.object.object);
+	return expectsErrorMessage(node.object);
 }
 function assertsMessage(node) {
 	const [actual, expected] = node.arguments;
@@ -1166,9 +1230,8 @@ function propertyName(node) {
 	return none();
 }
 function hasUnusedSetter(input) {
-	const declaration = input.node.parent;
-	if (declaration.type !== "VariableDeclarator" || declaration.id.type !== "ArrayPattern") return false;
-	const setter = declaration.id.elements[1];
+	if (input.node.parent.type !== "VariableDeclarator" || input.node.parent.id.type !== "ArrayPattern") return false;
+	const setter = input.node.parent.id.elements[1];
 	if (isNullish$1(setter)) return true;
 	if (setter.type !== "Identifier") return false;
 	return pipe(variableFromScope({
@@ -1226,10 +1289,13 @@ function check(input) {
 		node: argument
 	}))) return some(["!Array.isArray"]);
 	if (input.node.type !== "BinaryExpression") return none();
-	if (input.node.operator === "instanceof") return isSubject({
-		name: input.name,
-		node: input.node.left
-	}) && input.node.right.type === "Identifier" ? some([`instanceof ${input.node.right.name}`]) : none();
+	if (input.node.operator === "instanceof") {
+		if (!isSubject({
+			name: input.name,
+			node: input.node.left
+		}) || input.node.right.type !== "Identifier") return none();
+		return some([`instanceof ${input.node.right.name}`]);
+	}
 	return pipe(firstSomeOf([comparison({
 		name: input.name,
 		operator: input.node.operator,
@@ -1242,7 +1308,7 @@ function check(input) {
 		subject: input.node.right
 	})]), map(of));
 }
-function report$1(input) {
+function report$2(input) {
 	const predicate = input.node.returnType?.typeAnnotation;
 	const returned = returnedExpression(input.node);
 	if (predicate?.type !== "TSTypePredicate" || predicate.asserts || predicate.parameterName.type !== "Identifier" || isNullish$1(returned)) return;
@@ -1282,19 +1348,19 @@ function report$1(input) {
 const noHandWrittenGuard = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			report$1({
+			report$2({
 				context,
 				node
 			});
 		},
 		FunctionDeclaration: (node) => {
-			report$1({
+			report$2({
 				context,
 				node
 			});
 		},
 		FunctionExpression: (node) => {
-			report$1({
+			report$2({
 				context,
 				node
 			});
@@ -1303,6 +1369,18 @@ const noHandWrittenGuard = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-in-operator.ts
+const noInOperator = defineRule({
+	create: (context) => ({ BinaryExpression: (node) => {
+		if (node.operator !== "in") return;
+		context.report({
+			message: "Decode the value with Schema, or narrow it with Predicate.hasProperty, instead of the in operator.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-let.ts
 const noLet = defineRule({
 	create: (context) => ({ VariableDeclaration: (node) => {
@@ -1317,9 +1395,7 @@ const noLet = defineRule({
 //#region src/rules/no-multiline-comment.ts
 const directive = /^\s*(?:eslint|oxlint|@effect-diagnostics|@ts-|\/\s*<reference|#region|#endregion)/u;
 function adjacentLines(pair) {
-	const first = pair.first;
-	const second = pair.second;
-	return first?.type === "Line" && second?.type === "Line" && second.loc.start.line === first.loc.end.line + 1;
+	return pair.first?.type === "Line" && pair.second?.type === "Line" && pair.second.loc.start.line === pair.first.loc.end.line + 1;
 }
 const noMultilineComment = defineRule({
 	create: (context) => ({ Program: () => {
@@ -1351,7 +1427,10 @@ const noNativeControl = defineRule({
 		if (node.name.type !== "JSXIdentifier") return;
 		const name = node.name.name;
 		map(get$2(primitives, name), (primitive) => {
-			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), flatMap((attribute) => attribute.type === "JSXAttribute" && attribute.value?.type === "Literal" ? fromNullishOr(attribute.value.value) : none()), exists((value) => some$1(split(value, /\s+/u), matches(controlStyle))));
+			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), flatMap((attribute) => {
+				if (attribute.type !== "JSXAttribute" || attribute.value?.type !== "Literal") return none();
+				return fromNullishOr(attribute.value.value);
+			}), exists((value) => some$1(split(value, /\s+/u), matches(controlStyle))));
 			if (name !== "select" && !styled) return;
 			context.report({
 				message: `Use the ${primitive} UI primitive instead of a styled native control.`,
@@ -1450,7 +1529,8 @@ function freshRegExpFlags(input) {
 	if (input.node.type !== "NewExpression" && input.node.type !== "CallExpression" || input.node.callee.type !== "Identifier" || input.node.callee.name !== "RegExp") return none();
 	const flags = input.node.arguments[1];
 	if (flags === void 0) return some(some(""));
-	return some(flags.type === "Literal" && isString(flags.value) ? some(flags.value) : none());
+	if (flags.type !== "Literal" || !isString(flags.value)) return some(none());
+	return some(some(flags.value));
 }
 const noNativeMethodCall = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -1553,9 +1633,8 @@ function exits(node) {
 	], node.type) || node.type === "BlockStatement" && some$1(node.body, exits);
 }
 function earlyExit(input) {
-	const parent = input.node.parent;
-	if (parent?.type !== "BlockStatement" && parent?.type !== "Program") return false;
-	return some$1(take(parent.body, getOrElse(findFirstIndex(parent.body, (statement) => statement === input.node), () => 0)), (statement) => statement.type === "IfStatement" && exits(statement.consequent) && checks({
+	if (input.node.parent?.type !== "BlockStatement" && input.node.parent?.type !== "Program") return false;
+	return some$1(take(input.node.parent.body, getOrElse(findFirstIndex(input.node.parent.body, (statement) => statement === input.node), () => 0)), (statement) => statement.type === "IfStatement" && exits(statement.consequent) && checks({
 		...input,
 		name: "isNone",
 		operator: "||",
@@ -1563,8 +1642,7 @@ function earlyExit(input) {
 	}));
 }
 function guarded(input) {
-	const parent = input.node.parent;
-	if (parent === null || parent.type === "FunctionDeclaration") return false;
+	if (input.node.parent === null || input.node.parent.type === "FunctionDeclaration") return false;
 	function some(test) {
 		return checks({
 			...input,
@@ -1573,14 +1651,14 @@ function guarded(input) {
 			test
 		});
 	}
-	return parent.type === "IfStatement" && parent.consequent === input.node && some(parent.test) || parent.type === "ConditionalExpression" && parent.consequent === input.node && some(parent.test) || parent.type === "LogicalExpression" && parent.right === input.node && parent.operator === "&&" && some(parent.left) || parent.type === "LogicalExpression" && parent.right === input.node && parent.operator === "||" && checks({
+	return input.node.parent.type === "IfStatement" && input.node.parent.consequent === input.node && some(input.node.parent.test) || input.node.parent.type === "ConditionalExpression" && input.node.parent.consequent === input.node && some(input.node.parent.test) || input.node.parent.type === "LogicalExpression" && input.node.parent.right === input.node && input.node.parent.operator === "&&" && some(input.node.parent.left) || input.node.parent.type === "LogicalExpression" && input.node.parent.right === input.node && input.node.parent.operator === "||" && checks({
 		...input,
 		name: "isNone",
 		operator: "||",
-		test: parent.left
+		test: input.node.parent.left
 	}) || earlyExit(input) || guarded({
 		...input,
-		node: parent
+		node: input.node.parent
 	});
 }
 const noOptionValueAccess = defineRule({
@@ -1598,6 +1676,169 @@ const noOptionValueAccess = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-property-alias.ts
+const functions = [
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+];
+const deferred = [
+	"ChainExpression",
+	"ConditionalExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"IfStatement",
+	"LogicalExpression",
+	"SwitchStatement",
+	"WhileStatement"
+];
+function insideFunction(node) {
+	if (isNullish$1(node.parent) || node.parent.type === "Program") return false;
+	if (contains$1(functions, node.parent.type)) return true;
+	return insideFunction(node.parent);
+}
+function sameRoot(input) {
+	return getOrUndefined(variableFromScope({
+		name: input.name,
+		scope: input.context.sourceCode.getScope(input.declarator)
+	})) === getOrUndefined(variableFromScope({
+		name: input.name,
+		scope: input.context.sourceCode.getScope(input.read)
+	}));
+}
+function enclosed(input) {
+	if (isNullish$1(input.node.parent) || input.node.parent === input.block) return false;
+	if (contains$1(input.types, input.node.parent.type)) return true;
+	return enclosed({
+		...input,
+		node: input.node.parent
+	});
+}
+function between(input) {
+	return input.node.range[0] >= input.declaration.range[1] && input.node.range[1] <= input.read.range[0];
+}
+function objectRoot(node) {
+	if (node.type === "Identifier") return some(node.name);
+	if (node.type === "MemberExpression") return objectRoot(node.object);
+	return none();
+}
+function written(node) {
+	if (node.type === "AssignmentExpression") return objectRoot(node.left);
+	if (node.type === "UpdateExpression" || node.type === "UnaryExpression" && node.operator === "delete") return objectRoot(node.argument);
+	return none();
+}
+function inert(token) {
+	if (contains$1([
+		"Boolean",
+		"Identifier",
+		"Null",
+		"Numeric",
+		"String"
+	], token.type)) return true;
+	if (token.type === "Keyword") return contains$1(["const", "return"], token.value);
+	return token.type === "Punctuator" && contains$1([
+		"(",
+		",",
+		":",
+		"=",
+		"[",
+		"{"
+	], token.value);
+}
+function replacement(input) {
+	if (input.read.parent?.type === "Property" && input.read.parent.shorthand) return `${input.name}: ${input.text}`;
+	return input.text;
+}
+function report$1(input) {
+	const reads = pipe(input.variable.references, filter$1((reference) => reference.isRead()), map$1((reference) => reference.identifier));
+	const text = input.context.sourceCode.getText(input.init);
+	pipe(rootName(input.init), filter((root) => isArrayNonEmpty(reads) && every(reads, (read) => {
+		const used = outermost(read);
+		return read.parent.type !== "ExportSpecifier" && !enclosed({
+			block: input.declaration.parent,
+			node: read,
+			types: functions
+		}) && !(used.parent?.type === "CallExpression" && used.parent.callee === used) && !(used.parent?.type === "TaggedTemplateExpression" && used.parent.tag === used) && !some$1(input.writes, (write) => between({
+			declaration: input.declaration,
+			node: write,
+			read
+		}) && contains(written(write), root)) && sameRoot({
+			context: input.context,
+			declarator: input.node,
+			name: root,
+			read
+		});
+	})), match({
+		onNone: constVoid,
+		onSome: () => input.context.report({
+			fix: (fixer) => {
+				if (reads.length !== 1 || some$1(reads, (read) => startsWith("JSX")(read.parent.type) || enclosed({
+					block: input.declaration.parent,
+					node: read,
+					types: deferred
+				}) || some$1(input.statements, (node) => between({
+					declaration: input.declaration,
+					node,
+					read
+				})) || !every(input.context.sourceCode.getTokensBetween(input.declaration, read), inert))) return [];
+				return [fixer.remove(input.declaration), ...map$1(reads, (read) => fixer.replaceText(read, replacement({
+					name: input.name,
+					read,
+					text
+				})))];
+			},
+			message: `Read ${text} where it is used; this name adds no value.`,
+			node: input.node
+		})
+	}));
+}
+const noPropertyAlias = defineRule({
+	create: (context) => {
+		const writes = make$2();
+		const candidates = make$2();
+		function write(node) {
+			append$1(writes, node);
+		}
+		return {
+			AssignmentExpression: write,
+			"Program:exit": () => {
+				const nodes = toArray(writes);
+				for (const candidate of toArray(candidates)) pipe(variableFromScope({
+					name: candidate.name,
+					scope: context.sourceCode.getScope(candidate.node)
+				}), match({
+					onNone: constVoid,
+					onSome: (variable) => report$1({
+						...candidate,
+						context,
+						variable,
+						writes: nodes
+					})
+				}));
+			},
+			UnaryExpression: (node) => {
+				if (node.operator === "delete") write(node);
+			},
+			UpdateExpression: write,
+			VariableDeclarator: (node) => {
+				if (node.parent.type === "VariableDeclaration" && node.parent.kind === "const" && node.parent.declarations.length === 1 && (node.parent.parent.type === "BlockStatement" || node.parent.parent.type === "StaticBlock") && node.id.type === "Identifier" && node.id.typeAnnotation === null && node.init?.type === "MemberExpression" && insideFunction(node.parent)) append$1(candidates, {
+					declaration: node.parent,
+					init: node.init,
+					name: node.id.name,
+					node,
+					statements: node.parent.parent.body
+				});
+			}
+		};
+	},
+	meta: {
+		fixable: "code",
+		type: "problem"
+	}
+});
+//#endregion
 //#region src/rules/no-readonly-type-syntax.ts
 function isTopLevelStatement(node) {
 	if (node.parent.type === "Program") return true;
@@ -1615,10 +1856,13 @@ function typeDeclarations(input) {
 	if (input.name.type === "Identifier") return pipe(variableFromScope({
 		name: input.name.name,
 		scope: input.context.sourceCode.getScope(input.name)
-	}), flatMap((variable) => variable.scope.block.type === "ClassDeclaration" && some$1(variable.defs, (definition) => definition.node === variable.scope.block) ? variableFromScope({
-		name: variable.name,
-		scope: variable.scope.upper
-	}) : some(variable)), map((variable) => map$1(variable.defs, (definition) => definition.node)), getOrElse(() => empty()));
+	}), flatMap((variable) => {
+		if (variable.scope.block.type !== "ClassDeclaration" || !some$1(variable.defs, (definition) => definition.node === variable.scope.block)) return some(variable);
+		return variableFromScope({
+			name: variable.name,
+			scope: variable.scope.upper
+		});
+	}), map((variable) => map$1(variable.defs, (definition) => definition.node)), getOrElse(() => empty()));
 	if (input.name.type !== "TSQualifiedName") return [];
 	const name = input.name;
 	return pipe(typeDeclarations({
@@ -1649,15 +1893,18 @@ function shapeLiterals(input) {
 		type: alias.typeAnnotation
 	})));
 }
+function removeLeading(input) {
+	return (fixer) => pipe(input.context.sourceCode.getText(input.node), match$1(input.pattern), map((match) => fixer.replaceTextRange([input.node.range[0], input.node.range[0] + match[0].length], match[1] ?? "")), getOrUndefined);
+}
 const noReadonlyTypeSyntax = defineRule({
 	create: (context) => {
 		const cycleNames = schemaCycleNames({
 			context,
 			program: context.sourceCode.ast
 		});
-		const shapes = make$2(empty());
-		const properties = make$2(empty());
-		const methods = make$2(empty());
+		const shapes = make$3(empty());
+		const properties = make$3(empty());
+		const methods = make$3(empty());
 		function exempt(node) {
 			return insideCycleType({
 				cycleNames,
@@ -1684,10 +1931,16 @@ const noReadonlyTypeSyntax = defineRule({
 				}
 				for (const node of get$3(properties)) {
 					if (inShape(node) && !node.readonly) context.report({
+						fix: (fixer) => fixer.insertTextBefore(node, "readonly "),
 						message: "Mark this service property readonly.",
 						node
 					});
 					if (!inShape(node) && node.readonly && !exempt(node)) context.report({
+						fix: removeLeading({
+							context,
+							node,
+							pattern: /^readonly\s+/u
+						}),
 						message: "Remove the readonly property modifier.",
 						node
 					});
@@ -1699,12 +1952,22 @@ const noReadonlyTypeSyntax = defineRule({
 			},
 			TSIndexSignature: (node) => {
 				if (node.readonly) context.report({
+					fix: removeLeading({
+						context,
+						node,
+						pattern: /^readonly\s+/u
+					}),
 					message: "Remove the readonly index modifier.",
 					node
 				});
 			},
 			TSMappedType: (node) => {
 				if (node.readonly === true || node.readonly === "+") context.report({
+					fix: removeLeading({
+						context,
+						node,
+						pattern: /^(\{\s*)\+?readonly\s+/u
+					}),
 					message: "Remove the readonly mapped-type modifier.",
 					node
 				});
@@ -1717,78 +1980,24 @@ const noReadonlyTypeSyntax = defineRule({
 			},
 			TSTypeOperator: (node) => {
 				if (node.operator === "readonly" && !exempt(node)) context.report({
+					fix: (fixer) => fixer.replaceText(node, context.sourceCode.getText(node.typeAnnotation)),
 					message: "Use a mutable type shape.",
 					node
 				});
 			},
 			TSTypeReference: (node) => {
 				if (node.typeName.type === "Identifier" && node.typeName.name === "Readonly" && !exempt(node)) context.report({
+					fix: (fixer) => pipe(fromNullishOr(node.typeArguments?.params[0]), map((shape) => fixer.replaceText(node, `(${context.sourceCode.getText(shape)})`)), getOrUndefined),
 					message: "Use a mutable type shape.",
 					node
 				});
 			}
 		};
 	},
-	meta: { type: "problem" }
-});
-//#endregion
-//#region src/rules/no-redundant-return-type.ts
-function isExported(node) {
-	if (node.parent.type === "ExportNamedDeclaration" || node.parent.type === "ExportDefaultDeclaration") return true;
-	return node.parent.type === "VariableDeclarator" && node.parent.parent.type === "VariableDeclaration" && node.parent.parent.parent.type === "ExportNamedDeclaration";
-}
-function inferredIdentically(input) {
-	const text = input.context.sourceCode.getText;
-	const body = input.node.body;
-	if (body === null) return false;
-	const block = body.type === "BlockStatement";
-	const values = body.type === "BlockStatement" ? map$1(input.returns, (statement) => statement.argument) : [body];
-	const expressions = filter$1(values, isNotNull);
-	if (input.type.type === "TSVoidKeyword") return block && isArrayEmpty(expressions);
-	if (isArrayEmpty(expressions) || expressions.length !== values.length) return false;
-	if (input.type.type === "TSStringKeyword") return every(expressions, (value) => value.type === "TemplateLiteral" && isArrayNonEmpty(value.expressions));
-	if (isExported(input.node)) return false;
-	return every(expressions, (value) => value.type === "TSAsExpression" && text(value.typeAnnotation) === text(input.type) || !block && value.type === "NewExpression" && input.type.type === "TSTypeReference" && input.type.typeArguments === null && text(value.callee) === text(input.type.typeName));
-}
-const noRedundantReturnType = defineRule({
-	create: (context) => {
-		const frames = make$2(empty());
-		function enter() {
-			update(frames, append({ returns: empty() }));
-		}
-		function exit(node) {
-			const frame = last(get$3(frames));
-			update(frames, dropRight(1));
-			if (node.async || node.generator || isNullish$1(node.returnType)) return;
-			if (inferredIdentically({
-				context,
-				node,
-				returns: match$1(frame, {
-					onNone: () => empty(),
-					onSome: (top) => top.returns
-				}),
-				type: node.returnType.typeAnnotation
-			})) context.report({
-				message: "Drop this return type; inference gives the same type.",
-				node: node.returnType
-			});
-		}
-		return {
-			ArrowFunctionExpression: enter,
-			"ArrowFunctionExpression:exit": exit,
-			FunctionDeclaration: enter,
-			"FunctionDeclaration:exit": exit,
-			FunctionExpression: enter,
-			"FunctionExpression:exit": exit,
-			ReturnStatement: (node) => {
-				update(frames, (stack) => pipe(last(stack), match$1({
-					onNone: () => stack,
-					onSome: (top) => append(dropRight(stack, 1), { returns: append(top.returns, node) })
-				})));
-			}
-		};
-	},
-	meta: { type: "problem" }
+	meta: {
+		fixable: "code",
+		type: "problem"
+	}
 });
 //#endregion
 //#region src/rules/no-redundant-state-type.ts
@@ -1852,18 +2061,17 @@ const noRedundantUseRefNullType = defineRule({
 //#region src/rules/no-redundant-variable-annotation.ts
 const noRedundantVariableAnnotation = defineRule({
 	create: (context) => ({ VariableDeclarator: (node) => {
-		const annotation = node.id.typeAnnotation;
-		if (node.init === null || isNullish$1(annotation)) return;
+		if (node.init === null || isNullish$1(node.id.typeAnnotation)) return;
 		if (node.init.type === "ArrayExpression" && isArrayEmpty(node.init.elements)) {
 			context.report({
 				message: "Write Array.empty<T>() instead of annotating an empty array.",
-				node: annotation
+				node: node.id.typeAnnotation
 			});
 			return;
 		}
-		if (node.init.type === "TSAsExpression" && context.sourceCode.getText(node.init.typeAnnotation) === context.sourceCode.getText(annotation.typeAnnotation)) context.report({
+		if (node.init.type === "TSAsExpression" && context.sourceCode.getText(node.init.typeAnnotation) === context.sourceCode.getText(node.id.typeAnnotation.typeAnnotation)) context.report({
 			message: "Drop this annotation; inference gives the same type.",
-			node: annotation
+			node: node.id.typeAnnotation
 		});
 	} }),
 	meta: { type: "problem" }
@@ -1903,11 +2111,12 @@ const shipped = [
 	}
 ];
 function schemaMember(input) {
-	return input.node.type === "MemberExpression" && importedMember({
+	if (input.node.type !== "MemberExpression" || !importedMember({
 		context: input.context,
 		importedName: "Schema",
 		node: input.node
-	}) ? memberName(input.node) : none();
+	})) return none();
+	return memberName(input.node);
 }
 function shippedSchema(input) {
 	if (input.filter.type !== "CallExpression") return none();
@@ -1920,16 +2129,19 @@ function shippedSchema(input) {
 		node: input.filter.callee
 	});
 	const [value, ...rest] = input.filter.arguments;
-	return pipe(shipped, findFirst((entry) => contains(base, entry.base) && contains(check, entry.check) && isArrayEmpty(rest) && match$1(fromUndefinedOr(entry.only), {
+	return pipe(shipped, findFirst((entry) => contains(base, entry.base) && contains(check, entry.check) && isArrayEmpty(rest) && match(fromUndefinedOr(entry.only), {
 		onNone: () => value === void 0,
 		onSome: (only) => value?.type === "Literal" && value.value === only
 	})), map((entry) => entry.schema));
 }
 function pipedBase(node) {
-	const parent = node.parent;
-	if (parent.type !== "CallExpression") return none();
-	if (parent.callee.type === "Identifier" && parent.callee.name === "pipe" && parent.arguments.length === 2) return parent.arguments[1] === node ? fromNullishOr(parent.arguments[0]) : none();
-	return parent.callee.type === "MemberExpression" && contains(memberName(parent.callee), "pipe") && parent.arguments.length === 1 ? some(parent.callee.object) : none();
+	if (node.parent.type !== "CallExpression") return none();
+	if (node.parent.callee.type === "Identifier" && node.parent.callee.name === "pipe" && node.parent.arguments.length === 2) {
+		if (node.parent.arguments[1] !== node) return none();
+		return fromNullishOr(node.parent.arguments[0]);
+	}
+	if (node.parent.callee.type !== "MemberExpression" || !contains(memberName(node.parent.callee), "pipe") || node.parent.arguments.length !== 1) return none();
+	return some(node.parent.callee.object);
 }
 function reinventedSchema(input) {
 	if (input.node.callee.type !== "MemberExpression" || !contains(memberName(input.node.callee), "check")) return none();
@@ -1938,11 +2150,14 @@ function reinventedSchema(input) {
 	if (isSome(schemaMember({
 		context: input.context,
 		node: callee
-	}))) return pipe(pipedBase(input.node), flatMap((base) => input.node.arguments.length === 1 && filter !== void 0 ? shippedSchema({
-		base,
-		context: input.context,
-		filter
-	}) : none()));
+	}))) {
+		if (input.node.arguments.length !== 1 || filter === void 0) return none();
+		return pipe(pipedBase(input.node), flatMap((base) => shippedSchema({
+			base,
+			context: input.context,
+			filter
+		})));
+	}
 	return findFirst(input.node.arguments, (argument) => shippedSchema({
 		base: callee.object,
 		context: input.context,
@@ -1965,9 +2180,13 @@ const noReinventedSchema = defineRule({
 });
 //#endregion
 //#region src/rules/no-renamed-import.ts
+function exportedName(node) {
+	if (node.type === "Literal") return node.value;
+	return node.name;
+}
 const noRenamedImport = defineRule({
 	create: (context) => ({ ImportSpecifier: (node) => {
-		const imported = node.imported.type === "Literal" ? node.imported.value : node.imported.name;
+		const imported = exportedName(node.imported);
 		if (imported === node.local.name || imported === "it" && node.local.name === "test") return;
 		context.report({
 			message: `Import ${imported} under its own name.`,
@@ -1977,6 +2196,76 @@ const noRenamedImport = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-return-type.ts
+function boundName(node) {
+	if (node.parent.type === "CallExpression" && node.parent.parent.type === "VariableDeclarator" && node.parent.parent.id.type === "Identifier") return some(node.parent.parent.id.name);
+	return bindingName(node);
+}
+function functionScopes(input) {
+	const scope = input.context.sourceCode.getScope(input.node);
+	return filter$1([scope, ...scope.childScopes], (child) => child.block.range[0] >= input.node.range[0] && child.block.range[1] <= input.node.range[1]);
+}
+function propertyRead(reference) {
+	return reference.identifier.parent.type === "MemberExpression" && reference.identifier.parent.object === reference.identifier && !(reference.identifier.parent.parent.type === "CallExpression" && reference.identifier.parent.parent.callee === reference.identifier.parent);
+}
+function reaches(input) {
+	const reached = pipe(input.nodes, flatMap$1((node) => functionScopes({
+		context: input.context,
+		node
+	})), flatMap$1((scope) => scope.through), filter$1((reference) => !propertyRead(reference)), flatMap$1((reference) => toArray$1(fromNullishOr(reference.resolved))), dedupeWith(strictEqual()));
+	const known = containsWith(strictEqual());
+	if (some$1(reached, (variable) => known(input.targets, variable))) return true;
+	const next = filter$1(reached, (variable) => !known(input.visited, variable));
+	if (isArrayEmpty(next)) return false;
+	return reaches({
+		...input,
+		nodes: pipe(next, flatMap$1((variable) => variable.defs), filter$1((definition) => definition.type === "FunctionName" || definition.type === "Variable"), map$1((definition) => definition.node)),
+		visited: appendAll(input.visited, next)
+	});
+}
+function selfMethodCall(input) {
+	if (input.node.parent.type !== "MethodDefinition" || input.node.parent.key.type !== "Identifier") return false;
+	return matches(new RegExp(`\\bthis\\.${replaceAll("$", "\\$")(input.node.parent.key.name)}\\(`, "u"))(input.context.sourceCode.getText(input.node));
+}
+function recursive(input) {
+	const scope = input.context.sourceCode.getScope(input.node);
+	const targets = pipe([boundName(input.node), fromNullishOr(input.node.id?.name)], getSomes, flatMap$1((name) => toArray$1(variableFromScope({
+		name,
+		scope
+	}))), dedupeWith(strictEqual()));
+	return selfMethodCall(input) || isArrayNonEmpty(targets) && reaches({
+		context: input.context,
+		nodes: [input.node],
+		targets,
+		visited: []
+	});
+}
+const noReturnType = defineRule({
+	create: (context) => {
+		function check(node) {
+			if (isNullish$1(node.returnType) || node.body === null || node.returnType.typeAnnotation.type === "TSTypePredicate" || node.parent.type === "CallExpression" && importedMember({
+				context,
+				importedName: "Schema",
+				node: node.parent.callee,
+				propertyName: "suspend"
+			}) || recursive({
+				context,
+				node
+			})) return;
+			context.report({
+				message: "Drop the return type and let inference supply it; check a returned object with satisfies.",
+				node: node.returnType
+			});
+		}
+		return {
+			ArrowFunctionExpression: check,
+			FunctionDeclaration: check,
+			FunctionExpression: check
+		};
+	},
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-single-use-value.ts
 const repeating = [
 	"ArrowFunctionExpression",
@@ -1989,16 +2278,14 @@ const repeating = [
 	"WhileStatement"
 ];
 function runsOnce(input) {
-	const node = input.node;
-	const child = input.child;
-	if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && node.right === child || node.type === "IfStatement" && node.test === child || node.type === "ConditionalExpression" && node.test === child || node.type === "LogicalExpression" && node.left === child) return climb({
+	if ((input.node.type === "ForOfStatement" || input.node.type === "ForInStatement") && input.node.right === input.child || input.node.type === "IfStatement" && input.node.test === input.child || input.node.type === "ConditionalExpression" && input.node.test === input.child || input.node.type === "LogicalExpression" && input.node.left === input.child) return climb({
 		...input,
-		node
+		node: input.node
 	});
-	if (contains$1(repeating, node.type) || node.type === "IfStatement" || node.type === "ConditionalExpression" || node.type === "LogicalExpression" || node.type === "ChainExpression" || node.type === "SwitchStatement" || node.type === "TryStatement") return false;
+	if (contains$1(repeating, input.node.type) || input.node.type === "IfStatement" || input.node.type === "ConditionalExpression" || input.node.type === "LogicalExpression" || input.node.type === "ChainExpression" || input.node.type === "SwitchStatement" || input.node.type === "TryStatement") return false;
 	return climb({
 		...input,
-		node
+		node: input.node
 	});
 }
 function climb(input) {
@@ -2019,9 +2306,23 @@ function insideConditional(input) {
 	});
 }
 function candidate(node) {
-	const declaration = node.parent;
-	const init = node.init;
-	return declaration.type === "VariableDeclaration" && declaration.kind === "const" && declaration.declarations.length === 1 && declaration.parent.type === "BlockStatement" && node.id.type === "Identifier" && node.id.typeAnnotation === null && init !== null && !contains$1(["ArrowFunctionExpression", "FunctionExpression"], init.type) && !(init.type === "Literal" && !hasProperty(init, "regex")) && !(init.type === "TemplateLiteral" && isArrayEmpty(init.expressions));
+	return node.parent.type === "VariableDeclaration" && node.parent.kind === "const" && node.parent.declarations.length === 1 && node.parent.parent.type === "BlockStatement" && node.id.type === "Identifier" && node.id.typeAnnotation === null && node.init !== null && !contains$1(["ArrowFunctionExpression", "FunctionExpression"], node.init.type) && !(node.init.type === "MemberExpression" && isSome(rootName(node.init))) && !(node.init.type === "Literal" && !hasProperty(node.init, "regex")) && !(node.init.type === "TemplateLiteral" && isArrayEmpty(node.init.expressions));
+}
+function unwrapped(node) {
+	return pipe(typeWrapped(node), match({
+		onNone: () => node,
+		onSome: unwrapped
+	}));
+}
+function fixable(input) {
+	const read = outermost(input.read);
+	return !(unwrapped(input.init).type === "ClassExpression" || read.parent?.type === "CallExpression" && read.parent.callee === read || read.parent?.type === "TaggedTemplateExpression" && read.parent.tag === read);
+}
+function inlined(input) {
+	const value = `(${input.context.sourceCode.getText(input.init)})`;
+	if (input.read.parent?.type === "Property" && input.read.parent.shorthand) return `${input.name}: ${value}`;
+	if (input.read.range[0] === input.next.range[0]) return `;${value}`;
+	return value;
 }
 function report(input) {
 	const declaration = input.node.parent;
@@ -2038,17 +2339,33 @@ function report(input) {
 	}) && !(init.type === "ConditionalExpression" && insideConditional({
 		node: read,
 		statement: next
-	})) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])))), map(() => {
-		input.context.report({
+	})) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])), map((read) => ({
+		next,
+		read
+	})))), match({
+		onNone: constVoid,
+		onSome: (found) => input.context.report({
+			fix: (fixer) => {
+				if (!fixable({
+					init,
+					read: found.read
+				})) return [];
+				return [fixer.remove(declaration), fixer.replaceText(found.read, inlined({
+					context: input.context,
+					init,
+					name,
+					...found
+				}))];
+			},
 			message: "Inline this value into the next statement, its only use.",
 			node: input.node
-		});
+		})
 	}));
 }
 const noSingleUseValue = defineRule({
 	create: (context) => {
-		const effects = make$2(empty());
-		const candidates = make$2(empty());
+		const effects = make$3(empty());
+		const candidates = make$3(empty());
 		function effect(node) {
 			update(effects, append(node));
 		}
@@ -2072,7 +2389,10 @@ const noSingleUseValue = defineRule({
 			YieldExpression: effect
 		};
 	},
-	meta: { type: "problem" }
+	meta: {
+		fixable: "code",
+		type: "problem"
+	}
 });
 //#endregion
 //#region src/rules/no-stored-schema-operation.ts
@@ -2109,21 +2429,60 @@ function parameterName(parameter) {
 	if (parameter.type === "RestElement" && parameter.argument.type === "Identifier") return some(parameter.argument.name);
 	return none();
 }
-function forwardedCall(input) {
-	return input.node.arguments.length === input.names.length && every(input.node.arguments, (argument, index) => {
+function forwarded(input) {
+	return input.args.length === input.names.length && every(input.args, (argument, index) => {
 		const name = input.names[index];
 		if (argument.type === "SpreadElement") return argument.argument.type === "Identifier" && argument.argument.name === name;
 		return argument.type === "Identifier" && argument.name === name;
 	});
 }
-function exactForwardingFunction(node) {
-	const names = pipe(node.params, map$1(parameterName), getSomes);
-	const returned = returnedExpression(node);
-	if (isArrayEmpty(names) || names.length !== node.params.length || isNullish$1(returned)) return false;
+function callGroups(node) {
+	if (node.type !== "CallExpression") return {
+		callee: node,
+		groups: []
+	};
+	const inner = callGroups(node.callee);
+	return {
+		callee: inner.callee,
+		groups: append(inner.groups, node.arguments)
+	};
+}
+function detachable(input) {
+	if (input.node.type === "Identifier") return true;
+	if (input.node.type !== "MemberExpression" || input.node.object.type !== "Identifier") return false;
+	return pipe(rootName(input.node), flatMap((name) => variableFromScope({
+		name,
+		scope: input.context.sourceCode.getScope(input.node)
+	})), exists((variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && (definition.parent.source.value === "effect" || definition.node.type === "ImportNamespaceSpecifier" && matches(/^effect\//u)(definition.parent.source.value)))));
+}
+function forwardedChain(input) {
+	const chain = callGroups(input.returned);
+	function fixed(node) {
+		return node.type === "Literal" || exists(rootName(node), (root) => !contains$1(input.names, root));
+	}
+	return matchRight(chain.groups, {
+		onEmpty: constFalse,
+		onNonEmpty: (earlier, last) => fixed(chain.callee) && every(flatten(earlier), fixed) && forwarded({
+			args: last,
+			names: input.names
+		}) && (isArrayNonEmpty(earlier) || detachable({
+			context: input.context,
+			node: chain.callee
+		}))
+	});
+}
+function exactForwardingFunction(input) {
+	const names = pipe(input.node.params, map$1(parameterName), getSomes);
+	const returned = returnedExpression(input.node);
+	if (input.node.async || input.node.generator || isArrayEmpty(names) || names.length !== input.node.params.length || isNullish$1(returned)) return false;
 	if (returned.type === "Identifier") return names.length === 1 && returned.name === names[0];
-	return (returned.type === "CallExpression" || returned.type === "NewExpression") && returned.callee.type === "Identifier" && forwardedCall({
+	return returned.type === "NewExpression" && returned.callee.type === "Identifier" && forwarded({
+		args: returned.arguments,
+		names
+	}) || forwardedChain({
+		context: input.context,
 		names,
-		node: returned
+		returned
 	});
 }
 function isIdentity(node) {
@@ -2131,8 +2490,11 @@ function isIdentity(node) {
 	const returned = returnedExpression(node);
 	return node.params.length === 1 && parameter?.type === "Identifier" && returned?.type === "Identifier" && returned.name === parameter.name;
 }
-function indirectionMessage(node) {
-	return isIdentity(node) ? "Pass identity from effect instead of this function." : "Inline this function at its only use site.";
+function indirectionMessage(input) {
+	if (isIdentity(input.node)) return "Pass identity from effect instead of this function.";
+	const returned = returnedExpression(input.node);
+	if (exactForwardingFunction(input) && returned?.type === "CallExpression") return `Use ${input.context.sourceCode.getText(returned.callee)} directly; this function only passes its parameters on.`;
+	return "Inline this function at its only use site.";
 }
 function isExport(node) {
 	return node?.type === "ExportNamedDeclaration" || node?.type === "ExportDefaultDeclaration";
@@ -2211,38 +2573,56 @@ function singleUseLayerPart(input) {
 const noTrivialIndirection = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property") && (exactForwardingFunction(node) || singleUseThunk({
+			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property") && (exactForwardingFunction({
+				context,
+				node
+			}) || singleUseThunk({
 				context,
 				node
 			}) || singleCallerWrapper({
 				context,
 				node
 			}))) context.report({
-				message: indirectionMessage(node),
+				message: indirectionMessage({
+					context,
+					node
+				}),
 				node
 			});
 		},
 		FunctionDeclaration: (node) => {
-			if (exactForwardingFunction(node) || singleUseThunk({
+			if (exactForwardingFunction({
+				context,
+				node
+			}) || singleUseThunk({
 				context,
 				node
 			}) || singleCallerWrapper({
 				context,
 				node
 			})) context.report({
-				message: indirectionMessage(node),
+				message: indirectionMessage({
+					context,
+					node
+				}),
 				node
 			});
 		},
 		FunctionExpression: (node) => {
-			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property" || node.parent.type === "MethodDefinition" && node.parent.override !== true) && (exactForwardingFunction(node) || singleUseThunk({
+			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property" || node.parent.type === "MethodDefinition" && node.parent.override !== true) && (exactForwardingFunction({
+				context,
+				node
+			}) || singleUseThunk({
 				context,
 				node
 			}) || singleCallerWrapper({
 				context,
 				node
 			}))) context.report({
-				message: indirectionMessage(node),
+				message: indirectionMessage({
+					context,
+					node
+				}),
 				node
 			});
 		},
@@ -2341,13 +2721,12 @@ function unknownJsonSchema(input) {
 		node: input.node.arguments[0],
 		propertyName: "Unknown"
 	})) return false;
-	const parent = input.node.parent;
-	if (parent.type !== "CallExpression" || parent.arguments[0] !== input.node || parent.callee.type !== "MemberExpression") return false;
+	if (input.node.parent.type !== "CallExpression" || input.node.parent.arguments[0] !== input.node || input.node.parent.callee.type !== "MemberExpression") return false;
 	return importedMember({
 		context: input.context,
 		importedName: "Schema",
-		node: parent.callee
-	}) && pipe(memberName(parent.callee), exists(startsWith("decode")));
+		node: input.node.parent.callee
+	}) && pipe(memberName(input.node.parent.callee), exists(startsWith("decode")));
 }
 const noUnvalidatedJsonDecode = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -2436,7 +2815,6 @@ function reportSchemaVariable(input) {
 		node: input.variable.init
 	})) return;
 	const name = input.variable.id.name;
-	const annotation = input.variable.id.typeAnnotation;
 	const typeStatement = pipe(input.program.body, findFirstIndex((statement) => statement === input.statement), filter((index) => index > 0), flatMap((index) => get$1(input.program.body, index - 1)));
 	if (contains$1(input.cycleNames, name)) {
 		if (!pipe(namedTypeAlias({
@@ -2449,7 +2827,7 @@ function reportSchemaVariable(input) {
 			message: `Write \`type ${name} = ...\` by hand immediately before this recursive Schema; typeof ${name}.Type is circular.`,
 			node: input.variable
 		});
-		if (isNotNullish(annotation)) input.context.report({
+		if (isNotNullish(input.variable.id.typeAnnotation)) input.context.report({
 			message: "Annotate the Schema.suspend thunk, not the recursive Schema.",
 			node: input.variable.id
 		});
@@ -2472,9 +2850,9 @@ function reportSchemaVariable(input) {
 		message: "Infer this schema instead of restating Schema.Schema.",
 		node: input.variable.init
 	});
-	if (isNotNullish(annotation) && schemaSchemaType({
+	if (isNotNullish(input.variable.id.typeAnnotation) && schemaSchemaType({
 		context: input.context,
-		node: annotation.typeAnnotation
+		node: input.variable.id.typeAnnotation.typeAnnotation
 	})) input.context.report({
 		message: "Infer this schema instead of annotating Schema.Schema.",
 		node: input.variable.id
@@ -2512,7 +2890,40 @@ const reactLegacyApis = [
 ];
 const reactLegacyMessage = "Use React 19 function components with refs as props; React Compiler owns memoization.";
 const mapMessage = "Use HashMap, or MutableHashMap for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
-const runMessage = "Run the entry point with NodeRuntime.runMain, or bridge a Promise an external contract demands once, where it is returned, with Effect.runPromiseWith(Context.empty()).";
+const reactHooks = [
+	"use",
+	"useActionState",
+	"useContext",
+	"useDebugValue",
+	"useDeferredValue",
+	"useEffect",
+	"useEffectEvent",
+	"useId",
+	"useImperativeHandle",
+	"useInsertionEffect",
+	"useLayoutEffect",
+	"useOptimistic",
+	"useReducer",
+	"useRef",
+	"useState",
+	"useSyncExternalStore",
+	"useTransition"
+];
+const runMessage = "Run the entry point with NodeRuntime.runMain, and Effects in React through atoms. A Promise that an external contract demands takes Effect.runPromise once, with an inline disable that names the contract.";
+const runners = [
+	"runCallback",
+	"runCallbackWith",
+	"runFork",
+	"runForkWith",
+	"runPromise",
+	"runPromiseExit",
+	"runPromiseExitWith",
+	"runPromiseWith",
+	"runSync",
+	"runSyncExit",
+	"runSyncExitWith",
+	"runSyncWith"
+];
 const setMessage = "Use HashSet, or MutableHashSet for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
 const oxlint = defineConfig({
 	categories: {
@@ -2611,6 +3022,7 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-error-message-assertion": "error",
 		"@deslop/coding-standards/no-fake-ref-state": "error",
 		"@deslop/coding-standards/no-hand-written-guard": "error",
+		"@deslop/coding-standards/no-in-operator": "error",
 		"@deslop/coding-standards/no-let": "error",
 		"@deslop/coding-standards/no-multiline-comment": "error",
 		"@deslop/coding-standards/no-native-control": "error",
@@ -2618,13 +3030,14 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-native-method-call": "error",
 		"@deslop/coding-standards/no-nullish-ternary": "error",
 		"@deslop/coding-standards/no-option-value-access": "error",
+		"@deslop/coding-standards/no-property-alias": "error",
 		"@deslop/coding-standards/no-readonly-type-syntax": "error",
-		"@deslop/coding-standards/no-redundant-return-type": "error",
 		"@deslop/coding-standards/no-redundant-state-type": "error",
 		"@deslop/coding-standards/no-redundant-use-ref-null-type": "error",
 		"@deslop/coding-standards/no-redundant-variable-annotation": "error",
 		"@deslop/coding-standards/no-reinvented-schema": "error",
 		"@deslop/coding-standards/no-renamed-import": "error",
+		"@deslop/coding-standards/no-return-type": "error",
 		"@deslop/coding-standards/no-single-use-value": "error",
 		"@deslop/coding-standards/no-stored-schema-operation": "error",
 		"@deslop/coding-standards/no-switch-statement": "error",
@@ -2911,7 +3324,6 @@ const oxlint = defineConfig({
 		"no-misleading-character-class": "error",
 		"no-multi-assign": "error",
 		"no-negated-condition": "error",
-		"no-nested-ternary": "error",
 		"no-new": "error",
 		"no-param-reassign": ["error", { props: true }],
 		"no-plusplus": "error",
@@ -2991,31 +3403,11 @@ const oxlint = defineConfig({
 				message: "Use Predicate.hasProperty.",
 				property: "hasOwnProperty"
 			},
-			{
-				message: runMessage,
-				object: "Effect",
-				property: "runFork"
-			},
-			{
-				message: runMessage,
-				object: "Effect",
-				property: "runPromise"
-			},
-			{
+			...map$1(runners, (property) => ({
 				message: runMessage,
 				object: "Effect",
-				property: "runPromiseExit"
-			},
-			{
-				message: runMessage,
-				object: "Effect",
-				property: "runSync"
-			},
-			{
-				message: runMessage,
-				object: "Effect",
-				property: "runSyncExit"
-			},
+				property
+			})),
 			{
 				message: runMessage,
 				object: "ManagedRuntime",
@@ -3026,6 +3418,11 @@ const oxlint = defineConfig({
 				object: "Math",
 				property: "max"
 			},
+			{
+				message: "Use Option.getOrUndefined; undefined marks an absent value.",
+				object: "Option",
+				property: "getOrNull"
+			},
 			{
 				message: "Use Number.min.",
 				object: "Math",
@@ -3041,6 +3438,11 @@ const oxlint = defineConfig({
 				object: "React",
 				property
 			})),
+			...map$1(reactHooks, (property) => ({
+				message: `Import ${property} by name from react.`,
+				object: "React",
+				property
+			})),
 			{
 				message: "Use Schema.Struct.",
 				object: "Schema",
@@ -3140,6 +3542,7 @@ const oxlint = defineConfig({
 			"String"
 		] }],
 		"no-sparse-arrays": "error",
+		"no-ternary": "error",
 		"no-throw-literal": "error",
 		"no-unmodified-loop-condition": "error",
 		"no-unneeded-ternary": "error",
@@ -3316,6 +3719,7 @@ var oxlint_default = definePlugin({
 		"no-error-message-assertion": noErrorMessageAssertion,
 		"no-fake-ref-state": noFakeRefState,
 		"no-hand-written-guard": noHandWrittenGuard,
+		"no-in-operator": noInOperator,
 		"no-let": noLet,
 		"no-multiline-comment": noMultilineComment,
 		"no-native-control": noNativeControl,
@@ -3323,13 +3727,14 @@ var oxlint_default = definePlugin({
 		"no-native-method-call": noNativeMethodCall,
 		"no-nullish-ternary": noNullishTernary,
 		"no-option-value-access": noOptionValueAccess,
+		"no-property-alias": noPropertyAlias,
 		"no-readonly-type-syntax": noReadonlyTypeSyntax,
-		"no-redundant-return-type": noRedundantReturnType,
 		"no-redundant-state-type": noRedundantStateType,
 		"no-redundant-use-ref-null-type": noRedundantUseRefNullType,
 		"no-redundant-variable-annotation": noRedundantVariableAnnotation,
 		"no-reinvented-schema": noReinventedSchema,
 		"no-renamed-import": noRenamedImport,
+		"no-return-type": noReturnType,
 		"no-single-use-value": noSingleUseValue,
 		"no-stored-schema-operation": noStoredSchemaOperation,
 		"no-switch-statement": noSwitchStatement,