Minn\Content

The classic paragraph rules: a blank line makes a paragraph, a single newline a line break when asked.

Post content as HTML: blocks through the renderer, classic content through the paragraph rules.

The block renderer of the request being answered, which its runtime holds and builds over that request's own database door. With no runtime (the command line, the unit suite) one off-request renderer stands in.

Plain prose to paragraphs: texturize, split on blank lines, <br /> on single newlines. Shared by classic post content and comment text.

The text with its addresses made links: $url gets [whole, before, address, trailing], $web the same for a www. or ftp. host, $email [whole, before, user, domain].

A URL's trailing ")" taken off while the URL closes more parentheses than it opens: [the URL, what was taken off].

The class list a comment's list item carries, in the reference's order.

A record from a comments row; a missing column reads as empty.

A record for every row, in order.

The stored row, for the writers and shapers that still spell columns.

Approved, and so public.

Held for moderation.

A plain comment: the type column is '' on old rows and 'comment' on new ones.

One stored column by its database name, or null.

The migration bridge: the record answers to its column names the way the row did.

The migration bridge: one column by its stored name, or null.

Records are read-only; writes go through the repository.

Records are read-only; writes go through the repository.

The comment with this id, or null.

One meta value of a comment, or null when it has none.

Adds a meta row; a second row with the same key is allowed, as the reference allows it.

The same words on the same post from the same person, in any status but trash or spam.

The id of a comment this one would repeat (same post, same author, same words, not spam or trash), or null.

When the commenter last commented since the GMT time given, as a Unix time: matched by user id when signed in, else by address, or by email either way. Null when they have not.

Held comments per post, for the ids given (a post without any reads 0).

True when this name and email already have an approved comment.

Inserts a row from column => value pairs and returns the new id.

Sets the given columns on one comment.

How long each comment form field may be, read from the table as it is: a character column allows its declared length, a text column ten bytes fewer than it holds. A column the schema does not describe keeps the stock table's length.

The ids of every comment on a post, whatever its status, oldest first. @return list<int>

Every comment on a post as id => status, which the trash keeps to give back. @return array<int, string>

Sets one status on the given comments. @param list<int> $ids

A deleted comment's replies move up to its parent.

Removes the comment and its meta; the post's count is the caller's to recount.

Recomputes a post's stored comment_count (approved comments only).

DB approval token to the wp/v2 status string.

wp/v2 status parameter to DB token(s); null for an unknown status.

The columns an update really changes, compared as strings against the stored row; the approval shorthands hold/approve become the stored 0/1.

Tables the engine already speaks. Anything else is plugin data.

Built-in types the engine stores. Public ones are in data/types.json; the rest are silent core types that still occupy the posts table.

post_content that a visitor (or a theme template) can actually see.

Opening shortcode tags in $content. Escaped [[tag]] is skipped; closers [/tag] never match because a tag name starts with a letter.

Block names in $content, namespace included. A delimiter without a namespace is core/, matching the parser.

The tables under the prefix that are not the reference's own.

Group extra tables by the first underscore segment. Wordfence's tables are wfHits and wfls_* with no shared underscore prefix, so those two stems collapse to one family.

The post types in use that the reference does not register itself.

