fix(postprocess): suppress single-child wrappers with trailing delimiters

internal/postprocess/collapsing.go

@@ -227,8 +227,9 @@ func suppressInlineParentRedundancy(
 	}
 }
 
-// suppressCoextensiveWrappers climbs single-line parents and suppresses wrapper actions
-// that are truly coextensive with the child (exact same byte range).
+// suppressCoextensiveWrappers walks single-line parents and drops wrapper actions
+// that share the child's start byte, like single-child statements with trailing
+// semicolons or scaffolding.
 func suppressCoextensiveWrappers(
 	node *treesitter.ASTNode,
 	actionMap map[*treesitter.ASTNode]*actions.Action,
@@ -242,14 +243,12 @@ func suppressCoextensiveWrappers(
 		if r != nil && r.IsPair(parent.Type) {
 			continue
 		}
-		// Strict opening invariant: parent must not start before child (protects {hash}, [array], (expr))
-		if parent.StartByte == node.StartByte {
-			// Only suppress if parent is truly coextensive (exact same EndByte) and is a single-child or scaffolding wrapper
-			if parent.EndByte == node.EndByte && (len(parent.Children) <= 1 || parent.IsScaffolding()) {
-				parentAct := actionMap[parent]
-				if parentAct != nil && !suppressed[parentAct] && !parentAct.Subtree {
-					suppressed[parentAct] = true
-				}
+		// Parent can't start before the child: keeps opening delimiters like {hash}, [array], or (expr) intact.
+		if parent.StartByte == node.StartByte &&
+			(len(parent.Children) <= 1 || parent.IsScaffolding() || parent.EndByte == node.EndByte) {
+			parentAct := actionMap[parent]
+			if parentAct != nil && !suppressed[parentAct] && !parentAct.Subtree {
+				suppressed[parentAct] = true
 			}
 		}
 	}

internal/postprocess/collapsing_test.go

@@ -536,8 +536,7 @@ func TestInlineParentSuppression(t *testing.T) {
 		}
 	})
 
-	// (h) Trailing statement terminator (semicolon) in single-child expression_statement
-	// must STILL suppress the parent wrapper Insert even though parent.EndByte > dstChild.EndByte.
+	// (h) Trailing semicolons shouldn't keep single-child wrappers alive when their child moves.
 	t.Run("moved-child-suppresses-inline-parent-insert-with-semicolon", func(t *testing.T) {
 		srcChild := &treesitter.ASTNode{
 			Type:      "assignment_expression",
@@ -580,17 +579,17 @@ func TestInlineParentSuppression(t *testing.T) {
 				moveSurvives = true
 			}
 		}
-		if !parentSurvives {
-			t.Error("expected parent expression_statement Insert with trailing semicolon to survive for delimiter coverage")
+		if parentSurvives {
+			t.Error("expected parent expression_statement Insert with trailing semicolon to be suppressed")
 		}
 		if !moveSurvives {
 			t.Error("expected child assignment_expression Move to survive")
 		}
 	})
 
-	// (i) Bidirectional symmetry: source-side single-line statement wrapper Delete is preserved
-	// when parent contains trailing delimiter punctuation (e.g. semicolon).
-	t.Run("moved-child-preserves-source-side-parent-delete-with-semicolon", func(t *testing.T) {
+	// (i) Symmetrical delete: source-side single-line statement wrappers with trailing
+	// semicolons get dropped too when their child moves.
+	t.Run("moved-child-suppresses-source-side-parent-delete-with-semicolon", func(t *testing.T) {
 		srcChild := &treesitter.ASTNode{
 			Type:      "assignment_expression",
 			StartByte: 100, EndByte: 120,
@@ -633,8 +632,8 @@ func TestInlineParentSuppression(t *testing.T) {
 				moveSurvives = true
 			}
 		}
-		if !srcParentSurvives {
-			t.Error("expected source-side parent expression_statement Delete with trailing semicolon to survive")
+		if srcParentSurvives {
+			t.Error("expected source-side parent expression_statement Delete with trailing semicolon to be suppressed")
 		}
 		if !moveSurvives {
 			t.Error("expected child Move action to survive")