@salesforce/afv-skills 1.5.0 → 1.5.2

package/skills/searching-media/SKILL.md

@@ -0,0 +1,342 @@
+---
+name: searching-media
+description: "Searches for and retrieves existing visual media (images, logos, icons, photos, graphics, banners, thumbnails, hero images, backgrounds) from sources such as Salesforce CMS, Data 360 or any other source. Use this skill ANY TIME a user request involves finding, searching, getting, fetching, retrieving, grabbing, looking up, or locating media. Takes PRIORITY and activates FIRST when ANY media search/retrieval is mentioned, regardless of what else happens with the media afterward. Triggers for requests like \"search for logo\", \"find hero image\", \"get company logo\", \"locate icons\", \"fetch background image\", \"retrieve product photos\". Handles the search and source selection workflow. Does not apply when the request is about brand search, to generate NEW images with AI, design custom graphics from scratch, or edit existing images."
+compatibility: "Requires search_media_cms_channels and/or search_electronic_media MCP tools"
+metadata:
+  version: "1.0"
+---
+
+# Media Search
+
+Universal routing skill for searching and retrieving existing images and media.
+
+## Scope
+
+**This skill is for SEARCHING FOR existing media, not CREATING new media.**
+
+**Use this skill when the user wants to:**
+- Search for images in Salesforce CMS, Data Cloud
+- Find existing visual assets to use in their app
+- Retrieve media from connected sources
+- Browse available images for their project
+- Locate specific photos or graphics
+
+**DO NOT use this skill when the user wants to:**
+- Generate new images with AI (use image generation tools)
+- Create graphics or designs from scratch
+- Edit or modify existing images
+- Build custom visuals or diagrams
+
+## Before You Search
+
+**CRITICAL: This is a routing skill, not a direct search skill.**
+
+When a user requests to find an image:
+
+**Your first response MUST be plain text only — zero tool calls.** You MUST follow this sequence:
+
+1. **First response MUST be text only:** A numbered list of search sources for the user. No tool calls of any kind.
+2. **Wait for user to reply** with their selected option number
+3. **Only then** call the appropriate search tool (this is the FIRST tool call in the entire interaction)
+
+**Example of what NOT to do:**
+- ❌ Calling ANY tool before the user picks a source (MCP tools, file reads, descriptor checks, etc.)
+- ❌ "Checking which MCP tools are available" — do not probe or discover tools via tool calls
+- ❌ Immediately calling `search_electronic_media` or `search_media_cms_channels`
+- ❌ Reading MCP tool descriptors or schemas to see what's available
+- ❌ Deciding which search source to use without asking
+
+**Example of what TO do:**
+- ✅ Respond with ONLY text — a numbered list of search sources
+- ✅ Ask: "Which option would you like to use?"
+- ✅ Wait for user to reply with their choice
+- ✅ Then (and only then) call the tool they selected
+
+**Your first response when this skill triggers MUST be a text-only message presenting search sources. No tool calls. No exceptions.**
+
+
+## Workflow Overview
+
+**The user MUST choose the search source. You CANNOT skip this step.**
+
+Copy this checklist and track your progress:
+
+```
+Media Search Progress:
+- [ ] Step 1: Check your own tool list for available search tools (no tool calls — just inspect what's in your context)
+- [ ] Step 2: Present only the available options to the user as a numbered list (plain text, no tool calls)
+- [ ] Step 3: Wait for the user to reply with their selection
+- [ ] Step 4: Execute the selected search method (this is the first tool call)
+- [ ] Step 5: Present all results to user for selection
+- [ ] Step 6: Apply selected image to code
+```
+
+If you call any tool before step 4, you are not following this skill correctly.
+
+## Presenting Search Sources (First Response)
+
+**DO NOT call any tool, read any MCP descriptor, or make any external request to determine available tools.**
+
+Your tools are already loaded into your context. Look at the tool names you already have access to — this is introspection, not a tool call.
+
+**Step 1: Check your own tool list (no tool calls)**
+
+Look at the tools already in your context and check for these names:
+- `search_media_cms_channels` → If present, include **"Search using keywords"**
+- `search_electronic_media` → If present, include **"Search using Data 360 hybrid search"**
+- Always include **"Other"** as the last option
+
+**Step 2: Build your response**
+
+Include ONLY the sources whose tools you actually have. Number them sequentially.
+
+```
+I can help you find that image. Where would you like to search?
+
+[NUMBER]. [SEARCH SOURCE NAME] — [Brief description]
+...
+[NUMBER]. Other — Provide your own URL or path
+
+Which option would you like to use?
+```
+
+**Step 3: Stop and wait**
+
+After presenting the list, STOP. Do not call any tool. Do not proceed. Wait for the user to reply with their choice.
+
+### Examples
+
+**Both tools available:**
+```
+I can help you find that image. Where would you like to search?
+
+1. Search using Data 360 hybrid search — Semantic search across Salesforce CMS and connected DAMs
+2. Search using keywords — Search Salesforce CMS by keywords and taxonomies
+3. Other — Provide your own URL or path
+
+Which option would you like to use?
+```
+
+**Only `search_media_cms_channels` available:**
+```
+I can help you find that image. Where would you like to search?
+
+1. Search using keywords — Search Salesforce CMS by keywords and taxonomies
+2. Other — Provide your own URL or path
+
+Which option would you like to use?
+```
+
+**Only `search_electronic_media` available:**
+```
+I can help you find that image. Where would you like to search?
+
+1. Search using Data 360 hybrid search — Semantic search across Salesforce CMS and connected DAMs
+2. Other — Provide your own URL or path
+
+Which option would you like to use?
+```
+
+**Neither tool available:**
+```
+No automated media search sources are currently configured. Please provide a direct URL or asset library path.
+```
+
+**Wait for the user to select** before proceeding.
+
+## Executing the Selected Search Method
+
+**⚠️ ONLY reach this step if the user has explicitly selected an option from your numbered list.**
+
+If you haven't shown options yet, go back to the "Presenting Search Sources" section first.
+
+After the user selects an option, execute the corresponding search method below.
+
+### Search using keywords
+
+**Tool:** `search_media_cms_channels`
+
+**Process:**
+
+1. **Analyze the query** — Understand what the user is searching for (subject, attributes, domain)
+
+2. **Extract keywords** — Concrete nouns that would appear in image metadata
+   - Use domain-specific synonyms
+   - Maximum 10 terms
+   - Examples:
+     - "luxury apartments" → apartment, villa, penthouse, residence, condo
+     - "company logo" → logo, emblem, corporate logo
+     - "bright room" → _(empty if no concrete nouns)_
+
+3. **Extract taxonomies** — Descriptive qualities, styles, moods, categories
+   - Only adjectives and attributes
+   - Examples:
+     - "luxury apartment with river view" → Luxury, Premium, Waterfront, Riverside, Panoramic
+     - "bright spacious room" → Bright, Spacious, Open, Airy, Light
+     - "car" → _(empty if no descriptive terms)_
+
+4. **Determine locale** — Use format `en_US`, `es_MX`, `fr_FR` (default: `en_US`)
+
+5. **Build the JSON payload** — Construct this exact structure:
+
+```json
+{
+  "inputs": [{
+    "searchKeyword": "keyword1 OR keyword2 OR keyword3",
+    "taxonomyExpression": "{\"OR\": [\"Taxonomy1\", \"Taxonomy2\"]}",
+    "searchLanguage": "en_US",
+    "channelIds": "",
+    "channelType": "PublicUnauthenticated",
+    "contentTypeFqn": "sfdc_cms__image",
+    "pageOffset": 0,
+    "searchLimit": 5
+  }]
+}
+```
+
+**Field rules:**
+- `searchKeyword`: Join keywords with ` OR ` (space-OR-space). Use empty string if no keywords.
+- `taxonomyExpression`: Stringify JSON object `{"OR": ["term1", "term2"]}`. Use `"{}"` if no taxonomies.
+- `searchLanguage`: Locale with underscore (e.g., `en_US`)
+- `channelIds`: Always empty string
+- `channelType`: Always `"PublicUnauthenticated"`
+- `contentTypeFqn`: Always `"sfdc_cms__image"`
+- `pageOffset`: Start at `0`, increment by `searchLimit` for pagination
+- `searchLimit`: Default `5`, adjust if user requests more
+
+**Examples:**
+
+Query: "luxury apartment with river view"
+```json
+{
+  "inputs": [{
+    "searchKeyword": "apartment OR villa OR penthouse OR residence",
+    "taxonomyExpression": "{\"OR\": [\"Luxury\", \"Premium\", \"Waterfront\", \"Riverside\"]}",
+    "searchLanguage": "en_US",
+    "channelIds": "",
+    "channelType": "PublicUnauthenticated",
+    "contentTypeFqn": "sfdc_cms__image",
+    "pageOffset": 0,
+    "searchLimit": 5
+  }]
+}
+```
+
+Query: "bright spacious room" (no concrete nouns)
+```json
+{
+  "inputs": [{
+    "searchKeyword": "",
+    "taxonomyExpression": "{\"OR\": [\"Bright\", \"Spacious\", \"Open\", \"Airy\"]}",
+    "searchLanguage": "en_US",
+    "channelIds": "",
+    "channelType": "PublicUnauthenticated",
+    "contentTypeFqn": "sfdc_cms__image",
+    "pageOffset": 0,
+    "searchLimit": 5
+  }]
+}
+```
+
+Query: "car images" (no descriptive terms)
+```json
+{
+  "inputs": [{
+    "searchKeyword": "car OR automobile OR vehicle OR auto",
+    "taxonomyExpression": "{}",
+    "searchLanguage": "en_US",
+    "channelIds": "",
+    "channelType": "PublicUnauthenticated",
+    "contentTypeFqn": "sfdc_cms__image",
+    "pageOffset": 0,
+    "searchLimit": 5
+  }]
+}
+```
+
+6. **Call the tool** with the exact JSON payload
+
+### Search using Data 360 hybrid search
+
+**Tool:** `search_electronic_media`
+
+**Process:**
+
+1. Use the user's query **as-is** — no keyword extraction or transformation needed
+2. Call `search_electronic_media`
+3. Pass the query to the tool's `searchQuery` parameter
+
+**Example:**
+- User query: "modern luxury apartment with natural lighting"
+- Tool call: `search_electronic_media(searchQuery="modern luxury apartment with natural lighting")`
+
+### Other (User-Provided URL)
+
+Ask the user to provide:
+- Direct URL to the image
+- Asset library path
+- Specific system/location to check
+
+## Presenting Search Results
+
+Parse the tool response and present **ALL** results as numbered options. Show the image title only — do not display the URL. When the user selects an option, use the URL internally to apply the image.
+
+```
+I found 4 images. Which one would you like to use?
+
+1. Luxury Apartment Exterior
+   Source: Salesforce CMS
+
+2. Modern High-Rise Building
+   Source: Salesforce CMS
+
+3. Waterfront Residence
+   Source: Salesforce CMS
+
+4. Premium Condominium
+   Source: Salesforce CMS
+```
+
+**Never auto-select an image.** Always wait for user choice.
+
+## Applying the Selected Image
+
+After the user chooses:
+
+1. Confirm the selection with image name and URL
+2. Use the complete URL returned by the tool, including all query parameters. CMS and DAM URLs rely on query parameters for authentication, resizing, and CDN routing — dropping them breaks the image. For example, a URL like `https://cms.example.com/media/img.jpg?oid=00D&refid=0EM&v=2` must be used in full.
+3. Apply the URL to the user's code/component
+4. Show what was changed (file path and line number)
+
+## Error Handling
+
+| Error | Response |
+|---|---|
+| Tool unavailable | "The [source name] tool is unavailable. Would you like to try a different source?" |
+| Tool returns error | Show error message, offer retry with different terms or alternative source |
+| No results found | "No results found. Try broader keywords, removing descriptive terms, or a different source." |
+| Invalid user selection | Re-display options and ask again |
+
+**Never silently fail.** Always inform the user and offer alternatives.
+
+## Search Behavior Notes
+
+**Search using keywords:**
+- Both keyword and taxonomy → results match keyword OR (keyword + taxonomy)
+- Empty keyword → search by taxonomy only
+- Empty taxonomy → search by keyword only
+- Use `pageOffset` for pagination (increment by `searchLimit`)
+
+**Search using Data 360 hybrid search:**
+- Handles natural language queries
+- Semantic similarity matching
+- Searches across multiple connected systems
+
+## Key Principles
+
+1. **First response is always text-only** — Present search sources without calling any tool
+2. **Only show configured sources** — Check your own tool list (introspection, not tool calls) and only present sources whose tools you have
+3. **Wait for user selection** — Never auto-select a source or image
+4. **Show all results** — Let the user choose the best match
+5. **Confirm before applying** — Verify the selection before modifying code
+6. **Handle errors gracefully** — Provide clear feedback and alternatives

