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.

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.

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 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.

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.

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.

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 query's top-level comments with their descendants filled in.

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

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 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.

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 value through every early callback on the tag, lowest priority first; as given when there are none.

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].

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.

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.

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.

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.

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.

wp_setup_nav_menu_item: the item dressed, whatever it was, then the filter.

wp_get_nav_menu_items for a menu found.

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}.

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.

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.

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

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 (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: 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

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

A live post's slug through the reference's three filters: pre_wp_unique_post_slug may settle it; otherwise it is made free in its type's scope, the bad-slug filter judging the slug asked for when nothing else has taken it; and wp_unique_post_slug has the last word.

The row's guid and slug as wp_insert_post settles them (probe insert-defaults): an update keeps the guid it had, in its display form, ignoring a new one asked for; a live post's slug goes through the slug filters.

Whether a save leaves the slug as it is: a draft, a pending post, an auto-draft, a revision, a personal data request.

The row through wp_insert_post_data (wp_insert_attachment_data for an attachment), handed slashed as the reference hands it and unslashed back.

The queried object the query vars and flags point at.

The variables with every one the reference fills given its empty value: the template's keys up to search_columns (the ones after it are get_posts' own, settled when the query runs).

The is_* flags the query vars amount to.

The first registered taxonomy (other than the two built-in ones) whose query variable carries a value, as [taxonomy name, query var].

Seconds inside which a second boot failure pauses the extension.

The extension a file belongs to: a plugin as the active `folder/file.php` whose folder holds the file (or the bare file of a single-file plugin), a theme as its slug. The name is the one the loader checks against the paused list, so a fatal deep inside a plugin's subfolders pauses the plugin and not a folder nothing is called by. Anything outside the plugin and theme folders belongs to nobody, and is never paused: a fatal in the engine or in core is not a plugin's fault and pausing something would not fix it. A symlinked plugin reports its real location; the realpath map (real folder to the folder under plugins/) brings it home first.

Records an extension as paused. Returns false when it was already paused, so a caller can tell a fresh failure from a repeat and only notify once.

Notes a boot failure against an extension. True when it is the second inside the window, which is when the caller pauses it; the first is only remembered. Strikes older than the window are dropped as they are read, so the option never grows.

The plugins recovery mode has paused.

The themes recovery mode has paused.

The extensions of one kind ('plugin' or 'theme') recovery has paused.

Lets every extension of one kind load again. Returns how many were released.

Lets an extension load again. Returns false when it was not paused.

Lets everything load again. Returns how many were released.

Every registered setting by option name, in registration order. @return array<string, array<string, mixed>>

register_setting: $args an array, or (as it once was) the sanitize callback alone.

unregister_setting: the setting, its sanitize callback and its default gone, unregister_setting fired.

A setting's registered default, or $default when it registered none.

register_initial_settings: core's settings, each through register_setting.

Every post type.

One post type, or null.

Every taxonomy.

One taxonomy, or null.

Makes the one object for each registered type and taxonomy and binds $wp_post_types and $wp_taxonomies to them, as the reference shares them: a plugin changing one (relabelling Posts) is heard by every reader (probe type-object-sharing). Called once the facade classes exist; later registrations make their own.

The one object for a registered post type, or null.

The objects of every registered post type, in registration order.

The one object for a registered taxonomy, or null.

The objects of every registered taxonomy, in registration order.

Every post status.

One post status, or null.

The built-in types', taxonomies' and statuses' labels in the site's language, as the reference registers them again on init: each label asks for its own message (data/registry-labels.json, captured from the reference), and a type's single-item template and a taxonomy's archive template are named after the singular name. Rows and the shared objects both take them; what a plugin set before init gives way, as it does there.

Takes a built post type as the registered one: the object register_post_type made is the one every reader shares, and its properties are the type's row. Registering again puts a new object in the old one's place, as on the reference.

A type's labels from its own (probe post-remaining): the labels of its base type (page for a hierarchical type, post for any other) under the type's own. A missing name comes from the type's label, a missing singular name from the name, the menu name from the name, all items from the menu name, archives from all items, and the admin bar name from the singular name or else the type's name; a type with a singular name also names its single-item template.

A taxonomy's labels from its own (probe taxonomy-remaining): derived as a type's are, under the category labels for a hierarchical taxonomy or the tag labels for any other; one that names no template takes "%s Archives" with the singular name it ends up with.

A type's capability names (probe post-remaining): the eight primitive ones, the six more a mapped type uses, the type's own names merged over them, and create_posts last, the edit capability unless named.

Forgets a non-builtin post type.

Adds a feature to a type, registered or not: the reference keeps features apart from the type objects, so declaring one does not make the type exist. A feature with arguments keeps all of them.

