diff --git a/blink/internal/fixer/rules/blank_lines_before_namespace_config_test.go b/blink/internal/fixer/rules/blank_lines_before_namespace_config_test.go
new file mode 100644
index 0000000000..bc94ed45a7
--- /dev/null
+++ b/blink/internal/fixer/rules/blank_lines_before_namespace_config_test.go
@@ -0,0 +1,26 @@
+package rules
+
+import "testing"
+
+func TestBlankLinesBeforeNamespaceConfig(t *testing.T) {
+	t.Parallel()
+
+	src := "<?php\n\n\nnamespace Foo;"
+
+	// default collapses to exactly one blank line (2 line breaks).
+	if got, changed := apply(t, BlankLinesBeforeNamespace{}, src); !changed || got != "<?php\n\nnamespace Foo;" {
+		t.Fatalf("default changed=%v got=%q", changed, got)
+	}
+
+	// min=max=1 keeps a single line break.
+	f := BlankLinesBeforeNamespace{}.WithConfig(map[string]any{"min_line_breaks": float64(1), "max_line_breaks": float64(1)})
+	if got, changed := apply(t, f.(fixerRule), src); !changed || got != "<?php\nnamespace Foo;" {
+		t.Fatalf("min=max=1 changed=%v got=%q", changed, got)
+	}
+
+	// min=3 raises a single break up to three.
+	f = BlankLinesBeforeNamespace{}.WithConfig(map[string]any{"min_line_breaks": float64(3), "max_line_breaks": float64(4)})
+	if got, changed := apply(t, f.(fixerRule), "<?php\nnamespace Foo;"); !changed || got != "<?php\n\n\nnamespace Foo;" {
+		t.Fatalf("min=3 changed=%v got=%q", changed, got)
+	}
+}
diff --git a/blink/internal/fixer/rules/imports.go b/blink/internal/fixer/rules/imports.go
index 4f2330880f..c4b48c73d0 100644
--- a/blink/internal/fixer/rules/imports.go
+++ b/blink/internal/fixer/rules/imports.go
@@ -3,6 +3,7 @@ package rules
 import (
 	"strings"
 
+	"blink/internal/fixer"
 	"blink/internal/token"
 	"blink/internal/tokens"
 )
