Skip toolbar
WordPress.org

Make WordPress

Teams

  • Core

    The coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. team makes WordPress. Whether you’re a seasoned PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php, HTMLHTML HTML is an acronym for Hyper Text Markup Language. It is a markup language that is used in the development of web pages and websites., JavaScriptJavaScript JavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com or CSSCSS CSS is an acronym for cascading style sheets. This is what controls the design or look and feel of a site. developer or are just learning to code, we’d love to have you on board. You can write code, fix bugs, debate decisions, and help with development.

  • Design

    The design group is focused on the designing and developing the user interface. It’s a home for designers and UXers alike. There are regular discussions about mockups, design, and user testing.

  • Mobile

    The mobile team builds the iOSiOS The operating system used on iPhones and iPads. and Android apps. Lend them your Kotlin, Swift, or ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org Native skills. The team also needs designers, UXUX UX is an acronym for User Experience – the way the user uses the UI. Think ‘what they are doing’ and less about how they do it. experts, and testers to give users a smooth experience on every device.

  • Accessibility

    The a11yAccessibility Accessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) group provides accessibilityAccessibility Accessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) expertise across the project. They make sure that WordPress coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. and all of WordPress’ resources are accessible.

  • Polyglots

    WordPress is used all over the world in many different languages. If you’re a polyglot, you can help by translating WordPress into your own language or contributing to the GlotPress project, making translations easier and more effective for everyone.

  • Support

    Answering questions in the support forums, IRC, or SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ is one of the easiest ways to start contributing. Everyone knows the answer to something! Since the forums run on bbPress, you can also contribute by helping make the software behind them even better.

View all teams and their meetings

Latest activity

See the latest happenings across the entire project.

Adam Silverstein Core ·

Media changes in WordPress 7.2

WordPress 7.2 extends client-side media processing beyond the blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. editor, stops rewriting crossorigin attributes on the editor page, and generates animated sub-sizes for animated GIF and WebP uploads.

In short:

  • Image uploads from the Media Library grid, the Add New Media File screen and the media modal now go through the client-side pipeline in supported browsers.
  • wp_start_cross_origin_isolation_output_buffer() and wp_add_crossorigin_attributes() are deprecated. wp_send_document_isolation_policy_header() replaces the first; the second has no replacement.
  • Sub-sizes of animated GIF and WebP images keep their animation on the client-side path. The new wp_generate_animated_image_subsizes filterFilter Filters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. turns that off.

Client-side media processing now covers the Media Library and media modal

WordPress 7.1 introduced client-side media processing: in a cross-origin isolated page, the block editor uploads the original image through the REST APIREST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/, generates the sub-sizes in the browser with wasm-vips, then sideloads them and finalizes the attachment. This takes image processing off the server and gives the same results regardless of which image libraries the server has.

