@salesforce/afv-skills 1.5.1 → 1.5.3

package/skills/uplifting-components-to-slds2/references/rule-no-hardcoded-values.md

@@ -0,0 +1,160 @@
+# Rule: No Hardcoded Values
+
+**Rule ID:** `slds/no-hardcoded-values-slds2`
+**Severity:** Warning
+**Scope:** All CSS properties with hardcoded values that have SLDS 2 hook equivalents — colors, spacing, sizing, typography, borders, radius, and shadows.
+
+---
+
+## What the Linter Does
+
+The linter detects hardcoded values and reports them as warnings. Here's real output for an icon component:
+
+```
+  3:10  warning  Consider replacing the 32px static value with an SLDS 2 styling hook
+                 that has a similar value: --slds-g-sizing-9.                              slds/no-hardcoded-values-slds2
+
+  5:21  warning  Dynamic element with css-class "icon-container" using static value
+                 "#066afe" for "background-color" css property. Consider replacing
+                 the #066AFE static value with an SLDS 2 styling hook:
+                 1. --slds-g-color-surface-inverse-1
+                 2. --slds-g-color-surface-inverse-2
+                 3. --slds-g-color-surface-container-inverse-1                             slds/no-hardcoded-values-slds2
+
+  9:9   warning  Dynamic element with css-class "account-icon" using static value
+                 "#ffffff" for "fill" css property. Consider replacing:
+                 1. --slds-g-color-on-accent-1
+                 2. --slds-g-color-on-accent-2
+                 3. --slds-g-color-error-base-95
+                 4. --slds-g-color-warning-base-95                                         slds/no-hardcoded-values-slds2
+```
+
+**Non-color values** get single suggestions — auto-fixable with `--fix`:
+
+```css
+/* 32px → sizing-9 (single suggestion, auto-fixed) */
+width: var(--slds-g-sizing-9, 32px);
+```
+
+**Color values** get multiple suggestions — requires manual selection. The linter suggests hooks based on color-value similarity, **not semantic context**. You must inspect the HTML to choose correctly.
+
+---
+
+## What to Fix vs What to Skip
+
+| Property Type | Example Values | Action |
+|---|---|---|
+| Color properties (`color`, `fill`, `background`, `background-color`, `stroke`, `border-*-color`, `outline-color`) | `#fff`, `rgb(0,0,0)` | **Fix** — replace with color hook + fallback |
+| Spacing properties (`margin`, `padding`, `gap`) | `16px`, `1rem`, `24px` | **Fix** — replace with spacing hook + fallback |
+| Sizing properties (`width`, `height`, `min-*`, `max-*`) | `32px`, `2rem` | **Fix** — replace with sizing hook + fallback |
+| Font properties (`font-size`, `font-weight`, `line-height`) | `14px`, `bold`, `1.5` | **Fix** — replace with typography hook + fallback |
+| Border properties (`border-radius`, `border-width`) | `8px`, `1px` | **Fix** — replace with radius/border hook + fallback |
+| Shadow properties (`box-shadow`) | `0 4px 8px rgba(…)` | **Fix** — replace with shadow hook + fallback |
+| Layout/structural values | `100%`, `auto`, `0`, `inherit`, `none` | **Skip** — leave unchanged, removing breaks rendering |
+
+When the linter says "Remove the static value" for a layout value like `width: 100%` or `height: auto`, **do not remove it**.
+
+---
+
+## Replacement Pattern
+
+Always include the original value as fallback:
+
+```css
+property: var(--slds-g-[hook], originalValue);
+```
+
+The fallback must be the **exact original value** from the source CSS (e.g., `#066AFE`, not a converted equivalent).
+
+---
+
+## Decision Tree
+
+When examining a hardcoded value or deprecated token, follow this decision tree:
+
+```
+1. SLDS utility class available?
+   └─ Yes → Remove CSS, add utility class to HTML
+   └─ No  ↓
+
+2. At least one 1:1 styling hook mapping?
+   ├─ Exactly one  → Use it with fallback
+   ├─ Multiple     → Inspect HTML context to choose (see decision guides)
+   └─ None         ↓
+
+3. No exact match
+   └─ No close match → Leave hardcoded
+```
+
+### Step 1: Check for Utility Classes
+
+If an SLDS utility class sets the exact property to the exact value, remove the CSS and replace with the class on the HTML element(s).
+
+**Best fit vs perfect fit:** Use existing utilities that get you close enough, even if it means combining two or three classes. This keeps markup readable, styles consistent, and avoids unnecessary custom CSS. Don't write new CSS rules for edge cases unless absolutely necessary.
+
+**When modifying CSS classes:**
+- Before removing a CSS declaration, ensure you understand how it's used in HTML and in JS (computed classes)
+- Update any tests after changing CSS classes — some tests use class query selectors that should be replaced with `data-tid` attributes
+
+#### Example: Replacing with Utility Classes
+
+Common CSS like `display: flex` with alignment can often be replaced entirely:
+
+```css
+/* Before — component.css */
+.container {
+    display: flex;
+    flex-direction: row;
+    justify-content: center;
+    align-items: center;
+}
+```
+
+```html
+<!-- Before — component.html -->
+<div class="container">
+```
+
+These styles map to SLDS grid utility classes:
+
+```html
+<!-- After — component.html (CSS removed entirely) -->
+<div class="slds-grid slds-grid_align-center slds-grid_vertical-align-center">
+```
+
+Note: `flex-direction: row` is the default for `display: flex` — it can be removed entirely.
+
+### Steps 2 & 3: Choose the Right Hook
+
+For choosing between multiple hooks or finding the closest match, see the decision guides:
+
+| Category | Decision Guide |
+|---|---|
+| Color (background, foreground, border color) | [color-hooks-decision-guide.md](color-hooks-decision-guide.md) — surface vs container, semantic vs palette, applied examples from real PRs |
+| Spacing, sizing, typography, borders, radius, shadows | [non-color-hooks-decision-guide.md](non-color-hooks-decision-guide.md) — numbered scales, closest-match rules, density-aware variants |
+
+---
+
+## Common Mistakes
+
+1. **Inventing hook names** — Only use hooks documented in the SLDS design system.
+2. **Missing fallback** — Always include the original value: `var(--slds-g-hook, originalValue)`
+3. **Confusing spacing and sizing** — Spacing is for margins/padding/gaps. Sizing is for width/height/dimensions.
+4. **Using named hooks** — `--slds-g-spacing-medium`, `--slds-g-font-weight-bold`, `--slds-g-radius-large` do NOT exist. Only numbered hooks exist.
+5. **Replacing layout values** — Don't replace `100%`, `auto`, `flex: 1`, `none`, or `0` with hooks.
+6. **Blindly trusting linter suggestions for colors** — The linter matches by color value, not semantic context. Always inspect HTML before choosing.
+
+## What NOT to Replace
+
+Leave these unchanged (no SLDS hooks apply):
+
+```css
+width: 100%;                   /* layout values */
+height: auto;                  /* layout values */
+flex: 1;                       /* layout values */
+display: none;                 /* layout values */
+transition: color 0.3s ease;   /* animation values */
+opacity: 0.5;                  /* opacity */
+background: linear-gradient(…); /* gradients */
+left: 50%;                     /* positioning offsets */
+```

