Minn\Runtime

Fires the categories action once.

Fires the categories action, then the abilities action, each once.

Registers a category; its row, or null with the reference's notice. @return array<string, mixed>|null

Registers an ability; its row, or null with the reference's notice. @return array<string, mixed>|null

Removes an ability; its row, or null with the reference's notice. @return array<string, mixed>|null

Removes a category; its row, or null with the reference's notice. @return array<string, mixed>|null

One ability, or null with the reference's notice. @return array<string, mixed>|null

One ability, or null, asked after without a notice. @return array<string, mixed>|null

One category, or null with the reference's notice. @return array<string, mixed>|null

One category, or null, asked after without a notice. @return array<string, mixed>|null

Every ability, by name. @return array<string, array>

Every category, by slug. @return array<string, array>

Why an ability's properties are refused, as WP_Ability::prepare_properties says it, or null. @param array<string, mixed> $args

Why a category's properties are refused, as WP_Ability_Category::prepare_properties says it, or null. @param array<string, mixed> $args

An ability's meta with the reference's defaults: the three annotations first, show_in_rest (public's value when unset), then public.

True, or why the input does not fit.

True, or the error a permission answer other than true becomes (an error it returns is reported as a notice).

True, or why the output does not fit the output schema.

A reset link mailed to the account a login or email names: true, or the refusal (no name, no such account, a plugin's error, reset not allowed, or the mail failing).

A new password for a user, announced before (password_reset) and after (after_password_reset).

A new account for a login and an email, with a generated password and the nag to change it: its id, or every refusal at once (the name empty, illegal, taken or barred; the email empty, malformed or taken; whatever register_post and registration_errors add).

A new account announced: to the site's address (unless only the user is told), then to the user with a link to set their password (unless only the site is, or the old call shape asks for nobody).

Whether a request is for the endpoint, which the runtime boots as an admin request.

Runs the handlers registered for the action the request names.

The allowlist with each new name appended to its group once, groups created as needed. A group handed as anything but a list adds nothing.

A new password: its record and its plain text in groups of four, or the reference's refusal.

A password renamed (when the body names it): its record as it stands.

Whether any user has made an application password (is_in_use).

A new password for the user (create_new_application_password): [the password, its record], or the reference's error for a nameless one.

A user's passwords (get_user_application_passwords).

One of a user's passwords by its uuid (get_user_application_password), or null.

Whether one of a user's passwords has the name (application_name_exists_for_user).

A password renamed, the only field the reference changes (update_application_password): true, or its not-found error.

A use recorded, when and from where (record_application_password_usage): true, or the not-found error.

A password removed (delete_application_password): true, or the not-found error.

Every password of the user removed, each told to wp_delete_application_password (delete_all_application_passwords); how many went.

The signed-in user, the input unchanged, or the refusal.

determine_current_user's application password step: an earlier answer stands; else the user the REST request's application password signed in (the engine checked the password before plugins loaded), heard again as the reference hears it: the feature's availability, wp_authenticate_application_password_errors, then application_password_did_authenticate; a refusal is announced and leaves the request signed out.

get_post_type_archive_link.

get_post_type_archive_feed_link.

The edits applied. The view is rebuilt by every change the registry takes, so the edited view is read from the copy handed in.

The request's registry of one kind of asset, script or style, made the first time it is asked for.

The notice (doing it wrong, 3.3.0) for an asset function run before init and before any of the enqueue actions (_wp_scripts_maybe_doing_it_wrong), naming the handle when there is one.

A registered script queued (wp_enqueue_script with a handle alone).

A registered style queued (wp_enqueue_style with a handle alone).

A script file's element (wp_get_script_tag), its attributes through wp_script_attributes first.

Inline code's element (wp_get_inline_script_tag): the code trimmed between newlines, wp_inline_script_attributes asked.

A listener called after every change, so a plugin-facing view can stay current; and one called before a script's data changes, so what a plugin set in that view lands first.

The queue as a plugin left it after editing the view directly.

Registers an asset under a handle.

An existing handle's source, dependencies, version and arguments replaced, its data, inline code and place in the queue kept.

The hosts the queued assets load from, other than the site's own.

Forgets an asset.

Queues an asset for printing (probe placeholders-admin). One that is neither registered nor among the reference's own handles waits, and joins the queue when it is registered; one of the reference's own the engine ships no file for is queued as the reference would queue it.

Removes an asset from the queue, or from the handles waiting for registration.

Whether a handle is registered, by the site or as one the reference registers itself (data/default-assets.json).

A handle's dependencies: as registered, or as the reference registers it. @return list<string>

The registered handles that name a handle among their dependencies. @return list<string>

Whether a handle is a dependency, however deep, of any of the given handles.

Queued directly, or pulled in as the dependency of something queued, however deep. The reference answers the same way, and plugin code leans on it: WooCommerce only attaches its settings blob when it finds `wc-settings` "enqueued", and nothing queues that handle by name, it only ever rides in as a dependency.

The handles printed so far.

The printed handles as a plugin left them after editing the view directly.

Whether a handle has been printed.

Attaches inline code to an asset.

Attaches a data key to an asset.

Names the text domain and folder a script's translations come from, and makes the script depend on wp-i18n.

A data key of an asset, or false.

Attaches a localized object to a script.

Every queued handle not yet printed, dependencies first. @return list<string>

Enqueued handles that name a file on disk, mapped to that path. A style registered with a `path` datum is saying it can be inlined; whether it is small enough to be worth inlining is the caller's decision.

Drops a handle's source so it prints as markup rather than a link.

Records a handle as printed.

One registered asset, or null.

Every registered asset.

The handles queued.

Whether these are scripts or styles.

The registered sizes (_minn_image_sizes): the four from the options, then the ones add_image_size added.

The sizes plugins and themes added (wp_get_additional_image_sizes), kept where they read them: $_wp_additional_image_sizes.

Dimensions fitted inside a box (wp_constrain_dimensions), through wp_constrain_dimensions when there is a box.

Whether two sizes share a ratio (wp_image_matches_ratio): the wider one, fitted into the other's box, comes within a pixel of it.

Dimensions fitted for the editor to a named or given size (image_constrain_size_for_editor), within editor_max_image_size.

An attachment's file for a size (image_get_intermediate_size), as image_get_intermediate_size leaves it; false for none.

An image attachment at a size (image_downsize): its address, width, height and whether that is a resized copy, unless image_downsize answers first; false for no image.

An attachment's image at a size, or its icon when asked (wp_get_attachment_image_src), as wp_get_attachment_image_src leaves it.

A named size's dimensions from an image's metadata (_wp_get_image_size_from_meta): full for the original; false for one it lacks.

The srcset of an image's sizes with its ratio (wp_calculate_image_srcset), as wp_calculate_image_srcset leaves the sources; false for none.

The sizes attribute for an image's width (wp_calculate_image_sizes), as wp_calculate_image_sizes leaves it; false without a width.

Whether a sizes list starts with auto, alone or before a comma, in any case (wp_sizes_attribute_includes_valid_auto).

The width and height attributes for an image (image_hwstring), each when set.

Whether lazy loading is on for a tag in a context (wp_lazy_loading_enabled): images and iframes, as wp_lazy_loading_enabled leaves it.

The loading attributes an image or iframe earns (wp_get_loading_optimization_attributes), unless a plugin answers first: decoding async for an image; with both dimensions set, the caller's own priority and loading, else where it sits.

Fetch priority high for an image large enough to deserve it, while no other image has taken it.

The loading attributes and the srcset and sizes pair an attachment's image carries unless the caller set them.

An attachment's img element at a size (wp_get_attachment_image): its class, alt text, loading attributes and srcset, through wp_get_attachment_image_attributes and wp_get_attachment_image; empty for none.

The site icon's address at a size (get_site_icon_url), the address given when the site has none; as get_site_icon_url leaves it.

Whether the site has an icon (has_site_icon).

The uploads folder and its address for a time, the month's folder too when uploads go by month (_wp_upload_dir, wp_get_upload_dir), as upload_dir leaves them.

The uploads folder made on disk when asked (wp_upload_dir), and returned.

A folder made with its parents (wp_mkdir_p): whether it is there and may be written to.

A path under the uploads folder made relative to it (_wp_relative_upload_path), as _wp_relative_upload_path leaves it.

An attachment's file on disk (get_attached_file), the uploads folder before a relative one; through get_attached_file unless asked not to be.

An attachment's file recorded (update_attached_file), relative to the uploads folder; an empty one removes the record.

An attachment's address (wp_get_attachment_url): its file under the uploads address, else its guid; false for no attachment or no address.

An attachment's metadata (wp_get_attachment_metadata), the post being read's for none; one stored in a shape the meta reader refuses is parsed from its row; false for none; through wp_get_attachment_metadata unless asked not to be.

An attachment's metadata stored (wp_update_attachment_metadata) as wp_update_attachment_metadata leaves it; an empty one removed.

Whether an attachment is a kind of file (wp_attachment_is): image, audio, video, or a MIME type or extension.

Whether an attachment is an image (wp_attachment_is_image).

The audio file extensions the player takes (wp_get_audio_extensions), as wp_audio_extensions leaves them.

The video file extensions the player takes (wp_get_video_extensions), as wp_video_extensions leaves them.

An attachment stored (wp_insert_attachment): the arguments over a file and no parent, the parent given, saved as a post of type attachment.

An attachment deleted (wp_delete_attachment): to the trash first unless forced or the media trash is off; unless pre_delete_attachment answers, its terms, comments and meta removed, the row between delete_post and deleted_post, then its files. The post, or null.

An attachment's files deleted, its sizes and backups too (wp_delete_attachment_files); false when any was missing or outside the uploads folder.

A photo's own description from its IPTC and EXIF (wp_read_image_metadata), through wp_read_image_metadata_types and wp_read_image_metadata; false when there is no such file.

The data arguments normalised: sizes to integers, the default token, the rating lowercased.

The Gravatar hash an email yields; '' for no email.

A hash given as an md5.gravatar.com address, else null.

The Gravatar URL's query arguments for the data arguments. @return array<string, string|int|false>

The <img> classes: the size class, a default marker, the caller's own. @return list<string>

The extra attribute string with loading and decoding added when the caller did not set them.

The data filters the engine's renderer does itself for a block it renders natively: element styles, style variations, a gallery's image ids.

The render filters it does itself: the element and style variation classes, the layout's container classes (a child's own layout left to a stand-in), the paragraph's class.

Whether any block filter is registered.

A block as the parsed array plugins receive.

A block from the parsed array plugins hand back.

A parsed block through render_block_data, without the callbacks done already (NATIVE_DATA_DONE for a block the engine's renderer renders).

A rendered block through render_block and its per-name filter, without the callbacks done already (NATIVE_RENDER_DONE, with its stand-ins, for a block the engine's renderer renders).

A short-circuit from pre_render_block, or the block as render_block_data left it.

A rendered block through render_block and its per-name filter.

The blocks hooked to each anchor, by position (get_hooked_blocks), as the registered block types' block_hooks name them.

Whether block hooks are registered (the runtime's functions are there only once it is up).

A template part's markup with its hooked blocks inserted. The context is the part itself: a plugin reads its area to tell a header from a footer, and its content to see whether its block is already there.

A plugin-registered pattern's content, hooks already applied by the registry, for a slug the theme does not carry. Null when the runtime is not up or nothing registered that name.

A theme pattern's markup with its hooked blocks inserted, with the pattern array as the context (blockTypes and categories are how a plugin recognises a header pattern).

Block settings from a block.json, the way the reference maps its properties.

The script or style handle a block.json field registers under; core blocks keep the `wp-block-` spelling.

A query block's post query for a page (build_query_vars_from_query_block), through query_loop_block_query_vars when the block has a query context.

The comment query a comments block shows (build_comment_query_vars_from_block): approved comments oldest first, the reader's own held ones too, the post's, threaded and paged as the discussion settings say.

The registered row, or the refusal code the reference reports.

Forgets a registered template; the row, or null.

Every registered template.

One registered template, or null.

A registered template by slug, or null.

The legacy widget class a block widget maps to.

The globals, in the order the reference sets them.

Each global's value for this user agent and server software.

How long each comment form field may be (wp_get_comment_fields_max_lengths), as the table allows, through wp_get_comment_fields_max_lengths.

Whether a comment fits its columns (wp_check_comment_data_max_lengths): true, or the error naming the first field too long.

Each field through its pre_comment_ filter (wp_filter_comment), in the reference's order (the user first, the email last), marked filtered.

A comment's status (wp_get_comment_status): approved, unapproved, spam or trash; false for an unknown comment or status.

Whether a new post of a type starts open (get_default_comment_status): a page starts closed; another type follows the site's default when it supports comments (or trackbacks, for pings).

Whether a comment needs no moderation (check_comment): never while moderation is on; the links counted in the comment as comment_text shows it (comment_max_links_url may recount) against comment_max_links; the moderation words; and, when asked, an earlier approved comment from the same author (a pingback from one of the site's own posts, as wp_auto_approve_ping decides; a trackback never).

Whether a line of disallowed_keys appears in the comment's fields (wp_check_comment_disallowed_list): a word match, or an address's start; the comment read without its tags and entities too.

A comment's approval as its data asks (wp_check_comment_data): the post's author and a moderator are approved; anyone else's comment passes check_comment or is held, and the disallowed words send it to the trash (spam with the trash off); pre_comment_approved has the last word. The data may be slashed.

1, 0, "spam" or "trash" for a comment that may be stored (wp_allow_comment), in the reference's order: a duplicate, which duplicate_comment_id may name or clear, refuses with 409; check_comment_flood and wp_is_comment_flood refuse a flood with 429; then the approval. The error when asked for one, else the stop page, for a refusal.

A comment from outside stored the way the comment form stores one (wp_new_comment): preprocess_comment; the ids, user, parent, address, agent and dates filled in; wp_allow_comment; the pre_comment_ filters; the approval judged again on what they left; the comment stored; comment_post. The id, or the error when asked for one (false without).

The commenter remembered by the comment_author_ cookies (wp_get_current_commenter), as wp_get_current_commenter leaves them.

The address of the reader whose held comment the page may show (wp_get_unapproved_comment_author_email): from a held comment's link (its hash right, under ten minutes old), or else from the commenter's cookie.

Whether comments stay open on a post under the close-after-days setting.

Whether the setting closes a post of $postType published at $postDateGmt: the type is one of $types, the setting is on, and the post is older than the days allowed. The posts a single query hands over (_close_comments_for_old_posts) take their types from the close_comments_for_post_types filter, which is honoured there.

Whether plugins are loaded to be told anything.

The check a new comment passes on the reference before it is written: check_comment_flood, with the address, the email and the GMT date.

A comment created over REST with plugins loaded, as the reference's controller creates one (probe rest-comment-save): the request's fields through rest_preprocess_comment, the signed-in author filled in, the content check (allow_empty_comment), the date, the length check, wp_allow_comment (a duplicate is a 409, a flood a 400), rest_pre_insert_comment, then wp_insert_comment over wp_filter_comment; a refusal is its REST error.

A comment changed over REST with plugins loaded: the request's fields through rest_preprocess_comment, the content and length checks, wp_update_comment, then the status, as the reference's controller changes one.

A REST status asked for, as the reference's controller changes it: nothing when it is already so; approve and hold through wp_set_comment_status with that word, spam, unspam, trash and untrash through their own functions.

Writes a new comment and returns its id; an approved one is counted on its post. @param array<string, mixed> $columns

An edit through REST: the fields, as wp_update_comment writes them (which tells plugins even when nothing changed), then the status through wp_set_comment_status when it moves.

Moves a comment to the trash, keeping its status and the time for the way back.

Removes a comment for good.

rest_insert_comment, then rest_after_insert_comment, with the comment as it stands and the request; no $before is a new comment.

rest_delete_comment, after a trash or a delete, with the comment as it was and the response. @param array<string, mixed> $data

A listing's comments, then its posts narrowed to theirs: the posts query's join and where as they stand after posts_join.

A single post's comments, once the query has found the post.

The stored comment, or the refusal the form answers with.

The page a comment is on, through get_page_of_comment (handed the arguments as settled and as given); a threaded reply answers with its top-level comment's page. Null for a comment that is not there.

The page a comment's link names (before get_comment_link): the one asked for, the loop's, or the comment's own; '' for the default page when the oldest comments come first.

The comments page being shown (the cpage query variable) as the list's links and reply links name it: '' for the default page when the oldest comments come first.

A post's link opened at a page of its comments, as pretty or plain links write it.

The counts wp_count_comments reports, for one post or the site. @return array<string, int>

Runs the query, as WP_Comment_Query::get_comments() does: a count, ids, or comments.

The comment IDs for the query's vars (get_comment_ids), or the count when it counts; the request is written, and the found rows read when the request counts them and found some.

The WHERE pieces (joined with AND by the caller) and the posts join ('' when no post field is asked after).

A LIKE test over the columns (get_search_sql), as an AND clause. @param list<string> $columns

The comments a query finds (get_comments): comments, ids or a count, as the comment query answers.

How many comments a post or the site has in each status (wp_count_comments), unless wp_count_comments answers first.

When an approved comment last arrived (get_lastcommentmodified), in GMT ("gmt", and the server's own, the GMT date moved by the server's offset in the database, with microseconds) or the site's time ("blog"); false with none.

A comment's address, at the page of comments it is on (get_comment_link), as get_comment_link leaves it.

A post's address at its comments, or at the form when it has none (get_comments_link), as get_comments_link leaves it.

A comment's author (get_comment_author), "Anonymous" for none, as get_comment_author leaves it.

The author of the comment being read, for a feed (get_comment_author_rss), as comment_author_rss leaves it.

When a comment was written (get_comment_time): in the format given or the site's time format, local or UTC, names translated unless asked not to be; empty for no comment.

A comment author's address, escaped (get_comment_author_url); empty when none was given.

The query's top-level comments with their descendants filled in.

A comment's children, then each one's own, depth first, as a list.

A comment stored (wp_insert_comment): its id, the post's count kept when it is approved, then wp_insert_comment told.

A post's approved comments counted (wp_update_comment_count): put off while counting is deferred; asked with $deferred, the posts put off are counted now and the answer is true.

A post's approved comments counted now (wp_update_comment_count_now), unless pre_wp_update_comment_count_now supplies the count; plugins told the old and new counts, then the post edited.

A comment changed (wp_update_comment): the stored comment under the change, through the field filters and comment_save_pre, then wp_update_comment_data (handed the data, the stored comment and the change); the columns written, the post's count, edit_comment with the columns, and the status transition. 0 when nothing changed.

A comment's status set (wp_set_comment_status): hold, approve, spam or trash; false for an unknown comment or status.

A stored comment status in the words the transition actions use: approved, unapproved, spam, trash.

What plugins are told when a comment changes status (wp_transition_comment_status); one that keeps its status hears only comment_{status}_{type}.

Comments' cached rows and meta let go (clean_comment_cache), plugins told about each.

A comment deleted (wp_delete_comment): to the trash first unless forced, it is there already or the trash is off; its replies moved up to its parent; the post recounted when it was approved.

A comment to the trash (wp_trash_comment), or deleted when the trash is off.

A comment back from the trash (wp_untrash_comment).

A comment marked spam (wp_spam_comment).

A comment back from spam (wp_unspam_comment).

A post's comments to the trash with it (wp_trash_post_comments): each becomes post-trashed, its status kept on the post to give back; how many changed (one set aside with its post already does not count).

A post back from the trash gives its comments their statuses back (wp_untrash_post_comments).

Registers a connector, or the refusal.

Forgets a connector; its row, or null.

Every connector.

One connector, or null.

Whether a connector is registered.

The reference's three AI providers. Whether a provider's plugin is active is asked of the caller's closure, by the connector's id, when asked (probe connector-defaults).

Akismet, the spam filter connector the reference adds after the AI providers. Whether its plugin is active is asked of the caller's closure.

Keys of four characters or fewer are shown whole; longer ones keep their last four behind at most sixteen bullets.

Where a key comes from, in the reference's precedence: the environment, then a constant, then the stored option; empty values do not count.

"user:password" split at the first colon, both halves trimmed; anything else is empty credentials.

Stored credentials are an array of two text fields; a string, even a "user:password" one, is not accepted from storage.

The credentials a connector authenticates with, from the same three sources as a key, plus where they came from.

Defines the constants the reference defines at boot.

The scheduled events by timestamp (_get_cron_array), an old list upgraded first; empty when there is none.

The events stored (_set_cron_array): whether they were, or the error saying they could not be when asked for one.

The schedules events recur on (wp_get_schedules): hourly, twice daily, daily and weekly, after the ones cron_schedules adds.

An event run once (wp_schedule_single_event): refused near a duplicate (ten minutes either side) or when a plugin says no.

A recurring event (wp_schedule_event): refused for an unknown schedule or when a plugin says no.

A recurring event moved to its next run (wp_reschedule_event): the interval its schedule names, else the one the event carries.

One event removed (wp_unschedule_event).

Every event of a hook removed, whatever its arguments (wp_unschedule_hook): how many, 0 for none.

Every event of a hook with these arguments removed (wp_clear_scheduled_hook): how many, or the errors merged into one; arguments given loose (an old call) are taken as the list.

An event by hook and arguments, the next one or the one at a time (wp_get_scheduled_event), or false.

When an event next runs (wp_next_scheduled), as wp_next_scheduled leaves it; false for none.

The events due now (wp_get_ready_cron_jobs).

The due events run (wp_cron): each recurring one rescheduled first, each removed, then its hook fired with its arguments; how many ran. A failure to reschedule or remove is logged and told as cron_reschedule_event_error or cron_unschedule_event_error.

An old event list keyed by hook alone, keyed again by its arguments' hash and stored (_upgrade_cron_array).

The key an event's arguments hash to.

The table read from the option's stored blob: the version marker dropped, timestamps in order, an unreadable or absent blob empty.

Whether the same hook and arguments are already scheduled within the window around the timestamp.

The table with an event added at a timestamp.

The table with one event removed.

The table with every event of a hook removed.

When a hook and key are scheduled.

The entry for the hook and arguments at a timestamp, or at the next one when no timestamp is given, as [timestamp, entry].

The next run of a recurring event: one interval from now, aligned to the original timestamp when it is in the past.

The timestamps at or before now, in order.

The request's user id (get_current_user_id).

Settles the request's user and reader; returns the user's id (0 for nobody).

The CREATE TABLE statements in a batch, keyed by table name. @param list<string> $queries @return array<string, string>

Applies CREATE TABLE statements as dbDelta does; the statements run.

Every table in the database.

A table's columns with their definitions.

A table's index names.

Runs one DDL statement.

What PHP reports while WP_DEBUG is off: errors and warnings, no notices, strict or deprecation messages.

The settings the debug constants ask for: the error level, and the ini values to set (none for what they leave alone).

Where WP_DEBUG_LOG sends the log. True, 1 or "true" in any case mean debug.log in the content folder; any other string but "" and "0" is the path itself, "false" included; anything else keeps no log.

Whether what the boot knows marks a request that answers a machine, whose errors must never print into the answer: XML-RPC, REST or ms-files declared at all, an install or ajax declared true, or a request that asks for or sends JSON (a JSONP or XML one is not). The facade's wp_debug_mode() asks the same through wp_installing(), wp_doing_ajax() and wp_is_json_request(), filters included.

The debug and request constants defined right now, by name.

Sets PHP's error level and ini values to what settings() asked for.

wp_defer_term_counting: on, off, or asked; off counts what was put off.

wp_defer_comment_counting: on, off, or asked; off counts what was put off.

wp_suspend_cache_addition: on, off, or asked.

Puts terms' recount off while counting is deferred; false when it is not (count now). @param list<int> $terms

Puts a post's comment recount off while counting is deferred; false when it is not (count now).

The document title (wp_get_document_title), through the title filters, ready to print inside <title>.

The document title's parts from the main query's state: the title of what is shown, the page number past the first, then the tagline on the front page or the site's name elsewhere.

On a post type archive, the type's plural name after a prefix (post_type_archive_title), printed or returned; null elsewhere.

The queried term's name after a prefix (single_term_title), printed or returned; null off a term archive.

The queried post's title after a prefix (single_post_title), printed or returned; null when no post is queried.

The value through every early callback on the tag, lowest priority first; as given when there are none.

The address a post is edited at (get_edit_post_link), null for a post the user may not edit or of no known type.

The address a term is edited at (get_edit_term_link), null for one the user may not edit.

The address a user is edited at (get_edit_user_link): one's own profile for oneself; empty for one the user may not edit.

The address a user's profile is edited at (get_edit_profile_url), as edit_profile_url leaves it.

A user's dashboard address, at a path in it (get_dashboard_url), as user_dashboard_url leaves it.

A post's short address (wp_get_shortlink), unless pre_get_shortlink answers first: the front page's home address, a public post's ?p=, else empty; the query's post when asked for the query's.

A file's headers by field (get_file_data), empty for a header it does not carry.

A file name safe to store (sanitize_file_name): accents transliterated, the special characters out, spaces and runs of dashes as one dash, no dots or dashes at the ends; an inner part that looks like an extension but is no type the site allows gets an underscore; a name that is only an extension becomes unnamed-file.{ext}; as sanitize_file_name leaves it.

An inner part of a file name that looks like an extension (two to five letters, maybe a digit) and is no allowed type, given an underscore.

A clean name no file in the folder has (wp_unique_filename): the name sanitized, its extension lowercased, a callback's name when one is given, else -1, -2... before the extension; as wp_unique_filename leaves it.

A file's extension and type from its content as much as its name (wp_check_filetype_and_ext), with a corrected name when an image carried the wrong extension; as wp_check_filetype_and_ext leaves them.

A file deleted (wp_delete_file), as wp_delete_file names it; whether it went.

A file deleted only when it is inside the folder (wp_delete_file_from_directory); false when it is not, or not there.

The image types measured by their bytes, and the extension each takes.

ext, type, proper_filename, and the content's own type (real_mime).

The stored file (file, url, type) or ['error' => message].

Binds answers by name: currentUser, signedIn, user, userBy, becomeUser, cacheUsers, authenticate, setPassword, password, hashPassword, hash, createNonce, verifyNonce, mail, avatar, redirect, safeRedirect, stop, escSql, cacheGet, cacheSet, cacheDelete, and the record factories newError, newPost, postInstance, newTerm, newComment, commentInstance, newUser, and the query factories newQuery, newCommentQuery, newUserQuery, newTermQuery, newMetaQuery, newDateQuery, and the REST ones newRestRequest, restRequestFromUrl, newRestResponse, restController, newTheme, and the empty registered-type objects blankPostType and blankTaxonomy, a user's sessionTokens, the locale's newLocale and newTextdomainRegistry, newUpgrader and newUpgraderSkin, the blocks' newBlock, newBlockList, newBlockTemplate, newTagProcessor and newThemeJsonData, newSitemapStylesheet, and the registries blockTypes, blockPatterns, blockStyles, blockBindings, abilities and abilityCategories.

The user the request is (wp_get_current_user).

Whether someone is signed in (is_user_logged_in).

A user by id, or false (get_userdata).

A user by a field (id, ID, slug, email or login), or false (get_user_by).

Makes a user the request's (wp_set_current_user): the user's record.

Reads users and their meta into the cache together (cache_users).

Signs in by name and password (wp_authenticate): the user, or an error.

Sets a user's password (wp_set_password).

A random password (wp_generate_password).

A password hashed for storing (wp_hash_password).

A hash of the data keyed with the site's salt (wp_hash).

A nonce for an action (wp_create_nonce).

Whether a nonce holds for an action: 1 or 2 by its age, or false (wp_verify_nonce).

Sends an email (wp_mail): whether it was accepted for delivery.

A user's or address's avatar image, or false (get_avatar).

Sends the browser elsewhere (wp_redirect): whether it was sent.

Sends the browser elsewhere on the site's own hosts, else to the admin (wp_safe_redirect).

Ends the request with a message (wp_die), as the handler plugins choose draws it.

A value from the object cache (wp_cache_get), $found told whether it was there.

A value stored in the object cache (wp_cache_set).

A value removed from the object cache (wp_cache_delete).

A value, or each in a list, escaped for SQL by the database object plugins query with (esc_sql).

A list of errors, the first given (new WP_Error).

A post object made from a row or another post (new WP_Post).

The post object for an id, or false (WP_Post::get_instance).

A term object made from a row (new WP_Term).

A comment object made from a row (new WP_Comment).

The comment object for an id, or false (WP_Comment::get_instance).

A user object by id (or login, with no id), nobody for 0 (new WP_User).

A posts query, run at once when given its variables (new WP_Query).

A comments query, run at once when given its variables (new WP_Comment_Query).

A users query, run at once when given its variables (new WP_User_Query).

A terms query, run at once when given its variables (new WP_Term_Query).

A meta query from its clauses (new WP_Meta_Query).

A date query from its clauses and column (new WP_Date_Query).

A REST request for a method and route (new WP_REST_Request).

A REST request for an address on this site's API, or false (WP_REST_Request::from_url).

A REST response with data, a status and headers (new WP_REST_Response).

One of the REST controllers a filter is handed, by kind: menus, menu-items or menu-locations.

A post type's object with nothing set yet, for the registry to fill (WP_Post_Type, built without its constructor).

A taxonomy's object with nothing set yet, for the registry to fill (WP_Taxonomy, built without its constructor).

A user's sessions (WP_Session_Tokens::get_instance), through the manager session_token_manager names.

The site's locale: its names, number format and direction (new WP_Locale).

Where each text domain's translations are found (new WP_Textdomain_Registry).

An upgrader for plugins, or for themes when the kind is "theme", reporting through the skin.

The skin an upgrader reports through when no screen shows it (new WP_Ajax_Upgrader_Skin).

A block to render, with its context (new WP_Block).

Blocks to render as one list (new WP_Block_List).

An empty block template record (new WP_Block_Template).

A cursor over HTML's tags and attributes (new WP_HTML_Tag_Processor).

One origin's theme.json data for its filter (new WP_Theme_JSON_Data).

The stylesheet a sitemap is shown with (new WP_Sitemaps_Stylesheet).

The registered block types (WP_Block_Type_Registry::get_instance).

The registered block patterns (WP_Block_Patterns_Registry::get_instance).

The registered block styles (WP_Block_Styles_Registry::get_instance).

The registered block binding sources (WP_Block_Bindings_Registry::get_instance).

The registered abilities (WP_Abilities_Registry::get_instance).

The registered ability categories (WP_Ability_Categories_Registry::get_instance).

Whether the layer has bound an answer by that name yet (it binds them as it loads).

The site's roles object (wp_roles), made the first time it is asked for.

The content filters set again for the current user (kses_remove_filters, then kses_init_filters), by the names plugins remove them by.

A theme template file run where templates run (load_template): in the layer's globals, the query's variables in scope.

The object that loads translation files and looks translations up (WP_Translation_Controller::get_instance).

The rewrite object ($wp_rewrite), with the request's environment ($wp), made the first time they are asked for.

The widget factory ($wp_widget_factory) the registered widgets live in.

The sitemap server, started the first time it is asked for (wp_sitemaps_get_server).

The walker a menu is printed with when its arguments name none (new Walker_Nav_Menu).

An attachment's metadata made from its file by the layer's image editors (wp_generate_attachment_metadata): sizes, previews, the file's size.

The meta core and Minn Admin register on init, registered by the layer that holds their callbacks by name.

The theme file for a template type, through the hierarchy and its filters (get_query_template); a block theme's canvas when it has a block template.

The block templates a query finds, the theme's and the ones plugins registered (get_block_templates).

Content with its hooked blocks inserted by the callback named (apply_block_hooks_to_content).

A post's content with its hooked blocks inserted (apply_block_hooks_to_content_from_post_object), a navigation's root ignored list filled in.

A theme by its folder and root (new WP_Theme).

The answer for a beat, from the posted fields (unslashed).

Called with each hook name the first time a callback registers under it.

The live registry, for a hook object to share by reference.

How often each action, or each filter, has run, by hook.

How often each filter has run, by hook, by reference for the facade's global.

The hooks running now, outermost first, by reference for the facade\'s globals.

The priority a running hook is at, or false when it is idle.

Adds a callback to a hook at a priority.

Removes a callback from a hook.

Every callback of a hook, or only those at one priority. Always true, as observed.

With a callback: its lowest priority, or false; without: whether anything is registered.

Whether anything is hooked besides the callbacks the engine does the work of itself (named function => priority), as filterWithout skips them.

Runs a filter and returns the value.

Runs a filter without the callbacks a caller has already done the work of, named function => priority: the engine renders post content through its own pipeline, then runs the_content for everything else hooked there. A callback a plugin removed is simply not there to skip. A skipped callback can name a stand-in, [priority, function], that runs in its place: what of its work the engine has left to do.

Runs an action. With no arguments its callbacks still get one, an empty string, as do_action() gives them in the reference (a callback that requires a parameter is not short of one).

Runs an action with exactly the arguments given, none included (do_action_ref_array).

do_action_ref_array: the action's callbacks get the arguments, and an 'all' callback gets them as the one array they were passed in, as the reference hands them on.

apply_filters_ref_array: as filter(), with an 'all' callback handed the arguments as one array.

apply_filters_deprecated: the value as given while nothing is hooked; otherwise the deprecation notice, then the filter as filterRefArray runs it.

do_action_deprecated: nothing while nothing is hooked; otherwise the deprecation notice, then the action as actionRefArray runs it.

How often an action has run.

How often a filter has run.

The hook running now, or false.

Whether a hook, or any hook, is running.

Every hook with callbacks, by name.

The 'all' callbacks run with the arguments given, the hook's name first (_wp_call_all_hook). @param list<mixed> $args

What to run when processing meets a router region.

Reads or extends a namespace's state.

Every namespace's state, for the client.

Every namespace's config, for the client.

Reads or extends a namespace's config.

The current directive context of a namespace.

The element whose directives are being evaluated.

HTML with its directives resolved on the server.

The tables the contexts start from: post, data (the comment and description rules) and entities.

The elements and attributes allowed in a context (wp_kses_allowed_html): post, a user's description, strip, entities, the comment rules for any other, or an explicit list; as wp_kses_allowed_html leaves them.

Content filtered to the HTML allowed (wp_kses), with the site's protocols unless others are given. A context given as another scalar is read as text, as wp_kses_data's current_filter() is false outside a filter.

Content filtered to what a post may hold (wp_kses_post).

One attribute judged as a post's element would carry it (wp_kses_one_attr).

Content without its null bytes (wp_kses_no_null), or without any control characters when slash_zero is kept.

A caller's allowed HTML in any of its shapes, with the protocols and URI attributes in force. For content, the URI attributes are asked only when an opening tag of an allowed element that may carry attributes is there, as the reference asks them of each such tag; otherwise none are consulted.

The query being answered: $wp_query, else the main one, made empty when there is none.

The search terms the query answers (get_search_query), as get_search_query leaves them, escaped for an attribute unless asked not to be.

wp_update_nav_menu_object: a menu made (menu id 0) or changed, its id or the refusal. The name is checked first, as the reference checks it.

wp_delete_nav_menu: the items through wp_delete_post, the term through wp_delete_term, the locations let go, then wp_delete_nav_menu.

wp_update_nav_menu_item: an item made (id 0) or changed in a menu, its id or the refusal; the post save actions around the write, then the item actions, and wp_after_insert_post "now" or (a REST save, which fires it after its own actions) "later".

A menu saved over REST, as the reference's menus controller saves one: the request's fields (name, description, those given) through rest_pre_insert_nav_menu, then saveMenu(), then rest_insert_nav_menu and rest_after_insert_nav_menu.

A menu deleted over REST: deleteMenu(), then rest_delete_nav_menu with the menu as it was and the response. @param array<string, mixed> $previous

An item saved over REST, as the reference's menu-items controller saves one: its menu-id and menu-item-* arguments through rest_pre_insert_nav_menu_item, then saveItem(), then rest_insert_nav_menu_item, rest_after_insert_nav_menu_item and wp_after_insert_post.

An item deleted over REST: wp_delete_post, then rest_delete_nav_menu_item with the item as it was and the response. @param array<string, mixed> $previous

An item's own saved values as menu-item-* arguments, which a REST update starts from: the reference's save resets to its default any argument it isn't handed.

The items, each given its classes and its current, current_item_parent and current_item_ancestor flags for what the main query has in view.

Whether an object type has a meta table.

The meta query in flat query vars (meta_key, meta_value, the compare and type variants) as one clause, AND'd ahead of an explicit meta_query as its own group, as WP_Meta_Query::parse_query_vars reads them. An empty meta_value is no value.

Every row of an object's meta, values as stored, grouped by key in id order. @return array<string, list<string>>

update_meta_cache: each object's meta as all() gives it, the cached ones from the object cache and the rest read in one query and cached; an object with none has an empty list.

Every meta key an object type uses, once each, in key order. @return list<string>

Every row of an object's meta by key, then id, as the post meta box lists them: the key, the value, the row's id and the object's, all as stored (strings).

Every row of an object's meta in id order, for removing them one by one. @return list<array{meta_id: int, meta_key: string, meta_value: string}>

One meta row by its id, under the table's own column names, values as stored; null when there is none. @return array<string, string>|null

The column holding the object's id, and the one holding the row's: post_id and meta_id, user_id and umeta_id. @return array{0: string, 1: string}

Sets one row's key and stored value.

Inserts a meta row and returns its id.

The rows of one key on one object, in id order. @return list<array{meta_id: int, meta_value: string}>

Which of a key's rows an update touches: none when no previous value was named and the first row already holds the value, all of them when no previous value was named, otherwise only the rows holding it.

Sets the value of the given meta rows.

The rows a delete would take: by key, for one object or all, optionally only a stored value. @return list<array{meta_id: int, object_id: int}>

The objects whose value under the key is a number below the bound, lowest id first. @return list<int>

Deletes the given meta rows.

A value, a key's values, or every key's (get_metadata), the default when the key is unset.

What is stored (get_metadata_raw): false for no type or object, null for an unknown type or an unset key; get_{type}_metadata may answer first; else the object's meta, read once into the cache.

An unset key's value (get_metadata_default): empty, or an empty list, as default_{type}_metadata leaves it.

Whether a key is set for an object (metadata_exists), get_{type}_metadata answering first.

A value added (add_metadata): its id, or false; refused when unique and the key is already set.

A value changed (update_metadata): every row of the key, or only those holding the previous value given; a key not stored yet is added from the value as it was handed in (and the new row's id answers).

Values removed (delete_metadata): the key's, or only those holding the value given; for every object when all are asked.

Whether a key is private to code (is_protected_meta): one starting with an underscore, as the filter leaves it.

A value as its key's sanitizer leaves it (sanitize_meta), the subtype's own sanitizer first when one is hooked.

A meta type's table, or null when there is none: the built-in types, and a plugin's type by the table it set on $wpdb as "{type}meta".

A user's option (get_user_option): the site's prefixed key first, then the bare one; false for nobody or neither; as get_user_option_{option} leaves it.

One meta row by its id (get_metadata_by_mid): an object under the table's own column names, the value decoded, unless get_{type}_metadata_by_mid answers first; false when there is none.

One meta row removed by its id (delete_metadata_by_mid), with the delete actions for that row (posts and comments also told by their older names, with the row id alone), unless delete_{type}_metadata_by_mid answers first.

A post's meta (get_post_meta).

A post's meta changed (update_post_meta).

A user's meta changed (update_user_meta).

Every key of a post's meta (get_post_custom), the post being read's when none is named.

Registers a key; true when it joins the registry.

Takes a key out of the registry, and its callbacks off their filters.

The keys registered for an object type and subtype ('' for every subtype), in registration order. @return array<string, array<string, mixed>>

The keys that apply to one object: those for every subtype, then its subtype's. @return array<string, array<string, mixed>>

The registered default for a key as filter_default_metadata answers: the one for every subtype, else the object's subtype's; the value handed in when neither registered one.

The object's subtype: a post's type, a term's taxonomy, comment or user while they exist; '' otherwise.

A meta capability (edit, add or delete a post's, comment's, term's or user's meta) as the reference maps it: what editing the object needs, then the capability itself when the key is not allowed (protected, or refused by its auth filter); nothing for an object that does not exist. Null for any other capability.

Registers a meta type by its full table name; refused unless both are plain identifiers.

The full table name of a registered meta type, or null.

Every menu (wp_get_nav_menus): the nav_menu terms by name, empty ones too, as wp_get_nav_menus leaves them.

A menu by its term, id, slug or name (wp_get_nav_menu_object), or false, as the filter leaves it.

A menu's items (wp_get_nav_menu_items), or false for no menu.

A menu's items printed through the walker its arguments name, else the default (walk_nav_menu_tree).

The menu set for each of the theme's locations (get_nav_menu_locations).

The whole menu for wp_nav_menu(): resolve, fetch, decorate, walk, wrap, filter. Null when there is no menu (the caller's fallback runs); false when the items filtered away to nothing.

A menu item made ready to print (wp_setup_nav_menu_item), unless pre_wp_setup_nav_menu_item answers first.

The item dressed, whatever it was, then the filter (what wp_setup_nav_menu_item does past its pre filter).

wp_get_nav_menu_items for a menu found.

Whether a notice is raised: only under WP_DEBUG, and only while its filter (handed true and anything else given) still says so.

A deprecation of one kind (function, argument, hook, file or class): its name, the version that deprecated it, the alternative (for an argument, the message), and for a hook or a file a note added after the wording.

A class still constructed through its old PHP 4 style constructor, in its parent class when one is named.

A function called incorrectly, with why, and the version that added the message.

A notice's message as it would be raised, or null when it is not: wp_trigger_error_always_run hears every one; under WP_DEBUG, and unless wp_trigger_error_trigger_error silences it, wp_trigger_error_run hears it and it is cleaned to the markup a notice keeps.

The endpoint of the provider whose mask matches a URL, or null.

An oEmbed JSON body as an array, or null.

An oEmbed XML body as an array, or null.

The embed HTML for an oEmbed response, or null.

The provider endpoint a page names in its head: the first link of each oEmbed type (the linktypes map type to json or xml), JSON before XML, its address entity-decoded. Null when it names none.

Drops newlines from embed markup while leaving the inside of <pre> blocks untouched.

A cached value, or false.

Stores a value.

Stores a value only when the key is empty.

Removes a key.

Empties the cache.

Each group's size, its entries serialized, in bytes, in the order the groups were first written: what WP_Object_Cache::stats prints.

Empties one group.

The terms asked for apart, the taxonomies left (keys as they were), and the arguments for those.

The value as sanitize_option leaves it, through sanitize_option_{$option}.

A new option (add_option): refused when it already reads as anything but its default; its autoload flag decided when not given.

An option changed (update_option): the new value through its filters; an unchanged one writes nothing and tells nobody; one still at its default is added.

An option removed (delete_option): false when it was not there.

Stops the request at alloptions or notoptions, which nothing may write (wp_protect_special_option).

The autoload flag an option is stored with (wp_determine_option_autoload_value): "on" for on, yes or true, "off" for off, no or false; anything else is decided by wp_default_autoload_value (auto-on, auto-off) or left "auto".

Options' autoload flags set (wp_set_option_autoload_values): per option, whether its flag changed. Only false, no, off, auto-off and 0 mean off.

The options the engine keeps for itself: the symbol-gate cache a plugin could otherwise rewrite to pass its own gate, the recovery strikes, the cron lock, and the sign-in throttle rows. The facade refuses to write them; the engine writes them through this class directly.

The engine's own caches, read on demand and written with autoload off (Site::setOption). Rows an older engine wrote autoloaded are set right the first time a loaded list holds them.

The autoload column values that load an option with every request, in the reference's order.

Options not autoloaded that are read on every request (the symbol survey, recovery's paused plugins, the site language, the HTTPS migration flag, and the post types and taxonomies Minn Admin keeps and registers as it loads): read together as a request begins, as one read rather than one each.

Whether this store reads through the given connection.

Whether plugin code is refused a write to this option.

The autoloaded list as wp_load_alloptions() gives it: pre_wp_load_alloptions may answer first (told whether the cache was forced), and then alloptions is not heard; otherwise the list the group holds, through alloptions, which may add or change entries without the group keeping them.

An option as get_option() reads it, through the filters plugins hook: pre_option_{name}, then pre_option, may answer first; then the autoloaded list is read through its filters on every read; an unset option is its default (false when none is given) through default_option_{name}, which is told whether one was given; a set one goes through option_{name}.

An option's stored text, as Db::option() gives it, or null when it is unset: from the list or the group, a value written this request in its stored form (true as "1", a list serialized).

An option's value, decoded, or null when unset; home and siteurl answer to wp-config.php's constants.

Reads several options at once (wp_prime_option_caches): the ones not held yet in one query, each kept under its own key or noted unset, as a read of each one alone would leave them.

Whether an option exists.

Whether a read this request already found the option unset (the reference's notoptions).

Writes a new option. add_option has already decided it is new (its value is still the default); a row that is there anyway is written over, as the reference's add does, and false comes back when it already held this value. An autoloaded one joins the list.

Writes an option row whether or not one exists, as the reference does for every add: two requests that both find a transient missing and both add it must not fail on the unique name, so the second write lands over the first. True when the row was inserted or changed, false when the same value was already there.

False when the value is unchanged, as the reference reports.

Flips the autoload column; false when the option is missing or already so. The list is read again, the option's own key dropped.

Stops an option loading on every request; false when it already did not, or is unset. It leaves the list.

Removes an option: out of the list or its own key, and known unset.

The names of transients whose expiry has passed. The timeout row is the one that knows, so the sweep reads those and hands back the bare names.

Brings the group back in step with an option the engine wrote behind the store (its own rows, the CLI): the row is read again, into the list when it autoloads, and nothing else written this request is lost.

What the reference stores (maybe_serialize): arrays and objects serialized, a string that looks serialized serialized again so it reads back as that string, other scalars as their string form.

A stored option value decoded the way the reference reads it.

Hands the group to an object-cache.php drop-in's functions.

A key's value, found only when this request may trust it.

Stores a key; a drop-in is written only when it holds something else.

Removes a key.

The pages get_pages() answers for parsed arguments.

The post query the get_pages() arguments amount to, shaped as the reference hands it to get_pages_query_args (probe filter-inputs-2): the order by the columns as named, then (unless pages are picked by id) the excluded ones and the meta pair, the number or -1 and the offset, the type, the statuses as a list and the cache flags; then the picked pages, the authors and the parent, each when given.

The pages as the reference leaves them: with a hierarchy (unless a parent is named or pages are picked by id) or a child_of, only what descends from that page (the root by default), each parent followed by its subtree; then any branch left out, its places left empty.

What descends from a page within the list, depth first, siblings in list order (get_page_children); a page whose parent is not reached is left out.

Every page under one ancestor, in list order. @param list<object> $pages @return list<object>

Registers a block pattern, or the refusal.

Forgets a pattern.

One pattern, or null.

Every pattern.

The patterns registered after init, which the editor lists separately.

Registers a pattern category, or the refusal.

Forgets a category.

One category, or null.

Every category.

The categories registered after init.

Registers a block style, or the refusal.

Forgets a block style.

One block style, or null.

Every block style, or one block's.

Logs a call to a method of a real class that Minn answers with nothing by design (an admin-screen helper): compat-status counts the method as a dead end, where a hit() marks one still owed.

Logs a placeholder symbol being called, when the trace file exists.

Fills a query's placeholders from the arguments; null when one has no argument.

fill() with what wpdb::prepare reports alongside: how many placeholders the query has (%% not among them) and the type of each argument it could not use (an array or an object fills as '').

Activates one plugin ("dir/file.php"), announcing it to the hooks given, or to nobody (silent); null when it is active afterwards with nothing to report.

Deactivates plugins ("dir/file.php" each), announcing each to the hooks given, or to nobody (silent); those not active are passed over.

Where a plugin's folder really is, noted under the folder as given (wp_register_plugin_realpath); a file not on disk notes an empty place. The plugins and must-use folders themselves are refused.

A plugin file's name under the plugins or must-use folder (plugin_basename), a symlinked folder read as noted.

A plugin's headers (get_plugin_data), marked up and translated unless asked not to be; a plugin in its own folder that names no text domain uses the folder's name.

The headers as the plugin screens show them (_get_plugin_data_markup_translate). Translated: the plugin's domain loaded from its folder unless it is already, then the name, addresses, version, description and author through it. Always: the text cut to a, abbr, acronym, code, em and strong, the addresses escaped. Marked up: the title and author linked, the description texturized with its "By" line.

Whether a plugin can be uninstalled (is_uninstallable_plugin): it registered an uninstall callback, or ships an uninstall.php.

delete_plugins: true, false for none asked, or the error naming those left behind.

uninstall_plugin: pre_uninstall_plugin, then the plugin's uninstall.php (WP_UNINSTALL_PLUGIN naming it) or the callback it registered (heard on uninstall_<file>, with the plugin loaded); either is forgotten once run.

Null when the plugin may be activated, otherwise why not.

What the site's plugins offer for themselves, empty when no runtime is booted or nothing filters the transient.

The filtered transient as the state's two buckets: offers under `plugins`, plugins that answered "current" under `no_update`, both as arrays, and only for files this site actually has.

Loads the active plugins as code and fires the boot hooks. Recovery is armed for exactly this window: a failure here is one every visitor would hit, so it may be recorded against its extension.

The theme's setup without the plugins: setup_theme, the theme's functions.php, after_setup_theme, then wp_loaded. The probe runtime ends its boot with this, so a theme's supports are what a request's would be and a late declaration is judged as one; it skips init, whose work the probes compare on their own.

The plugins that loaded.

The plugins the symbol gate refused, with what they lacked.

Loads one plugin's main file now, as activating it does: the reference includes the file (once) before activate_plugin fires, so the plugin's activation hook is in place to hear activate_<file>, and announces no plugin_loaded for it. The same gate as the boot decides, its folder walked again first; null once the plugin is running, otherwise why the gate refused it.

True when the named plugin file is running as code this request.

A post's caches let go (clean_post_cache).

A post made the one being read (setup_postdata): through the query being answered when there is one (which tells the_post), else its globals set here; false for no post.

The loop's globals for a post: its id, author, dates, pages and whether more shows.

id, authordata, currentday, currentmonth, page, pages, multipage, more, numpages. The page comes from the query given (the main query otherwise); more is set on a single, a page or a feed, or past the first page of a post split into pages (probe query-compat).

The content get_the_content gives: the asked page, cut at the more tag unless "more" is set.

A post deleted for good through the reference's own deletion, so its hooks fire and its children (revisions, autosaves) go with it: the one path every permanent delete takes. Deleting needs the facade, so unlike the events it runs only under a booted runtime, which the engine's write routes are. Answers what the deletion answered.

A post (an attachment too) sent to the trash through the reference's own trashing, as deleteForGood deletes.

Whether plugins are loaded to be told anything.

Before the row is written: pre_post_insert for a new post, pre_post_update for one that exists. @param array<string, mixed> $columns

Once the row is written: the caches, the status transition, the edit actions of an update, the save actions.

A post keeps a category through every save, the default when it has none: through wp_set_post_categories with plugins loaded (which tells them, set_object_terms included), quietly without.

The terms a REST body names, set through wp_set_object_terms with plugins loaded, quietly without: a plugin's type takes its own REST taxonomies under their REST bases (probe rest-plugin-types).

The meta a REST body names: through the registered keys with plugins loaded (probe rest-meta; a plugin's type only when it supports custom fields), core's own written directly without.

A new attachment's metadata made by the runtime, as the reference's REST upload makes it: wp_generate_attachment_metadata over the stored file (the sizes cut with the attachment's id, the metadata stored as each one lands, so an optimiser hooked there finds it), then wp_update_attachment_metadata. Every upload has some: an image its sizes, a PDF its previews, any file its size (probe hook-inputs-2).

rest_insert_{type}, before the request's own terms and fields are applied; a post with no $before is a new one.

rest_after_insert_{type}, once the request's terms and fields are in; a post with no $before is a new one.

wp_after_insert_post, last; the revision of an update is saved from it.

rest_delete_{type}, after a trash or a delete, with the post as it was answered and the response. @param array<string, mixed> $data

One field in a context (sanitize_post_field).

Every field of a post object or array in a context (sanitize_post), unless it is in that context already.

Text made ready for an edit field (format_to_edit): through format_to_edit, encoded for a textarea unless rich.

Whether the user edits in the rich editor (user_can_richedit): their preference, and a browser that can.

The columns the posts table takes, filled from a postarr, with a new post's defaults. @param array<string, mixed>|null $existing @return array<string, string>

A post with nothing in title, content, and excerpt is empty when its type supports all three. @param array<string, mixed>|null $existing

The columns as they will be written: the status a request lands in (attachments inherit, unprivileged publishes pend, a future date schedules), the dates, the slug (sanitized; not yet free), and the integer columns.

Writes the resolved columns; a new post without a guid gets the ?p= form. @return int the post id

The categories a saved post should carry: the ones given, or the default for a new post of a type that has categories; null when nothing should change.

The slug kept as its placeholder.

The address an editor previews: a draft as if published.

A post's address by its kind (get_permalink): a page's, an attachment's, a plugin type's or a post's; false for no post. A post filtered for "sample" is shown as it would be published.

A page's address (get_page_link): the home address for the front page; then page_link.

A page's own address, front page or not (_get_page_link); no such page is the plain address with no id.

An attachment's address (get_attachment_link), or false.

A plugin type's post address (get_post_permalink), or false.

A post's address (not a page, attachment or plugin type).

A page's own address, before page_link: ?page_id= while unpublished, its tag when the name is left, else its path.

An attachment's address: under a parent it belongs to, else its own slug, else ?attachment_id=.

A plugin type's address by its pattern, by its query var, or by the type and id plainly.

The address an editor shows with the slug to edit, and the slug (get_sample_permalink); two empty strings for no post.

The address an editor shows with the slug to edit: the post as if published, its name made unique, the address with the name left, a page's parents written in.

The id of a post with this title among the types, or null.

Revision rows newest first. @return list<array<string, mixed>>

How many posts of a type there are per status.

How many attachments there are per mime type.

How many posts an author has among the types and statuses.

Post counts for several authors at once, as stored (strings), for those that have any.

How many authors (up to a limit) have published posts of a type, for is_multi_author.

Post counts by author for wp_list_authors: the types' posts in the statuses given, and the private ones of the viewer (an id, or -1 for none) beside them.

Every post id of an author.

The attachment whose stored file path is the given one.

Runs a query object's variables and fills it in: the posts (or ids, or id => parent), the request, the counts. Returns what get_posts returns.

A search's WHERE fragment, settling the search variables (the terms, how many the string split into, the title matches its order ranks by).

The search stopwords, translated and filtered. @return list<string>

The pieces posts_clauses and posts_clauses_request see, in their order.

Whether an attachment's status follows its parent's (a taxonomy archive's attachments).

The post type the query settles on: a name, a list, `any`, or empty.

The statuses asked for by name, which a single post's status check lets through. @var list<string>

The seven pieces by name. @return array<string, mixed>

Takes back the pieces a clauses filter returned; one it dropped becomes empty. @param array<array-key, mixed> $clauses

The SELECT as the reference writes it, line breaks and all, for the given field list.

Settles the posts a query found: status check, stickies, the_posts, then the count and the current post. @param array<string, mixed> $q

Settles the post type the caps come from: a list of several types has none (its caps are named for multiple_post_type), any other names one.

Appends the type and status clause. @param array<string, mixed> $q

The tax query a set of variables makes, settling the variables it reads.

The post types a taxonomy archive with no type searches: every searchable type the queried taxonomies are registered for, one as a string, several sorted, none as `any`.

The compatibility variables the queried terms set: taxonomy and term (or term_id) from the first taxonomy other than category and post_tag when none is set, and cat, category_name and tag_id from those two.

Menu order, the m date, the date variables and the date_query. @param array<string, mixed> $q

The post a slug, a page path, an attachment slug, a name list, an id or an id list names, and the parent; a post type's query var stands for the name (the page path, for a hierarchical type).

Authors (an author list's negatives become author__not_in, which wins over author__in), an author slug, a comment count, and mime types. The slug and mime clauses wait to follow the search.

A password, or whether there is one, and comment and ping status. @param array<string, mixed> $q

A page's path from its ancestors' slugs (get_page_uri), or false.

A page by its path (get_page_by_path): one type looks among attachments too; a list looks among exactly its types.

A post's type (get_post_type), or false.

A post's status (get_post_status): an attachment's is its parent's (a trashed parent's from before the trash); false for none.

One of a post's fields in a context (get_post_field), empty when there is none.

Whether a post can be viewed by anyone (is_post_publicly_viewable): its type and its status both viewable.

When a public post was last published or changed (_get_last_post_time), in GMT, the site's time or the server's (with microseconds); false for none or a question it cannot answer.

When a public post was last published (get_lastpostdate), as get_lastpostdate leaves it.

When a public post last changed or was published, the later (get_lastpostmodified), pre_get_lastpostmodified answering first.

Posts by query arguments (get_posts): five published posts by date unless asked otherwise, numberposts read as posts_per_page, category, include and exclude read as the query's own, stickies ignored, no rows counted.

A post's children (get_children), the post being read's when none is named, keyed by id, as objects or arrays.

A post's categories (wp_get_post_categories), their ids unless asked otherwise; empty on an error.

The WHERE clause for MIME types (wp_post_mime_type_where), a wildcard or a list.

The SQL limiting posts to what may be read (get_posts_by_author_sql): an author's own, the published, and the private ones the reader may read.

Posts read into the caches together (_prime_post_caches): rows, and their meta and terms unless asked not to.

A list of posts kept in the caches (update_post_caches): whole posts kept as they are, then primed.

The post an address names (url_to_postid): a ?p= or ?page_id= id, else with pretty permalinks a page by its path, a post whose own address it is, or an attachment by its own; 0 for none.

A post's revisions (wp_get_post_revisions), newest first unless asked otherwise, keyed by id (or a list of ids); none while its revisions are switched off, unless check_enabled is false.

How many revisions a post keeps (wp_revisions_to_keep): WP_POST_REVISIONS (all, -1, when unset or true), none for a type without revision support, then wp_revisions_to_keep and wp_{type}_revisions_to_keep.

Whether a post keeps any revisions (wp_revisions_enabled).

A revision deleted (wp_delete_post_revision); anything but a revision is left alone, and nothing comes back.

The fields a revision keeps (_wp_post_revision_fields), through _wp_post_revision_fields; the filtered list is what the next call starts from, as on the reference.

A revision's row (_wp_post_revision_data): the post's revision fields, its parent, inherit, revision, its name, and the post's modified time as its date.

A post as a revision's row is made from: its own fields, as an (array) cast gives them.

The new revision's id, or null when none was called for.

The revision (or autosave) row _wp_post_revision_data made, written through wp_insert_post, then _wp_put_post_revision; its id.

The columns to write after the filters.

A direct save's changed columns through every column's db context, as an update runs them over the whole post (pre_post_* and *_save_pre, where kses and the global styles strip sit): a global styles save writes its post this way (probe global-styles-unfiltered). Without a booted runtime the changes are as given.

wp_insert_post's array with its defaults filled in (ID 0 for a new post), through sanitize_post's db context: slashed in, slashed out.

wp_insert_post_empty_content over whether a type with an editor, a title and an excerpt has none of them. @param array<string, mixed> $sanitized

The parent through wp_insert_post_parent (whose default refuses a loop). @param array<string, mixed> $sanitized