Adding upstream version 6.6.1+dfsg1.upstream/6.6.1+dfsg1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 283 insertions, 147 deletions

diff --git a/wp-includes/interactivity-api/class-wp-interactivity-api-directives-processor.php b/wp-includes/interactivity-api/class-wp-interactivity-api-directives-processor.php
index 3b2dcb1..590cf96 100644
--- a/wp-includes/interactivity-api/class-wp-interactivity-api-directives-processor.php
+++ b/wp-includes/interactivity-api/class-wp-interactivity-api-directives-processor.php
@@ -107,7 +107,7 @@ final class WP_Interactivity_API_Directives_Processor extends WP_HTML_Tag_Proces
 
 		$bookmark = 'append_content_after_template_tag_closer';
 		$this->set_bookmark( $bookmark );
-		$after_closing_tag = $this->bookmarks[ $bookmark ]->start + $this->bookmarks[ $bookmark ]->length + 1;
+		$after_closing_tag = $this->bookmarks[ $bookmark ]->start + $this->bookmarks[ $bookmark ]->length;
 		$this->release_bookmark( $bookmark );
 
 		// Appends the new content.
@@ -140,7 +140,7 @@ final class WP_Interactivity_API_Directives_Processor extends WP_HTML_Tag_Proces
 		}
 		list( $opener_tag, $closer_tag ) = $bookmarks;
 