package/skills/uplifting-components-to-slds2/references/rule-no-slds-class-overrides.md

@@ -0,0 +1,126 @@
+# Rule: No SLDS Class Overrides
+
+**Rule ID:** `slds/no-slds-class-overrides`
+**Severity:** Warning
+**Scope:** Detects CSS selectors that directly target `.slds-*` classes.
+
+---
+
+## What the Linter Does
+
+The linter detects CSS classes that directly override SLDS classes and reports them as **warnings**. It does **not** auto-fix — all changes require manual work in both CSS and HTML.
+
+```
+  1:1  warning  Overriding slds-button isn't supported. To differentiate SLDS and
+               custom classes, create a CSS class in your namespace.
+               Examples: myapp-input, myapp-button.                  slds/no-slds-class-overrides
+```
+
+**Manual steps required:**
+1. Rename `.slds-*` selectors in CSS to `{componentName}-{sldsElementPart}`
+2. Add the new component class to markup (`.html` for LWC, `.cmp` for Aura) **alongside** the original SLDS class
+3. Never remove the original SLDS class from markup
+
+---
+
+## Naming Convention
+
+**Format:** `{componentName}-{sldsElementPart}` (camelCase component name)
+
+| SLDS Class | Component: `userProfile` | Result |
+|---|---|---|
+| `.slds-button` | `userProfile` | `userProfile-button` |
+| `.slds-card` | `userProfile` | `userProfile-card` |
+| `.slds-modal__content` | `userProfile` | `userProfile-modal__content` |
+| `.slds-button_brand` | `userProfile` | `userProfile-button_brand` |
+
+---
+
+## Common Patterns
+
+### Pattern 1: Simple Selector
+
+```css
+/* Before CSS */
+.slds-button { border-radius: 8px; }
+
+/* After CSS */
+.myComponent-button { border-radius: 8px; }
+```
+
+```html
+<!-- After HTML (manual) -->
+<button class="slds-button myComponent-button">Click</button>
+```
+
+### Pattern 2: Descendant Selector
+
+```css
+/* Before CSS */
+.slds-card .slds-button { margin-top: 1rem; }
+
+/* After CSS */
+.myComponent-card .myComponent-button { margin-top: 1rem; }
+```
+
+```html
+<!-- After HTML (manual) — each SLDS class gets a component class -->
+<div class="slds-card myComponent-card">
+  <button class="slds-button myComponent-button">Click</button>
+</div>
+```
+
+### Pattern 3: Multi-Class Selector
+
+```css
+/* Before CSS */
+.slds-card.slds-p-around_medium { border: 1px solid blue; }
+
+/* After CSS */
+.myComponent-card.myComponent-p-around_medium { border: 1px solid blue; }
+```
+
+```html
+<!-- After HTML (manual) -->
+<div class="slds-card slds-p-around_medium myComponent-card myComponent-p-around_medium">
+```
+
+---
+
+## Core Rules
+
+1. **Never remove SLDS classes** from markup (`.html` or `.cmp`) — only ADD component classes alongside them
+2. **One-to-one mapping** — each SLDS class in a CSS selector gets exactly one component class
+3. **CamelCase component name** — `sampleComponent-button`, not `sample-component-button`
+4. **Preserve SLDS element names** — `.slds-button` becomes `componentName-button` (strip `slds-` prefix, keep the rest)
+
+---
+
+## Interaction with Other Rules
+
+If the overridden CSS properties include hardcoded colors, you must also apply `rule-no-hardcoded-values.md` to those properties:
+
+```css
+/* Before */
+.slds-icon-action-check { background: #4bca81; }
+
+/* After — both rules applied */
+.myComponent-icon-action-check { background: var(--slds-g-color-success-base-70, #4bca81); }
+```
+
+---
+
+---
+
+## Validation Checklist
+
+**CSS:**
+- [ ] All `.slds-*` overrides reported by the linter are addressed
+- [ ] Component name is camelCase
+- [ ] SLDS element names preserved after prefix
+
+**Markup (`.html` for LWC, `.cmp` for Aura):**
+- [ ] Original SLDS classes preserved
+- [ ] Component classes added alongside SLDS classes
+- [ ] Every element in CSS selector chain updated in markup
+- [ ] One component class per SLDS class

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
+    }
+  }
+}
+```