package/skills/{using-webapp-salesforce-data → using-ui-bundle-salesforce-data}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: using-webapp-salesforce-data
-description: "Salesforce data access for reading, writing, and querying records via REST, GraphQL, Apex, or Platform SDK. Use when the user wants to fetch, search, filter, sort, display, create, update, delete, or attach files to Salesforce records (standard objects like Accounts, Contacts, Opportunities, Cases, Quotes, or any custom object) in a web app or UI component (React, Angular, Vue, etc.); call Chatter, Connect, or Apex REST APIs; or invoke AuraEnabled Apex methods from an external app. Does not apply to authentication/OAuth setup, schema changes (adding fields, relationships), Bulk/Tooling/Metadata API usage, declarative automation (Flows, Process Builder), general LWC/Apex coding guidance without a specific data operation, or Salesforce admin/configuration tasks."
+name: using-ui-bundle-salesforce-data
+description: "Salesforce data access for reading, writing, and querying records via REST, GraphQL, Apex, or Platform SDK. Use when the user wants to fetch, search, filter, sort, display, create, update, delete, or attach files to Salesforce records (standard objects like Accounts, Contacts, Opportunities, Cases, Quotes, or any custom object) in a UI bundle or UI component (React, Angular, Vue, etc.); call Chatter, Connect, or Apex REST APIs; or invoke AuraEnabled Apex methods from an external app. Does not apply to authentication/OAuth setup, schema changes (adding fields, relationships), Bulk/Tooling/Metadata API usage, declarative automation (Flows, Process Builder), general LWC/Apex coding guidance without a specific data operation, or Salesforce admin/configuration tasks."
 ---
 
 # Salesforce Data Access