In 7.1 this only ran in the block editor. The Media Library grid, the Add New Media File screen and the media modal still uploaded through wp.Uploader and plupload to async-upload.php, with all processing on the server. A HEIC file that converted when dropped on an Image block could fail in the media modal on a server without HEIC support (#65661, #66220).

What changed in 7.2

Uploads from these three places now use the same pipeline as the editor:

  • The Media Library grid (upload.php in grid mode).
  • The Add New Media File screen (media-new.php).
  • The media modal, meaning every wp.media frame that uploads through wp.Uploader: the Image block’s “Media Library” button, the featured imageFeatured image A featured image is the main image used on your blog archive page and is pulled when the post or page is shared on social media. The image can be used to display in widget areas on your site or in a summary list of posts. panel, and the same frame in the site editor and the block widgets screen.

The existing UIUI User interface is reused, so progress bars, grid tiles and error notices look and behave as before. Error messages come from the pipeline, so the platform-specific HEIC wording from the editor shows up on these screens too. While an upload is in flight, the page warns before navigating away, since an interrupted client-side upload could lose sub-sizes that were not yet sideloaded.

Cross-origin isolation on more screens

wp_set_up_cross_origin_isolation() now also runs on load-upload.php and load-media-new.php. The Media Library is only isolated in grid mode, since list mode uploads go through the Add New Media File screen. The action query parameter check that skips third-party editors does not apply to these screens.

New functions:

  • wp_is_document_isolation_policy_supported() returns whether the requesting browser honors the headerHeader The header of your site is typically the first thing people will experience. The masthead or header art located across the top of your page is part of the look and feel of your website. It can influence a visitor’s opinion about your content and you/ your organization’s brand. It may also look different on different screen sizes., based on its User-Agent. Today that means Chromium 137 or newer.
  • wp_is_cross_origin_isolated_request() returns whether coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. isolated the current response, meaning wp_send_document_isolation_policy_header() (see below) sent the header. A header a pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. sends itself does not count.
  • wp_get_media_library_mode() returns grid or list using the same resolution as upload.php, without updating the saved user option.
  • wp_get_media_library_upload_settings() returns the settings the pipeline needs: maximum upload size, allowed mime types, the registered image sub-sizes, and the image processing settings described below.
  • wp_enqueue_media_frame_upload() and wp_enqueue_media_new_upload() enqueue the screen scripts. wp_enqueue_media() calls the first one, so most code never needs to.

The image processing settings pass through the same filters the server uses: big_image_size_threshold, image_strip_meta and image_max_bit_depth. A plugin that changes them affects client-side uploads too. Because the server never decodes the image on this path, image_max_bit_depth receives 16, the maximum the client encoder can produce, as both its value and the current depth.

Three scripts were added: media-upload-pipeline, which configures the @wordpress/upload-media store and exposes wp.mediaUploadPipeline, plus media-frame-upload and media-new-upload, which hand files added to the existing uploader to the pipeline. They are only enqueued when client-side media processing is enabled, the browser supports Document-Isolation-Policy and core isolated the request.

What still uses the classic upload

When client-side processing is turned off with the wp_client_side_media_processing_enabled filter, or the browser does not support it (Firefox and Safari today), uploads work as they did in 7.1 through async-upload.php. Some uploads stay on the classic path even in a supported browser:

  • Anything that is not an image the pipeline can process (JPEG, PNG, GIF, WebP, AVIF, HEIC/HEIF). Audio, video, PDF, SVG, JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. and archives upload through async-upload.php as before. So does an image whose type is not in the allowed mime types the page was rendered with, which leaves the decision to the server.
  • Uploaders that do not post attachments. Only uploaders using async-upload.php with the upload-attachment action are intercepted, so a plugin’s own wp.Uploader pointed elsewhere is left alone.
  • JPEG and PNG files while plupload resizing is enabled, through the “Scale images” setting or a resize value passed through plupload_init.
  • A HEIC file the browser cannot decode (Linux, and Windows without the HEVC extension), when the server’s image editor supports HEIC. When neither can convert it, the pipeline’s error is shown.
  • Screens core did not isolate: the CustomizerCustomizer Tool built into WordPress core that hooks into most modern themes. You can use it to preview and modify many of your site’s appearance settings., the Site Icon picker, the classic editor’s media modal, and any screen where a plugin sends its own Document-Isolation-Policy header.

Extra multipart params added through plupload_default_params or wp.Uploader.param() are forwarded to the REST request, so they still arrive in $_POST.

Multisitemultisite Used to describe a WordPress installation with a network of multiple blogs, grouped by sites. This installation type has shared users tables, and creates separate database tables for each blog (wp_posts becomes wp_0_posts). See also network, blog, site: sub-sizes count against the site’s upload space

On a multisite networknetwork (versus site, blog) with the “Site upload space” limit turned on, client-side media checks every file (including generated sub-sizes) against the site’s storage quota, not just the original.

On the classic path, only the original upload is checked (through check_upload_size() on wp_handle_upload_prefilter). The server then writes the sub-sizes straight to disk, so they never hit the quota check. With client-side media, each sub-size generated in the browser is a separate request to /wp/v2/media/{id}/sideload, and each one is checked for space left, the network’s maximum upload file size (fileupload_maxk) and the site quota.

In practice this only matters for a site that is close to its limit: the original fits, then some or all of the sub-sizes are rejected with rest_upload_limited_space or rest_upload_user_quota_exceeded.

When that happens:

  • If some sub-sizes fit, the image is saved with only those sizes. The missing sizes are not currently reported to the user.
  • If none fit, the upload fails: the attachment is deleted and the block resets. The error shown is the server’s message for the rejected sub-size, eg. “Not enough space to upload. 2 KB needed.”

Better handling for both cases is being worked on in #86834.

Note that networks with the upload space check disabled (the upload_space_check_disabled site option) are not affected.

A site that needs the old behavior can turn off client-side media processing:

add_filter( 'wp_client_side_media_processing_enabled', '__return_false' );

Sub-sizes in the attachment’s output format are allowed

Sideloaded sub-sizes also go through the network’s “Upload file types” setting (upload_filetypes). Networks created before 5.8 have no webp in that list and those created before 6.5 have no avif, so with a plugin filtering image_editor_output_format to either format, every sub-size was rejected and the upload failed.

In 7.2, the attachment’s output format is added to upload_filetypes for the duration of a sideload only, matching the classic path where the server writes sub-sizes in any output format. Other formats are still checked against the network setting, and a type removed through upload_mimes is still blocked. Single site is not affected.

Related: #66680, #66681, r65533.

Running the pipeline on a plugin’s own screen

The media frame integration only loads on a screen where wp_send_document_isolation_policy_header() sent the header. A Document-Isolation-Policy header a plugin sends itself does not count, so a page builder that isolates its editor for its own reasons keeps classic uploads in every wp.media frame on that screen, as in 7.1.

To opt a screen into the client-side pipeline, send the header through core before wp_enqueue_media() runs:

add_action( 'load-toplevel_page_my-plugin', function () {
	if ( wp_is_client_side_media_processing_enabled() ) {
		wp_send_document_isolation_policy_header();
	}
} );

The function returns false and sends nothing when headers were already sent or the browser does not support the header. Isolating a screen blocks same-origin access to iframes that are not isolated too, so test the screen before opting in.

The GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ plugin sends the header itself on the editor screens, so its media modal uses classic uploads until the site runs a Gutenberg release that includes #86542. Uploads made in the block editor itself are not affected.

Related: #66490, r65356, r65532.

What changes for upload hooksHooks In WordPress theme and development, hooks are functions that can be applied to an action or a Filter in WordPress. Actions are functions performed when a certain event occurs in WordPress. Filters allow you to modify certain functions. Arguments used to hook both filters and actions look the same.

Pipeline uploads go to the REST API (POST /wp/v2/media, then /sideload per sub-size and /finalize) instead of async-upload.php. Most upload hooks still run, but a few things differ:

  • Extra params added through plupload_default_params or wp.Uploader.param() are sent as POST fields, so they still arrive in $_POST and $_REQUEST. action, _wpnonce and post_id are not forwarded: the attachment’s parent is sent as post.
  • $_POST['action'] is not upload-attachment and DOING_AJAX is not defined. Code that detects media uploads that way will miss pipeline uploads; check for a REST request, or hook the upload filters directly.
  • The original file goes through wp_handle_upload(), so wp_handle_upload_prefilter and upload_mimes run as before. Sub-sizes generated in the browser go through wp_handle_sideload(), so they run wp_handle_sideload_prefilter.

Related: r64588, #12585, Gutenberg #82409.

The editor no longer rewrites crossorigin attributes

In 7.1 the editor page was buffered with ob_start() and rewritten with WP_HTML_Tag_Processor to add crossorigin="anonymous" to cross-origin scripts, stylesheets, audio and video, alongside the Document-Isolation-Policy: isolate-and-credentialless header. That caused two problems:

  • Running the tagtag A directory in Subversion. WordPress uses tags to store a single snapshot of a version (3.6, 3.6.1, etc.), the common convention of tags in version control systems. (Not to be confused with post tags.) processor inside an output buffer display handler could end in a fatal error and a blank screen on Chromium 137+ when the page loaded any cross-origin resource (#65930).
  • Forcing crossorigin="anonymous" turns a subresource load into a CORS request, which fails for any host that does not send Access-Control-Allow-Origin, such as media offloaded to a CDN (#65673).

With isolate-and-credentialless, cross-origin subresources load without credentials instead of being blocked, so the attribute was never needed. In testing with current Chromium builds, resources without the attribute loaded identically with and without the header.

What changed in 7.2

  • The new wp_send_document_isolation_policy_header() sends the header and returns whether it did. It returns false if headers were already sent or the browser does not support Document-Isolation-Policy.
  • wp_set_up_cross_origin_isolation() now returns that boolean instead of void.
  • The editor page is no longer buffered or rewritten, and wp_print_media_templates() no longer adds crossorigin="anonymous" to AUDIO and VIDEO tags in the media modal templates.
  • wp_start_cross_origin_isolation_output_buffer() and wp_add_crossorigin_attributes(), both added in 7.1, are deprecated. They still exist and trigger a deprecation notice. The first now only sends the header; the second returns the HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. unchanged, so calls can be removed.
// Before (7.1).
wp_start_cross_origin_isolation_output_buffer();

// After (7.2).
wp_send_document_isolation_policy_header();

What plugin and theme developers should check

  • Code that calls either deprecated function, or that parsed the editor output expecting crossorigin attributes, needs updating. Hooking or removing wp_set_up_cross_origin_isolation on the load-* actions keeps working.
  • Plugins that added their own crossorigin injection to make cross-origin media work in the editor can drop it. Under isolate-and-credentialless it is not required, and it breaks hosts without CORS headers.
  • To confirm isolation is active on a screen, check window.crossOriginIsolated in the browser console. In browsers without Document-Isolation-Policy support, such as Firefox and Safari, it is false and uploads use the server as before.
  • Safari support needs require-corp, which does need the attribute. The Client-Side Media Everywhere plugin keeps the injection for that case.
  • A response that has already sent headers before the load-* action fires cannot receive the policy header. Debug output or early echo calls in a plugin are the usual cause.

Related: r64489, #13446, Gutenberg #82614.

Animated image sub-sizes are generated by default

Resized versions of animated GIFs have always lost their animation, because both GD and Imagick flatten animated images when resizing #28474 (open since 2014). Server-side it stalled because GD cannot preserve frames at all, Imagick is only available on some hosts, and re-encoding every frame is costly on shared CPU.

Client-side media processing changes that. Decoding, scaling and encoding happen in the uploader’s browser, so every frame can be processed regardless of the host, and the cost is paid once by the uploader #65656.

What changed in 7.2

When client-side media processing is used, every sub-size of an animated GIF or WebP keeps its animation by default, including cropped sizes such as thumbnail, where each frame is cropped with the same rectangle. If an animation is too large to decode in the browser, the pipeline falls back to a static first-frame sub-size instead of failing the upload.

Server-side uploads still produce static sub-sizes. The change only affects the client-side path.

The wp_generate_animated_image_subsizes filter

The new filter takes a boolean and defaults to true. Returning false generates static first-frame sub-sizes, matching the server-side path, which keeps upload times down on low powered devices or sites that upload many large animations.

add_filter( 'wp_generate_animated_image_subsizes', '__return_false' );

The Disable Animated Sub-sizes plugin does exactly this, for sites that prefer not to add code.

The filtered value is exposed on the REST API index as generate_animated_image_subsizes, alongside image_size_threshold and image_max_bit_depth, for users who can upload_files. The Media Library screens receive the same value through wp_get_media_library_upload_settings().

What developers should check

  • Themes and plugins that assumed sub-sizes of an uploaded GIF or WebP are static first frames may now receive animated files, which are larger than a still frame.
  • wp_calculate_image_srcset() still declines to mix a full-size animated GIF with its sub-sizes in one srcset. With animated sub-sizes that guard is more conservative than it needs to be but harmless. Relaxing it is a possible follow-up.
  • The client-side code ships through the Gutenberg package sync (Gutenberg #80385), so the filter and the REST field are the core-side surface.

Related: r64490, #12572, #28474.

Unattached images are auto-attached to posts when saved in the block editor

In the classic editor, images are auto-attached to a post as soon as a user picks them from the Media Library. This feature has been a gap in the block editor, where only images uploaded to a post were auto-attached. In WordPress 7.2 when a post is saved in the block editor, unattached images are auto-attached. This occurs later in the process than in the classic editor, so that an image added and then removed is not auto-attached.

Some details:

  • This only runs on a successful manual save or publish of a post or page
  • Only counts Image blocks (including within Galleries), and skips if there are more than 100 images to check
  • Images already attached to another post or page are ignored
  • Once a post is published, only images added since the last save are attached, so as not to unintentionally re-attach images that have been detached from a post
  • Images in templates, template parts, and synced patterns are not affected
  • This behaviour is editor-only as it’s part of a UXUX User experience workflow, so posts saved via REST API, WP-CLIWP-CLI WP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/ https://make.wordpress.org/cli/ etc are not affected

The feature is automatically disabled for sites with attachment pages enabled (the wp_attachment_pages_enabled option). On such sites, changing the attachment parent changes the attachment’s URLURL A specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org resulting in a 404 for the old URL, so the feature defaults to false.

For sites or plugins that wish to switch this feature on or off, the editor setting autoAttachMediaEnabled controls the behaviour. To turn it off, use the block_editor_settings_all filter:

add_filter( 'block_editor_settings_all', static function ( array $settings ): array {
    $settings['autoAttachMediaEnabled'] = false;
    return $settings;
} );

A site with attachment pages enabled can switch the feature on by setting the value above to true.

References

#7-2, #client-side-media, #dev-notes, #dev-notes-7-2, #media, #media-library

Adam Silverstein Core ·

REST API changes in WordPress 7.2

WordPress 7.2 includes three REST APIREST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/ changes. The first two change response and parameter shapes that existing code may depend on.

In short:

  • Revision and autosave responses no longer include metaMeta Meta is a term that refers to the inside workings of a group. For us, this is the team that works on internal WordPress sites like WordCamp Central and Make WordPress. keys that are not revisioned. Plugins that write meta onto revisionsRevisions The WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision. directly need to register those keys with revisions_enabled or add them with the wp_post_revision_meta_keys filterFilter Filters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output..
  • The comments endpoint’s status parameter is now an array. Code that compared $request['status'] to a string needs updating.
  • The new rest_allowed_cors_methods filter controls the Access-Control-Allow-Methods headerHeader The header of your site is typically the first thing people will experience. The masthead or header art located across the top of your page is part of the look and feel of your website. It can influence a visitor’s opinion about your content and you/ your organization’s brand. It may also look different on different screen sizes., and a value set on a REST response is no longer discarded.

Revision and autosave responses only include revisioned meta

Visual Revisions in the blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. editor (new in 7.0) restores a revision by reading it from the REST API and saving its meta onto the post. Before 7.2, WP_REST_Revisions_Controller returned every show_in_rest meta key registered for the parent post type, read from the revision ID. Only revisioned keys are stored on a revision, so every other key came back as its registered default, or null when the default did not pass the key’s schema, and the restore wrote those values over the post’s real meta.

The visible effects were:

  • Restoring an unsynced pattern sent null for wp_pattern_sync_status, which deleted the status and made the pattern synced.
  • Restoring a synced pattern failed with a rest_invalid_stored_value error after the content had already been saved.
  • On other post types, non-revisioned show_in_rest keys were silently reset.

The classic revisions screen was never affected, because wp_restore_post_revision() only restores the keys from wp_post_revision_meta_keys(). The editor cannot tell which keys are revisioned, since revisions_enabled is not exposed over REST, so the fix had to happen in the endpoint (#66329).

What changed in 7.2

The new WP_REST_Revision_Meta_Fields class, a subclass of WP_REST_Post_Meta_Fields, limits a revision’s meta response and schema to the keys returned by wp_post_revision_meta_keys() for the parent post type. WP_REST_Revisions_Controller uses it for its $meta property. Keys registered with a custom show_in_rest name are handled the same way.

  • Autosave responses follow the same rules, because the revisions controller prepares them. Autosave requests are still validated against the parent post type’s meta schema, but only revisioned keys are stored, and only on an autosave revision. An author’s autosave of their own draft doesn’t store the meta it receives.
  • When an author autosaves their own draft, the autosaves controller updates the post itself and returns it instead of an autosave. That response still includes all of the post’s meta.
  • Anything returned by the wp_post_revision_meta_keys filter that is not a string is ignored.

What pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. developers should check

A meta key is revisioned when it is registered with revisions_enabled set to true, or when it is added with the wp_post_revision_meta_keys filter.

register_post_meta(
	'post',
	'my_meta',
	array(
		'show_in_rest'      => true,
		'single'            => true,
		'type'              => 'string',
		'revisions_enabled' => true,
	)
);

For meta registered elsewhere, or by code that cannot be changed, use the filter:

add_filter(
	'wp_post_revision_meta_keys',
	static function ( array $keys ): array {
		$keys[] = 'my_meta';
		return $keys;
	}
);
  • Plugins that write meta onto revisions directly, without either of the above, will no longer see those keys in REST revision and autosave responses. Adding the key to wp_post_revision_meta_keys brings it back, and also makes the key part of what the classic screen restores, so confirm that is wanted.
  • Clients that read revision meta over REST should expect non-revisioned keys to be absent rather than present with a default value. The meta schema for revisions shrinks to match.
  • When a post type has no revisioned meta, a revision’s meta is now an empty JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. array ([]) instead of an object holding each key’s default. JavaScriptJavaScript JavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com clients that read revision.meta.some_key get undefined either way, but code that checks the type of meta, or a PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher client that decodes it, will see an array.
  • Visual Revisions restores meta through the REST API, so a revisioned key also needs show_in_rest to be restored from the block editor. The classic revisions screen restores it either way (Gutenberg #85549).
  • Code that inspects the controller’s $meta property now finds a WP_REST_Revision_Meta_Fields instance. It still extends WP_REST_Post_Meta_Fields.

Sites running the GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ plugin on WordPress 7.0 and 7.1 get the same filtering from a compat change in Gutenberg (#85509), but the meta schema isn’t changed.

Related: r64731, #14359, Gutenberg #84809.

The comments endpoint accepts multiple statuses

The comments collection endpoint (/wp/v2/comments) now accepts several statuses in one request. WP_Comment_Query has always supported an array of statuses, but the endpoint only accepted a single string, so clients that needed comments in more than one status had to make a request for each (#63982).

/wp/v2/comments?status=approve,hold
/wp/v2/comments?status[]=approve&status[]=hold

Single status requests work as before, and so does the all status. The permission check is unchanged: users without the edit_posts capabilitycapability A capability is permission to perform one or more types of task. Checking if a user has a capability is performed by the current_user_can function. Each user of a WordPress site might have some permissions but not others, depending on their role. For example, users who have the Author role usually have permission to edit their own posts (the “edit_posts” capability), but not permission to edit other users’ posts (the “edit_others_posts” capability)., including unauthenticated requests, may only use the default approve status. Anything else, including a list that contains approve, is rejected with rest_forbidden_param.

What changed in 7.2

  • The status collection parameter is now an array of strings with a default of array( 'approve' ), and the route’s argument schema says so.
  • The new WP_REST_Comments_Controller::sanitize_comment_statuses() accepts a string, a comma-separated list or an array. It sanitizes each value with sanitize_key, removes duplicates and drops empty values. A literal 0 is kept, because held comments are stored with a comment_approved value of 0.
  • No enum of allowed values was added. WP_Comment_Query supports custom comment statuses, so an enum would have broken existing requests.

What plugin developers should check

After sanitization, $request['status'] is always an array, and so is status in the arguments passed to the rest_comment_query filter. Code that compared it to a string will no longer match:

// Before: only matches in 7.1 and earlier.
if ( 'hold' === $request['status'] ) {
	// ...
}

// After: works in 7.1 and in 7.2.
if ( in_array( 'hold', (array) $request['status'], true ) ) {
	// ...
}

Clients and tools that read the route’s argument schema will see status as an array rather than a string.

Related: r64494, #9870, Gutenberg #71271.

New rest_allowed_cors_methods filter

WordPress 7.2 adds a rest_allowed_cors_methods filter for the Access-Control-Allow-Methods header that the REST API sends with cross-origin (CORS) requests. It also stops discarding an Access-Control-Allow-Methods value set on a REST response (#46992).

The problem

When a request carries an Origin header, rest_send_cors_headers() sent a hardcoded list of methods: OPTIONS, GET, POST, PUT, PATCH, DELETE. The only ways to change it were to unhook rest_send_cors_headers() and re-implement it, or to call header() at a later priority. Both are fragile, and two plugins doing it will conflictconflict A conflict occurs when a patch changes code that was modified after the patch was created. These patches are considered stale, and will require a refresh of the changes before it can be applied, or the conflicts will need to be resolved..

Setting the header on the response through rest_post_dispatch did not work either. rest_send_cors_headers() runs after the response’s own headers have been sent, and replaced whatever value the response set.

The two sibling CORS headers have had filters since 5.5: rest_exposed_cors_headers for Access-Control-Expose-Headers and rest_allowed_cors_headers for Access-Control-Allow-Headers. This filter fills in the third.

The new filter

rest_allowed_cors_methods follows the same shape as its siblings. It receives the list of methods as an array, along with the request in context, and the result is joined into the header. The request is null when rest_send_cors_headers() is called directly rather than while serving a REST request.

/**
 * @param string[]             $allow_methods The list of HTTP methods to allow.
 * @param WP_REST_Request|null $request       The request in context, if available.
 */
apply_filters( 'rest_allowed_cors_methods', $allow_methods, $request );

Callbacks should return an array, though coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. also accepts a comma-separated string such as 'OPTIONS, GET'. Because callbacks run in a chain, a callback can receive a string returned by an earlier one, so avoid an array type hint on $methods and normalize the value with wp_parse_list() before changing it.

Advertise an extra method, for example for a route that accepts PROPFIND:

add_filter(
	'rest_allowed_cors_methods',
	static function ( $methods ): array {
		$methods   = wp_parse_list( $methods );
		$methods[] = 'PROPFIND';
		return $methods;
	}
);

Narrow the list for cross-origin requests to a read-only namespace:

add_filter(
	'rest_allowed_cors_methods',
	static function ( $methods, ?WP_REST_Request $request ) {
		if ( $request && str_starts_with( $request->get_route(), '/my-plugin/v1/public' ) ) {
			return array( 'OPTIONS', 'GET' );
		}
		return $methods;
	},
	10,
	2
);

This is not a permission check. Access-Control-Allow-Methods only affects the preflight requests browsers send for some cross-origin requests. Simple cross-origin requests, such as a POST with a form content type, are not preflighted, and non-browser clients ignore the header. Use permission_callback on the route to restrict who can do what.

Returning an empty array omits the header entirely. Entries that are not valid HTTPHTTP HTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. method tokens are dropped, an array entry such as 'GET, POST' is split into its methods, and a callback that returns something other than an array or a string is ignored in favor of the unfiltered list.

Response values are no longer discarded

If a response sets its own Access-Control-Allow-Methods header, for example from rest_post_dispatch, that value is now the starting list passed to the filter instead of being overwritten by the default:

add_filter(
	'rest_post_dispatch',
	static function ( WP_HTTP_Response $response ): WP_HTTP_Response {
		$response->header( 'Access-Control-Allow-Methods', 'OPTIONS, GET' );
		return $response;
	}
);

The filter still runs after that, so a site always has the last word. If the response value names no valid methods, the default list is used. With ?_envelope=1, the response’s headers are moved into the body before rest_send_cors_headers() runs, so a value set on the response is not seen and the filtered default is sent.

Backward compatibility

The default output is unchanged. A site that neither sets the header on a response nor uses the filter sends the same OPTIONS, GET, POST, PUT, PATCH, DELETE list as before.

rest_send_cors_headers() gains three optional parameters, $result, $request and $server, and is now hooked to rest_pre_serve_request with four accepted arguments. Existing calls with a single argument keep working, and remove_filter( 'rest_pre_serve_request', 'rest_send_cors_headers' ) still removes it, since the priority is unchanged at 10. When serving a REST request, the CORS headers are now sent through WP_REST_Server::send_header() rather than a direct header() call.

Related: r64730, #13151, #57752 (the sibling filters gained the $request parameter in 6.3).

#7-2, #dev-notes, #dev-notes-7-2, #rest-api

Aditya Dhade Core ·

Performance Chat Summary: 17 November 2026

The full chat log is available beginning here on Slack.

WordPress Performance TracTrac An open source project by Edgewall Software that serves as a bug tracker and project management tool for WordPress. tickets

  • @westonruter said the 7.2 milestone is basically over and shared the 7.2 performance tickets and the 7.3 performance tickets. After the 7.2-RC1 release activities, he believes trunktrunk A directory in Subversion containing the latest development code in preparation for the next major release cycle. If you are running “trunk”, then you are on the latest revision. would soon be open for 7.3 work.
  • @westonruter pointed to #66642 as an interesting performance improvement recently added to the 7.3 milestone. Based on brief review iterations, he thought it seemed like a good direction.
  • @westonruter said minifying stylesheets for classic themes in CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. #64109 is mostly there. The work was a bit tedious, though tooling had made it easier.
  • @westonruter said both tickets had been marked high priority.

Performance Lab PluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. (and other performance plugins)

  • @westonruter said the plugins would need their “Tested up to” bumps soon and said Modern Image Formats was the only plugin at the moment with a relevant merged change to release.
    • @b1ink0 asked to resolve issue #2662 so Modern Image Formats would be ready for client-side media processing in the Media Library with WordPress 7.2 release.
    • @westonruter added issue #2662 to the upcoming milestone.

Our next chat will be held on Tuesday, December 1, 2026 at 16:00 UTC in the #core-performance channel in Slack.

#core-performance, #hosting, #performance, #performance-chat, #summary

Bijay Yadav Team Updates ·

Themes team update November 17, 2026

i)  Theme directory stats

Currently,

  • 124 new tickets are waiting for review.
    • 0 tickets are older than 4 weeks
    • 0 tickets are older than 2 weeks
    • 27 tickets are older than 1 week
    • 73 tickets are older than 3 days
  • 115 tickets are assigned.
    • 24 tickets are older than 4 weeks
    • 69 tickets are older than 2 weeks
    • 107 tickets are older than 1 week
    • 114 tickets are older than 3 days
  • 35 new themes are approved but are waiting to be made live.
  • 20 theme updates are approved but are waiting to be made live.

In the past 7 days,

  • 1066 tickets were opened
  • 1150 tickets were closed
    • 1043 tickets were made live.
      • 36 new Themes were made live.
      • 1007 Theme updates were made live.
      • 28 new themes was approved but are waiting to be made live.
      • 20 theme updates are approved but are waiting to be made live.
    • 107 tickets were not approved.
    • 0 tickets were closed-newer-version-uploaded.

Note: These stats include both the new theme tickets and updated theme tickets as well. And data from themes trac.

Number of reviewers: 16 (@acosmin,@benlumia007, @bijayyadav, @bikram_sth, @dineshksharma1994, @fahimmurshed, @franchidesign, @jqueryacrobatics, @kafleg, @luzuk, @maheshbohara, @markcbain, @martatorre, @nitspatel, @productiveminds, @vowelweb)

ii)  BlockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. Theme Stats

  • 104 Block themes are currently being reviewed
  • 21 block themes have been live for the last 7 days

iii) HelpScout Stats

In the past 7 days,

Email Conversations 23Messages Received 20
Replies Sent 13Emails Created 8
Resolved 13Resolved on First Reply 100%

iv) Extras

  • Create Block Theme pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. now has 20000+ active installs. There are 106 active issues and 33 pull requests in GitHub.
  • Theme Check Plugin has 13 PRs and 40 issues.

Co-written by @kafleg

#themes, #weekly-updates

luisherranz Core ·

Changes to the Interactivity API in WordPress 7.2

WordPress 7.2 brings three main changes to the Interactivity APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.. There’s a new data-wp-html directive to render HTMLHTML HyperText Markup Language. The semantic scripting language primarily used for outputting content in web browsers. from the store, the router now tells you when a navigation is in progress and who started it, and three behaviors that were deprecated in previous versions have been removed.

New data-wp-html directive

data-wp-text sets the text of an element, but until now there was no equivalent for HTML. If a value in your store contained a description with links or some formatting, data-wp-text showed the markup as text, and the only alternative was to set innerHTML yourself from a data-wp-watch callback, outside of the Interactivity API rendering. That worked, but those changes could be overwritten by client-side navigation.

WordPress 7.2 adds the data-wp-html directive to fill that gap. It sets the inner HTML of an element, but only from values created with the new asDangerousHTML() function.

import { asDangerousHTML, store } from '@wordpress/interactivity';

const { state } = store( 'myPlugin', {
	actions: {
		*loadPreview() {
			const response = yield fetch( state.previewUrl );
			const html = yield response.text();
			state.preview = asDangerousHTML( html );
		},
	},
} );
<div data-wp-interactive="myPlugin">
	<button data-wp-on--click="actions.loadPreview">Show preview</button>
	<div data-wp-html="state.preview"></div>
</div>

Why asDangerousHTML()?

Rendering arbitrary HTML is a security concern, so data-wp-html never renders a plain string, by design. Values in the page’s markup, like the ones in data-wp-context, can come from content that your pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. doesn’t fully control, and a string that ends up in the wrong place must not become HTML on the page. So the directive only renders values that your plugin’s JavaScriptJavaScript JavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com explicitly marked as trusted.

Keep in mind that asDangerousHTML() doesn’t sanitize anything. It’s the same responsibility that you take on when you use dangerouslySetInnerHTML in ReactReact React is a JavaScript library that makes it easy to reason about, construct, and maintain stateless and stateful user interfaces. https://reactjs.org. Passing untrusted input to it is an XSS risk, so never pass it raw user input, and never pass it a value read from context. The rule to follow is “context selects, state supplies”. Use context to choose which trusted HTML to show (an ID, or a flag), and build the HTML itself in state, from a source your plugin trusts.

The value that asDangerousHTML() returns is opaque, and it’s trusted because of its identity, not its content. If you copy it into data-wp-context, spread it into a new object or serialize it as JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML., the copy is not trusted anymore.

Which values render

The element follows the value of its reference.

  • A value returned by asDangerousHTML() renders its HTML.
  • null, undefined, or a path that doesn’t exist empty the element.
  • Anything else, including plain strings, empties the element and shows a warning in development mode (when SCRIPT_DEBUG is enabled).

There are two exceptions that keep the server-rendered content in place, which are explained in the server section below.

The content is inert to the Interactivity API

The content of a data-wp-html element is inert to the Interactivity API. The server doesn’t process the directives inside it, and in the browser they don’t run, the interactive regions inside it aren’t hydrated, and the router ignores the router regions inside it. This applies to the HTML inserted with asDangerousHTML() and also to the content that the element already had when the page loaded.

But “inert” only means inert to the Interactivity API. The content is still live HTML for the browser, so content that isn’t safe to render as HTML isn’t made safe by going through data-wp-html.

The directive can’t be combined with data-wp-text, data-wp-each or data-wp-router-region on the same element, because all of them want to own the content of the element. If you combine them, data-wp-html is ignored and you’ll see a warning in development mode.

Trusted Types

If your site enforces Trusted Types, asDangerousHTML() also accepts a TrustedHTML value created by your own policy, like asDangerousHTML( policy.createHTML( html ) ). The package doesn’t create a policy of its own. If the browser rejects a value, the element is emptied and you’ll see a warning in development mode.

Server-side rendering

The directive works on the server too. In PHPPHP The web scripting language in which WordPress is primarily architected. WordPress requires PHP 7.4 or higher, mark the HTML as trusted with the new wp_interactivity_as_dangerous_html() function, and the server renders it inside the element during directive processing.

<?php
wp_interactivity_state(
	'myPlugin',
	array( 'preview' => wp_interactivity_as_dangerous_html( $html ) )
);
?>
<div data-wp-interactive="myPlugin">
	<div data-wp-html="state.preview"></div>
</div>

wp_interactivity_as_dangerous_html() doesn’t sanitize the HTML. In the cases where the browser shows a warning, the server triggers a _doing_it_wrong() notice.

The HTML is not included in the data that the server sends to the client. In its place, the server prints { "wpServerHtml": true }. When the client sees that value, it keeps the server-rendered content in place until the value changes, for example when your store sets a new asDangerousHTML() value.

Server-rendered content is also preserved when a derived state property is defined as a closure in PHP and its JavaScript getter hasn’t been registered yet. This keeps the content visible while the client-side module loads. Once the getter is available, data-wp-html follows its value using the rules described above.

See #83092, #84652, #84889, #84919 and #66246 for more details.

Props to @theaminuldev for the initial implementation, and to @darerodz, @santosguillamot and @luisherranz for the follow-ups and the server-side implementation.

Tracking client-side navigations

The WordPress 7.0 dev note deprecated state.navigation.hasStarted and state.navigation.hasFinished from the core/router store, and announced an official way to track navigations. That mechanism is now available in WordPress 7.2.

The core/router store has two new properties.

  • state.navigating is truthy while a client-side navigation is in progress.
  • state.initiator identifies who started the navigation. By default, it’s the ID of the closest router region that contains the element whose directive called actions.navigate(), or null when nobody identifiable started it, like in a back or forward navigation.

With them, a blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. can show its own loading indicator only when the navigation started inside it, which wasn’t possible before without workarounds. This is how it looks.

import { store } from '@wordpress/interactivity';

const { state: routerState } = store( 'core/router' );

store( 'myPlugin', {
	state: {
		get isLoading() {
			return (
				!! routerState.navigating &&
				routerState.initiator === 'myPlugin/quote'
			);
		},
	},
} );
<div data-wp-interactive="myPlugin" data-wp-router-region="myPlugin/quote">
	<span data-wp-class--is-loading="state.isLoading"></span>
	<!-- ... -->
</div>

You can also set the initiator yourself with the new initiator option of actions.navigate(). A string is used as it is, and null leaves the navigation without initiator.

yield actions.navigate( url, { initiator: 'myPlugin/cart' } );

There are a few things to keep in mind.

  • Both properties are undefined until the first client-side navigation, and on pages where the router never loads. So check them by truthiness (if ( state.navigating )) instead of comparing them with false or null.
  • state.navigating becomes false on a later frame than the one where the new content is added to the DOM, so a watcher that reacts to the end of the navigation sees the new page. Note that the promise returned by actions.navigate() resolves before that.
  • state.initiator is not cleared when the navigation ends. It keeps its value until the next navigation starts, so a watcher that reacts to the end can still know who started it.
  • They’re updated in every client-side navigation, including back and forward navigations served from the router’s cache. actions.prefetch() doesn’t count as a navigation.

state.navigation still works in WordPress 7.2, but it’s still deprecated and it will stop working in a future version. If you’re using state.navigation.hasStarted, you can replace it with state.navigating. There’s one difference, though. hasStarted was made for the loading bar, so it only became true after 400 milliseconds, and only when the loadingAnimation option was enabled. state.navigating is updated immediately, so if you don’t want to show a loading indicator on fast navigations, you’ll need to add that delay yourself.

You can find more examples, like how to move the focus after a navigation that started in a specific region, in the client-side navigation guide.

See #83280 for more details.

Props to @luisherranz for the implementation, and to @darerodz and @fabiankaegy for the reviews.

Removal of expired deprecations

Three behaviors that were deprecated in previous versions don’t work anymore in WordPress 7.2. If your blocks, plugins or themes use any of them, you’ll need to update your markup and stores.

Unique IDs with two hyphens

Unique IDs let you add several directives of the same type to the same element, and they are written after three hyphens, like data-wp-watch---id. Until now, the runtime also accepted two hyphens (data-wp-watch--id) with a deprecation warning. That form is not a unique ID anymore, and what happens now depends on the directive.

  • data-wp-watch, data-wp-init and data-wp-run don’t support suffixes, so the directive is skipped and its callback never runs. You’ll see a warning in development mode.
  • data-wp-on, data-wp-on-window and data-wp-on-document use the whole text after -- as the event name. So data-wp-on--click--counter now listens for an event called click--counter, and a click doesn’t run it. You’ll see a warning in development mode, but in production the handler just stops responding.

The deprecated data-wp-on-async directives are not affected by this change.

To migrate, add the missing hyphen.

<!-- Before -->
<div
	data-wp-init--setup="callbacks.setup"
	data-wp-watch--log="callbacks.log"
></div>
<button data-wp-on--click--counter="actions.count">Count</button>

<!-- After -->
<div
	data-wp-init---setup="callbacks.setup"
	data-wp-watch---log="callbacks.log"
></div>
<button data-wp-on--click---counter="actions.count">Count</button>

Since the event directives fail silently in production, it’s worth searching your code for them instead of waiting for a warning. These commands, run from the root of your project, should find most of the cases.

# Lifecycle directives with a suffix.
grep -rnE 'data-wp-(watch|init|run)--[^-]' .

# Event directives with a unique ID after two hyphens.
grep -rnE 'data-wp-on(-window|-document)?--[^ "=]*[^- "=]--[^-]' .

Negating a function

Until now, a directive value that started with ! and pointed to a function, like !actions.isEmpty, called the function and negated its result, with a deprecation warning. Now the function is not called, the value is undefined, and you’ll see a warning in development mode.

The solution is to use derived state, which you can negate as before.

const { state } = store( 'myPlugin', {
	state: {
		items: [],
		get isEmpty() {
			return state.items.length === 0;
		},
	},
} );
<div data-wp-interactive="myPlugin">
	<p data-wp-bind--hidden="!state.isEmpty">The list is empty.</p>
</div>

data-wp-ignore

The data-wp-ignore directive has been removed. An element with this attribute is now hydrated like any other element, so the directives inside it run, and you’ll see a warning in development mode. Please remove the attribute.

See #84098 for more details.

Props to @luisherranz for the implementation and to @darerodz for the review.

#7-2, #dev-notes, #dev-notes-7-2, #interactivity-api

leemon

I notice that @wordpress/dom provides a safeHTML() function for sanitizing HTML, but it cannot be imported or used inside a script module such as view.js.

How should I safely sanitize HTML strings before rendering them via the Interactivity API’s

data-wp-html

directive?

Thanks

Reply

Gaurav Tiwari

Hey @leemon, wp-scripts blocks every @wordpress/* package inside script modules except interactivity, interactivity-router and a11y. That’s why you can’t pull in @wordpress/dom from view.js.

Two ways I’d handle it:

1. Sanitize on the server. If the HTML comes from your own REST endpoint, run it through wp_kses_post() (or wp_kses() with a tighter allowlist) before returning it. Then just wrap the response in asDangerousHTML() on the client. This also fits the “context selects, state supplies” rule from the post. I’d go with this one.

2. Use DOMPurify in view.js. It’s a normal npm package, so wp-scripts bundles it with your module and doesn’t throw.

import DOMPurify from 'dompurify';
state.preview = asDangerousHTML( DOMPurify.sanitize( html ) );

Running Trusted Types? Pass RETURN_TRUSTED_TYPE: true and you get TrustedHTML back, which asDangerousHTML() accepts. Just allow the dompurify policy in your CSP, or pass TRUSTED_TYPES_POLICY: null and wrap it in your own policy.

Also, safeHTML() works by removing known bad stuff (scripts, on* handlers, javascript: URLs). For HTML you don’t control, I’d rather use an allowlist like wp_kses or DOMPurify.

And remember, asDangerousHTML() doesn’t clean anything. It only tells the directive “I already checked this.”

Reply

Milana Cap Team Updates ·

Documentation Team Update – November 17, 2026

New schema for docs meetings:

Documentation Issue Tracker stats.

Current state

By status:

By version:

By project:

Past month

2 pull requests merged.

24 issues closed.

28 issues were created.

Current projects:

The Documentation team repositories:

#docs

Muhibul Haque Training ·

Meeting Agenda for November 17th, 2026

This week’s meeting will be held on Tuesday, November 17th, 2026, at 07:00 UTC. The meeting will take place on SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ in the #training channel. Anyone is welcome to contribute by commenting in Slack threads during the meeting and throughout the following days.

We’ll publish the meeting notes by the following Tuesday to incorporate these asynchronous conversations as well.

This week’s meeting will be hosted by @devmuhib009.

1. Intro/Welcome

  • Welcome to all the new teammates who joined the Training Team this week!
  • Icebreaker: If you could teach one WordPress skill to 1,000 students, what would it be?

2. Contributor Updates

  • What have you been working on, and how has it been going?
  • Anything you’ve accomplished since the last meeting?
  • Do you have any blockers?
  • Can other contributors or Training Team members help you in some way?

3. Open Discussions

If you have topics you’d like discussed in the meeting, please leave them as a comment on this post.

  • Have you tried the new AI course created on the Learn platform?
    • AI-Powered WordPress
    • Have you tried to complete the course or just had a quick look at the content? What do you think about it?
    • If you already have experience working with AI in WordPress, can you help us with Feedback – Free AI APIs on AI Powered WordPress Course?
    • We want to provide the best possible AI experience for everyone interested in working with AI in WordPress, including those who aren’t ready to pay for commercial models and agents.

4. News

1. Meeting Note Takers

  • 17th November: @Harshjadav08
  • 24th November: @UpekaR
  • 1st December: @miyanialkesh7
  • 8th December: Looking for a volunteer
  • 15th December: Looking for a volunteer

2. Looking for Feedback

We are proposing a community-driven review of the Learn WordPress Learning Pathways (User, Developer, and Designer) to identify outdated content and gather improvement suggestions from experienced WordPress users and contributors.

Check out this post for details.

3. Looking for Volunteers

Translation Review Volunteers

We have many lessons translated into different languages, but we need volunteers to review them and share their feedback on translation quality and possible improvements.

Join us on GitHub, find a language you speak and understand, and help us with the review process.

We don’t want these translated lessons and courses to remain unnoticed in GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/!

Content Review Volunteers

We need volunteers to review and identify content that should be updated or consolidated. We are looking for two groups: one for the handbook and another for courses.

Lesson Thumbnails

Work has started on creating thumbnails for lessons that need them. Team members are welcome to contribute to the remaining thumbnails through GitHub Issue #3428.

Issue Cleanup

The team is working toward organizing the many open issues into smaller categories and reviewing them systematically.

  • Review Workflow: Review issues one by one, identify outdated or irrelevant items, suggest next steps, and add comments before closing or updating issues.
  • Good First Issues: Contributors can start with issues labeled Good First Issue, especially those related to content feedback. Please follow the handbook guide for validating feedback.
  • Issue Categories: Bug issues have been suggested as a priority. Other categories include Needs Translation Reviewer, Unlabeled, Awaiting Triage, and Content Feedback.
  • Next Steps: Team members are encouraged to suggest which categoryCategory The ‘category’ taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging. should be reviewed first. Issues can then be divided among contributors.

Our goal is to work together to clean up and keep the repository organized.

4. Updates from Last Week’s Triage Squad Session

  • No Triage Squad meetings last week.

5. Other Announcements and News

5. Come and Contribute

Content ready for review

See the Guidelines for reviewing content when reviewing content.

  • We have 9 issues ready for review.

Feedback awaiting validation

See Validating and Applying Content Feedback for step-by-step guidance on validating feedback.

  • We have 37 issues that require validation.

Topics awaiting vetting

See Vetting Topic Ideas for step-by-step guidance on vetting topic ideas.

  • We have 2 issues that require vetting.

Validated feedback awaiting fix

Contributors, see Validating and Applying Content Feedback for guidance on applying feedback that has been validated.

  • We have 27 issues awaiting a fix.

6. Contribution Acknowledgement

Badges awarded:

Congratulations, and thank you for your contributions!

7. Project Updates

  • Training Team Blog Homepage: @chekle has redesigned the homepage of our Training Team blog! Congratulations to him on the great work. We’d love to hear your thoughts and feedback. Please share them in GitHub Issue #3674.
  • WordPress Credits Milestone: WordPress Credits has reached over 50 institutions worldwide in just one year! A big shoutout to all the organizers, mentors, and students who made this possible. Read more about this milestone.

8. Upcoming Online Workshops

  • No workshop scheduled.

You can see all meetings scheduled on this meeting calendar. If you are new to the Training Team, come walk through our onboarding program to learn more about the team and how we work.

If you have any questions, feel free to reach out in the #training Slack channel at any time.

Vasantsinh Rajput Training ·

Training Team Meeting Recap – 10th November 2026


This meeting followed this meeting agenda in GitHub #3740, Meeting agenda Post. You can see conversations from the meeting in this Slack Log. (If you don’t have a SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ account, you can set one up.)

Introductions and Welcome

There were 14 attendees: @dilip2615, @rjekic, @atik0130961, @mrinal013, @VasantRajput, @andrewssanya, @gohelkunjan, @sumitsingh, @pravin1996, @makanikaran, @sibokul, @mebo (async), @upekar99 (async), @jenish1234 (async), @jagirbahesh (async)

Newcomers: @jarmada, @rarcemunoz, @jbarquero90228

Meeting hosted by: @rjekic

Note Taker: @gohelkunjan @VasantRajput

Note Reviewer: @VasantRajput

Welcome! Please post in the #training channel or reach out to a team member to help you with contributing. Resources to check out our onboarding program, and our Guide Program.

Contributor Updates

  • What have you been working on, and how has it been going?
  • Anything you’ve accomplished since the last meeting?
  • Do you have any blockers?
  • Can other contributors or Training Team members help you in some way?
    • @snehal5774: I recently completed the Advanced WordPress User course and noticed that the “Continue to next lesson” option is available even before completing the quiz. This can be a little misleading, as in other courses, the option becomes available only after the quiz has been completed.
      It would be helpful if the course followed the same flow to ensure learners complete the quiz before moving on to the next lesson.
    • @rjekic: Thank you for pointing this out! Yes, I also find this a bit odd, but it is the default behaviour – that is, by design. We do not force users to finish the content or pass the course with the predefined percentage (for instance, 70%), but maybe it is time to consider the course design.

Open Discussions

  • If you have topics you’d like discussed in the meeting, please leave them as a comment on this post.
    • Have you tried new AI course created on the Learn platform?
      • This is one of the new AI-related courses created on our Learn platform: https://learn.wordpress.org/course/ai-powered-wordpress/
      • Have you tried to finish the course or just get a quick glimpse of the content? What do you think about it?
        • @atik0130961: I’ve recently started the AI-Powered WordPress course on Learn WordPress. I haven’t completed it yet, but I’ve started exploring the lessons.
          • @rjekic: Great! What do you think about the course? Is it easy to follow for someone without previous AI experience?
          • @atik0130961: So far, the course seems easy to follow. I hope the upcoming lessons will be just as easy to understand.
      • If you already have experience working with AI in WordPress, can you help us with this issue: Feedback – free AI APIs on AI Powered WordPress course #3686. We would like to give the best possible AI experience for all the people eager to work with AI in WordPress, but still not ready to pay for the commercial models and agents.

News

  1. Meeting Note Takers
  2. Looking for feedback
  3. Looking for volunteers
    • Translation Review Volunteers: We have a lot of lessons translated into many beautiful languages, but we need someone to review them and give us their opinion about the translation quality and possible improvements. Join us on GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/ by following this link: https://github.com/WordPress/Learn/issues?q=is%3Aissue+state%3Aopen+project%3AWordPress%2F104. Find the language you speak and know, and help us in the review phase. We do not want to leave all those translated lessons and courses in GitHub oblivion…
      • This is the area where we need help the most. Everyday we are getting more and more translations that need to be reviewed and approved before going live.
    • Content Review Volunteers: Volunteers are needed to review and identify content that should be updated or consolidated. Two groups are needed: one for the handbook and one for courses.
    • Lesson Thumbnails: Work has started on creating thumbnails for lessons that need them. Team members are welcome to contribute to the remaining thumbnails through GitHub Issue #3428.
    • Issue Cleanup: The team discussed organising the many open issues into smaller categories and reviewing them systematically.
      • Review Workflow: The proposed process is to review issues one by one, identify outdated or irrelevant items, suggest next steps, and add comments before closing or updating issues.
        • Good First Issues: Contributors can start with issues labeled Good First Issue, especially those related to content feedback, and follow the handbook guide for validating feedback.
        • Issue Categories: The team discussed starting with a specific categoryCategory The ‘category’ taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging., with Bug issues suggested as a priority. Other options include Needs Translation Reviewer, Unlabeled, Awaiting Triage, and Content Feedback.
        • Next Steps: Team members are encouraged to suggest which category should be reviewed first, after which the issues can be divided among contributors.
      • Goal: Work together to clean up and keep the repository organised.
  4. Updates from last week’s Triage Squad session
    • No triage squad meetings last week
  5. Other announcements and news

Come and Contribute

This week’s contribution focus area

  1. Content ready for review: 9 issues. See Guidelines for reviewing content.
  2. Feedback awaiting validation: 37 issues. See Validating and Applying Content Feedback.
  3. Topics awaiting vetting: 2 issues. See Vetting Topic Ideas.
  4. Validated feedback awaiting fix: 27 issues.

Contribution Acknowledgement

Project updates

Upcoming Online Workshops

  • N/A

You can see all meetings scheduled on this meeting calendar. If you are new to the Training Team, then come walk through our onboarding program to get to know the team and how we work. And if you have questions, feel free to reach out in the #training Slack channel at any time.

#meeting-recap, #training, #training-team

moknah Polyglots ·

Hello Polyglots,

I am the author of the pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. ATS Moknah – Text to Speech, AI Voice & Audio Player:

  • https://wordpress.org/plugins/ats-moknah-article-to-speech/

I would like to request Project Translation EditorProject Translation Editor A Project Translation Editor (often referred to as PTE) is a person, who has access to validate strings on a specific project (for example BuddyPress, WooCommerce or Twenty Fourteen) for one specific locale. A project translation editor can approve strings that are added by translation contributors. Per project translation, editors are appointed by a general translation editor after a request by the project author or by the contributors themselves. (PTEProject Translation Editor A Project Translation Editor (often referred to as PTE) is a person, who has access to validate strings on a specific project (for example BuddyPress, WooCommerce or Twenty Fourteen) for one specific locale. A project translation editor can approve strings that are added by translation contributors. Per project translation, editors are appointed by a general translation editor after a request by the project author or by the contributors themselves.) access for the following localeLocale Locale = language version, often a combination of a language code and a region code, for instance es_MX denotes Spanish as it’s used in Mexico. A list of all locales supported by WordPress in https://make.wordpress.org/polyglots/teams/:

I am a native Arabic speaker and the plugin author. The plugin already ships a complete Arabic translation, and the Arabic readme translation is already submitted and waiting for review. I would like to import, review and maintain Arabic for both the “Stable (latest release)” and “Stable Readme” projects.

Thank you!

Fakhri Azzouz

Hi @moknah,

I’m writing to let you know that your PTE request for #ar has been denied, as the current quality does not meet our standards.

Specifically, “theme” was not localized according to the #ar glossary, and it was translated inconsistently across the project. This suggests that the translations have not been thoroughly reviewed.

Additionally, the following color names should be translated into Arabic rather than transliterated:

* Aurora Mint

* Royal Amethyst

* Ocean Teal

* Sunset Ember

* Charcoal Lime

Finally, please complete the remaining 117 untranslated strings.

Regards,
Fakhri

Reply

moknah

Hi @fakhriaz,

Thank you for the detailed review. I have addressed all three points:

1. “theme” is now translated as قالب / قوالب throughout the project, following the #ar glossary, including the player’s light/dark themes (القالب الفاتح / القالب الداكن).
2. The color names are now translated into Arabic: نعناع الشفق، الجمشت الملكي، فيروزي المحيط، جمر الغروب، فحمي ليموني.
3. All remaining strings are translated (0 untranslated).

I also reviewed the whole project against the #ar glossary (مقالة، نوع محتوى، نسخة، انقر، تنصيب، مفتاح واجهة برمجة التطبيقات (API)، إلخ) and applied the same corrections to the Stable Readme.

The newest waiting suggestions replace my earlier ones. Could you please take another look at the PTE request?

Thank you!

Reply

David Perez Plugins ·

Introducing SMTP: a community-maintained way to send WordPress email reliably

Email is one of those things WordPress needs to just work. Password resets, new user notifications, form submissions, order receipts: they all go through wp_mail(), which by default relies on PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php’s mail() function.

On a growing number of servers, that is no longer an option. Many hosts disable mail() or blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience. outbound port 25 to prevent abuse. Containerized and cloud setups often have no local mail transfer agent at all. When that happens, WordPress fails quietly. The site looks fine, but nobody gets the password reset.

Today the Plugins Team is sharing a new pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. built for exactly this case: SMTP, available now in the Plugin Directory and developed in the open on GitHub.

Why this matters

Sending WordPress email through SMTP is one of the most common needs in the ecosystem. The most popular SMTP plugins in the Directory add up to well over five million active installations. Requests to add SMTP settings to coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. have come up over the years (see #7284, #29069 and its duplicates). Core’s long-standing position is that this belongs in plugin territory, and we agree.

What has been missing is a simple, neutral option that belongs to the community. It configures the mailer WordPress already ships with, and nothing more.

What it does

  • Any SMTP server. Host, port, encryption (none, SSLSSL Secure Socket Layer – Encryption from the server to the browser and back. Prevents prying eyes from seeing what you are sending between your browser and the server. or TLS), username, password and From address.
  • Configuration in wp-config.php. Constants such as SMTP_HOST, SMTP_USER or SMTP_PASSWORD override saved values and lock the field in the settings screen. This is the recommended approach for production.
  • Careful handling of secrets. On WordPress 7.2 and later, passwords and other credentials are stored through the new core Secrets API, encrypted at rest, so they no longer sit in plain text in the database or in backups. On earlier versions they are stored apart from the other settings. In both cases they are never printed back into the page, and they are redacted from the test email’s connection log.
  • Email log of recipient, subject, status and error. Message bodies, headers and attachments are never stored. Entries are purged after 30 days by default.
  • Failure alerts outside email. A broken mailer can’t report itself, so the plugin can notify a SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ channel when wp_mail() fails. Alerts are throttled to avoid flooding.
  • WP-CLIWP-CLI WP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/ https://make.wordpress.org/cli/ support: wp smtp settings set, wp smtp test and wp smtp status, built for provisioning and automation. Passwords are read from STDIN rather than passed as arguments.
  • ExtensibleExtensible This is the ability to add additional functionality to the code. Plugins extend the WordPress core software.. Providers and alert channels can be added through filters (smtp_providers, smtp_alert_channels).

It requires WordPress 6.3+ and PHP 7.4+, and is licensed GPLGPL GPL is an acronym for GNU Public License. It is the standard license WordPress uses for Open Source licensing https://wordpress.org/about/license/. The GPL is a ‘copyleft’ license https://www.gnu.org/licenses/copyleft.en.html. This means that derivative work can only be distributed under the same license terms. This is in distinction to permissive free software licenses, of which the BSD license and the MIT License are widely used examples.-2.0-or-later.

Calling all email providers

SMTP is built around a small provider APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.. Each provider declares its own fields, required values and wp-config.php constants, and configures the PHPMailer instance used by wp_mail(). The built-in Generic SMTP provider is registered through the same smtp_providers filterFilter Filters are one of the two types of Hooks https://codex.wordpress.org/Plugin_API/Hooks. They provide a way for functions to modify data of other functions. They are the counterpart to Actions. Unlike Actions, filters are meant to work in an isolated manner, and should never have side effects such as affecting global variables and output. any provider can use.

That means email services don’t need to ship a separate plugin to offer a smooth setup in WordPress. If you run an email delivery service, we invite you to contribute a provider for it to the repository:

  • SMTP-based providers can be added today. A provider definition is a label, a few fields, and a configure callback that sets the host, port and credentials.
  • API-based providers, which send over HTTPHTTP HTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. instead of SMTP, aren’t supported yet. Designing that layer is the next big step, and it’s being discussed in #1. Providers who want to see their API supported are very welcome to help shape it.

Contributed providers go through the same pull request review as any other code, and need to:

  • follow WordPress coding standardsWordPress Coding Standards The Accessibility, PHP, JavaScript, CSS, HTML, etc. coding standards as published in the WordPress Coding Standards Handbook. May also refer to The collection of PHP_CodeSniffer rules (sniffs) used to format and validate PHP code developed for WordPress according to the PHP coding standards.;
  • include tests;
  • keep secrets out of the page and out of logs;
  • contain no tracking, upsells or promotional content.

The goal is a neutral plugin where every provider sits on equal footing.

About the smtp slug

The plugin will be published under the existing smtp slug, which has a long history in the Directory. It was originally created by Serghei Iakovlev and later maintained for many years by Sorin Iclanzan, who has now given his approval for it to become a community plugin. We want to thank both of them for their work and for keeping it going all this time.

Existing users will upgrade in place. Their host, port, encryption and username are imported automatically. The legacy plugin encrypted passwords with mcrypt, which was removed in PHP 7.2, so on most servers the password can’t be migrated. In that case an admin notice will ask the site owner to enter it again.

A shared resource, maintained together

The Plugins Team has started this plugin, but it doesn’t belong to the team, and the team doesn’t provide support for it. Like WordPress itself, it belongs to the community, and its future depends on the people who use it and contribute to it.

There are many ways to help keep it healthy:

  • Contribute code, fixes and tests through pull requests on GitHub.
  • Review open pull requests and help triage issues.
  • Help answer questions in the plugin’s support forumSupport Forum WordPress Support Forums is a place to go for help and conversations around using WordPress. Also the place to go to report issues that are caused by errors with the WordPress code and implementations. on WordPress.orgWordPress.org The community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/.
  • Contribute a provider for your email service, or help design API-based sending in #1.
  • Translate it on translate.wordpress.org.

If sending email from WordPress matters to you, and it matters to almost everyone, this is a great place to give back.

Eduard Doloc

I am still confused why this is not core; especially with raising security concerns where 2FA with email code would be a very well-received upgrade.

I know some hosting providers that block unauthenticated email sending, thus being dependant of a plugin, sadly when that author decides to sell/rework the whole data, things break and the most suffering is from the owner of the site and its users.

Reply

Not sure which team to contribute to?

Check out our contributor wizard and find how to get started.