-		$after_opener_tag  = $this->bookmarks[ $opener_tag ]->start + $this->bookmarks[ $opener_tag ]->length + 1;
+		$after_opener_tag  = $this->bookmarks[ $opener_tag ]->start + $this->bookmarks[ $opener_tag ]->length;
 		$before_closer_tag = $this->bookmarks[ $closer_tag ]->start;
 
 		if ( $rewind ) {
@@ -198,16 +198,19 @@ final class WP_Interactivity_API_Directives_Processor extends WP_HTML_Tag_Proces
 	public function skip_to_tag_closer(): bool {
 		$depth    = 1;
 		$tag_name = $this->get_tag();
-		while ( $depth > 0 && $this->next_tag(
-			array(
-				'tag_name'    => $tag_name,
-				'tag_closers' => 'visit',
-			)
-		) ) {
-			if ( $this->has_self_closing_flag() ) {
-				continue;
+
+		while ( $depth > 0 && $this->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
+			if ( ! $this->is_tag_closer() && $this->get_attribute_names_with_prefix( 'data-wp-' ) ) {
+				/* translators: 1: SVG or MATH HTML tag. */
+				$message = sprintf( __( 'Interactivity directives were detected inside an incompatible %1$s tag. These directives will be ignored in the server side render.' ), $tag_name );
+				_doing_it_wrong( __METHOD__, $message, '6.6.0' );
+			}
+			if ( $this->get_tag() === $tag_name ) {
+				if ( $this->has_self_closing_flag() ) {
+					continue;
+				}
+				$depth += $this->is_tag_closer() ? -1 : 1;
 			}
-			$depth += $this->is_tag_closer() ? -1 : 1;
 		}
 
 		return 0 === $depth;
diff --git a/wp-includes/interactivity-api/class-wp-interactivity-api.php b/wp-includes/interactivity-api/class-wp-interactivity-api.php
index 3db539a..3924e87 100644
--- a/wp-includes/interactivity-api/class-wp-interactivity-api.php
+++ b/wp-includes/interactivity-api/class-wp-interactivity-api.php
@@ -74,21 +74,75 @@ final class WP_Interactivity_API {
 	private $has_processed_router_region = false;
 
 	/**
+	 * Stack of namespaces defined by `data-wp-interactive` directives, in
+	 * the order they are processed.
+	 *
+	 * This is only available during directive processing, otherwise it is `null`.
+	 *
+	 * @since 6.6.0
+	 * @var array<string>|null
+	 */
+	private $namespace_stack = null;
+
+	/**
+	 * Stack of contexts defined by `data-wp-context` directives, in
+	 * the order they are processed.
+	 *
+	 * This is only available during directive processing, otherwise it is `null`.
+	 *
+	 * @since 6.6.0
+	 * @var array<array<mixed>>|null
+	 */
+	private $context_stack = null;
+
+	/**
 	 * Gets and/or sets the initial state of an Interactivity API store for a
 	 * given namespace.
 	 *
 	 * If state for that store namespace already exists, it merges the new
 	 * provided state with the existing one.
 	 *
+	 * When no namespace is specified, it returns the state defined for the
+	 * current value in the internal namespace stack during a `process_directives` call.
+	 *
 	 * @since 6.5.0
+	 * @since 6.6.0 The `$store_namespace` param is optional.
 	 *
-	 * @param string $store_namespace The unique store namespace identifier.
+	 * @param string $store_namespace Optional. The unique store namespace identifier.
 	 * @param array  $state           Optional. The array that will be merged with the existing state for the specified
 	 *                                store namespace.
 	 * @return array The current state for the specified store namespace. This will be the updated state if a $state
 	 *               argument was provided.
 	 */
-	public function state( string $store_namespace, array $state = array() ): array {
+	public function state( ?string $store_namespace = null, ?array $state = null ): array {
+		if ( ! $store_namespace ) {
+			if ( $state ) {
+				_doing_it_wrong(
+					__METHOD__,
+					__( 'The namespace is required when state data is passed.' ),
+					'6.6.0'
+				);
+				return array();
+			}
+			if ( null !== $store_namespace ) {
+				_doing_it_wrong(
+					__METHOD__,
+					__( 'The namespace should be a non-empty string.' ),
+					'6.6.0'
+				);
+				return array();
+			}
+			if ( null === $this->namespace_stack ) {
+				_doing_it_wrong(
+					__METHOD__,
+					__( 'The namespace can only be omitted during directive processing.' ),
+					'6.6.0'
+				);
+				return array();
+			}
+
+			$store_namespace = end( $this->namespace_stack );
+		}
 		if ( ! isset( $this->state_data[ $store_namespace ] ) ) {
 			$this->state_data[ $store_namespace ] = array();
 		}
@@ -167,10 +221,41 @@ final class WP_Interactivity_API {
 		}
 
 		if ( ! empty( $interactivity_data ) ) {
+			/*
+			 * This data will be printed as JSON inside a script tag like this:
+			 *   <script type="application/json"></script>
+			 *
+			 * A script tag must be closed by a sequence beginning with `</`. It's impossible to
+			 * close a script tag without using `<`. We ensure that `<` is escaped and `/` can
+			 * remain unescaped, so `</script>` will be printed as `\u003C/script\u00E3`.
+			 *
+			 *   - JSON_HEX_TAG: All < and > are converted to \u003C and \u003E.
+			 *   - JSON_UNESCAPED_SLASHES: Don't escape /.
+			 *
+			 * If the page will use UTF-8 encoding, it's safe to print unescaped unicode:
+			 *
+			 *   - JSON_UNESCAPED_UNICODE: Encode multibyte Unicode characters literally (instead of as `\uXXXX`).
+			 *   - JSON_UNESCAPED_LINE_TERMINATORS: The line terminators are kept unescaped when
+			 *     JSON_UNESCAPED_UNICODE is supplied. It uses the same behaviour as it was
+			 *     before PHP 7.1 without this constant. Available as of PHP 7.1.0.
+			 *
+			 * The JSON specification requires encoding in UTF-8, so if the generated HTML page
+			 * is not encoded in UTF-8 then it's not safe to include those literals. They must
+			 * be escaped to avoid encoding issues.
+			 *
+			 * @see https://www.rfc-editor.org/rfc/rfc8259.html for details on encoding requirements.
+			 * @see https://www.php.net/manual/en/json.constants.php for details on these constants.
+			 * @see https://html.spec.whatwg.org/#script-data-state for details on script tag parsing.
+			 */
+			$json_encode_flags = JSON_HEX_TAG | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_LINE_TERMINATORS;
+			if ( ! is_utf8_charset() ) {
+				$json_encode_flags = JSON_HEX_TAG | JSON_UNESCAPED_SLASHES;
+			}
+
 			wp_print_inline_script_tag(
 				wp_json_encode(
 					$interactivity_data,
-					JSON_HEX_TAG | JSON_HEX_AMP
+					$json_encode_flags
 				),
 				array(
 					'type' => 'application/json',
@@ -181,6 +266,46 @@ final class WP_Interactivity_API {
 	}
 
 	/**
+	 * Returns the latest value on the context stack with the passed namespace.
+	 *
+	 * When the namespace is omitted, it uses the current namespace on the
+	 * namespace stack during a `process_directives` call.
+	 *
+	 * @since 6.6.0
+	 *
+	 * @param string $store_namespace Optional. The unique store namespace identifier.
+	 */
+	public function get_context( ?string $store_namespace = null ): array {
+		if ( null === $this->context_stack ) {
+			_doing_it_wrong(
+				__METHOD__,
+				__( 'The context can only be read during directive processing.' ),
+				'6.6.0'
+			);
+			return array();
+		}
+
+		if ( ! $store_namespace ) {
+			if ( null !== $store_namespace ) {
+				_doing_it_wrong(
+					__METHOD__,
+					__( 'The namespace should be a non-empty string.' ),
+					'6.6.0'
+				);
+				return array();
+			}
+
+			$store_namespace = end( $this->namespace_stack );
+		}
+
+		$context = end( $this->context_stack );
+
+		return ( $store_namespace && $context && isset( $context[ $store_namespace ] ) )
+			? $context[ $store_namespace ]
+			: array();
+	}
+
+	/**
 	 * Registers the `@wordpress/interactivity` script modules.
 	 *
 	 * @since 6.5.0
@@ -208,6 +333,9 @@ final class WP_Interactivity_API {
 	public function add_hooks() {
 		add_action( 'wp_enqueue_scripts', array( $this, 'register_script_modules' ) );
 		add_action( 'wp_footer', array( $this, 'print_client_interactivity_data' ) );
+
+		add_action( 'admin_enqueue_scripts', array( $this, 'register_script_modules' ) );
+		add_action( 'admin_print_footer_scripts', array( $this, 'print_client_interactivity_data' ) );
 	}
 
 	/**
@@ -224,9 +352,14 @@ final class WP_Interactivity_API {
 			return $html;
 		}
 
-		$context_stack   = array();
-		$namespace_stack = array();
-		$result          = $this->process_directives_args( $html, $context_stack, $namespace_stack );
+		$this->namespace_stack = array();
+		$this->context_stack   = array();
+
+		$result = $this->_process_directives( $html );
+
+		$this->namespace_stack = null;
+		$this->context_stack   = null;
+
 		return null === $result ? $html : $result;
 	}
 
@@ -234,17 +367,17 @@ final class WP_Interactivity_API {
 	 * Processes the interactivity directives contained within the HTML content
 	 * and updates the markup accordingly.
 	 *
-	 * It needs the context and namespace stacks to be passed by reference, and
-	 * it returns null if the HTML contains unbalanced tags.
+	 * It uses the WP_Interactivity_API instance's context and namespace stacks,
+	 * which are shared between all calls.
 	 *
-	 * @since 6.5.0
+	 * This method returns null if the HTML contains unbalanced tags.
 	 *
-	 * @param string $html            The HTML content to process.
-	 * @param array  $context_stack   The reference to the array used to keep track of contexts during processing.
-	 * @param array  $namespace_stack The reference to the array used to manage namespaces during processing.
+	 * @since 6.6.0
+	 *
+	 * @param string $html The HTML content to process.
 	 * @return string|null The processed HTML content. It returns null when the HTML contains unbalanced tags.
 	 */
-	private function process_directives_args( string $html, array &$context_stack, array &$namespace_stack ) {
+	private function _process_directives( string $html ) {
 		$p          = new WP_Interactivity_API_Directives_Processor( $html );
 		$tag_stack  = array();
 		$unbalanced = false;
@@ -252,6 +385,13 @@ final class WP_Interactivity_API {
 		$directive_processor_prefixes          = array_keys( self::$directive_processors );
 		$directive_processor_prefixes_reversed = array_reverse( $directive_processor_prefixes );
 
+		/*
+		 * Save the current size for each stack to restore them in case
+		 * the processing finds unbalanced tags.
+		 */
+		$namespace_stack_size = count( $this->namespace_stack );
+		$context_stack_size   = count( $this->context_stack );
+
 		while ( $p->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
 			$tag_name = $p->get_tag();
 
@@ -261,6 +401,11 @@ final class WP_Interactivity_API {
 			 * We still process the rest of the HTML.
 			 */
 			if ( 'SVG' === $tag_name || 'MATH' === $tag_name ) {
+				if ( $p->get_attribute_names_with_prefix( 'data-wp-' ) ) {
+					/* translators: 1: SVG or MATH HTML tag, 2: Namespace of the interactive block. */
+					$message = sprintf( __( 'Interactivity directives were detected on an incompatible %1$s tag when processing "%2$s". These directives will be ignored in the server side render.' ), $tag_name, end( $this->namespace_stack ) );
+					_doing_it_wrong( __METHOD__, $message, '6.6.0' );
+				}
 				$p->skip_to_tag_closer();
 				continue;
 			}
@@ -341,20 +486,32 @@ final class WP_Interactivity_API {
 						? self::$directive_processors[ $directive_prefix ]
 						: array( $this, self::$directive_processors[ $directive_prefix ] );
 
-					call_user_func_array(
-						$func,
-						array( $p, $mode, &$context_stack, &$namespace_stack, &$tag_stack )
-					);
+					call_user_func_array( $func, array( $p, $mode, &$tag_stack ) );
 				}
 			}
 		}
 
+		if ( $unbalanced ) {
+			// Reset the namespace and context stacks to their previous values.
+			array_splice( $this->namespace_stack, $namespace_stack_size );
+			array_splice( $this->context_stack, $context_stack_size );
+		}
+
 		/*
 		 * It returns null if the HTML is unbalanced because unbalanced HTML is
 		 * not safe to process. In that case, the Interactivity API runtime will
-		 * update the HTML on the client side during the hydration.
+		 * update the HTML on the client side during the hydration. It will also
+		 * display a notice to the developer to inform them about the issue.
 		 */
-		return $unbalanced || 0 < count( $tag_stack ) ? null : $p->get_updated_html();
+		if ( $unbalanced || 0 < count( $tag_stack ) ) {
+			$tag_errored = 0 < count( $tag_stack ) ? end( $tag_stack )[0] : $tag_name;
+			/* translators: %1s: Namespace processed, %2s: The tag that caused the error; could be any HTML tag.  */
+			$message = sprintf( __( 'Interactivity directives failed to process in "%1$s" due to a missing "%2$s" end tag.' ), end( $this->namespace_stack ), $tag_errored );
+			_doing_it_wrong( __METHOD__, $message, '6.6.0' );
+			return null;
+		}
+
+		return $p->get_updated_html();
 	}
 
 	/**
@@ -362,17 +519,21 @@ final class WP_Interactivity_API {
 	 * store namespace, state and context.
 	 *
 	 * @since 6.5.0
+	 * @since 6.6.0 The function now adds a warning when the namespace is null, falsy, or the directive value is empty.
+	 * @since 6.6.0 Removed `default_namespace` and `context` arguments.
 	 *
-	 * @param string|true $directive_value   The directive attribute value string or `true` when it's a boolean attribute.
-	 * @param string      $default_namespace The default namespace to use if none is explicitly defined in the directive
-	 *                                       value.
-	 * @param array|false $context           The current context for evaluating the directive or false if there is no
-	 *                                       context.
-	 * @return mixed|null The result of the evaluation. Null if the reference path doesn't exist.
+	 * @param string|true $directive_value The directive attribute value string or `true` when it's a boolean attribute.
+	 * @return mixed|null The result of the evaluation. Null if the reference path doesn't exist or the namespace is falsy.
 	 */
-	private function evaluate( $directive_value, string $default_namespace, $context = false ) {
+	private function evaluate( $directive_value ) {
+		$default_namespace = end( $this->namespace_stack );
+		$context           = end( $this->context_stack );
+
 		list( $ns, $path ) = $this->extract_directive_value( $directive_value, $default_namespace );
-		if ( empty( $path ) ) {
+		if ( ! $ns || ! $path ) {
+			/* translators: %s: The directive value referenced. */
+			$message = sprintf( __( 'Namespace or reference path cannot be empty. Directive value referenced: %s' ), $directive_value );
+			_doing_it_wrong( __METHOD__, $message, '6.6.0' );
 			return null;
 		}
 
@@ -389,13 +550,42 @@ final class WP_Interactivity_API {
 		$path_segments = explode( '.', $path );
 		$current       = $store;
 		foreach ( $path_segments as $path_segment ) {
-			if ( isset( $current[ $path_segment ] ) ) {
+			if ( ( is_array( $current ) || $current instanceof ArrayAccess ) && isset( $current[ $path_segment ] ) ) {
 				$current = $current[ $path_segment ];
+			} elseif ( is_object( $current ) && isset( $current->$path_segment ) ) {
+				$current = $current->$path_segment;
 			} else {
 				return null;
 			}
 		}
 
+		if ( $current instanceof Closure ) {
+			/*
+			 * This state getter's namespace is added to the stack so that
+			 * `state()` or `get_config()` read that namespace when called
+			 * without specifying one.
+			 */
+			array_push( $this->namespace_stack, $ns );
+			try {
+				$current = $current();
+			} catch ( Throwable $e ) {
+				_doing_it_wrong(
+					__METHOD__,
+					sprintf(
+						/* translators: 1: Path pointing to an Interactivity API state property, 2: Namespace for an Interactivity API store. */
+						__( 'Uncaught error executing a derived state callback with path "%1$s" and namespace "%2$s".' ),
+						$path,
+						$ns
+					),
+					'6.6.0'
+				);
+				return null;
+			} finally {
+				// Remove the property's namespace from the stack.
+				array_pop( $this->namespace_stack );
+			}
+		}
+
 		// Returns the opposite if it contains a negation operator (!).
 		return $should_negate_value ? ! $current : $current;
 	}
@@ -497,15 +687,13 @@ final class WP_Interactivity_API {
 	 *
 	 * @since 6.5.0
 	 *
-	 * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
-	 * @param string                                    $mode            Whether the processing is entering or exiting the tag.
-	 * @param array                                     $context_stack   The reference to the context stack.
-	 * @param array                                     $namespace_stack The reference to the store namespace stack.
+	 * @param WP_Interactivity_API_Directives_Processor $p    The directives processor instance.
+	 * @param string                                    $mode Whether the processing is entering or exiting the tag.
 	 */
-	private function data_wp_interactive_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
+	private function data_wp_interactive_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
 		// When exiting tags, it removes the last namespace from the stack.
 		if ( 'exit' === $mode ) {
-			array_pop( $namespace_stack );
+			array_pop( $this->namespace_stack );
 			return;
 		}
 
@@ -529,9 +717,9 @@ final class WP_Interactivity_API {
 				$new_namespace = $attribute_value;
 			}
 		}
-		$namespace_stack[] = ( $new_namespace && 1 === preg_match( '/^([\w\-_\/]+)/', $new_namespace ) )
+		$this->namespace_stack[] = ( $new_namespace && 1 === preg_match( '/^([\w\-_\/]+)/', $new_namespace ) )
 			? $new_namespace
-			: end( $namespace_stack );
+			: end( $this->namespace_stack );
 	}
 
 	/**
@@ -544,18 +732,16 @@ final class WP_Interactivity_API {
 	 *
 	 * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
 	 * @param string                                    $mode            Whether the processing is entering or exiting the tag.
-	 * @param array                                     $context_stack   The reference to the context stack.
-	 * @param array                                     $namespace_stack The reference to the store namespace stack.
 	 */
-	private function data_wp_context_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
+	private function data_wp_context_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
 		// When exiting tags, it removes the last context from the stack.
 		if ( 'exit' === $mode ) {
-			array_pop( $context_stack );
+			array_pop( $this->context_stack );
 			return;
 		}
 
 		$attribute_value = $p->get_attribute( 'data-wp-context' );
-		$namespace_value = end( $namespace_stack );
+		$namespace_value = end( $this->namespace_stack );
 
 		// Separates the namespace from the context JSON object.
 		list( $namespace_value, $decoded_json ) = is_string( $attribute_value ) && ! empty( $attribute_value )
@@ -567,8 +753,8 @@ final class WP_Interactivity_API {
 		 * previous context with the new one.
 		 */
 		if ( is_string( $namespace_value ) ) {
-			$context_stack[] = array_replace_recursive(
-				end( $context_stack ) !== false ? end( $context_stack ) : array(),
+			$this->context_stack[] = array_replace_recursive(
+				end( $this->context_stack ) !== false ? end( $this->context_stack ) : array(),
 				array( $namespace_value => is_array( $decoded_json ) ? $decoded_json : array() )
 			);
 		} else {
@@ -577,7 +763,7 @@ final class WP_Interactivity_API {
 			 * It needs to do so because the function pops out the current context
 			 * from the stack whenever it finds a `data-wp-context`'s closing tag.
 			 */
-			$context_stack[] = end( $context_stack );
+			$this->context_stack[] = end( $this->context_stack );
 		}
 	}
 
@@ -591,10 +777,8 @@ final class WP_Interactivity_API {
 	 *
 	 * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
 	 * @param string                                    $mode            Whether the processing is entering or exiting the tag.
-	 * @param array                                     $context_stack   The reference to the context stack.
-	 * @param array                                     $namespace_stack The reference to the store namespace stack.
 	 */
-	private function data_wp_bind_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
+	private function data_wp_bind_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
 		if ( 'enter' === $mode ) {
 			$all_bind_directives = $p->get_attribute_names_with_prefix( 'data-wp-bind--' );
 
@@ -605,7 +789,7 @@ final class WP_Interactivity_API {
 				}
 
 				$attribute_value = $p->get_attribute( $attribute_name );
-				$result          = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
+				$result          = $this->evaluate( $attribute_value );
 
 				if (
 					null !== $result &&
@@ -645,10 +829,8 @@ final class WP_Interactivity_API {
 	 *
 	 * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
 	 * @param string                                    $mode            Whether the processing is entering or exiting the tag.
-	 * @param array                                     $context_stack   The reference to the context stack.
-	 * @param array                                     $namespace_stack The reference to the store namespace stack.
 	 */
-	private function data_wp_class_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
+	private function data_wp_class_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
 		if ( 'enter' === $mode ) {
 			$all_class_directives = $p->get_attribute_names_with_prefix( 'data-wp-class--' );
 
@@ -659,7 +841,7 @@ final class WP_Interactivity_API {
 				}
 
 				$attribute_value = $p->get_attribute( $attribute_name );
-				$result          = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
+				$result          = $this->evaluate( $attribute_value );
 
 				if ( $result ) {
 					$p->add_class( $class_name );
@@ -680,10 +862,8 @@ final class WP_Interactivity_API {
 	 *
 	 * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
 	 * @param string                                    $mode            Whether the processing is entering or exiting the tag.
-	 * @param array                                     $context_stack   The reference to the context stack.
-	 * @param array                                     $namespace_stack The reference to the store namespace stack.
 	 */
-	private function data_wp_style_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
+	private function data_wp_style_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
 		if ( 'enter' === $mode ) {
 			$all_style_attributes = $p->get_attribute_names_with_prefix( 'data-wp-style--' );
 
@@ -694,7 +874,7 @@ final class WP_Interactivity_API {
 				}
 
 				$directive_attribute_value = $p->get_attribute( $attribute_name );
-				$style_property_value      = $this->evaluate( $directive_attribute_value, end( $namespace_stack ), end( $context_stack ) );
+				$style_property_value      = $this->evaluate( $directive_attribute_value );
 				$style_attribute_value     = $p->get_attribute( 'style' );
 				$style_attribute_value     = ( $style_attribute_value && ! is_bool( $style_attribute_value ) ) ? $style_attribute_value : '';
 
@@ -773,13 +953,11 @@ final class WP_Interactivity_API {
 	 *
 	 * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
 	 * @param string                                    $mode            Whether the processing is entering or exiting the tag.
-	 * @param array                                     $context_stack   The reference to the context stack.
-	 * @param array                                     $namespace_stack The reference to the store namespace stack.
 	 */
-	private function data_wp_text_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
+	private function data_wp_text_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
 		if ( 'enter' === $mode ) {
 			$attribute_value = $p->get_attribute( 'data-wp-text' );
-			$result          = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
+			$result          = $this->evaluate( $attribute_value );
 
 			/*
 			 * Follows the same logic as Preact in the client and only changes the
@@ -911,17 +1089,15 @@ HTML;
 	 *
 	 * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
 	 * @param string                                    $mode            Whether the processing is entering or exiting the tag.
-	 * @param array                                     $context_stack   The reference to the context stack.
-	 * @param array                                     $namespace_stack The reference to the store namespace stack.
 	 * @param array                                     $tag_stack       The reference to the tag stack.
 	 */
-	private function data_wp_each_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack, array &$tag_stack ) {
+	private function data_wp_each_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$tag_stack ) {
 		if ( 'enter' === $mode && 'TEMPLATE' === $p->get_tag() ) {
 			$attribute_name   = $p->get_attribute_names_with_prefix( 'data-wp-each' )[0];
 			$extracted_suffix = $this->extract_prefix_and_suffix( $attribute_name );
 			$item_name        = isset( $extracted_suffix[1] ) ? $this->kebab_to_camel_case( $extracted_suffix[1] ) : 'item';
 			$attribute_value  = $p->get_attribute( $attribute_name );
-			$result           = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
+			$result           = $this->evaluate( $attribute_value );
 
 			// Gets the content between the template tags and leaves the cursor in the closer tag.
 			$inner_content = $p->get_content_between_balanced_template_tags();
@@ -955,7 +1131,7 @@ HTML;
 			}
 
 			// Extracts the namespace from the directive attribute value.
-			$namespace_value         = end( $namespace_stack );
+			$namespace_value         = end( $this->namespace_stack );
 			list( $namespace_value ) = is_string( $attribute_value ) && ! empty( $attribute_value )
 				? $this->extract_directive_value( $attribute_value, $namespace_value )
 				: array( $namespace_value, null );
@@ -964,17 +1140,17 @@ HTML;
 			$processed_content = '';
 			foreach ( $result as $item ) {
 				// Creates a new context that includes the current item of the array.
-				$context_stack[] = array_replace_recursive(
-					end( $context_stack ) !== false ? end( $context_stack ) : array(),
+				$this->context_stack[] = array_replace_recursive(
+					end( $this->context_stack ) !== false ? end( $this->context_stack ) : array(),
 					array( $namespace_value => array( $item_name => $item ) )
 				);
 
 				// Processes the inner content with the new context.
-				$processed_item = $this->process_directives_args( $inner_content, $context_stack, $namespace_stack );
+				$processed_item = $this->_process_directives( $inner_content );
 
 				if ( null === $processed_item ) {
 					// If the HTML is unbalanced, stop processing it.
-					array_pop( $context_stack );
+					array_pop( $this->context_stack );
 					return;
 				}
 
@@ -987,7 +1163,7 @@ HTML;
 				$processed_content .= $i->get_updated_html();
 
 				// Removes the current context from the stack.
-				array_pop( $context_stack );
+				array_pop( $this->context_stack );
 			}
 
 			// Appends the processed content after the tag closer of the template.
diff --git a/wp-includes/interactivity-api/interactivity-api.php b/wp-includes/interactivity-api/interactivity-api.php
index b8f3e50..e007d51 100644
--- a/wp-includes/interactivity-api/interactivity-api.php
+++ b/wp-includes/interactivity-api/interactivity-api.php
@@ -8,71 +8,6 @@
  */
 
 /**
- * Processes the directives on the rendered HTML of the interactive blocks.
- *
- * This processes only one root interactive block at a time because the
- * rendered HTML of that block contains the rendered HTML of all its inner
- * blocks, including any interactive block. It does so by ignoring all the
- * interactive inner blocks until the root interactive block is processed.
- *
- * @since 6.5.0
- *
- * @param array $parsed_block The parsed block.
- * @return array The same parsed block.
- */
-function wp_interactivity_process_directives_of_interactive_blocks( array $parsed_block ): array {
-	static $root_interactive_block = null;
-
-	/*
-	 * Checks whether a root interactive block is already annotated for
-	 * processing, and if it is, it ignores the subsequent ones.
-	 */
-	if ( null === $root_interactive_block ) {
-		$block_name = $parsed_block['blockName'];
-		$block_type = WP_Block_Type_Registry::get_instance()->get_registered( $block_name );
-
-		if (
-			isset( $block_name ) &&
-			( ( isset( $block_type->supports['interactivity'] ) && true === $block_type->supports['interactivity'] ) ||
-			( isset( $block_type->supports['interactivity']['interactive'] ) && true === $block_type->supports['interactivity']['interactive'] ) )
-		) {
-			// Annotates the root interactive block for processing.
-			$root_interactive_block = array( $block_name, $parsed_block );
-
-			/*
-			 * Adds a filter to process the root interactive block once it has
-			 * finished rendering.
-			 */
-			$process_interactive_blocks = static function ( string $content, array $parsed_block ) use ( &$root_interactive_block, &$process_interactive_blocks ): string {
-				// Checks whether the current block is the root interactive block.
-				list($root_block_name, $root_parsed_block) = $root_interactive_block;
-				if ( $root_block_name === $parsed_block['blockName'] && $parsed_block === $root_parsed_block ) {
-					// The root interactive blocks has finished rendering, process it.
-					$content = wp_interactivity_process_directives( $content );
-					// Removes the filter and reset the root interactive block.
-					remove_filter( 'render_block_' . $parsed_block['blockName'], $process_interactive_blocks );
-					$root_interactive_block = null;
-				}
-				return $content;
-			};
-
-			/*
-			 * Uses a priority of 100 to ensure that other filters can add additional
-			 * directives before the processing starts.
-			 */
-			add_filter( 'render_block_' . $block_name, $process_interactive_blocks, 100, 2 );
-		}
-	}
-
-	return $parsed_block;
-}
-/*
- * Uses a priority of 100 to ensure that other filters can add additional attributes to
- * $parsed_block before the processing starts.
- */
-add_filter( 'render_block_data', 'wp_interactivity_process_directives_of_interactive_blocks', 100, 1 );
-
-/**
  * Retrieves the main WP_Interactivity_API instance.
  *
  * It provides access to the WP_Interactivity_API instance, creating one if it
@@ -112,7 +47,11 @@ function wp_interactivity_process_directives( string $html ): string {
  * If state for that store namespace already exists, it merges the new
  * provided state with the existing one.
  *
+ * The namespace can be omitted inside derived state getters, using the
+ * namespace where the getter is defined.
+ *
  * @since 6.5.0
+ * @since 6.6.0 The namespace can be omitted when called inside derived state getters.
  *
  * @param string $store_namespace The unique store namespace identifier.
  * @param array  $state           Optional. The array that will be merged with the existing state for the specified
@@ -120,7 +59,7 @@ function wp_interactivity_process_directives( string $html ): string {
  * @return array The state for the specified store namespace. This will be the updated state if a $state argument was
  *               provided.
  */
-function wp_interactivity_state( string $store_namespace, array $state = array() ): array {
+function wp_interactivity_state( ?string $store_namespace = null, array $state = array() ): array {
 	return wp_interactivity()->state( $store_namespace, $state );
 }
 
@@ -168,3 +107,21 @@ function wp_interactivity_data_wp_context( array $context, string $store_namespa
 		( empty( $context ) ? '{}' : wp_json_encode( $context, JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_QUOT | JSON_HEX_AMP ) ) .
 		'\'';
 }
+
+/**
+ * Gets the current Interactivity API context for a given namespace.
+ *
+ * The function should be used only during directive processing. If the
+ * `$store_namespace` parameter is omitted, it uses the current namespace value
+ * on the internal namespace stack.
+ *
+ * It returns an empty array when the specified namespace is not defined.
+ *
+ * @since 6.6.0
+ *
+ * @param string $store_namespace Optional. The unique store namespace identifier.
+ * @return array The context for the specified store namespace.
+ */
+function wp_interactivity_get_context( ?string $store_namespace = null ): array {
+	return wp_interactivity()->get_context( $store_namespace );
+}