@@ -58,9 +59,13 @@ func skipWhitespace(s *tokens.Stream, i int) int {
 // PHP-CS-Fixer: https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/Import/SingleImportPerStatementFixer.php
 //
 // SingleImportPerStatement splits a grouped import into one per line:
-// "use A, B;" -> "use A;\nuse B;". Group imports ("use A\{B, C};") and closure
-// "use (...)" are left alone.
-type SingleImportPerStatement struct{}
+// "use A, B;" -> "use A;\nuse B;". With group_to_single_imports (the default) a
+// brace group "use A\{B, C};" is also expanded; set it to false to keep groups.
+// Closure "use (...)" is always left alone.
+type SingleImportPerStatement struct {
+	// keepGroups leaves brace group imports untouched (group_to_single_imports:false).
+	keepGroups bool
+}
 
 func (SingleImportPerStatement) Name() string {
 	return `PhpCsFixer\Fixer\Import\SingleImportPerStatementFixer`
@@ -70,8 +75,15 @@ func (SingleImportPerStatement) SourceURL() string {
 	return "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/Import/SingleImportPerStatementFixer.php"
 }
 
-func (SingleImportPerStatement) Fix(s *tokens.Stream) bool {
-	return splitUseStatements(s, false)
+func (f SingleImportPerStatement) WithConfig(config map[string]any) fixer.Fixer {
+	if v, ok := config["group_to_single_imports"].(bool); ok {
+		f.keepGroups = !v
+	}
+	return f
+}
+
+func (f SingleImportPerStatement) Fix(s *tokens.Stream) bool {
+	return splitUseStatements(s, false, !f.keepGroups)
 }
 
 // PHP-CS-Fixer: https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/ClassNotation/SingleTraitInsertPerStatementFixer.php
@@ -89,12 +101,13 @@ func (SingleTraitInsertPerStatement) SourceURL() string {
 }
 
 func (SingleTraitInsertPerStatement) Fix(s *tokens.Stream) bool {
-	return splitUseStatements(s, true)
+	return splitUseStatements(s, true, false)
 }
 
 // splitUseStatements splits grouped "use" statements one per line. inClass picks
 // the scope: false handles top-level imports, true handles in-class trait use.
-func splitUseStatements(s *tokens.Stream, inClass bool) bool {
+// expandGroups also expands brace group imports ("use A\{B, C};").
+func splitUseStatements(s *tokens.Stream, inClass, expandGroups bool) bool {
 	changed := false
 	i := 0
 	for i < s.Len() {
@@ -102,7 +115,7 @@ func splitUseStatements(s *tokens.Stream, inClass bool) bool {
 			i++
 			continue
 		}
-		next, c := splitUseAt(s, i, inClass)
+		next, c := splitUseAt(s, i, inClass, expandGroups)
 		i = next
 		if c {
 			changed = true
@@ -113,7 +126,7 @@ func splitUseStatements(s *tokens.Stream, inClass bool) bool {
 
 // splitUseAt splits the "use" statement at index i when its scope matches
 // inClass. It returns the index to continue from and whether it changed.
-func splitUseAt(s *tokens.Stream, i int, inClass bool) (int, bool) {
+func splitUseAt(s *tokens.Stream, i int, inClass, expandGroups bool) (int, bool) {
 	if inClassLikeBody(s, i) != inClass {
 		return i + 1, false
 	}
@@ -130,7 +143,7 @@ func splitUseAt(s *tokens.Stream, i int, inClass bool) (int, bool) {
 		return i + 1, false // closure "use (...)"
 	}
 
-	semi, group := -1, false
+	semi, group, openBrace := -1, false, -1
 	var commas []int
 	for k := j; k < s.Len(); k++ {
 		if s.At(k).Kind != token.Punct {
@@ -139,6 +152,7 @@ func splitUseAt(s *tokens.Stream, i int, inClass bool) (int, bool) {
 		switch s.At(k).Value {
 		case "{":
 			group = true
+			openBrace = k
 		case ";":
 			semi = k
 		case ",":
@@ -148,7 +162,13 @@ func splitUseAt(s *tokens.Stream, i int, inClass bool) (int, bool) {
 			break
 		}
 	}
-	if group || semi < 0 || len(commas) == 0 {
+	if group {
+		if !expandGroups {
+			return i + 1, false
+		}
+		return expandGroupImport(s, i, j, openBrace, modifier)
+	}
+	if semi < 0 || len(commas) == 0 {
 		return i + 1, false
 	}
 
@@ -171,6 +191,119 @@ func splitUseAt(s *tokens.Stream, i int, inClass bool) (int, bool) {
 	return i + len(repl), true
 }
 
+// expandGroupImport expands a brace group import "use Prefix\{A, function b, const C};"
+// into one single import per member, carrying the common prefix and any outer or
+// per-member "function"/"const" modifier. prefixStart points at the first prefix
+// token (after "use" and an outer modifier), openBrace at the "{".
+func expandGroupImport(s *tokens.Stream, useIdx, prefixStart, openBrace int, outerModifier string) (int, bool) {
+	closeBrace := -1
+	depth := 0
+	for k := openBrace; k < s.Len(); k++ {
+		if s.At(k).Kind != token.Punct {
+			continue
+		}
+		switch s.At(k).Value {
+		case "{":
+			depth++
+		case "}":
+			depth--
+			if depth == 0 {
+				closeBrace = k
+			}
+		}
+		if closeBrace >= 0 {
+			break
+		}
+	}
+	if closeBrace < 0 {
+		return useIdx + 1, false
+	}
+
+	semi := -1
+	for k := closeBrace + 1; k < s.Len(); k++ {
+		if s.At(k).Kind == token.Whitespace || s.At(k).Kind == token.Comment || s.At(k).Kind == token.DocComment {
+			continue
+		}
+		if s.At(k).Kind == token.Punct && s.At(k).Value == ";" {
+			semi = k
+		}
+		break
+	}
+	if semi < 0 {
+		return useIdx + 1, false
+	}
+
+	var prefix []token.Token
+	for k := prefixStart; k < openBrace; k++ {
+		prefix = append(prefix, s.At(k))
+	}
+	prefix = trimWhitespace(prefix)
+
+	items := splitGroupItems(s, openBrace+1, closeBrace)
+	indent := indentBefore(s, useIdx)
+
+	var repl []token.Token
+	emitted := 0
+	for _, item := range items {
+		item = trimWhitespace(item)
+		if len(item) == 0 {
+			continue // trailing comma
+		}
+		modifier := outerModifier
+		rest := item
+		if item[0].Kind == token.Keyword {
+			if lw := strings.ToLower(item[0].Value); lw == "function" || lw == "const" {
+				modifier = item[0].Value
+				rest = trimWhitespace(item[1:])
+			}
+		}
+		if emitted > 0 {
+			repl = append(repl, token.Token{Kind: token.Whitespace, Value: "\n" + indent})
+		}
+		repl = append(repl, token.Token{Kind: token.Keyword, Value: "use"}, token.Token{Kind: token.Whitespace, Value: " "})
+		if modifier != "" {
+			repl = append(repl, token.Token{Kind: token.Keyword, Value: modifier}, token.Token{Kind: token.Whitespace, Value: " "})
+		}
+		repl = append(repl, prefix...)
+		repl = append(repl, rest...)
+		repl = append(repl, token.Token{Kind: token.Punct, Value: ";"})
+		emitted++
+	}
+	if emitted == 0 {
+		return useIdx + 1, false
+	}
+
+	s.ReplaceRange(useIdx, semi, repl)
+	return useIdx + len(repl), true
+}
+
+// splitGroupItems slices the tokens in (open, close) at top-level commas.
+func splitGroupItems(s *tokens.Stream, from, close int) [][]token.Token {
+	var items [][]token.Token
+	var cur []token.Token
+	depth := 0
+	for k := from; k < close; k++ {
+		t := s.At(k)
+		if t.Kind == token.Punct {
+			switch t.Value {
+			case "{", "[", "(":
+				depth++
+			case "}", "]", ")":
+				depth--
+			case ",":
+				if depth == 0 {
+					items = append(items, cur)
+					cur = nil
+					continue
+				}
+			}
+		}
+		cur = append(cur, t)
+	}
+	items = append(items, cur)
+	return items
+}
+
 // PHP-CS-Fixer: https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/Import/SingleLineAfterImportsFixer.php
 //
 // SingleLineAfterImports ensures one blank line after the last import in a block
diff --git a/blink/internal/fixer/rules/modifier_keywords.go b/blink/internal/fixer/rules/modifier_keywords.go
index 01dfb266a6..5a367adc6f 100644
--- a/blink/internal/fixer/rules/modifier_keywords.go
+++ b/blink/internal/fixer/rules/modifier_keywords.go
@@ -4,6 +4,7 @@ import (
 	"slices"
 	"strings"
 
+	"blink/internal/fixer"
 	"blink/internal/token"
 	"blink/internal/tokens"
 )
@@ -18,7 +19,31 @@ import (
 // This handles class-body const/property/method members. Constructor promoted
 // properties and PHP 8.4 asymmetric set-visibility (public(set)) are left
 // untouched; members whose modifier run contains a comment are skipped.
-type ModifierKeywords struct{}
+//
+// The `elements` option limits which member kinds (const, property, method) are
+// fixed; nil fixes all three, matching the PHP-CS-Fixer default.
+type ModifierKeywords struct {
+	// elements is the set of enabled member kinds; nil means all three.
+	elements map[string]bool
+}
+
+func (f ModifierKeywords) WithConfig(config map[string]any) fixer.Fixer {
+	if list, ok := arrayNotationStringList(config["elements"]); ok {
+		set := make(map[string]bool, len(list))
+		for _, item := range list {
+			set[item] = true
+		}
+		f.elements = set
+	}
+	return f
+}
+
+func (f ModifierKeywords) enabled(kind string) bool {
+	if f.elements == nil {
+		return true
+	}
+	return f.elements[kind]
+}
 
 func (ModifierKeywords) Name() string {
 	return `PhpCsFixer\Fixer\ClassNotation\ModifierKeywordsFixer`
@@ -28,7 +53,7 @@ func (ModifierKeywords) SourceURL() string {
 	return "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/ClassNotation/ModifierKeywordsFixer.php"
 }
 
-func (ModifierKeywords) Fix(s *tokens.Stream) bool {
+func (f ModifierKeywords) Fix(s *tokens.Stream) bool {
 	changed := false
 	for i := 0; i < s.Len(); i++ {
 		if s.At(i).Kind != token.Punct || s.At(i).Value != "{" {
@@ -38,7 +63,7 @@ func (ModifierKeywords) Fix(s *tokens.Stream) bool {
 			continue
 		}
 		for _, m := range slices.Backward(classMemberStarts(s, i)) {
-			if orderModifierKeywords(s, m) {
+			if f.orderModifierKeywords(s, m) {
 				changed = true
 			}
 		}
@@ -46,7 +71,21 @@ func (ModifierKeywords) Fix(s *tokens.Stream) bool {
 	return changed
 }
 
-func orderModifierKeywords(s *tokens.Stream, m int) bool {
+// modifierMemberKind classifies the member whose modifier run ends at index
+// after: "const", "method" (a function) or "property".
+func modifierMemberKind(s *tokens.Stream, after int) string {
+	if after < s.Len() && s.At(after).Kind == token.Keyword {
+		switch strings.ToLower(s.At(after).Value) {
+		case "const":
+			return "const"
+		case "function":
+			return "method"
+		}
+	}
+	return "property"
+}
+
+func (f ModifierKeywords) orderModifierKeywords(s *tokens.Stream, m int) bool {
 	var absFinal []string
 	visibility := ""
 	static := ""
@@ -97,6 +136,9 @@ func orderModifierKeywords(s *tokens.Stream, m int) bool {
 	if after < s.Len() && (s.At(after).Kind == token.Comment || s.At(after).Kind == token.DocComment) {
 		return false
 	}
+	if !f.enabled(modifierMemberKind(s, after)) {
+		return false
+	}
 	if visibility == "" {
 		visibility = "public"
 	}
diff --git a/blink/internal/fixer/rules/modifier_keywords_config_test.go b/blink/internal/fixer/rules/modifier_keywords_config_test.go
new file mode 100644
index 0000000000..2b286fc4f4
--- /dev/null
+++ b/blink/internal/fixer/rules/modifier_keywords_config_test.go
@@ -0,0 +1,29 @@
+package rules
+
+import "testing"
+
+func TestModifierKeywordsConfig(t *testing.T) {
+	t.Parallel()
+
+	src := "<?php class C { const A = 1; static $b; static function c() {} }"
+
+	// default adds visibility to const, property and method.
+	wantAll := "<?php class C { public const A = 1; public static $b; public static function c() {} }"
+	if got, changed := apply(t, ModifierKeywords{}, src); !changed || got != wantAll {
+		t.Fatalf("default changed=%v got=%q", changed, got)
+	}
+
+	// elements:[method] fixes only the method, leaving const and property.
+	f := ModifierKeywords{}.WithConfig(map[string]any{"elements": []any{"method"}})
+	wantMethod := "<?php class C { const A = 1; static $b; public static function c() {} }"
+	if got, changed := apply(t, f.(fixerRule), src); !changed || got != wantMethod {
+		t.Fatalf("elements=[method] changed=%v got=%q", changed, got)
+	}
+
+	// elements:[const] fixes only the const.
+	f = ModifierKeywords{}.WithConfig(map[string]any{"elements": []any{"const"}})
+	wantConst := "<?php class C { public const A = 1; static $b; static function c() {} }"
+	if got, changed := apply(t, f.(fixerRule), src); !changed || got != wantConst {
+		t.Fatalf("elements=[const] changed=%v got=%q", changed, got)
+	}
+}
diff --git a/blink/internal/fixer/rules/nullable_type_declaration.go b/blink/internal/fixer/rules/nullable_type_declaration.go
index f61f39f411..31821e6733 100644
--- a/blink/internal/fixer/rules/nullable_type_declaration.go
+++ b/blink/internal/fixer/rules/nullable_type_declaration.go
@@ -3,6 +3,7 @@ package rules
 import (
 	"strings"
 
+	"blink/internal/fixer"
 	"blink/internal/token"
 	"blink/internal/tokens"
 )
@@ -14,7 +15,11 @@ import (
 // fires only for a two-member union whose sole other member is a single type
 // name, in a confirmed type position (parameter, return or typed property).
 // Unions of three or more members, intersections and DNF types are left alone.
-type NullableTypeDeclaration struct{}
+// With `syntax: union` the fixer goes the other way: "?int" becomes "int|null".
+type NullableTypeDeclaration struct {
+	// syntax is "question_mark" (the default when empty) or "union".
+	syntax string
+}
 
 func (NullableTypeDeclaration) Name() string {
 	return `PhpCsFixer\Fixer\LanguageConstruct\NullableTypeDeclarationFixer`
@@ -24,7 +29,56 @@ func (NullableTypeDeclaration) SourceURL() string {
 	return "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/LanguageConstruct/NullableTypeDeclarationFixer.php"
 }
 
-func (NullableTypeDeclaration) Fix(s *tokens.Stream) bool {
+func (f NullableTypeDeclaration) WithConfig(config map[string]any) fixer.Fixer {
+	if v, ok := config["syntax"].(string); ok {
+		f.syntax = v
+	}
+	return f
+}
+
+func (f NullableTypeDeclaration) Fix(s *tokens.Stream) bool {
+	if f.syntax == "union" {
+		return f.fixUnion(s)
+	}
+	return f.fixQuestionMark(s)
+}
+
+// fixUnion rewrites a "?T" nullable marker to the explicit "T|null" union.
+func (f NullableTypeDeclaration) fixUnion(s *tokens.Stream) bool {
+	changed := false
+	for i := 0; i < s.Len(); i++ {
+		if !isPunctVal(s, i, "?") || !isNullableType(s, i) {
+			continue
+		}
+		j := i + 1
+		for j < s.Len() && s.At(j).Kind == token.Whitespace {
+			j++
+		}
+		start := j
+		for j < s.Len() {
+			t := s.At(j)
+			if t.Kind == token.Ident || t.Kind == token.Keyword || (t.Kind == token.Punct && t.Value == `\`) {
+				j++
+				continue
+			}
+			break
+		}
+		if j == start {
+			continue // no type name after "?"
+		}
+		repl := make([]token.Token, 0, j-start+2)
+		for k := start; k < j; k++ {
+			repl = append(repl, s.At(k))
+		}
+		repl = append(repl, token.Token{Kind: token.Punct, Value: "|"}, token.Token{Kind: token.Ident, Value: "null"})
+		s.ReplaceRange(i, j-1, repl)
+		changed = true
+		i += len(repl) - 1
+	}
+	return changed
+}
+
+func (f NullableTypeDeclaration) fixQuestionMark(s *tokens.Stream) bool {
 	changed := false
 	for i := 0; i < s.Len(); i++ {
 		t := s.At(i)
diff --git a/blink/internal/fixer/rules/nullable_type_declaration_config_test.go b/blink/internal/fixer/rules/nullable_type_declaration_config_test.go
new file mode 100644
index 0000000000..0a13d01850
--- /dev/null
+++ b/blink/internal/fixer/rules/nullable_type_declaration_config_test.go
@@ -0,0 +1,27 @@
+package rules
+
+import "testing"
+
+func TestNullableTypeDeclarationConfig(t *testing.T) {
+	t.Parallel()
+
+	src := "<?php function f(?int $x): ?string {}"
+
+	// default (question_mark) leaves the "?" syntax as is.
+	if _, changed := apply(t, NullableTypeDeclaration{}, src); changed {
+		t.Fatal("question_mark default must leave ?int / ?string untouched")
+	}
+
+	// union rewrites "?T" to "T|null".
+	f := NullableTypeDeclaration{}.WithConfig(map[string]any{"syntax": "union"})
+	got, changed := apply(t, f.(fixerRule), src)
+	if want := "<?php function f(int|null $x): string|null {}"; !changed || got != want {
+		t.Fatalf("union changed=%v got=%q want=%q", changed, got, want)
+	}
+
+	// union still collapses nothing when the type is already a union.
+	already := "<?php function f(int|null $x) {}"
+	if _, changed := apply(t, f.(fixerRule), already); changed {
+		t.Fatal("union must leave an existing union alone")
+	}
+}
diff --git a/blink/internal/fixer/rules/operator_linebreak.go b/blink/internal/fixer/rules/operator_linebreak.go
index 71721ac00e..03192619cf 100644
--- a/blink/internal/fixer/rules/operator_linebreak.go
+++ b/blink/internal/fixer/rules/operator_linebreak.go
@@ -3,6 +3,7 @@ package rules
 import (
 	"strings"
 
+	"blink/internal/fixer"
 	"blink/internal/token"
 	"blink/internal/tokens"
 )
@@ -18,7 +19,21 @@ import (
 // intersection type separator is left alone; and a "&" that is a return-ref or a
 // reference is left alone. Object operators "->"/"?->" and "::" are moved too,
 // matching php-cs-fixer's getObjectOperatorKinds() + T_PAAMAYIM_NEKUDOTAYIM.
-type OperatorLinebreak struct{}
+//
+// The `position` option places the operator at the beginning (default) or end of
+// the line; `only_booleans` limits the set to the boolean operators.
+type OperatorLinebreak struct {
+	// onlyBooleans limits the operator set to &&, ||, and, or, xor.
+	onlyBooleans bool
+	// position is "beginning" (the default when empty) or "end".
+	position string
+}
+
+// operatorLinebreakBooleanPunct are the boolean operator tokens kept when
+// only_booleans is set.
+var operatorLinebreakBooleanPunct = map[string]bool{
+	"||": true, "&&": true,
+}
 
 // operatorLinebreakPunct are the always-unambiguous operator tokens.
 var operatorLinebreakPunct = map[string]bool{
@@ -40,7 +55,17 @@ func (OperatorLinebreak) SourceURL() string {
 	return "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/Operator/OperatorLinebreakFixer.php"
 }
 
-func isOperatorLinebreakToken(t token.Token) bool {
+func (f OperatorLinebreak) WithConfig(config map[string]any) fixer.Fixer {
+	if v, ok := config["only_booleans"].(bool); ok {
+		f.onlyBooleans = v
+	}
+	if v, ok := config["position"].(string); ok {
+		f.position = v
+	}
+	return f
+}
+
+func (f OperatorLinebreak) isOperatorToken(t token.Token) bool {
 	switch t.Kind {
 	case token.Keyword:
 		switch strings.ToLower(t.Value) {
@@ -48,6 +73,9 @@ func isOperatorLinebreakToken(t token.Token) bool {
 			return true
 		}
 	case token.Punct:
+		if f.onlyBooleans {
+			return operatorLinebreakBooleanPunct[t.Value]
+		}
 		return operatorLinebreakPunct[t.Value]
 	}
 	return false
@@ -75,11 +103,11 @@ func operatorLinebreakExcluded(s *tokens.Stream, i int, switchColons map[int]boo
 	return false
 }
 
-func (OperatorLinebreak) Fix(s *tokens.Stream) bool {
+func (f OperatorLinebreak) Fix(s *tokens.Stream) bool {
 	changed := false
 	switchColons := switchCaseColons(s)
 	for i := s.Len() - 1; i > 0; i-- {
-		if !isOperatorLinebreakToken(s.At(i)) {
+		if !f.isOperatorToken(s.At(i)) {
 			continue
 		}
 		if operatorLinebreakExcluded(s, i, switchColons) {
@@ -104,11 +132,20 @@ func (OperatorLinebreak) Fix(s *tokens.Stream) bool {
 		if !operatorSpanMultiline(s, prevM+1, nextM-1) {
 			continue
 		}
-		// already at the beginning of a line if there is no newline after it
-		if !operatorSpanMultiline(s, hi, nextM-1) {
-			continue
+
+		if f.position == "end" {
+			// already at the end of a line if there is no newline before it
+			if !operatorSpanMultiline(s, prevM+1, lo) {
+				continue
+			}
+			moveOperatorToLineEnd(s, opIndices, prevM)
+		} else {
+			// already at the beginning of a line if there is no newline after it
+			if !operatorSpanMultiline(s, hi, nextM-1) {
+				continue
+			}
+			moveOperatorToLineStart(s, opIndices, nextM)
 		}
-		moveOperatorToLineStart(s, opIndices, nextM)
 		changed = true
 		i = lo // resume before the moved group
 	}
@@ -155,3 +192,30 @@ func moveOperatorToLineStart(s *tokens.Stream, opIndices []int, nextM int) {
 		s.InsertAt(at, token.Token{Kind: token.Whitespace, Value: " "})
 	}
 }
+
+// moveOperatorToLineEnd mirrors fixMoveToTheEnd: it clears each operator (and the
+// whitespace immediately after it) and re-inserts the operators just after the
+// previous meaningful token, keeping a single trailing space when a space
+// followed the group.
+func moveOperatorToLineEnd(s *tokens.Stream, opIndices []int, prevM int) {
+	hi := opIndices[len(opIndices)-1]
+	hadSpaceAfter := hi+1 < s.Len() && s.At(hi+1).Kind == token.Whitespace
+
+	clones := make([]token.Token, len(opIndices))
+	for k, idx := range opIndices {
+		clones[k] = token.Token{Kind: s.At(idx).Kind, Value: s.At(idx).Value}
+	}
+	for _, idx := range opIndices {
+		if idx+1 < s.Len() && s.At(idx+1).Kind == token.Whitespace {
+			s.SetValue(idx+1, "")
+		}
+		s.SetValue(idx, "")
+	}
+
+	at := prevM + 1
+	if hadSpaceAfter {
+		s.InsertAt(at, token.Token{Kind: token.Whitespace, Value: " "})
+		at++
+	}
+	s.InsertSliceAt(at, clones)
+}
diff --git a/blink/internal/fixer/rules/operator_linebreak_config_test.go b/blink/internal/fixer/rules/operator_linebreak_config_test.go
new file mode 100644
index 0000000000..f6ceed8519
--- /dev/null
+++ b/blink/internal/fixer/rules/operator_linebreak_config_test.go
@@ -0,0 +1,27 @@
+package rules
+
+import "testing"
+
+func TestOperatorLinebreakConfig(t *testing.T) {
+	t.Parallel()
+
+	// position: end moves an operator from the start of a line to the end of the
+	// previous one.
+	src := "<?php\n$a = $b\n&& $c;"
+	f := OperatorLinebreak{}.WithConfig(map[string]any{"position": "end"})
+	got, changed := apply(t, f.(fixerRule), src)
+	if want := "<?php\n$a = $b &&\n$c;"; !changed || got != want {
+		t.Fatalf("position end changed=%v got=%q want=%q", changed, got, want)
+	}
+
+	// only_booleans leaves a non-boolean operator (concat) untouched.
+	concat := "<?php\n$a = $b .\n$c;"
+	f = OperatorLinebreak{}.WithConfig(map[string]any{"only_booleans": true})
+	if _, changed := apply(t, f.(fixerRule), concat); changed {
+		t.Fatal("only_booleans must leave the concat operator alone")
+	}
+	// the default still moves the concat operator to the beginning.
+	if got, changed := apply(t, OperatorLinebreak{}, concat); !changed || got != "<?php\n$a = $b\n. $c;" {
+		t.Fatalf("default concat changed=%v got=%q", changed, got)
+	}
+}
diff --git a/blink/internal/fixer/rules/rules_test.go b/blink/internal/fixer/rules/rules_test.go
index 5f091e5be2..505b84d3cb 100644
--- a/blink/internal/fixer/rules/rules_test.go
+++ b/blink/internal/fixer/rules/rules_test.go
@@ -324,12 +324,14 @@ func TestSingleImportPerStatement(t *testing.T) {
 	if want := "<?php\nuse A\\B;\nuse C\\D;"; !changed || got != want {
 		t.Fatalf("changed=%v got=%q want=%q", changed, got, want)
 	}
-	// closure use and group import are left alone
+	// closure use is left alone
 	if _, changed := apply(t, SingleImportPerStatement{}, "<?php $f = function () use ($a, $b) {};"); changed {
 		t.Fatal("closure use must not be split")
 	}
-	if _, changed := apply(t, SingleImportPerStatement{}, "<?php use A\\{B, C};"); changed {
-		t.Fatal("group import must not be split")
+	// group imports are expanded by default (group_to_single_imports: true)
+	got, changed = apply(t, SingleImportPerStatement{}, "<?php use A\\{B, C};")
+	if want := "<?php use A\\B;\nuse A\\C;"; !changed || got != want {
+		t.Fatalf("group default changed=%v got=%q want=%q", changed, got, want)
 	}
 }
 
diff --git a/blink/internal/fixer/rules/single_import_per_statement_config_test.go b/blink/internal/fixer/rules/single_import_per_statement_config_test.go
new file mode 100644
index 0000000000..1d2f70f379
--- /dev/null
+++ b/blink/internal/fixer/rules/single_import_per_statement_config_test.go
@@ -0,0 +1,34 @@
+package rules
+
+import "testing"
+
+func TestSingleImportPerStatementConfig(t *testing.T) {
+	t.Parallel()
+
+	// group_to_single_imports:false keeps a brace group but still splits commas.
+	f := SingleImportPerStatement{}.WithConfig(map[string]any{"group_to_single_imports": false})
+	if _, changed := apply(t, f.(fixerRule), "<?php use A\\{B, C};"); changed {
+		t.Fatal("group_to_single_imports:false must keep the group")
+	}
+	if got, changed := apply(t, f.(fixerRule), "<?php use A, B;"); !changed || got != "<?php use A;\nuse B;" {
+		t.Fatalf("comma split changed=%v got=%q", changed, got)
+	}
+
+	// a group with per-member function/const modifiers expands each with its own.
+	got, changed := apply(t, SingleImportPerStatement{}, "<?php use Foo\\{function a, const B, C};")
+	if want := "<?php use function Foo\\a;\nuse const Foo\\B;\nuse Foo\\C;"; !changed || got != want {
+		t.Fatalf("mixed group changed=%v got=%q want=%q", changed, got, want)
+	}
+
+	// an outer "function" modifier is carried to every member.
+	got, changed = apply(t, SingleImportPerStatement{}, "<?php use function Foo\\{a, b};")
+	if want := "<?php use function Foo\\a;\nuse function Foo\\b;"; !changed || got != want {
+		t.Fatalf("outer modifier changed=%v got=%q want=%q", changed, got, want)
+	}
+
+	// aliases are preserved.
+	got, changed = apply(t, SingleImportPerStatement{}, "<?php use Foo\\{Bar as Baz, Qux};")
+	if want := "<?php use Foo\\Bar as Baz;\nuse Foo\\Qux;"; !changed || got != want {
+		t.Fatalf("alias changed=%v got=%q want=%q", changed, got, want)
+	}
+}
diff --git a/blink/internal/fixer/rules/structural.go b/blink/internal/fixer/rules/structural.go
index 4213af70cc..74dc603d62 100644
--- a/blink/internal/fixer/rules/structural.go
+++ b/blink/internal/fixer/rules/structural.go
@@ -3,15 +3,21 @@ package rules
 import (
 	"strings"
 
+	"blink/internal/fixer"
 	"blink/internal/token"
 	"blink/internal/tokens"
 )
 
 // PHP-CS-Fixer: https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/NamespaceNotation/BlankLinesBeforeNamespaceFixer.php
 //
-// BlankLinesBeforeNamespace ensures exactly one blank line before a namespace
-// declaration that sits on its own line.
-type BlankLinesBeforeNamespace struct{}
+// BlankLinesBeforeNamespace keeps the line breaks before a namespace declaration
+// within the configured bounds (both default to 2, i.e. exactly one blank line).
+type BlankLinesBeforeNamespace struct {
+	// minLineBreaks / maxLineBreaks bound the line breaks before namespace; 0
+	// means the default of 2.
+	minLineBreaks int
+	maxLineBreaks int
+}
 
 func (BlankLinesBeforeNamespace) Name() string {
 	return `PhpCsFixer\Fixer\NamespaceNotation\BlankLinesBeforeNamespaceFixer`
@@ -21,7 +27,25 @@ func (BlankLinesBeforeNamespace) SourceURL() string {
 	return "https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/NamespaceNotation/BlankLinesBeforeNamespaceFixer.php"
 }
 
-func (BlankLinesBeforeNamespace) Fix(s *tokens.Stream) bool {
+func (f BlankLinesBeforeNamespace) WithConfig(config map[string]any) fixer.Fixer {
+	f.minLineBreaks = configInt(config, "min_line_breaks", 2)
+	f.maxLineBreaks = configInt(config, "max_line_breaks", 2)
+	return f
+}
+
+func (f BlankLinesBeforeNamespace) lineBreaks() (int, int) {
+	minBreaks, maxBreaks := f.minLineBreaks, f.maxLineBreaks
+	if minBreaks == 0 {
+		minBreaks = 2
+	}
+	if maxBreaks == 0 {
+		maxBreaks = 2
+	}
+	return minBreaks, maxBreaks
+}
+
+func (f BlankLinesBeforeNamespace) Fix(s *tokens.Stream) bool {
+	minBreaks, maxBreaks := f.lineBreaks()
 	changed := false
 	for i := range s.Len() {
 		t := s.At(i)
@@ -32,14 +56,45 @@ func (BlankLinesBeforeNamespace) Fix(s *tokens.Stream) bool {
 			continue
 		}
 		prev := s.At(i - 1)
-		if prev.Kind == token.Whitespace && hasNewline(prev.Value) && prev.Value != "\n\n" {
-			s.SetValue(i-1, "\n\n")
+		if prev.Kind != token.Whitespace || !hasNewline(prev.Value) {
+			continue
+		}
+		target := clampLineBreaks(strings.Count(prev.Value, "\n"), minBreaks, maxBreaks)
+		indent := prev.Value
+		if idx := strings.LastIndexByte(prev.Value, '\n'); idx >= 0 {
+			indent = prev.Value[idx+1:]
+		}
+		want := strings.Repeat("\n", target) + indent
+		if prev.Value != want {
+			s.SetValue(i-1, want)
 			changed = true
 		}
 	}
 	return changed
 }
 
+func clampLineBreaks(n, minBreaks, maxBreaks int) int {
+	if n < minBreaks {
+		return minBreaks
+	}
+	if n > maxBreaks {
+		return maxBreaks
+	}
+	return n
+}
+
+// configInt reads an int option (a JSON number arrives as float64), falling back
+// to def when absent.
+func configInt(config map[string]any, key string, def int) int {
+	switch n := config[key].(type) {
+	case float64:
+		return int(n)
+	case int:
+		return n
+	}
+	return def
+}
+
 // PHP-CS-Fixer: https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/blob/master/src/Fixer/NamespaceNotation/BlankLineAfterNamespaceFixer.php
 //
 // BlankLineAfterNamespace ensures one blank line after a "namespace X;"