Removes a feature from a post type.

Removes every feature of a post type.

The features a post type supports.

The default labels of a family as label => [the plain one's, the hierarchical one's]: post and page for types, tag and category for taxonomies, from the built-in data (WP_Post_Type::get_default_labels).

Takes a built taxonomy as the registered one, the object every reader shares, its properties the taxonomy's row.

Whether a registered rewrite settles into its full form: with pretty permalinks or in the admin; otherwise it stays as given.

Forgets a non-builtin taxonomy.

Attaches a taxonomy to a post type.

Detaches a taxonomy from a post type.

Registers a post status.

generate_rewrite_rules: the rules for one structure.

rewrite_rules: every rule, assembled and filtered.

The rules as the engine itself would make them, in their stored form and with no plugin's filter or action on them: what the stored rules are when no plugin changed them. The site's rewrite is left as it is.

The built-in taxonomies' tags and patterns, set once on the site's rewrite under the front of the structure then; a structure set later leaves them, and a plugin's, as they were (probe registry-rewrites).

A post type's archive rules, which join the top rules as it registers (probe cpt-rules): its archive slug (the rewrite slug when the archive is just true) under the front of the structure, or the root when the type opts out of the front; the archive, its two feed rules when the type has feeds, its pages when it has those.

Whether a structure begins with a tag that could be a page's path too (use_verbose_page_rules).

The runtime for one request. Everything about the request itself comes from the context; the fields below it are the same values, kept as properties because plugin code reaches for them by name.

The database door this request answers through.

The site's options.

The request being answered, absent on the command line.

Who reads this request; settled again (identify()) once plugins have said who the user is.

The capability engine.

The minn/ folder: the engine's own files.

The site root with a trailing slash.

The WordPress release whose contracts the runtime speaks.

The request's reader from now on: the user plugin code named through determine_current_user (Runtime\CurrentUser).

Holds the extension seams this request registered, so nothing static has to.

The extension seams, or null before the front has registered any (REST and the CLI never do).

The render state for this request, made on first use: one set of counters for everything rendered.

Makes a render state this request's, so a renderer that brought its own is the one the leaves read.

The block renderer for this request, made on first use over this request's own database door.

Makes this request's runtime the one the facade sees and defines the facade.

Deliberately does NOT start the facade's registries empty. A process answering a second request would then have a fresh hook table that no plugin can fill again: plugin files register their hooks as they are included, and an include happens once per process. Until a plugin's registrations can be replayed, a second boot inherits the first's registries on purpose, which is why a worker runtime is not yet something the engine claims (see contracts/runtime.md).

The booted runtime; throws when there is none.

Whether the runtime is up.

The hook registry.

The options store.

The options store for a connection, made as soon as the request has one (Engine::answer) and kept by the boot that follows: the reads made while routing come from the same autoloaded list as everything after, and Db::option() reads through it from then on.

Whether this request is installing (wp_installing()); false before a runtime boots.

Tells the option store about a row the engine wrote behind it; nothing to do when no store was made.

Runs an action and returns what it printed. Plugin callbacks may open output buffers of their own during the action (a page post-processor started in wp_head) or close one they think is theirs (the same plugin in wp_footer); a sentinel buffer under the capture keeps the output either way: extra buffers are flushed through their handlers into the capture, and a capture closed early lands in the sentinel.

Content the engine rendered itself, through the_content for everything else hooked there.

The object cache.

The text domains loaded for this request.

The locales this request switched into.

The shortcode registry.

The script modules registry.

The interactivity API.

The registered block templates.

The post types, taxonomies, and statuses.

A fresh post query over the runtime's registry.

A per-request state value.

Sets a per-request state value.

Whether the request is over HTTPS.

wp-content under the site root.

Defines the facade functions once; safe to call again.

The pluggable functions, once the plugins have had their chance to define their own: each is defined only where no plugin did. The plugin loader calls this before plugins_loaded; a boot that loads no plugins calls it straight away.

Fresh per-request state, for suites.

Why a strategy or fetch priority value is refused, as the notice the reference gives; null when the value is fine (empty is fine).

The strategy a script loads with: 'defer', 'async', or '' for blocking. @param array<string, true> $checked

Whether the head pass holds a script for the footer: one that asked to be delayed but has inline code after it, with nothing enqueued that depends on it.

A script's own fetch priority and the one it loads with. @return array{0: string, 1: string}

Registers a module by id.

Queues a module, registering it when a source is given.

Removes a module from the queue.

Forgets a module.

Sets a module's fetch priority.

Moves a module to the footer or the head.

Prints a module in the head; false when it is not registered.

The module ids queued.

One registered module, or null.

The import map script tag.

The modulepreload links.

