Fix fatal error in Abilities API registration when instance is unavailable (#435) (#436)

* Add regression test for abilities registration with unavailable instance (code-writer)

* Bail registration callbacks when internal post type instance unavailable (code-writer)

* Harden schema merge against missing properties key (code-writer)

Treat a missing properties key on either the entity or internal schema as
an empty array so the merge no longer emits an undefined-key warning or
fatals with array_merge(): Argument #1 must be of type array, null given.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Add changelog entry for abilities registration crash fix (doc-writer)

* Avoid caching unavailable abilities instances

---------

Props cbravobernal, dhenriet.

Author: cbravobernal

includes/abilities/class-scf-internal-post-type-abilities.php

@@ -78,12 +78,19 @@ public function __construct() {
 		/**
 		 * Gets the internal post type instance.
 		 *
-		 * @return ACF_Internal_Post_Type
+		 * @return ACF_Internal_Post_Type|false
 		 */
 		private function instance() {
-			if ( null === $this->instance ) {
-				$this->instance = acf_get_internal_post_type_instance( $this->internal_post_type );
+			if ( ! $this->instance ) {
+				$instance = acf_get_internal_post_type_instance( $this->internal_post_type );
+
+				if ( $instance ) {
+					$this->instance = $instance;
+				}
+
+				return $instance;
 			}
+
 			return $this->instance;
 		}
 
@@ -199,7 +206,10 @@ private function get_internal_fields_schema() {
 		private function get_entity_with_internal_fields_schema() {
 			$schema               = $this->get_entity_schema();
 			$internal             = $this->get_internal_fields_schema();
-			$schema['properties'] = array_merge( $schema['properties'], $internal['properties'] );
+			$schema['properties'] = array_merge(
+				$schema['properties'] ?? array(),
+				$internal['properties'] ?? array()
+			);
 			return $schema;
 		}
 
@@ -211,6 +221,10 @@ private function get_entity_with_internal_fields_schema() {
 		 * @return void
 		 */
 		public function register_categories() {
+			if ( ! $this->instance() ) {
+				return;
+			}
+
 			wp_register_ability_category(
 				$this->ability_category(),
 				array(
@@ -234,6 +248,10 @@ public function register_categories() {
 		 * @return void
 		 */
 		public function register_abilities() {
+			if ( ! $this->instance() ) {
+				return;
+			}
+
 			$this->register_list_ability();
 			$this->register_get_ability();
 			$this->register_create_ability();

readme.txt

@@ -51,6 +51,13 @@ This plugin builds upon and is a fork of the previous work done by the contribut
 
 
 == Changelog ==
+= Next =
+*Release Date TBD*
+
+*Fixes*
+
+- SCF's Abilities API integration for its internal post types no longer triggers PHP warnings, notices, or a fatal error (500) on block editor and REST API requests when another active plugin builds the WordPress abilities registry earlier in the request; registration is skipped cleanly in that case and normal abilities behavior is otherwise unchanged.
+
 = 6.8.6 =
 *Release Date 27th May 2026*
 

tests/php/includes/abilities/test-scf-internal-post-type-abilities.php

@@ -801,6 +801,55 @@ public function test_ability_name_uses_singular_for_get() {
 		$this->assertEquals( 'scf/get-taxonomy', $method->invoke( $this->abilities, 'get' ) );
 	}
 
+	/**
+	 * Test registration skips cleanly when the internal post type instance is unavailable.
+	 *
+	 * Reproduces the issue's crash path: when the internal post type instance lookup
+	 * resolves to false (e.g. the post type is not registered yet), the abilities and
+	 * categories registration must not attempt to dereference the missing instance.
+	 * Asserts that nothing is registered and that no warning, notice, deprecation, or
+	 * fatal TypeError is emitted (the suite promotes such emissions to test failures).
+	 */
+	public function test_registration_skips_cleanly_when_instance_unavailable() {
+		global $mock_registered_abilities, $mock_registered_ability_categories;
+		$mock_registered_abilities          = array();
+		$mock_registered_ability_categories = array();
+
+		$store             = acf_get_store( 'internal-post-types' );
+		$original_instance = $store ? $store->get( 'acf-taxonomy' ) : null;
+
+		$reflection = new ReflectionClass( SCF_Internal_Post_Type_Abilities::class );
+		$property   = $reflection->getProperty( 'instance' );
+		$property->setAccessible( true );
+		$property->setValue( $this->abilities, null );
+
+		if ( $store ) {
+			$store->remove( 'acf-taxonomy' );
+		}
+
+		try {
+			$this->abilities->register_categories();
+			$this->abilities->register_abilities();
+
+			$this->assertEmpty(
+				$mock_registered_ability_categories,
+				'No categories should be registered when the instance is unavailable'
+			);
+			$this->assertEmpty(
+				$mock_registered_abilities,
+				'No abilities should be registered when the instance is unavailable'
+			);
+			$this->assertNull(
+				$property->getValue( $this->abilities ),
+				'Unavailable instances should not be cached so later registration attempts can retry'
+			);
+		} finally {
+			if ( $store && $original_instance ) {
+				$store->set( 'acf-taxonomy', $original_instance );
+			}
+		}
+	}
+
 	/**
 	 * Test instance() method caches result
 	 */