Pro module37 abilities
Oxygen 6
These abilities register when Oxygen 6 is detected on the site and a Pro licence is active. If either is missing the module stays absent rather than failing at call time.
At a glance
Oxygen 6 registers 37 abilities: 17 that only read, 3 that write, and 17 marked destructive. That split is the practical answer to how much of this module can run unattended. Reads cost nothing and are safe to repeat, so discovery is the part to be generous with; the writes are where review belongs, and the destructive calls stop for an explicit confirmation every single time regardless of which profile is active.
What this module is for
Inspect and update Oxygen element trees, templates, conditions, global classes, variables, dynamic data, and global settings through plugin-aware operations.
Before you rely on it: Validate loops and dynamic-data bindings with representative content before publishing.
Typical workflows
- Map an Oxygen page tree before editing one component
- Apply dynamic data to a schema-compatible element
- Review loop and template conditions together
The Oxygen integration page covers the same module from the workflow side, with the capability map and the questions worth asking before a first write.
Availability on your site
The Oxygen 6 module needs three things at once: WPPilot Free as the MCP foundation, an active Pro licence, and the companion plugin detected on the site. Miss any one and the module does not register, which is deliberate: an ability that appears in the tool list but fails at call time is worse than an ability that was never offered. What the connected agent can actually call is then narrowed twice more: by the safety profile active on the site, and by the WordPress capabilities of the user behind the credential. A read that succeeds for an administrator can be absent entirely for an editor.
Every write these abilities perform is recorded in the change ledger, and destructive calls can be routed through the approval queue so a person signs off before anything is applied. A successful tool result means the operation returned, not that the front end, the cache, and every dependent template are correct: that still needs a look.
Reads
Available in every safety profile, including Read Only. Inspection costs nothing and is not rate limited.
| Ability | What it does |
|---|---|
wppilot/oxygen-check-setupCheck Oxygen Setup | Returns the Oxygen 6 runtime state in one call: whether the plugin is active, its version, whether the minimum supported release is satisfied, the license mode (free vs pro), a snapshot of the live element registry, and the detection state of the two legacy Oxygen Classic companion plugins (oxygen-gutenberg, oxygen-woocommerce). Use this BEFORE any other Oxygen ability. Every other call is gated on plugin.active && plugin.min_satisfied. The elements block reports how many native OxygenElements\* elements are registered and whether the optional "Breakdance Elements for Oxygen" extension is active (it adds the EssentialElements\* set — Section, Heading, Image2, etc.). Always pick element types from the live registry via oxygen-list-element-types, never from a fixed list. Oxygen 6 shares its engine with Breakdance (BREAKDANCE_MODE=oxygen); the two integrations are mutually exclusive at the gate level, so this ability only registers when the running plugin identifies itself as Oxygen. Companions are legacy Oxygen Classic add-ons that do NOT function on Oxygen 6 — surface companions.*.active=true as a warning so an agent guides the user toward the standard Gutenberg / WooCommerce abilities instead. |
wppilot/oxygen-get-dynamic-data-fieldGet Oxygen Dynamic Data Field | Returns the full configuration of a single dynamic-data field by slug: label, category, subcategory, returnTypes, defaultAttributes, the full controls tree (form-control schema agents need when binding a control to dynamic data), and proOnly. Use list-dynamic-data-fields first to discover the slug. |
wppilot/oxygen-get-elementGet Oxygen Element | Returns the full payload of a single Oxygen element by id: type, the full properties blob (every builder control value), parent_id (null for root), child summaries, and child_count. Call get-element-tree first to find the id you want to read, then pass the returned properties (or a subset of its top-level keys) back to future edit-element calls to patch the node. |
wppilot/oxygen-get-element-schemaGet Oxygen Element Schema | Progressive-disclosure schema for an Oxygen element's controls — the content.*, design.*, settings.*, and native binding-metadata paths, with each control's type and allowed enum values. With no other argument you get a compact group map; drill with group or search. Oxygen global selectors are bound by stable ids at meta.classes (prefer oxygen-apply-global-class). The exact serialized value of compound controls is best confirmed by setting it once and reading it back. |
wppilot/oxygen-get-element-treeGet Oxygen Element Tree | Returns the Oxygen element tree (the builder canvas) of any post the builder edits — including templates AND regular pages/posts that have been opened in Oxygen. The response is a nested summary of {id, type, child_count, children} rows. Use depth to control how deep the walk goes: 1 (default) returns the root and its direct children, 2 includes grandchildren, -1 walks the entire tree. Pair with get-element to fetch the full properties blob of a specific node. Applies progressive disclosure: the cap (max_nodes, default 500) is applied to the nodes PROJECTED at the requested depth, not to the whole page — so a shallow query of a large page still returns the root and its children. Only when the projection itself exceeds the cap is the walk budgeted (up to max_nodes rows) and truncated: true set; every returned row keeps its id and child_count, so continue by re-issuing get-element-tree on a child id. projected_nodes reports the projection size and total_nodes the whole page. |
wppilot/oxygen-get-form-submissionGet Oxygen Form Submission | Returns the full payload of an Oxygen form submission by id: id, form_id, the host post_id, submission date, status, fields (the actual submitted values), ip, referer, user_agent, user_id, form_actions (the actions run on submit, with their statuses), and uploads (the files attached to the submission, as a safe public shape — fieldId, public url, type; the absolute server-side filesystem path each FormFile also carries is stripped). Applies progressive disclosure: every leaf string is capped at max_field_bytes (64 KiB by default) with a (truncated, N bytes) marker, cut on a UTF-8 boundary. |
wppilot/oxygen-get-global-classGet Oxygen Global Class | Returns a native Oxygen selector by stable id (preferred) or name: {id,name,type,collection,properties,children}. Use get-global-class-schema before constructing properties. |
wppilot/oxygen-get-global-class-schemaGet Oxygen Global Class Schema | Discovers the property vocabulary Oxygen 6 native selectors actually render. With no arguments returns compact top-level groups; pass group or search to receive control paths. Every control ships a sample: a complete, ready-to-send properties fragment that is verified to emit CSS, including any companion the renderer requires (gap and flex alignment only render inside display:flex) — copy the sample and change its values rather than assembling a path by hand. Paths are rooted at properties.* and follow Oxygen mode, which differs from Breakdance mode on the compound controls: padding and margin live under spacing.spacing.*, radius under borders.border_radius, gap carries row and column, alignment lives under layout.flex_align, and raw CSS under custom_css.custom_css (where :selector is replaced with the class). Also returns the currently registered breakpoint ids. |
wppilot/oxygen-get-global-settingsGet Oxygen Global Settings | Returns the persisted Global Settings tree plus available_sections discovered from Oxygen's live control registry. Base Oxygen 6 disables this surface, so an empty available_sections list is authoritative; optional extensions may re-enable sections. |
wppilot/oxygen-get-templateGet Oxygen Template | Returns the full Oxygen template payload for a single id: title, post_type, status, modified date, and the entire decoded _oxygen_template_settings JSON (type slug, ruleGroups, triggers, priority, fallback). Use this when you need the conditions / triggers in full — list-templates only carries summary counts. |
wppilot/oxygen-list-dynamic-data-fieldsList Oxygen Dynamic Data Fields | Lists every dynamic-data source Oxygen can resolve at render time: post fields, site info, ACF/Metabox/JetEngine integration fields, Featured Image, Author, Current User, URL & Query, and so on. Each row is a compact summary: slug (the id used when binding a control to dynamic data), label, category, subcategory, return_types (e.g. string, image_url, url), and pro_only. pro_only comes from the Soflyy catalogue, whose base field class defaults to true — most integration fields (Meta Box, ACF, ...) carry it even when core-adjacent. It gates the builder-UI picker only, NOT front-end rendering; on free-license sites still prefer non-pro fields so the user could recreate the binding in the builder UI. The full controls tree per field is heavy — use get-dynamic-data-field for that. |
wppilot/oxygen-list-element-typesList Oxygen Element Types | Lists the element types this Oxygen 6 install's BUILDER actually offers, live, reproducing the engine's own visibility logic: an element whose availableIn() does not include the current mode is excluded entirely (in Oxygen mode only elements declaring oxygen exist in the builder), and elements the builder hides from the add panel — alwaysHide internals plus the builder_hidden_elements option, which Oxygen seeds by default with EssentialElements\Section, Div, Heading, Text, TextLink, WrapperLink, Icon, RichText, CodeBlock, Image2 — are omitted unless include_hidden=true. The visible base set is the native OxygenElements\* elements (Container, Text, RichText, Image, PostsLoop, PhpCode, HtmlCode, CssCode, JavaScriptCode, oEmbed, Shortcode, ContainerShortcode, WpWidget, DynamicDataLoop, TermLoopBuilder, …), plus any oxygen-declared EssentialElements\* / third-party elements. Each row is compact: slug (the exact, case-sensitive string add-element expects — for the built-in elements this is the fully-qualified class name, e.g. OxygenElements\PhpCode), label (the editor name), category, and is_oxygen_native (true for the base OxygenElements\* elements). The editor resolves elements by exact slug, so casing matters — this is the source of truth for it. Filter with category, namespace, search, or only_oxygen_native=true. NOTE: the raw-code elements (PhpCode, HtmlCode, CssCode, JavaScriptCode, CodeBlock) are write-gated — add-element / set-content refuse them unless the user explicitly approved allow_code_elements: true. The heavy per-element control/property schema is NOT returned here: read get-element-schema for that. |
wppilot/oxygen-list-form-submissionsList Oxygen Form Submissions | Lists Oxygen-owned rows from the shared form-submissions CPT (breakdance_form_res). Ownership is proven by the mode-specific _oxygen_form_id metadata marker, so retained standalone-Breakdance submissions are never exposed. Each row carries id, the source form_id, the host post_id, submission date, status, IP, referer, and the count of fields. Filter by form_id to scope to a single form. |
wppilot/oxygen-list-global-classesList Oxygen Global Classes | Lists Oxygen 6 native selectors from oxy_selectors_json_string. Each compact row includes stable id, emitted name, type, collection, and property_count. Elements bind selector ids at properties.meta.classes; use apply-global-class rather than writing that list manually. |
wppilot/oxygen-list-template-conditionsList Oxygen Template Conditions | Returns the catalogue of conditions an Oxygen template (or header/footer) can use to scope visibility. The catalogue is CPT-specific: oxygen_template exposes the single, archive, 404, search shape while oxygen_header / oxygen_footer additionally surface the "Everywhere" pseudo-rule. Each row is a {slug, label, values, ...} record sourced live from Breakdance\Themeless\getConditionsWithValuesForPostType, the same source the admin SPA uses. For entity pickers (posts, authors, taxonomies, products), values is only the current capped preview, not an exhaustive allow-list; a valid id omitted from that preview is still accepted by set-template-conditions in the native array shape. Use the slug field as the ruleCategorySlug / ruleSlug value when composing a payload. The response also includes template_types: the registered values valid for a template's type field (set via create-template / edit-template). Each is {slug, label, category}; for a single template targeting a custom post type the slug IS that post type's slug, alongside generic types like all-singles, archive types, 404, search, front-page (hyphenated — the engine registers front-page, not front_page). |
wppilot/oxygen-list-templatesList Oxygen Templates | Lists Oxygen "template-like" posts across the editable template CPTs Oxygen 6 registers (oxygen_template, oxygen_header, oxygen_footer, oxygen_block). Each row is a compact summary: id, title, post_type + friendly label, status, modified date, the template settings type slug (e.g. single, archive), the priority value, and the number of rule groups currently attached. Use post_type to scope (e.g. only headers) and limit to keep the response small. |
wppilot/oxygen-list-variablesList Oxygen Variables | Lists every Oxygen design variable (custom property the builder generates into CSS vars). Each variable returns the full shape: id, cssVariableName, label, type, collection, value and dynamicData. The response also includes collections, the user-defined groupings variables belong to (e.g. "colors", "spacing"). Variables are stored as a single JSON blob option, so this call decodes the whole table on every read; it remains cheap because the option is small. |
Writes
Gated by the active profile and your WordPress capabilities. Rate limited to 120 per minute per credential.
| Ability | What it does |
|---|---|
wppilot/oxygen-apply-dynamic-dataApply Oxygen Dynamic Data | Binds a dynamic-data field to an element control by writing the [breakdance_dynamic field="<slug>"] shortcode into the control VALUE at a dotted path (e.g. content.content.text). This is how Oxygen resolves live data at render time — the shortcode goes IN the property value, never in a sibling *_dynamic_meta key (which the renderer ignores). Validation runs server-side: the field slug must be a real registered dynamic-data source (discover via oxygen-list-dynamic-data-fields) and the element must exist, otherwise the call fails HARD without touching the canvas. The value at path is replaced by the shortcode while every sibling key on the element is preserved — so you can target one deep leaf without rebuilding the whole tab. For a repeating LOOP over a repeater field use oxygen-set-loop instead; this ability binds a single scalar control. EXECUTABLE payloads are gated: the phpreturn field (whose code attribute the engine eval()s) and the process_value attribute (piped through eval()) are rejected unless you pass allow_code_elements: true after the user explicitly confirms. The gate reads the FINAL merged shortcode attributes, so a params='{…}' JSON blob (which the engine merges OVER the plain attributes) cannot hide either of them. |
wppilot/oxygen-apply-global-classApply Oxygen Global Class | Attaches an existing Oxygen 6 native selector of type class to an element by adding its stable id to properties.meta.classes, the binding path the Oxygen renderer consumes. Custom CSS selectors are stylesheet rules and cannot be attached as class tokens. Pass class_id (preferred) or class_name; names are resolved to ids before write. Idempotent: an existing id is a no-op. The attach is GATED when the element already stores executable per-selector conditions for that selector at properties.meta.classes_conditions: those only run for selectors the element actually wears, so attaching one is what ARMS them, and the call is rejected unless you pass allow_code_elements: true after the user explicitly confirms — even though the request itself carries no code. |
wppilot/oxygen-create-templateCreate Oxygen Template | Creates a new Oxygen template post under one of the editable template CPTs. post_type is required and must be one of oxygen_template, oxygen_header, oxygen_footer, oxygen_block (the mode-aware slugs Oxygen 6 registers). title (or the WordPress-native alias post_title) is required. Optional settings is the template-settings JSON object. The template is seeded with ruleGroups: [] (like Oxygen's own template manager): the engine only CONSIDERS a template for request matching when the ruleGroups key exists, and an empty list means "no extra constraints" — the template applies wherever its settings.type matches. To narrow WHERE it applies, call set-template-conditions afterwards; to keep it from rendering anywhere until configured, pass settings: {"disabled": true}. Element-tree content (the builder canvas) is NOT created here — pair with add-element / set-content or open the template in the Oxygen editor. Popups are not part of the editable template surface in Oxygen mode and are not created here. If settings.parentId points at a template that ALREADY stores executable code, the create is gated behind allow_code_elements: true: the parent's stored tree renders through the new template. |
Destructive
Marked destructive in the source, so each call needs an explicit confirmation flag, every time.
| Ability | What it does |
|---|---|
wppilot/oxygen-add-elementAdd Oxygen Element | Inserts a new element into the Oxygen element tree of a post. parent_id is the id of the element that will contain the new node (use 1 for the root). type is the element type slug in case-sensitive PascalCase, resolved against the LIVE element registry — always discover valid slugs with wppilot/oxygen-list-element-types instead of guessing. Base Oxygen 6 ships the native OxygenElements\* set: for example OxygenElements\Container, OxygenElements\Text, OxygenElements\RichText, OxygenElements\Image, OxygenElements\ContainerShortcode, OxygenElements\Shortcode, OxygenElements\WpWidget, OxygenElements\DynamicDataLoop, OxygenElements\oEmbed. Builder elements such as EssentialElements\Section, EssentialElements\Heading, EssentialElements\Image2 exist only when the optional "Breakdance Elements for Oxygen" extension is active (check elements.essential_extension_present in check-setup). The RAW-CODE elements (OxygenElements\PhpCode, HtmlCode, CssCode, JavaScriptCode, EssentialElements\CodeBlock) are a last resort and are GATED: the call is rejected unless you pass allow_code_elements: true after the user explicitly confirms they want a raw code element. A wrong-cased slug is normalised to the registered one; an unknown type is rejected with the nearest match. Optional properties is the element-type-specific blob (same shape as get-element returns). position is the zero-based index inside the parent's children array (omit to append at the end). The new id is allocated from the tree's monotonic _nextNodeId counter. |
wppilot/oxygen-create-global-classCreate Oxygen Global Class | Creates a native Oxygen selector. name is the emitted CSS token, while Oxygen generates a separate stable id used by element bindings. collection defaults to WPPilot. Properties must use paths discovered by get-global-class-schema; element-style design.* input is rejected before write. A literal empty block {} anywhere in the row is rejected because Oxygen's native saver rewrites it to null. |
wppilot/oxygen-create-variableCreate Oxygen Variable | Creates a new Oxygen design variable. Required: label (human-readable name, e.g. "Brand Primary"), value (the literal value — a color hex, a length, a number, etc.), type (variable kind — one of text, number, unit, color, font_family, image_url; there is NO size/typography/shadow kind, those render broken). Optional: id (defaults to a slug derived from label), cssVariableName (defaults to a slug too; must be a valid CSS custom-property identifier), collection (group the variable belongs to). The variable is appended to the global variables JSON blob and the response returns the full new variable. |
wppilot/oxygen-delete-elementDelete Oxygen Element | Removes an element from the Oxygen element tree, along with its entire subtree (every descendant). Deletion is immediate — there is no trash for canvas nodes. The root (id 1) cannot be deleted; to clear a whole canvas call wppilot/oxygen-set-content with elements: [] (the supported operation) rather than deleting the root. |
wppilot/oxygen-delete-form-submissionDelete Oxygen Form Submission | Deletes an Oxygen form submission. With the default force=false the row is TRASHED (recoverable) via an explicit trash call, and its uploaded files are preserved. With force=true the row is permanently deleted and Oxygen's before_delete_post hook also removes the submission's uploaded files. The response mode reflects what actually happened: trashed or force_deleted. |
wppilot/oxygen-delete-global-classDelete Oxygen Global Class | Deletes a native Oxygen selector by stable id (preferred) or name. Existing elements retain the now-dangling selector id at properties.meta.classes and therefore lose its styles. |
wppilot/oxygen-delete-templateDelete Oxygen Template | Removes an Oxygen template. Default behaviour: trash. NOTE: the template CPTs register with show_ui: false, so there is NO WordPress-admin trash bin for them — a trashed template is recoverable only from Oxygen's own Templates manager (Oxygen → Templates, which lists trashed rows and can restore them) or via wp-cli/code (wp post untrash <id>). Pass force=true to hard-delete (irrecoverable). Use trash whenever possible — there is no abilities-side restore flow. Deletion does NOT cascade-clean references to this template id from OTHER templates: parentId pointers, ruleGroups rules whose value matches this id, and _oxygen_data element trees that embed a now-deleted global block all stay as dangling pointers (silently broken). Inspect dependents with list-templates and get-template before force-deleting. |
wppilot/oxygen-delete-variableDelete Oxygen Variable | Removes an Oxygen design variable by id. Deletion is immediate and irreversible. Any element using the variable continues to reference its CSS variable name; Oxygen falls back to the literal value at render time, but new edits will see the variable as missing. |
wppilot/oxygen-edit-elementEdit Oxygen Element | Patches the properties of an existing Oxygen element. Every submitted path is validated against that element type's live control schema before write. Merge semantics on the top level of properties: keys you pass replace the corresponding key on the stored element, keys you omit are kept as-is. To wipe a top-level key, pass null. Element type is immutable here (use add-element + delete-element if you need to swap an element's type). EXECUTABLE settings payloads are gated: a custom-php display condition, a wp_query envelope in PHP mode, a term_query envelope on TermLoopBuilder, or a phpreturn / process_value dynamic-data payload (including one hidden in a shortcode's params JSON, which the engine merges OVER the plain attributes) is rejected unless you pass allow_code_elements: true after the user explicitly confirms — the engine eval()s each of them on every render. |
wppilot/oxygen-edit-global-classEdit Oxygen Global Class | Patches a native Oxygen selector, identified by stable id (preferred) or compatibility name. The id/name remain immutable. properties is shallow-merged at its top level; pass null for a top-level property group to remove it. Unknown property paths and literal {} substrings that Oxygen's saver would rewrite are rejected before saving. |
wppilot/oxygen-edit-global-settingsEdit Oxygen Global Settings | Patches only top-level Global Settings sections exposed by Oxygen's live control registry. Unknown sections are rejected before write; base Oxygen normally exposes none unless an extension enables them. Merge is shallow: pass the whole discovered section object, or null to remove it. |
wppilot/oxygen-edit-templateEdit Oxygen Template | Patches an existing Oxygen template. Merge semantics on settings: only the top-level keys you pass are updated, omitted keys keep their current value (so you can patch priority without touching ruleGroups). title and slug are routed through wp_update_post. To replace the conditions wholesale use set-template-conditions instead. This ability is for everything that is NOT conditions. Two patches are GATED behind allow_code_elements: true even though they carry no code themselves, because they make the engine start running code the template ALREADY stores: clearing settings.disabled on a disabled template whose tree/ruleGroups contain an eval()'d payload, and attaching a settings.parentId whose template does. Enabling or re-parenting a clean template needs no flag. |
wppilot/oxygen-edit-variableEdit Oxygen Variable | Updates an existing Oxygen design variable identified by id. Use list-variables first to discover the id. Only the fields you pass are touched, omitted fields are kept as-is. id itself is immutable; to rename a variable, delete-variable then create-variable. label, type and cssVariableName cannot be set to empty strings, and cssVariableName must remain unique across the project (collisions are rejected). |
wppilot/oxygen-move-elementMove Oxygen Element | Relocates an element (and its entire subtree) inside the Oxygen canvas. new_parent_id may be the same as the current parent; in that case only position (the zero-based index inside the new parent's children array) is updated. Omitting position appends to the end. Moving an element under one of its own descendants is rejected to prevent cycles. |
wppilot/oxygen-set-contentSet Oxygen Content | Replaces the entire Oxygen element tree of a post in one atomic write. elements is a NESTED list of the page's top-level elements (the children of the root); each node is {type, properties?, children?}. Node ids are allocated automatically from the tree's monotonic counter — do not supply them. Every type is resolved against the live element registry and every property branch against that type's live control schema; an unknown type/path aborts the whole write before persistence. Build with native elements (Container, Text, RichText, Image, …) — the raw-code element types (OxygenElements\PhpCode, HtmlCode, CssCode, JavaScriptCode, EssentialElements\CodeBlock) AND executable settings payloads (a custom-php display condition, a wp_query envelope in PHP mode, a term_query envelope on TermLoopBuilder, a phpreturn / process_value dynamic-data payload — including one hidden in a shortcode's params JSON, which the engine merges OVER the plain attributes) are gated at ANY depth of the tree: a tree containing one is rejected unless you pass allow_code_elements: true after the user explicitly confirms they want executable code. Storage uses the native Oxygen Data API and is read back after its save lifecycle. Use this to lay down or fully replace a page; use add/edit/move/delete-element for small incremental edits. Passing elements: [] clears the canvas. |
wppilot/oxygen-set-loopConfigure Oxygen Query Loop | Configures an existing loop element so it repeats a template once per query result. Handles the three native loop types, each with its OWN contract (mismatched inputs are rejected, not silently ignored): OxygenElements\PostsLoop — a post query built from post_types + posts_per_page + ordering (written to content.query.query); OxygenElements\TermLoopBuilder — a taxonomy-term query from taxonomy (required) + hide_empty + posts_per_page (term limit) + ordering (written to content.query.taxonomy/hide_empty/limit/orderby/order, NOT the post envelope); OxygenElements\DynamicDataLoop — a repeater_field slug. The REPEATED ITEM (content.repeated_block.global_block) must be the id of an oxygen_block post holding the item subtree — the loop element has no child slot (its children are ignored). Build the item block first (create-template with post_type: oxygen_block, then set-content on it), then point the loop at it here. posts_per_page is clamped to 1..100. Add the loop element itself with add-element; use this to wire up its query. |
wppilot/oxygen-set-template-conditionsSet Oxygen Template Conditions | Writes the ruleGroups field onto an existing Oxygen template's _oxygen_template_settings. ruleGroups is a list of OR-groups: each top-level entry is itself a list of AND-rules. A rule is {ruleSlug: string (required), operand: string, ruleDynamic?: string, value?: string|string[]} (operands are the exact catalogue strings from list-template-conditions, e.g. is, is not, is one of; a lenient is_not is auto-canonicalised to is not). Every rule is validated against the live catalogue for the template's post type BEFORE writing, mirroring the native matcher: (1) ruleSlug is required and must be registered (an empty rule makes its whole AND-group impossible); (2) MULTISELECT conditions (post-status, post-type, has-taxonomy, …) need value as an ARRAY like ["publish"] — native {text,value} item objects are canonicalised to their scalar value; (3) value is required for every operand except is empty/is not empty, and must be a member of the condition's fixed set when it has one; (4) the dynamic-data condition needs exactly one registered [breakdance_dynamic ...] shortcode; (5) on a typed oxygen_template a condition not offered for that type (its availableForType) is rejected; (6) the custom-php condition is GATED — the engine eval()s its value as PHP, so a rule using it is rejected unless you pass allow_code_elements: true after the user explicitly confirms. The whole bucket is replaced wholesale: pass the COMPLETE list, or [] to clear it. Other settings are untouched; use edit-template for the writable closed settings schema. |