The head's module tags.

The footer's module tags.

The script-module-data tags.

The a11y module's tag, once.

Under the site's wp-content, so backups and migrations carry it.

Where the script pack lives under wp-content.

Whether the script pack is on disk.

Every handle the pack can register: the packages manifest keyed by `name.js` becomes `wp-name`, plus the three vendor handles. A handle whose file is missing from the pack is skipped rather than registered against a 404.

Copies the packages out of a WordPress tree (or an unpacked core download) into the site's pack directory. Only the built JavaScript and the manifest are taken, and only from the paths they live at, so a wrong source folder copies nothing rather than something odd.

Removes the pack; the engine's own packages keep working without it.

The attribute pattern shortcode_parse_atts reads by (get_shortcode_atts_regex).

The registry itself, by reference, so the $shortcode_tags global plugin code reads and copies is this array and not a snapshot of it.

Registers a shortcode.

Forgets a shortcode.

Forgets every shortcode.

Whether a shortcode is registered.

Every shortcode with its callback.

Replaces the registry, after a save-and-restore.

Every shortcode name.

The regex matching the registered shortcodes, or null for none.

Content with its shortcodes run (do_shortcode, probe shortcode-run): only the registered names the text holds; inside HTML tags first (inTags: run, or with 'escape' as with ignore_html, left alone), then in the text, each through run(); the brackets set aside as entities come back at the end. Images rendered meanwhile see the do_shortcode context.

One matched shortcode (do_shortcode_tag): [[tag]] gives the tag as written; otherwise pre_do_shortcode_tag may answer, or the callback runs with the attributes, the content ("" when it closes itself) and the name, and do_shortcode_tag sees the output in its brackets.

Shortcodes inside HTML tags (do_shortcodes_in_html_tags), run before the text: a quoted attribute value's shortcode runs and the attribute is judged again by kses, kept when anything is left; an unquoted one (or one standing as a name or as the tag) runs as written. Comments, CDATA and, with 'escape', every tag are left alone. Brackets left in a tag (and entities already written for them) are set aside so the text pass cannot reach them.

Content with its shortcodes taken out (strip_shortcodes): the names strip_shortcodes_tagnames leaves, never inside a tag; [[tag]] gives the tag as written.

One matched shortcode taken out (strip_shortcode_tag): its outer brackets stay, [[tag]] gives the tag. @param array<int, string> $m

Shortcode attribute text as an array (shortcode_parse_atts): no-break and zero-width spaces read as spaces; name=value pairs (names lower case) and bare values in order, each a token followed by whitespace or the end, backslash escapes undone; a value holding "<" that is not whole tags becomes "".

Registers what a record naming this class becomes.

The reviver the serialized reader takes: PHP's array wrappers rebuilt, a factory's object, or the properties as they are.

Whether a factory is registered for the class.

Forgets every factory, for suites.

Reads the reference's interface and subtracts everything the loaded facade defines. A plugin may define a name as it loads, so each call asks again, but only about the names still lacking: a name once defined stays defined, and asking about all four thousand for every plugin was a cost of its own.

The gap read from the engine's own files without loading them, for a machine that has the engine but runs no site with it yet (preflight): a name counts as defined when a facade file declares it.

The gap read from its JSON file.

Whether the runtime lacks a function.

Whether the runtime already defines a function of the reference's interface, so a plugin declaring it again without a guard would fail to compile. The pluggable functions are not counted: the runtime defines those after the plugins load, each only where no plugin did.

Whether the runtime lacks a class.

The gap as JSON.

Notes a function called.

Notes a class referenced.

Notes a function the folder declares, a method included: a call by that name is not a need.

Notes a function declared in the global scope, which the runtime must not already define.

Notes a class the folder declares.

A name an existence check protects: function_exists, class_exists, defined, and the rest.

The table as the gate reads it.

What a plugin folder needs that the runtime lacks, cached by mtime.

The folder is walked again at its next check instead of trusted on its fingerprint: an install, an update or an activation never waits out the window. The walk still keeps the cached read when nothing changed.

The functions one file declares in the global scope, unguarded, that the loaded runtime already defines: including that file would not compile.

The same read against an exported gap instead of the running engine, so a folder can be judged with no database, no options, and no facade loaded.

What a folder needs and what it reaches that Minn answers with nothing, in one read, for a machine judging a site before the engine runs it (preflight): the gate's verdict against the gap given, and the dead ends it calls (the wp-admin screens, the editors, the Customizer, XML-RPC, what was left out), by area. A call the folder guards or answers itself is not counted, as the gate counts it.

An attribute's value, or null.

Whether the tag has an attribute.

