Outputformatting exception when saving page with repeater matrix field

[adrianbj]

Can’t save page (id=50813): /repeaters/for-field-185/for-page-50808/1762281864-5294-2/: Call $page->of(false); before getting/setting values that will be modified and saved. [body] (/wire/core/PagesEditor.php:470)

And another related one that referenced [Page::statusCorrupted] instead of [body]

These are happening when simply saving a page in the admin. It is a complex repeater matrix field and some of the blocks include repeater fields.

I feel like I have reported this before but can't seem to find at the moment.

[adrianbj]

A little more debugging - the block type was one with a simple body field (CK Editor) and if I save with text in the field then I get that error, but if I add the block, save, and then add text to the body field, then it saves OK.

Maybe that [Page::statusCorrupted] is the key to all this - maybe it got stuck in some weird state?

[adrianbj]

@ryancramerdesign - did you test to see if you could reproduce when the page has the corrupted status?

[adrianbj]

Tracking this down — I can pin the proximate cause but not the leak that puts the matrix item into the offending state, which is probably why @ryancramerdesign can't reproduce.

Proximate cause

The error is thrown from PagesEditor::isSaveable() in two adjacent branches:

  // wire/core/PagesEditor.php:175                                                                                                                                                  
  if($page->hasStatus(Page::statusCorrupted)) {
      $corruptedFields = $page->_statusCorruptedFields;                                                                                                                             
      foreach($page->getChanges() as $change) {
          if(isset($corruptedFields[$change])) $corrupted[] = $change;                                                                                                              
      }                                   
      ...                                                                                                                                                                           
  }                                       
  ...
  // PagesEditor.php:192
  } else if(count($corrupted)) {                                                                                                                                                    
      $reason = $outputFormattingReason . " [Page::statusCorrupted] fields: " . implode(', ', $corrupted);
                                                                                                                                                                                    
  // PagesEditor.php:203                  
  if($saveable && $page->outputFormatting) {                                                                                                                                        
      foreach($page->getChanges() as $change) {                                                                                                                                     
          ...
          if($page->template->fieldgroup->getField($change) !== null) {                                                                                                             
              $reason = $outputFormattingReason . " [$change]";                                                                                                                     
              $saveable = false;
              break;                                                                                                                                                                
          }                               
      }
      if($saveable) foreach($page->getArray() as $key => $value) {                                                                                                                  
          ...
          if($value instanceof Wire && $value->isChanged()) {                                                                                                                       
              $reason = $outputFormattingReason . " [$key]";                                                                                                                        
              $saveable = false;
              break;                                                                                                                                                                
          }                               
      }
  }

The [body] variant of the error comes from line 208, the [Page::statusCorrupted] variant comes from line 193. They share a single root condition: at the moment $pages->save($p) is called on the matrix item from FieldtypeRepeater::___savePageField() (FieldtypeRepeater.module:1651), that matrix item has $p->of() === true AND a custom field in getChanges().

The [Page::statusCorrupted] variant has one more step. When InputfieldRepeater::formToPage() does $page->set($name, $value) on a matrix item (InputfieldRepeater.module:1162), PageValues::setFieldValue() reaches this block:

  // wire/core/PageValues.php:1101        
  } else if($page->of()) {
      // check if value is modified by being formatted
      $result = $fieldtype->_callHookMethod('formatValue', array($page, $field, $value));                                                                                           
      if($result != $value) $isCorrupted = true;                                                                                                                                    
  }                                                                                                                                                                                 
  if($isCorrupted) {                                                                                                                                                                
      $page->set('status', $page->status | Page::statusCorrupted);
      ...                                                                                                                                                                           
      $corruptedFields[$field->name] = $field->name;
      $page->set('_statusCorruptedFields', $corruptedFields);                                                                                                                       
  }                                                                                                                                                                                 

body runs CKEditor textformatters (HTML purifier / entity encoding), so formatValue($value) != $value whenever there is actual content — which is exactly why your "save empty, then add text" sequence dodges it. The first save sees no body change so no corruption flag is set; subsequent typing happens on an item already saved with of(false) set back to it (line 793 of PagesEditor::save() restores $of after save).

Why "can't reproduce"

This only fires when the matrix item's outputFormatting is true at processInput / save time. In the normal flow, items in FieldtypeRepeater::___wakeupValue() come out of $pages->find() with of(false) (the PagesLoader default at PagesLoader.php:25). Something in your environment is flipping the matrix item to of(true) between wakeup and save —
possibilities I'd look at:

• A hook on Pages::loaded, Pages::saveReady, or Page::loaded in your install that touches the matrix value with $p->of(true).
• A custom Pageclass for the matrix items that overrides of() defaults.
• Something in the request path (a Tracy custom panel, a process-wide module) that reads $page->matrix_field with output formatting on, which then triggers
  FieldtypeRepeater::___formatValue() — that method explicitly does $p->of(true); on every item (FieldtypeRepeater.module:1379), and that state sticks because nothing turns it back
  off.

The third bullet is the most likely culprit on a complex site, and is consistent with "universal with hooks" — anything that reads the matrix field with the outer page in an of(true) state taints the items for the rest of the request.

Suggested fix (defensive, in core)

FieldtypeRepeater::___savePageField() already disables output formatting on the parent ($page->of(false); happens in PagesEditor::save), but it does not normalize state on the items it iterates before calling $pages->save() on them. A small guard makes the save robust to whatever leaked of(true) into the items:

   // iterate the pages that had changes and need to be saved
   foreach($savePages as $p) {                                                                                                                                                      
       /** @var Page|RepeaterPage $p */
       ...                                                                                                                                                                          
                                          
       // save the repeater page
  +    $pOf = $p->of();
  +    if($pOf) $p->of(false);                                                                                                                                                      
       $pages->save($p, $saveOptions);
  +    if($pOf) $p->of(true);                                                                                                                                                       
   }    

This is the same pattern used elsewhere in core (e.g. PagesEditor::save() around lines 764/793, PagesEditor::___clonePage at 1395-1396/1410). It does not paper over a corruption
— by the time we reach this loop, processInput is already complete and the value being saved is the value we want to persist; the of() check in isSaveable is meant to catch API caller mistakes, not a re-entrant internal save.

Caveat about statusCorrupted

The defensive of(false) fix above prevents the [body] variant but the [Page::statusCorrupted] variant would still fire (the status was set during setFieldValue, before savePageField runs). For that variant, the cleaner fix is in InputfieldRepeater::formToPage() at InputfieldRepeater.module:1141 — set $page->of(false) once at the top before iterating the wrapper, so PageValues::setFieldValue never enters the $page->of() branch:

   protected function formToPage(InputfieldWrapper $wrapper, Page $page, $level = 0) {
                                                                                                                                                                                    
       $languages = $this->wire()->languages;
  +    $pOf = $page->of();                                                                                                                                                          
  +    if($pOf) $page->of(false);                                                                                                                                                   
   
       foreach($wrapper as $inputfield) {                                                                                                                                           
           ...                            
       }
  +    if($pOf) $page->of(true);
   }                                                                                                                                                                                

Both fixes together close the door on both error variants regardless of where the of(true) leak originates.

[adrianbj]

@ryancramerdesign - while you have Claude bug fixing, there should be enough info here to take care of this now.