@@ -17,7 +17,7 @@ Use this skill when the user wants to:
 
 ## Data SDK Requirement
 
-> **All Salesforce data access MUST use the Data SDK** (`@salesforce/sdk-data`). The SDK handles authentication, CSRF, and base URL resolution. Never use `fetch()` or `axios` directly.
+> **All Salesforce data access MUST use the Data SDK** (`@salesforce/sdk-data`). The SDK handles authentication, CSRF, and base URL resolution.
 
 ```typescript
 import { createDataSDK, gql } from "@salesforce/sdk-data";
@@ -48,7 +48,7 @@ const res = await sdk.fetch?.("/services/apexrest/my-resource");
 **Not supported:**
 
 - **Enterprise REST query endpoint** (`/services/data/v*/query` with SOQL) — blocked at the proxy level. Use GraphQL for record reads; use Apex REST if server-side SOQL aggregates are required.
-- **Aura-enabled Apex** (`@AuraEnabled`) — an LWC/Aura pattern with no invocation path from React webapps.
+- **Aura-enabled Apex** (`@AuraEnabled`) — an LWC/Aura pattern with no invocation path from React UI bundles.
 - **Chatter API** (`/chatter/users/me`) — use `uiapi { currentUser { ... } }` in a GraphQL query instead.
 - **Any other Salesforce REST endpoint** not listed in the supported table above.
 
@@ -67,6 +67,24 @@ const res = await sdk.fetch?.("/services/apexrest/my-resource");
 
 ---
 
+## GraphQL Non-Negotiable Rules
+
+These rules exist because Salesforce GraphQL has platform-specific behaviors that differ from standard GraphQL. Violations cause silent runtime failures.
+
+1. **Schema is the single source of truth** — Every entity name, field name, and type must be confirmed via the schema search script before use in a query. Never guess — Salesforce field names are case-sensitive, relationships may be polymorphic, and custom objects use suffixes (`__c`, `__e`). See [Schema Introspection](references/schema-introspection.md) for entity identification and iterative lookup procedures.
+
+2. **`@optional` on all record fields** (read queries) — Salesforce field-level security (FLS) causes queries to fail entirely if the user lacks access to even one field. The `@optional` directive (v65+) tells the server to omit inaccessible fields instead of failing. Apply it to every scalar field, parent relationship, and child relationship. Consuming code must use optional chaining (`?.`) and nullish coalescing (`??`).
+
+3. **Correct mutation syntax** — Mutations wrap under `uiapi(input: { allOrNone: true/false })`, not bare `uiapi { ... }`. Always set `allOrNone` explicitly. Output fields cannot include child relationships or navigated reference fields. See [Mutation Query Generation](references/mutation-query-generation.md).
+
+4. **Explicit pagination** — Always include `first:` in every query. If omitted, the server silently defaults to 10 records. Include `pageInfo { hasNextPage endCursor }` for any query that may need pagination.
+
+5. **SOQL-derived execution limits** — Max 10 subqueries per request, max 5 levels of child-to-parent traversal, max 1 level of parent-to-child (no grandchildren), max 2,000 records per subquery. If a query would exceed these, split into multiple requests.
+
+6. **HTTP 200 does not mean success** — Salesforce returns HTTP 200 even when operations fail. Always parse the `errors` array in the response body.
+
+---
+
 ## GraphQL Workflow
 
 ### Step 1: Acquire Schema
@@ -74,7 +92,7 @@ const res = await sdk.fetch?.("/services/apexrest/my-resource");
 The `schema.graphql` file (265K+ lines) is the source of truth. **Never open or parse it directly.**
 
 1. Check if `schema.graphql` exists at the SFDX project root
-2. If missing, run from the **webapp dir**: `npm run graphql:schema`
+2. If missing, run from the **UI bundle dir**: `npm run graphql:schema`
 3. Custom objects appear only after metadata is deployed
 
 ### Step 2: Look Up Entity Schema
@@ -82,11 +100,11 @@ The `schema.graphql` file (265K+ lines) is the source of truth. **Never open or
 Map user intent to PascalCase names ("accounts" → `Account`), then **run the search script from the project root**:
 
 ```bash