The block names that are not core/*, with their counts.

Names sorted and comma-separated, cut with a count past the cap.

Each emoji character in the text as its hexadecimal entity.

The text with its emoji as images under $baseUrl (each file named for its code points, $extension after).

The more tag ends a listing's excerpt but not a feed's, and a feed texturizes before the tags go (so inline code keeps straight quotes) where a listing texturizes the finished text.

The drop-ins a single site recognises, in the reference's order: the file => its description and the constant that must be true for it to load (true when nothing gates it).

Regular plugins, then must-use, then drop-ins, each group sorted by name.

The mu-plugins folder's PHP files, each with its header.

The drop-in files present in wp-content.

Every theme folder with its style.css header.

Every regular plugin's main file: relative "dir/file.php" (or "file.php" for a single-file plugin) to its absolute path.

The columns a link row holds, in the table's order.

A link's row, its values as strings the way the reference reads them. @return array<string, mixed>|null

The links a get_bookmarks call asks for.

A link written: a new row when the id is 0, else that row's columns set. The id it was written under.

A link's row removed.

[video]. @param array<string, mixed>|string $attr

[audio]. @param array<string, mixed>|string $attr

get_attached_media: the post's attachments of a kind ("video", "audio", a MIME type), as the reference's children query finds them.

Every nav_menu term.

One menu by id, or null.

The id of the menu with exactly this name, or null.

The items of one menu, or of every menu, in menu order.

Navigation-link blocks for the first classic menu. Empty when the site has no nav_menu terms with items.

A menu item as the navigation block it renders through (its classes: its own, then the menu item ones).

A menu item's navigation link attributes, as the reference writes them for a menu turned into blocks (probe navigation-blocks): its classes joined, its description, the object it links to (none for a custom link) and that object's kind, its title as the label, a new tab for a _blank target, its XFN as rel, its attribute title, its URL.

Whether this menu auto-adds new top-level pages, from the nav_menu_options blob.

Location slugs from the active theme's theme_mods that point at this menu.

The theme's registered locations mapped to menu ids, from theme_mods.

One nav_menu_item by id, or null when it is missing or trashed.

Whether a name may be given to a menu. A menu keeps its own name; any other menu holding it refuses the write, and the refused id rides along so a caller can point at the menu in the way.

title: string, url: string, type: string, object: string, objectId: int, parent: int, menuOrder: int, target: string, status: string, menuId: int, attrTitle: string, description: string, authorId: int, classes?: list<string>, xfn?: string } $fields

Applies the given fields to one item, stored the way the reference stores them.

The ids of the menu items, in any menu or none, that point at an object of a kind (post_type, taxonomy). @return list<int>

Adds a page to the end of a menu, titled by the page itself, as a menu set to add new pages takes it.

The content on either side of a more tag, with the tag's own text.

Markup with every note marker's tags taken out.

The labels, the object's own filled in by the rules above and laid over the defaults.

No rows and a total of zero.

Whether the page holds no rows.

How many rows are on this page.

The ids of the rows on this page.

How many pages the whole listing makes at this page size.

True while the post has a password the reader's cookie does not match.

Whether a wp-postpass cookie opens a post with this password. Only a hash in the setting the reference writes ("$P$B") is tried, as the reference tries it: a cookie naming its own work factor could otherwise make one request hash up to 2^30 times.

"Protected: " for a password, "Private: " for a private post, as the reference prefixes titles.

The form, with the reference's stray closing p after the hidden field; with the message a wrong password earns ($invalid, see invalid()) above the field and named by it.

The form as the current reader sees it: with the wrong-password message when their own form sent them back.

The message over the form for a reader the post's own page sent back with a password cookie set (the referer is exactly its address), as plugins word it (the_password_form_incorrect_password); '' for anyone else. The cookie is not checked: the form only shows while it fails. $post gives the post the filter is handed, asked for only then.

One exported item, its rows in the order given, a row whose value is empty left out.

The export files in $dir last written before $before.

The player and its data.

The two templates, each title wrapped in the quoting format given (its %s takes the title placeholder).

The relative "dir/file.php" of a WordPress plugin, else the extension for a slug, else null. A folder carrying both records in active_plugins like the reference does (the loader counts its own folder there as active); only a pure extension uses the engine's list.

Whether a plugin, by file, or a Minn extension is active.

Records a plugin or an extension as active, in the option each kind uses; null, or why a plugin was refused (unexpected_output leaves it active, as the reference does).

Records a plugin, by file, or a Minn extension as inactive; an extension also deactivates the plugins it replaced.

The class list a post carries on its article element, in the reference's order.

The reference keeps letters, digits, hyphens and underscores in a class name.

A record from a posts row; a missing column reads as empty.

A record for every row, in order.

The stored row, for the writers and shapers that still spell columns.

The row as the table holds it, joined columns and all.

The status as an enum case, or null for a status only a plugin knows.

Published, and so public.

Publish, future or private: it counts, it links, it is not a draft.

In the trash.

Behind a password.

A page.

An attachment.

One stored column by its database name, or null.

A joined column, or any column by its table name.

The migration bridge: the record answers to its column names the way the row did.

The migration bridge: one column by its stored name, or null.

Records are read-only; writes go through the repository.

Records are read-only; writes go through the repository.

The slug, or its first free numbered form.

A row's status, or null for a value no enum case spells (a plugin's own status).

Publish, future and private are live: they count, they link, they are not drafts.

Whether the status shows the post to anonymous readers.

The stored strings of these statuses.

The statuses whose post may have a floating date (no GMT date yet).

Whether a term of the taxonomy has the id.

Inserts a posts row from column => value pairs and returns the new id.

Sets the given columns on one post; nothing happens for none.

Changes one post's status.

Moves a post to another type, leaving it alone when it is already there.

Sets one meta value, inserting the row when the key is new.

Whether a post's date floats: never given one, it is still a draft or pending with no GMT date.

Adds a meta row even when the key already has one (a non-unique key).

Keeps a published post's previous slug or date on record (_wp_old_slug, _wp_old_date) so its old address still finds it: the value it moves to stops being an old one, the value it leaves becomes one, once.

Gives a post the site's default category when it has none, as every save of a post does in the reference.

The row of a post moving to the trash, as the reference writes it: the slug gains __trashed, the modified time moves, a floating draft's date settles, a post keeps a category, and the published counts follow. What the trash keeps for the way back (the status, the time, the slug it had) is meta the caller adds, and the revision comes from the save.

Removes every meta row with this key from a post.

A free slug for the desired text, sanitized first, in the type's scope (see PostSlugs).

The rules a live post's slug is settled by.

Replaces a post's links in one taxonomy and refreshes that taxonomy's counts.

The taxonomies a post has terms in.

Recounts every term the post is in, after a status change.

term_taxonomy.count is stored and trusted on read, so every status change refreshes it.

Whether the post is in the sticky_posts option.

Puts a post on the sticky list, then post_stuck when it was not on it (probe rest-sticky).

Takes a post off the sticky list, then post_unstuck when it was on it (probe rest-sticky).

Assigns (or clears) the post-format term, creating it on first use.

The side effects shared by create and update: sticky, format, featured media.

The meta core registers, written directly when no plugins are loaded: footnotes, and a pattern's sync status.

Assigns categories, tags, and pattern categories from a write body, replacing existing links.

The terms a REST body names, by taxonomy: categories, tags, and pattern categories, each only when the body has the field.

Snapshots the post's NEW state as a revision exactly when the reference would: compared against the latest revision, identical content-bearing fields add nothing, and the first update always snapshots.

The row of the revision a post's current state calls for, or null when it calls for none (an unrevisioned type, or nothing changed since the latest revision).

Writes a revision row and gives it its guid; returns its id. @param array<string, mixed> $columns

Moves a deleted post's children of the given types to another parent, the way the reference keeps pages and attachments attached. @param list<string> $types

Moves every post of one author to another.

The database door this writer writes through, for a caller wrapping several of its verbs in one transaction.

Hard-deletes a post with its revisions and its meta.

The post with this id, or null.

Reads a list's posts, their meta and their terms in the given taxonomies in one query each, as update_post_caches does, so the list's rendering reads none of them again.

Keeps rows a query already read (WP_Query's whole posts), so priming those posts reads them no second time.

Reads the rows of the posts not read yet, in one query. @param list<int> $ids

Reads the meta of the posts whose meta is not read yet, in one query (update_post_meta_cache). @param list<int> $ids

Reads the posts' terms in the given taxonomies, in one query, for the posts some of whose taxonomies are not read yet.

The post with this slug among the given types; published only unless asked otherwise.

The post with this slug among the given types in any status but trash, or null. @param list<string> $types

The post that once answered to the slug: every former slug stays in `_wp_old_slug` meta, and the reference redirects it to the current link whatever the post's status (a draft or trashed post goes to its `?p=` form).

Walks a page hierarchy: ["sample-page", "docs"] finds the page named docs whose parent is named sample-page at the root.

The page at a slug path in any status but trash, or null. @param list<string> $segments

The post at a slug path among the given types (each segment's parent the one before it), in any status but trash; at the last segment the first type wins over the others, as the reference prefers the type it was asked for over the attachment it also looks at.

The slash-joined ancestry of a page: "sample-page/docs".

The published post whose name starts with the given text, among the given types, as the reference guesses a destination for a missing URL: one prefix query and no order of its own, so the database's plan for it decides which match comes first (on a small table its name index, alphabetical; on a large one its type and date index, oldest first), the same on both stacks over one database.

Whether any post of a type is published.

Every post id of a type, whatever its status, as stored (strings), in the table's order. @return list<string>

One meta value of a post, or null when it has none.

The post's terms in one taxonomy, as [term_id, slug] pairs.

How many revisions the post has.

Reads many posts' revision counts and latest revisions in one query, for a list that links to each post's history (a REST list).

The latest revision id, an autosave counting as one, newest by date then id (probe rest-latest-revision), or 0.

Whether a live post carries an autosave newer than its saved state.

The newest value of a date column (post_date, post_modified, or their GMT twins) among published posts of the types given, for get_lastpostdate and get_lastpostmodified.

The days of one month a published post of a type was dated on, ascending.

The periods holding a published post of a type, newest first by default: one row per month, year, day, or week, with the count and the earliest post date inside it. A WHERE and JOIN given (what wp_get_archives' getarchives_where and getarchives_join answered) are used as they are.

The JOIN, WHERE and ORDER BY of the post before ($direction "previous") or after a post, written as the reference writes them for get_adjacent_post (probe filter-inputs), for its filters to edit: kept to $sameTerms in $taxonomy when there are some, out of the $excluded terms, and published, or private too ($private "all"), or the reader's own private ones too ($private "own").

The post the clauses find (as their filters left them), or 0.

Published posts of a type for a post-by-post archive, by date or by title; a WHERE and JOIN given are used as they are (archiveBuckets).

The nearest month before one with a published post of a type, as [year, month], or null.

The nearest month after one with a published post of a type, as [year, month], or null.

The newest autosave of a post (by date, then id), by one author or, given 0, any (probe revision-more); null when there is none.

The slug of the post's first category, or null.

The reader who is nobody: no session, no private posts, only the post password they typed.

The reader a signed-in user is, asked of the capability engine: what they may read privately, what they may edit, and the roles they hold. User 0 is nobody, whatever the capabilities say.

The reader of the request being answered. The runtime holds it (the context it was built with carries it), so there is one holder and a request cannot see the reader of the one before it. Without a runtime, on the command line and in unit tests, nobody is reading.

Whether the reader has a session.

Whether this reader may edit a given post.

The revisions, or the autosaves, of a post, newest first, as rows.

Every revision of a post, its autosaves among them, newest first by date then id, as rows: what the revisions route lists (probe rest-latest-revision).

The autosaves of a post, newest first, as rows.

One autosave slot per author: updated in place when it exists.

The kept value of a kind for a key, read through $load the first time.

Whether a value is kept.

A kept value, or null when there is none.

Keeps a value read elsewhere (a batch read for a whole list).

Has a kind named at run time (a plugin's meta type, whose table only the registration knows) dropped whenever that table is written, as the kinds above are by theirs.

Drops one kept value, or every one of a kind.

Drops everything kept.

One option's raw value, or null when it is unset.

Writes an option, inserting it as autoloaded when it does not exist; the option store hears of it. An $autoload given is written too, so a cache the engine reads on demand (autoload "off") stays out of the list every request loads.

Removes an option row; the option store hears of it.

A new post's comment or ping status, as the reference picks it: a post follows the site's two defaults, an attachment follows the comment default and never takes pings, a page and every other type start closed; with plugins loaded, get_default_comment_status() decides (support a plugin removed, the filter). $kind is "comment" or "pingback".

The site's timezone (wp_timezone): the zone timezone_string names, else gmt_offset as a fixed offset. With a zone set, the stored gmt_offset is not read at all, as the reference does not read it.

The site's offset from UTC in seconds now: the zone's, daylight saving included, or gmt_offset's.

Now in the site's local time, MySQL format.

A site-local datetime from a write body ("2031-01-01T00:00:00") to the pair of columns it fills, plus its timestamp.

A GMT datetime from a write body (date_gmt) to the same pair of columns, its local half in the site's zone at that date.

The icon's path under uploads, or null when the site has none.

The URL of the icon's smallest generated size that covers a square of $size pixels, or of the original when no size does; empty without an icon.

The icon's URL, empty when the site has none.

The head links a site with an icon prints (wp_site_icon): the 32 and 192 pixel icons, the Apple touch icon, and the tile image; empty without one.

A title as the reference's sanitize_title makes a slug of it when saving, without the filters (the runtime's sanitize_title adds those): accents spelled plainly, then the dash form, non-ASCII percent-encoded up to 200 bytes.

Non-ASCII characters as lower-case percent escapes, a whole character at a time, stopping before one would take the text past $length bytes (0 for no limit); each ASCII character goes through $ascii (as it is, or rawurlencode).

A slug cut to a byte length without splitting a multibyte character or leaving a dash hanging off the end.

The reference's dash form of a title: tags and marks stripped, spaces to dashes, and the save-time rules when saving.

The markup with every element closed in order and every stray closer gone.

Anchor tags for these terms joined by a separator, the way the reference prints a term list.

The category list: an unordered list when the separator is empty, a joined run otherwise. Both carry rel="category tag". A row may bring markup to go before its link (its parents) and the space before rel.

A record from a joined terms row; a missing column reads as empty.

A record for every row, in order.

The stored row, for the writers and shapers that still spell columns.

Whether the term sits under another.

One stored column by its database name, or null.

The migration bridge: the record answers to its column names the way the row did.

The migration bridge: one column by its stored name, or null.

Records are read-only; writes go through the repository.

Records are read-only; writes go through the repository.

A term joined with its taxonomy row: term_id, name, slug, term_taxonomy_id, parent, count.

One term in a taxonomy, or null.

The row shape the term controllers work with, including term_taxonomy_id.

The id of the term with exactly this name in a taxonomy, or null.

A slug unique within the taxonomy: base, -2, -3 on collision.

Inserts a term and its taxonomy row and returns the term id.

Inserts a terms row alone (name, slug, term_group), as the reference writes it before the taxonomy row; returns the term id.

Puts a term in a taxonomy; returns the term_taxonomy id.

Rewrites a terms row (name, slug, term_group).

Drops a term's rows that a plugin's duplicate check said to give up.

Changes a term's name and slug.

Changes a term's description and parent within one taxonomy.

Reparents children to the grandparent, detaches relationships, drops the rows.

"parent/child" for hierarchical taxonomies, the bare slug otherwise.

The search pattern smilies_init leaves in $wp_smiliessearch, from the codes in their stored order (reverse-sorted): one alternative per first character, its code's rest quoted and joined, each bounded by whitespace, a no-break space or the line's ends (probe functions-utils).

Smilies become their emoji, or an image for the few that have one: a code only counts as a whole word between spaces, and nothing inside a code, pre, script, style or textarea element, or inside a tag, changes.

"Wordpress" spelled right after a space, a parenthesis, a tag, or an opening curly quote; elsewhere it stays.

"Wordpress" spelled right everywhere, as a title is.

The site's own http address made https, escaped forms included.

A feed carries an embedded post's iframe without the style that hides it until its script runs.

Every link given a rel (wp_rel_nofollow, wp_rel_ugc), on slashed text as the content filters carry it, slashed again after (probes comment-fields, plugin-queue5). A link to the site itself does not take "nofollow".

One link's opening tag with the rel added (wp_rel_callback): a tag that has a rel keeps its words first, gains the new ones, and is written again with every attribute double-quoted and rel last; one without keeps its attributes as written and takes rel at the end.

A span keeps no class in a comment (where a note's mention would be faked); slashed text in, slashed out.

Whether text is texturized at all (run_wptexturize): asked on the first text of a request and again after askAgain(); once the answer is no, it holds for the rest of the request (probe filter-inputs-3).

Has the next text ask run_wptexturize again (wptexturize's reset), unless the answer was already no.

The characters texturizing writes, as the site's language writes them (each asked by its translation context, as the reference asks them): the dashes, the curly quotes, the apostrophe and the primes.

The elements whose text stays as written (no_texturize_tags: pre, code, kbd, style, script and tt), read on every text, as a pattern alternation.

Curly quotes, dashes, and ellipses in the text of HTML, leaving tags and the skipped elements alone; registered shortcodes stay as written (probe shortcode-run), and so does the text inside the ones no_texturize_shortcodes names ([code] by default). Nothing changes once texturizing is off. A caller that already read the skip pattern hands it over, so each text asks the filters once.

Bare ampersands made entities outside the skipped elements, as wptexturize leaves them after the rest.

The same substitutions on a plain string with no tags.

The pattern that cuts markup for texturizing (wp_html_split's pieces with comments whole and, given, shortcodes): comments run to "-->" or the end, a tag to its first ">", and each piece is captured.

The pattern fragment for shortcodes with these names: an opening or closing tag, or an escaped [[one]], its name ended by a space, "/" or "]", its attributes up to the first "]".

Keeps the stack of open elements texturize leaves alone: an opening tag or shortcode of a listed name is pushed (a self-closing one is not), its closing one pops it when it is the last opened.

Each $needle in the text made a prime after a digit; otherwise a double quote becomes the closing quote, and a single one does only where a word ends (before the end, whitespace, a no-break space or . , ; : ! ? ) ] } -), staying an apostrophe or opening quote elsewhere.

A record from a users row; a missing column reads as empty.

A record for every row, in order.

The stored row, for the writers and shapers that still spell columns.

The row as the table holds it.

The name shown for this person: the display name, or the login when none was set.

One stored column by its database name, or null.

The migration bridge: the record answers to its column names the way the row did.

The migration bridge: one column by its stored name, or null.

Records are read-only; writes go through the repository.

Records are read-only; writes go through the repository.

The user with this id, or null.

The user with this login, or null.

The user with this email, or null.

The user with this nicename, or null.

The unique-nicename rule: sanitized login, -2, -3 on collision.

Inserts a user and the 14 default meta rows the reference writes.

login: string, email: string, password: string, role: string, display_name: string, url?: string, nicename?: string, nickname?: string, first_name?: string, last_name?: string, description?: string, locale?: string, } $fields

The display name an account gets when none is given, as the reference picks it: first and last name, whichever of the two there is, or the login. The nickname plays no part.

A new account's row alone: the caller adds its meta and role, and keeps the count. @param array<string, mixed> $fields

The twelve profile meta rows the reference gives a new account, in its order (the role's two follow).

Recounts the accounts into user_count, quietly.

Removes the account's row alone: the caller removes its meta and keeps the count.

Inserts a users row from column => value pairs and returns the new id.

Sets the given columns on one user.

Removes the user and their meta; their posts are reassigned or removed first by the caller.

User ids in login order, optionally the first N. @return list<int>

Stores a new password hash and clears any pending reset key.

How many users the site has.

The newest users registered since a site-local time, up to the limit.

Removes one meta key from a user.

Every user with a capabilities row under the key given, as the old get_users_of_blog listed them: id twice, login, display name, email and the stored capabilities, in id order.

The ids of users whose capabilities row names none of the roles (a pattern of their names). @return list<string>

One usermeta value, raw. Serialized blobs come back as stored.

Replaces one usermeta row. The (user_id, meta_key) pair carries no unique index on the stock schema, so this is a delete plus insert rather than an upsert.