true sets a bare boolean attribute; a URL attribute (href, src, ...) keeps only a URL whose scheme is allowed, as the reference's set_attribute keeps it.

Removes an attribute.

Adds or removes a class.

Removes a class, and the attribute when it was the last one.

Sets or removes one inline style property.

The tag as edited.

Whether plugins are loaded to be told anything.

A term created over REST with plugins loaded, as the reference's controller creates one (probe rest-term-save): the request's fields as the prepared term, through rest_pre_insert_{taxonomy}, into wp_insert_term; a refusal is its REST error.

A term changed over REST with plugins loaded: the fields the request sends, through rest_pre_insert_{taxonomy}, into wp_update_term (when any are left); a refusal is its REST error.

Deletes a term, then tells plugins over REST with the term as it was and the response.

rest_insert_{taxonomy}, then rest_after_insert_{taxonomy}, with the term as it stands and the request.

The fields sanitize_term runs, in its order.

One field's value in a context; a lookup with no taxonomy names false, and its filters get false.

A term (object or array) with each of its fields in the context, and its filter set to the context; the term's own id goes to the filters.

ASC when asked for, DESC for anything else.

The ORDER BY body for an orderby value, filtered as the reference filters it.

A meta key, meta_value[_num] or a named meta clause as SQL (parse_orderby_meta), or '' when the query has no such clause.

A term row joined with its taxonomy row, by id (and taxonomy when known). @return array<string, mixed>|null

The term id and taxonomy a field value names; null when nothing matches or the field is not one a term can be found by.

Whether a term (by id, or by slug or name) exists, optionally under a taxonomy and parent; the ids when it does.

The term whose slug or name (as stored) is exactly the value, optionally in a taxonomy and under a parent (0 for the top level).

Whether any term in the taxonomies (any taxonomy for null) sits under the parent: the reference answers a lookup under a childless parent with nothing before it looks.

Whether a term other than the one named holds the slug, in any taxonomy.

get_terms() arguments normalised: the "get all" shortcut, integer lists, sanitised slugs.

The term rows the arguments match, ordered and paged, with the tree filters applied.

Every parent in a taxonomy that has children, mapped to its children's ids. A taxonomy nobody nested reads as an empty map.

Every term id under a term, however deep. @return list<int>

The object ids attached to any of the terms in any of the taxonomies. @param list<int> $termIds @param list<string> $taxonomies @return list<int>

Runs a term query object's variables: its terms in the shape the fields ask for, a count, or what a plugin answered first.

The terms the rows name, keyed as the rows were.

The terms after the tree has had its say: descendants only, padded counts, empty branches dropped, the page cut.

Each term's count raised to the published posts in it or under it, as _pad_term_counts does for a hierarchical taxonomy.

The terms in the shape the fields ask for.

A new term's ids, or why not.

A changed term's ids, or why not.

Deletes a term; objects left without a category fall back to the default one. Returns the object ids the term was attached to.

Makes an object's relationships in a taxonomy exactly $keep (or $old plus $keep when appending), in the reference's order: each new relationship between add_term_relationship and added_term_relationship, the counts of those terms, then the ones that went, between delete_term_relationships and deleted_term_relationships, and their counts. $count recounts a list of term_taxonomy ids and tells plugins (wp_update_term_count); without it the taxonomy is recounted quietly.

Removes the given relationships between delete_term_relationships and deleted_term_relationships, then recounts those terms; true when any row went.

How many objects in the counted statuses a term holds, as the stored count keeps it (published ones unless a plugin widens the list).

Gives a taxonomy row that shares its term with another taxonomy a term of its own (the same name, slug and group), and moves its children under it. Null when no other taxonomy holds the term.

Every object filed under a term, whatever it is: the count a taxonomy of links or other non-posts keeps.

Stores a term's count.

The term ids behind term_taxonomy ids, as stored (strings), in the order given. @param list<int> $ttIds @return list<string>

Every feature the theme has declared, as stored. @return array<string, mixed>

add_theme_support: false when refused. @param list<mixed> $args

remove_theme_support: false when the theme did not support it.

_add_default_theme_supports: what every block theme supports before its own setup.

wp_enable_block_templates and wp_setup_widgets_block_editor: a block theme's templates, and the block widget editor for any theme.

_custom_header_background_just_in_time: the header's and background's defaults filled in once loaded.

register_theme_feature: true, or why the feature cannot be registered.

Core's features, then those registered since. @return array<string, array<string, mixed>>

The active theme's supports as wp/v2/themes shows them: each feature shown in REST, shaped by its schema. @return array<string, mixed>

One feature's support as the REST API shows it (the runtime's WP_REST_Themes_Controller::prepare_theme_support): a feature that is not variadic shown by its first value, through its prepare_callback or else cut to its schema.