-# From project root — look up all relevant schema info for one or more entities
-bash .a4drules/skills/using-salesforce-data/graphql-search.sh Account
+# Look up all relevant schema info for one or more entities
+bash scripts/graphql-search.sh Account
 
 # Multiple entities at once
-bash .a4drules/skills/using-salesforce-data/graphql-search.sh Account Contact Opportunity
+bash scripts/graphql-search.sh Account Contact Opportunity
 ```
 
 The script outputs five sections per entity:
@@ -96,11 +114,11 @@ The script outputs five sections per entity:
 4. **Create input** — fields accepted by create mutations
 5. **Update input** — fields accepted by update mutations
 
-Use this output to determine exact field names before writing any query or mutation. **Maximum 2 script runs.** If the entity still can't be found, ask the user — the object may not be deployed.
+Use this output to determine exact field names before writing any query or mutation. **Maximum 2 script runs.** If the entity still can't be found, ask the user — the object may not be deployed. For entity identification procedures (`_Record` suffix, `__c` conventions) and iterative introspection cycles, see [Schema Introspection](references/schema-introspection.md).
 
 ### Step 3: Generate Query
 
-Use the templates below. Every field name **must** be verified from the script output in Step 2.
+Use the templates below. Every field name **must** be verified from the script output in Step 2. For detailed generation rules, filtering, pagination, ordering, semi-joins, and field value wrappers, see [Read Query Generation](references/read-query-generation.md). For mutation chaining, input/output constraints, and transactional semantics, see [Mutation Query Generation](references/mutation-query-generation.md).
 
 #### Read Query Template
 
@@ -138,7 +156,7 @@ const name = node.Name?.value ?? "";
 
 ```graphql
 mutation CreateAccount($input: AccountCreateInput!) {
-  uiapi {
+  uiapi(input: { allOrNone: true }) {
     AccountCreate(input: $input) {
       Record { Id Name { value } }
     }
@@ -215,21 +233,26 @@ const fields = response?.data?.uiapi?.objectInfos?.[0]?.fields ?? [];
 
 ### Step 4: Validate & Test
 
-1. **Lint**: `npx eslint <file>` from webapp dir
+1. **Lint**: `npx eslint <file>` from UI bundle dir
 2. **Test**: Ask user before testing. For mutations, request input values — never fabricate data.
 
 **If ESLint reports a GraphQL error** (e.g. `Cannot query field`, `Unknown type`, `Unknown argument`), the field or type name is wrong. Re-run the schema search script to find the correct name — do not guess:
 
 ```bash
 # From project root — re-check the entity that caused the error
-bash .a4drules/skills/using-salesforce-data/graphql-search.sh <EntityName>
+bash scripts/graphql-search.sh <EntityName>
 ```
 
-Then fix the query using the exact names from the script output.
+Then fix the query using the exact names from the script output. For detailed error categories, status handling, and retry strategy, see [Query Testing](references/query-testing.md).
 
 ---
 
-## Webapp Integration (React)
+## UI Bundle Integration (React)
+
+Two integration patterns are available:
+
+- **Pattern 1 — External `.graphql` file** (recommended for complex queries): Create a `.graphql` file, run `npm run graphql:codegen`, import with `?raw` suffix
+- **Pattern 2 — Inline `gql` tag** (for simple queries): Use the `gql` template tag from `@salesforce/sdk-data`. **Must use `gql`** — plain template strings bypass ESLint schema validation.
 
 ```typescript
 import { createDataSDK, gql } from "@salesforce/sdk-data";
@@ -242,8 +265,9 @@ const GET_ACCOUNTS = gql`
           edges {
             node {
               Id
-              Name @optional { value }
-              Industry @optional { value }
+              Name @optional {
+                value
+              }
             }
           }
         }
@@ -254,14 +278,14 @@ const GET_ACCOUNTS = gql`
 
 const sdk = await createDataSDK();
 const response = await sdk.graphql?.(GET_ACCOUNTS);
-
 if (response?.errors?.length) {
   throw new Error(response.errors.map(e => e.message).join("; "));
 }
-
 const accounts = response?.data?.uiapi?.query?.Account?.edges?.map(e => e.node) ?? [];
 ```
 
+For detailed patterns (external .graphql files, codegen, error handling strategies, quality checklists), see [UI Bundle Integration](references/ui-bundle-integration.md).
+
 ---
 
 ## REST API Patterns
@@ -311,16 +335,16 @@ const response = await sdk.graphql?.(GET_CURRENT_USER);
 <project-root>/                              ← SFDX project root
 ├── schema.graphql                           ← grep target (lives here)
 ├── sfdx-project.json
-└── force-app/main/default/webapplications/<app-name>/  ← webapp dir
+└── force-app/main/default/uiBundles/<app-name>/  ← UI bundle dir
     ├── package.json                         ← npm scripts
     └── src/
 ```
 
 | Command | Run From | Why |
 |---------|----------|-----|
-| `npm run graphql:schema` | webapp dir | Script in webapp's package.json |
-| `npx eslint <file>` | webapp dir | Reads eslint.config.js |
-| `bash .a4drules/skills/using-salesforce-data/graphql-search.sh <Entity>` | project root | Schema lookup |
+| `npm run graphql:schema` | UI bundle dir | Script in UI bundle's package.json |
+| `npx eslint <file>` | UI bundle dir | Reads eslint.config.js |
+| `bash scripts/graphql-search.sh <Entity>` | project root | Schema lookup |
 | `sf api request rest` | project root | Needs sfdx-project.json |
 
 ---
@@ -332,7 +356,7 @@ const response = await sdk.graphql?.(GET_CURRENT_USER);
 Run the search script to get all relevant schema info in one step:
 
 ```bash
-bash .a4drules/skills/using-salesforce-data/graphql-search.sh <EntityName>
+bash scripts/graphql-search.sh <EntityName>
 ```
 
 | Script Output Section | Used For |
@@ -358,6 +382,9 @@ bash .a4drules/skills/using-salesforce-data/graphql-search.sh <EntityName>
 ### Checklist
 
 - [ ] All field names verified via search script (Step 2)
-- [ ] `@optional` applied to record fields (reads)
+- [ ] `@optional` applied to all record fields (reads)
+- [ ] Mutations use `uiapi(input: { allOrNone: ... })` wrapper
+- [ ] `first:` specified in every query
 - [ ] Optional chaining in consuming code
+- [ ] `errors` array checked in response handling
 - [ ] Lint passes: `npx eslint <file>`

package/skills/using-ui-bundle-salesforce-data/references/mutation-query-generation.md

@@ -0,0 +1,140 @@
+# Mutation Query Generation
+
+## Mutation Types
+
+The GraphQL engine supports three mutation operations:
+
+- **Create** — Insert a new record
+- **Update** — Modify an existing record (Id-based)
+- **Delete** — Remove an existing record (Id-based)
+
+Mutations are GA in API v66+. They live under `mutation { uiapi { ... } }` and only support UI API-available objects.
+
+## Generation Rules
+
+1. **Input fields validation** — Validate that input fields satisfy the constraints for the operation type
+2. **Output fields validation** — Validate that output fields satisfy the constraints for the operation type
+3. **Type consistency** — Variables used as query arguments and their related fields must share the same GraphQL type. Verify types via the schema search script — do NOT assume types
+4. **Input arguments** — `input` is the default argument name unless otherwise specified
+5. **Output field** — For `Create` and `Update`, the output field is always named `Record` (type: EntityName)
+6. **Field name validation** — Every field name in the generated mutation **MUST** match a field confirmed via the schema search script. Do NOT guess or assume field names exist
+7. **Raw input values** — Numeric values must be raw numbers without commas, currency symbols, or locale formatting (e.g., `80000` not `"80,000"` or `"$80,000"`). Compound fields (like addresses) require constituent fields (e.g., `BillingCity`, `BillingStreet`) — do not attempt to set the compound wrapper itself.
+
+## Transactional Semantics: `allOrNone`
+
+The `uiapi` mutation input accepts an `allOrNone` argument that controls rollback behavior:
+
+- **`allOrNone: true` (default)** — If any operation fails, all operations in the request are rolled back. Use when operations must succeed or fail together.
+- **`allOrNone: false`** — Independent operations can succeed individually. However, dependent operations (those using `@{alias}` references) still roll back together with their dependencies.
+
+Always set `allOrNone` explicitly to make transactional intent clear.
+
+## Mutation Schema Patterns
+
+Replace `EntityName` with the actual entity name (e.g., Account, Case). `Delete` operations use generic `Record` types.
+
+```graphql
+input EntityNameCreateRepresentation {
+  # Subset of EntityName fields
+}
+input EntityNameCreateInput { EntityName: EntityNameCreateRepresentation! }
+type EntityNameCreatePayload { Record: EntityName! }
+
+input EntityNameUpdateRepresentation {
+  # Subset of EntityName fields
+}
+input EntityNameUpdateInput { Id: IdOrRef! EntityName: EntityNameUpdateRepresentation! }
+type EntityNameUpdatePayload { Record: EntityName! }
+
+input RecordDeleteInput { Id: IdOrRef! }
+type RecordDeletePayload { Id: ID }
+
+type UIAPIMutations {
+  EntityNameCreate(input: EntityNameCreateInput!): EntityNameCreatePayload
+  EntityNameDelete(input: RecordDeleteInput!): RecordDeletePayload
+  EntityNameUpdate(input: EntityNameUpdateInput!): EntityNameUpdatePayload
+}
+```
+
+## Input Field Constraints
+
+### Create
+
+- **Must** include all required fields (unless `defaultedOnCreate` is `true` and not explicitly requested)
+- **Must** only include `createable` fields
+- Child relationships cannot be set — exclude them
+- Reference fields (`REFERENCE` type) can only be assigned IDs through their `ApiName` name
+- **No nested child creates** — Creating a record with child relationships in a single create operation is not supported. To create a parent and child together, use separate operations with `IdOrRef` chaining (see [Mutation Chaining](#mutation-chaining)).
+
+### Update
+
+- **Must** include the `Id` of the entity to update
+- **Must** only include `updateable` fields
+- Child relationships cannot be set — exclude them
+- Reference fields (`REFERENCE` type) can only be assigned IDs through their `ApiName` name
+
+### Delete
+
+- **Must** include the `Id` of the entity to delete
+
+## Output Field Constraints
+
+### Create and Update
+
+- **Must** exclude all child relationships (child relationships cannot be queried in mutations)
+- **Must** exclude all `REFERENCE` fields unless accessed through their `ApiName` member (no navigation to referenced entity, no sub fields)
+- Inaccessible fields are reported in the `errors` attribute of the returned payload
+
+### Delete
+
+- **Must** only include the `Id` field
+
+## Mutation Chaining
+
+Chain related mutations in a single request using references to `Id` values from previous mutations. This is the required approach for creating parent-child records together, since nested child creates are not supported.
+
+1. **Ordering** — Mutation `B` can reference mutation `A` only if `A` comes first in the query
+2. **Notation** — Use `SomeId: "@{A}"` in mutation `B` to set a field to the `Id` produced by mutation `A`
+3. **IDs only** — `@{A}` is always interpreted as the `Id` from mutation `A`
+4. **Restrictions** — `A` must be a `Create` or `Delete` mutation (chaining from `Update` will fail)
+
+### Chaining Example
+
+```graphql
+mutation CreateAccountAndContact {
+  uiapi(input: { allOrNone: true }) {
+    AccountCreate(input: { Account: { Name: "Acme" } }) {
+      Record { Id }
+    }
+    ContactCreate(input: { Contact: { LastName: "Smith", AccountId: "@{AccountCreate}" } }) {
+      Record { Id }
+    }
+  }
+}
+```
+
+## Mutation Query Template
+
+```graphql
+mutation mutateEntityName(
+  # arguments
+) {
+  uiapi(input: { allOrNone: true }) {
+    EntityNameOperation(input: {
+      # For Create and Update only:
+      EntityName: {
+        # Input fields — use raw values, no formatting
+      }
+      # For Update and Delete only:
+      Id: ... # id here
+    }) {
+      # For Create and Update only:
+      Record {
+        # Output fields
+      }
+      # For Delete only:
+      Id
+    }
+  }
+}
+```