@salesforce/webapp-template-feature-react-chart-experimental 1.56.0 → 1.56.1

package/dist/.a4drules/code-quality.md

@@ -31,7 +31,6 @@ npm run lint   # Run ESLint (always available in the template web app)
 import { useState, useEffect } from 'react';
 
 // 2. External libraries (alphabetical)
-import axios from 'axios';
 import clsx from 'clsx';
 
 // 3. UI components (alphabetical)

package/dist/.a4drules/graphql.md

@@ -28,24 +28,71 @@ For a GraphQL operation named `GetHighRevenueAccounts`:
 
 ## Core Types & Function Signatures
 
-### executeGraphQL Function
-Located in `force-app/main/default/webapplications/<appName>/src/api/graphql.ts`:
+### getDataSDK Function
+Available from `@salesforce/webapp-experimental/api`:
 
 ```typescript
-function executeGraphQL<T, InputVariables = Record<string, unknown>>(
-  query: string,
-  variables?: InputVariables
-): Promise<T>
+import { getDataSDK } from '@salesforce/webapp-experimental/api';
+
+const data = await getDataSDK();
+const response = await data.graphql?.<ResponseType, VariablesType>(query, variables);
 ```
 
-- `T` - The response type (e.g., `GetHighRevenueAccountsQuery`)
-- `InputVariables` - The variables type (e.g., `GetHighRevenueAccountsQueryVariables`)
+`getDataSDK()` returns a lazily-initialized `DataSDK` singleton. The `graphql` method uses optional chaining (`?.`) because not all surfaces support GraphQL.
+
+### GraphQLResponse Shape
+`data.graphql?.()` returns `GraphQLResponse<T>`. Callers destructure `{ data, errors }` and handle errors themselves:
+
+```typescript
+interface GraphQLResponse<T> {
+  data: T;
+  errors?: Array<{
+    message: string;
+    locations?: Array<{ line: number; column: number }>;
+    path?: string[];
+  }>;
+}
+```
+
+### Handling Mixed Responses (Partial Success)
+
+GraphQL can return **both `data` and `errors`** in the same response (partial success). For example, some fields may resolve while others fail due to field-level security. Choose a strategy per use case:
+
+```typescript
+// Strategy A: Strict — treat any errors as failure (default for most queries)
+if (response?.errors?.length) {
+  throw new Error(response.errors.map(e => e.message).join('; '));
+}
+const result = response?.data;
+
+// Strategy B: Tolerant — log errors but use partial data
+if (response?.errors?.length) {
+  console.warn('GraphQL partial errors:', response.errors);
+}
+const result = response?.data;
+
+// Strategy C: Discriminated — fail only when no data came back
+if (response?.errors?.length && !response?.data) {
+  throw new Error(response.errors.map(e => e.message).join('; '));
+}
+if (response?.errors?.length) {
+  console.warn('Partial success with errors:', response.errors);
+}
+const result = response?.data;
+```
+
+**When to use each:**
+- **Strategy A** — Default. Use for queries where incomplete data would be misleading (e.g., financial summaries, approval workflows).
+- **Strategy B** — Use when partial data is still useful and the UI can degrade gracefully (e.g., dashboard tiles, optional fields).
+- **Strategy C** — Use for mutations where the operation may succeed but some return fields are inaccessible.
+
+For mutation-specific partial responses, see `docs/generate-mutation-query.md` which covers `PARTIAL` and `FAILED` status handling workflows.
 
 ### gql Template Tag
-Also exported from `graphql.ts` for inline query definitions:
+Also available from `@salesforce/webapp-experimental/api` for inline query definitions:
 
 ```typescript
-import { gql } from '../api/graphql';
+import { gql } from '@salesforce/webapp-experimental/api';
 
 const MY_QUERY = gql`
   query MyQuery {
@@ -58,25 +105,11 @@ const MY_QUERY = gql`
 
 The `gql` tag is a template literal that allows defining GraphQL queries inline while maintaining syntax highlighting in most editors.
 
-### GraphQLResponse Shape
-The raw response wrapper (handled internally by `executeGraphQL`):
-
-```typescript
-interface GraphQLResponse<T> {
-  data: T;
-  errors?: Array<{
-    message: string;
-    locations?: Array<{ line: number; column: number }>;
-    path?: string[];
-  }>;
-}
-```
-
 ### NodeOfConnection Utility Type
 Extract the node type from a connection (edges/node pattern):
 
 ```typescript
-import { type NodeOfConnection } from '../api/graphql';
+import { type NodeOfConnection } from '@salesforce/webapp-experimental/api';
 
 // Extract Account node type from the query response
 type AccountNode = NodeOfConnection<
@@ -147,26 +180,32 @@ This generates types in `graphql-operations-types.ts`:
 
 #### Step 3: Import and Use
 ```typescript
-import { executeGraphQL, type NodeOfConnection } from '../api/graphql';
+import { getDataSDK, type NodeOfConnection } from '@salesforce/webapp-experimental/api';
 import MY_QUERY from './query/myQuery.graphql?raw';
 import type {
   GetMyDataQuery,
   GetMyDataQueryVariables,
 } from '../graphql-operations-types';
 
-// Extract node type for cleaner return types
 type MyNode = NodeOfConnection<GetMyDataQuery['uiapi']['query']['MyObject']>;
 
 export async function getMyData(
   variables: GetMyDataQueryVariables
 ): Promise<MyNode[]> {
-  const response = await executeGraphQL<GetMyDataQuery>(MY_QUERY, variables);
-  return response.uiapi?.query?.MyObject?.edges?.map(edge => edge?.node) || [];
+  const data = await getDataSDK();
+  const response = await data.graphql?.<GetMyDataQuery, GetMyDataQueryVariables>(MY_QUERY, variables);
+
+  if (response?.errors?.length) {
+    const errorMessages = response.errors.map(e => e.message).join('; ');
+    throw new Error(`GraphQL Error: ${errorMessages}`);
+  }
+
+  return response?.data?.uiapi?.query?.MyObject?.edges?.map(edge => edge?.node) || [];
 }
 ```
 
 **Key imports for Pattern 1:**
-- `executeGraphQL` - Execute the query
+- `getDataSDK` - Get the DataSDK singleton
 - `NodeOfConnection` - Extract node types from connection responses
 - Query from `.graphql` file with `?raw` suffix
 - Generated types from `graphql-operations-types.ts`
@@ -193,7 +232,7 @@ export async function getMyData(
 For simpler queries without variables or when colocation is preferred:
 
 ```typescript
-import { executeGraphQL, gql } from '../api/graphql';
+import { getDataSDK, gql } from '@salesforce/webapp-experimental/api';
 import { type CurrentUserQuery } from '../graphql-operations-types';
 
 const CURRENT_USER_QUERY = gql`
@@ -216,9 +255,14 @@ interface User {
 
 export async function getCurrentUser(): Promise<User | null> {
   try {
-    const response = await executeGraphQL<CurrentUserQuery>(CURRENT_USER_QUERY);
+    const data = await getDataSDK();
+    const response = await data.graphql?.<CurrentUserQuery>(CURRENT_USER_QUERY);
+
+    if (response?.errors?.length) {
+      throw new Error(response.errors.map(e => e.message).join('; '));
+    }
 
-    const userData = response.uiapi.currentUser;
+    const userData = response?.data?.uiapi.currentUser;
 
     if (!userData) {
       throw new Error('No user data found');
@@ -236,7 +280,7 @@ export async function getCurrentUser(): Promise<User | null> {
 ```
 
 **Key imports for Pattern 2:**
-- `executeGraphQL` - Execute the query
+- `getDataSDK` - Get the DataSDK singleton
 - `gql` - Template tag for inline query definition
 - Generated types from `graphql-operations-types.ts`
 
@@ -259,7 +303,7 @@ See `force-app/main/default/webapplications/<appName>/src/api/utils/accounts.ts`
 1. Importing query from `.graphql` file with `?raw` suffix
 2. Importing generated types from `graphql-operations-types.ts`
 3. Using `NodeOfConnection` to extract node types
-4. Proper typing with `executeGraphQL<ResponseType>(query, variables)`
+4. Proper typing with `data.graphql?.<ResponseType>(query, variables)`
 5. Safe data extraction from the nested response
 
 ### Pattern 2 Example: user.ts
@@ -315,14 +359,15 @@ fragment ContactFields on Account {
 
 ### Usage
 ```typescript
-import { executeGraphQL } from '../api/graphql';
+import { getDataSDK } from '@salesforce/webapp-experimental/api';
 import QUERY from './query/getAccountDetails.graphql?raw';
 import type {
   GetAccountDetailsQuery,
   GetAccountDetailsQueryVariables,
 } from '../graphql-operations-types';
 
-const data = await executeGraphQL<GetAccountDetailsQuery>(QUERY, {
+const data = await getDataSDK();
+const response = await data.graphql?.<GetAccountDetailsQuery, GetAccountDetailsQueryVariables>(QUERY, {
   id: accountId,
   includeFinancials: userWantsFinancials,
   includeContacts: userWantsContacts,
@@ -343,32 +388,38 @@ const data = await executeGraphQL<GetAccountDetailsQuery>(QUERY, {
 // NOT RECOMMENDED: Direct axios/fetch calls for GraphQL
 const response = await axios.post('/graphql', { query });
 
-// PREFERRED: Use executeGraphQL
-const data = await executeGraphQL<ResponseType>(query, variables);
+// PREFERRED: Use the DataSDK
+const data = await getDataSDK();
+const response = await data.graphql?.<ResponseType>(query, variables);
 ```
 
 ### Missing Type Definitions
 ```typescript
 // NOT RECOMMENDED: Untyped GraphQL calls
-const data = await executeGraphQL(query);
+const data = await getDataSDK();
+await data.graphql?.(query);
 
 // PREFERRED: Provide response type
-const data = await executeGraphQL<GetMyDataQuery>(query);
+const data = await getDataSDK();
+const response = await data.graphql?.<GetMyDataQuery>(query);
 ```
 
 ### Plain String Queries (Without gql Tag)
 ```typescript
 // NOT RECOMMENDED: Plain string queries without gql tag
 const query = `query { ... }`;
-const data = await executeGraphQL(query);
+const data = await getDataSDK();
+await data.graphql?.(query);
 
 // PREFERRED: Use gql tag for inline queries
 const QUERY = gql`query { ... }`;
-const data = await executeGraphQL<ResponseType>(QUERY);
+const data = await getDataSDK();
+const response = await data.graphql?.<ResponseType>(QUERY);
 
 // OR: Use .graphql file for complex queries
 import QUERY from './query/myQuery.graphql?raw';
-const data = await executeGraphQL<ResponseType>(QUERY);
+const data = await getDataSDK();
+const response = await data.graphql?.<ResponseType>(QUERY);
 ```
 
 **Why avoid plain strings:**
@@ -376,11 +427,11 @@ const data = await executeGraphQL<ResponseType>(QUERY);
 - Harder to maintain and refactor
 - More error-prone
 
-## Benefits of executeGraphQL
-- Centralized error handling for GraphQL errors
+## Benefits of the DataSDK GraphQL API
+- Uses the DataSDK with proper authentication and CSRF token handling
 - Consistent typing with `GraphQLResponse<T>` interface
-- Uses the configured `baseDataClient` with proper authentication
-- Automatic extraction of `data` from response envelope
+- Optional chaining (`?.`) safely handles surfaces where GraphQL is unavailable
+- Callers get full `GraphQLResponse<T>` for flexible error handling
 
 ## Quality Checklist
 Before completing GraphQL data access code:
@@ -390,7 +441,7 @@ Before completing GraphQL data access code:
 2. [ ] Run `npm run graphql:codegen` to generate types
 3. [ ] Import query with `?raw` suffix
 4. [ ] Import generated types from `graphql-operations-types.ts`
-5. [ ] Use `executeGraphQL<ResponseType>()` with proper generic
+5. [ ] Use `data.graphql?.<ResponseType>()` with proper generic
 6. [ ] Use `NodeOfConnection` for cleaner node types when needed
 7. [ ] Handle optional chaining for nested response data
 8. [ ] Follow the pattern in `accounts.ts`
@@ -399,8 +450,8 @@ Before completing GraphQL data access code:
 1. [ ] Define query using `gql` template tag
 2. [ ] Ensure query name matches generated types in `graphql-operations-types.ts`
 3. [ ] Import generated types for the query
-4. [ ] Use `executeGraphQL<ResponseType>()` with proper generic
-5. [ ] Handle errors with try/catch when appropriate
+4. [ ] Use `data.graphql?.<ResponseType>()` with proper generic
+5. [ ] Handle `response.errors` and destructure `response.data`
 6. [ ] Handle optional chaining for nested response data
 7. [ ] Follow the pattern in `user.ts`
 

package/dist/.a4drules/react.md

@@ -123,7 +123,7 @@ Before implementing data access, **MUST** verify `orchestrate_lds_data_requireme
 
 ## Data Access Rules (CRITICAL)
 
-- MANDATORY: Use `axios` for all API calls from React.
+- MANDATORY: Use the DataSDK (`getDataSDK()` from `@salesforce/webapp-experimental/api`) for all API calls from React. The SDK handles authentication and CSRF token management. Do NOT use `axios` or raw `fetch` for Salesforce API calls.
 
 ### Data Access Workflow (MANDATORY)
 
@@ -158,46 +158,12 @@ The LWC MCP server's `orchestrate_lds_data_requirements` tool follows this prior
 
 The following code examples serve as reference patterns for React applications. **Always consult the LWC MCP server's `orchestrate_lds_data_requirements` tool first** to ensure you're using the most appropriate pattern and latest best practices for your specific use case.
 
-UI API example (read):
-
-```javascript
-async function fetchRecord(recordId) {
-  try {
-    const res = await axios.get(
-      `/services/data/v62.0/ui-api/records/${recordId}`
-    );
-    return res.data;
-  } catch (error) {
-    const text = error.message;
-    throw new Error(`UI API failed: ${error.status} ${text}`);
-  }
-}
-```
-
-GraphQL utility (supports both queries and mutations):
-
-```javascript
-export async function sfGraphQL(query, variables = {}) {
-  try {
-    const res = await axios.post('/services/data/v62.0/graphql', {
-      query,
-      variables,
-    });
-    const json = res.data;
-    if (Array.isArray(json.errors) && json.errors.length) {
-      throw new Error(json.errors.map(e => e.message).join('; '));
-    }
-    return json.data;
-  } catch (error) {
-    throw new Error(`GraphQL error: ${error.status}`);
-  }
-}
-```
-
 GraphQL query example:
 
-```javascript
-const GET_ACCOUNT = `
+```typescript
+import { getDataSDK, gql } from '@salesforce/webapp-experimental/api';
+
+const GET_ACCOUNT = gql`
   query GetAccount($id: ID!) {
     uiapi {
       query {
@@ -216,13 +182,22 @@ const GET_ACCOUNT = `
   }
 `;
 
-const account = await sfGraphQL(GET_ACCOUNT, { id: '001...' });
+const data = await getDataSDK();
+const response = await data.graphql?.<GetAccountQuery>(GET_ACCOUNT, { id: '001...' });
+
+if (response?.errors?.length) {
+  throw new Error(response.errors.map(e => e.message).join('; '));
+}
+
+const account = response?.data;
 ```
 
 GraphQL mutation example:
 
-```javascript
-const UPDATE_ACCOUNT = `
+```typescript
+import { getDataSDK, gql } from '@salesforce/webapp-experimental/api';
+
+const UPDATE_ACCOUNT = gql`
   mutation UpdateAccount($id: ID!, $name: String!) {
     uiapi {
       AccountUpdate(input: {
@@ -242,10 +217,32 @@ const UPDATE_ACCOUNT = `
   }
 `;
 
-const result = await sfGraphQL(UPDATE_ACCOUNT, {
+const data = await getDataSDK();
+const result = await data.graphql?.<UpdateAccountMutation>(UPDATE_ACCOUNT, {
   id: '001...',
   name: 'New Name',
 });
+
+if (result?.errors?.length) {
+  throw new Error(result.errors.map(e => e.message).join('; '));
+}
+```
+
+UI API example (using the SDK's fetch):
+
+```typescript
+import { getDataSDK } from '@salesforce/webapp-experimental/api';
+
+async function fetchRecord(recordId: string) {
+  const data = await getDataSDK();
+  const response = await data.fetch!(`/services/data/v62.0/ui-api/records/${recordId}`);
+
+  if (!response.ok) {
+    throw new Error(`UI API failed: ${response.status}`);
+  }
+
+  return response.json();
+}
 ```
 
 ## Einstein LLM Gateway (AI/Generative Features)
@@ -259,30 +256,35 @@ Einstein LLM Gateway provides AI and generative capabilities for your React appl
 
 ### Einstein LLM Gateway Pattern
 
-```javascript
-async function callEinsteinGenerations({ prompt, model = 'gpt-4', signal }) {
+```typescript
+import { getDataSDK } from '@salesforce/webapp-experimental/api';
+
+async function callEinsteinGenerations({ prompt, model = 'gpt-4', signal }: {
+  prompt: string;
+  model?: string;
+  signal?: AbortSignal;
+}): Promise<string> {
   const url = '/services/data/v62.0/einstein/llm/prompt/generations';
-  try {
-    const resp = await axios.post(
-      url,
-      {
-        additionalConfig: {
-          applicationName: 'PromptTemplateGenerationsInvocable',
-          model,
-        },
-        promptTextorId: prompt,
+  const sdk = await getDataSDK();
+  const resp = await sdk.fetch!(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+    body: JSON.stringify({
+      additionalConfig: {
+        applicationName: 'PromptTemplateGenerationsInvocable',
+        model,
       },
-      {
-        signal,
-      }
-    );
-    const data = resp.data;
-    return data?.generations?.[0]?.text || '';
-  } catch (error) {
-    throw new Error(
-      error.message || `Einstein LLM request failed (${error.status})`
-    );
+      promptTextorId: prompt,
+    }),
+    signal,
+  });
+
+  if (!resp.ok) {
+    throw new Error(`Einstein LLM request failed (${resp.status})`);
   }
+
+  const data = await resp.json();
+  return data?.generations?.[0]?.text || '';
 }
 ```
 
@@ -324,9 +326,8 @@ async function safeFetch(recordId) {
 
 ### Authentication Error Handling (MANDATORY)
 
-- All axios clients MUST include response interceptors that handle 401/403 errors.
+- The Data SDK handles 401/403 errors.
 - When a 401 (Unauthorized) or 403 (Forbidden) response is received, trigger a page refresh with `window.location.reload()` to redirect to login.
-- Always return `Promise.reject(error)` after handling authentication errors to maintain proper error flow.
 
 ### Notes
 

package/dist/.a4drules/typescript.md

@@ -133,33 +133,22 @@ interface Account extends SalesforceRecord {
   Name: { value: string };
   Industry?: { value: string | null };
 }
-
-// Type API functions
-async function fetchAccount(id: string): Promise<Account> {
-  const response = await axios.get<Account>(`/services/data/v62.0/ui-api/records/${id}`);
-  return response.data;
-}
 ```
 
-### GraphQL
-```typescript
-interface GraphQLResponse<T> {
-  data: T;
-  errors?: Array<{ message: string; locations?: Array<{ line: number; column: number }> }>;
-}
+### GraphQL via DataSDK
+Use `getDataSDK()` from `@salesforce/webapp-experimental/api` for all GraphQL operations. The SDK handles authentication and CSRF token management:
 
-async function executeGraphQL<T>(query: string, variables?: Record<string, unknown>): Promise<T> {
-  const response = await axios.post<GraphQLResponse<T>>('/services/data/v62.0/graphql', {
-    query,
-    variables,
-  });
+```typescript
+import { getDataSDK } from '@salesforce/webapp-experimental/api';
 
-  if (response.data.errors?.length) {
-    throw new Error(response.data.errors.map(e => e.message).join('; '));
-  }
+const data = await getDataSDK();
+const response = await data.graphql?.<GetAccountsQuery>(QUERY, variables);
 
-  return response.data.data;
+if (response?.errors?.length) {
+  throw new Error(response.errors.map(e => e.message).join('; '));
 }
+
+const accounts = response?.data;
 ```
 
 ## Error Handling Types

package/dist/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.56.1](https://github.com/salesforce-experience-platform-emu/webapps/compare/v1.56.0...v1.56.1) (2026-02-25)
+
+**Note:** Version bump only for package @salesforce/webapp-template-base-sfdx-project-experimental
+
+
+
+
+
 # [1.56.0](https://github.com/salesforce-experience-platform-emu/webapps/compare/v1.55.0...v1.56.0) (2026-02-25)
 
 **Note:** Version bump only for package @salesforce/webapp-template-base-sfdx-project-experimental

package/dist/force-app/main/default/webapplications/feature-react-chart/package-lock.json

@@ -6069,19 +6069,19 @@
       }
     },
     "node_modules/@salesforce/sdk-core": {
-      "version": "1.55.0",
-      "resolved": "https://registry.npmjs.org/@salesforce/sdk-core/-/sdk-core-1.55.0.tgz",
-      "integrity": "sha512-T9KEN9bhCKu/WDJmSN6LeRl3ajDNN0eqf9dgxnS1YxFsky2fMPnjH8/FDkFRXuM1tbOcdiMWY+JWmwdoMrKXJw==",
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@salesforce/sdk-core/-/sdk-core-1.56.0.tgz",
+      "integrity": "sha512-53S8tkgkyTCc7LMZjJSOekyR1EBkqcYkORRyfl2TH4gVYpeUjjoeEE7ilVV1b9oMeV5x7Bn0BuHuAs3vLGJkrw==",
       "license": "SEE LICENSE IN LICENSE.txt"
     },
     "node_modules/@salesforce/sdk-data": {
-      "version": "1.55.0",
-      "resolved": "https://registry.npmjs.org/@salesforce/sdk-data/-/sdk-data-1.55.0.tgz",
-      "integrity": "sha512-KfJW5HG6qnXTILNn2tkcx4u0o822uGR089W39O2AY2Nub77D8K+j3u2tnCCrqtbSYyG+NsXlIgL5Hts0kLFUAg==",
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@salesforce/sdk-data/-/sdk-data-1.56.0.tgz",
+      "integrity": "sha512-w6CTntTspVcILVGSBM8TQ61YA70vB+dU0cH+p2YLjI8ZiP1ZWdjGN/pDy5Dle9+4Gxat0shcXgnVPBmX3Xlapg==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@conduit-client/salesforce-lightning-service-worker": "^3.7.0",
-        "@salesforce/sdk-core": "^1.55.0"
+        "@salesforce/sdk-core": "^1.56.0"
       }
     },
     "node_modules/@salesforce/ts-types": {
@@ -6094,15 +6094,15 @@
       }
     },
     "node_modules/@salesforce/vite-plugin-webapp-experimental": {
-      "version": "1.55.0",
-      "resolved": "https://registry.npmjs.org/@salesforce/vite-plugin-webapp-experimental/-/vite-plugin-webapp-experimental-1.55.0.tgz",
-      "integrity": "sha512-HAncjTYbLMjeuFvwgbCuaRT5dO437R5CFQOEVwu58NBMFvlJWMgm1OhG7qGzax+Yj4Fya3JEz+pw9oZYuP6Z6w==",
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@salesforce/vite-plugin-webapp-experimental/-/vite-plugin-webapp-experimental-1.56.0.tgz",
+      "integrity": "sha512-lD6US3e/bwooMW4EmLoGhbnQzQhPXWUC9WG85yiEiLPyHyfHi3D4b1QUrlVHxsxlvYC3YesVx0boDfTVl/VICw==",
       "dev": true,
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@babel/core": "^7.28.4",
         "@babel/helper-plugin-utils": "^7.28.3",
-        "@salesforce/webapp-experimental": "^1.55.0"
+        "@salesforce/webapp-experimental": "^1.56.0"
       },
       "engines": {
         "node": ">=20.0.0"
@@ -6112,13 +6112,13 @@
       }
     },
     "node_modules/@salesforce/webapp-experimental": {
-      "version": "1.55.0",
-      "resolved": "https://registry.npmjs.org/@salesforce/webapp-experimental/-/webapp-experimental-1.55.0.tgz",
-      "integrity": "sha512-sJU8t0zQpg8TUoaukli/bQ7a7CLinGKYVRhOCEboF5gE7pcXLWm0Z6XICkyjdRzEkg2FxMAd/usxnIQdr3h6rg==",
+      "version": "1.56.0",
+      "resolved": "https://registry.npmjs.org/@salesforce/webapp-experimental/-/webapp-experimental-1.56.0.tgz",
+      "integrity": "sha512-i4yG9URMxZi8EsY2QV0OHsSPT0/Bkv/+702D0OpcQxC+fy0wLSSMUzaTh1vW4txikbZf26tToxN/qyp1NY0zNA==",
       "license": "SEE LICENSE IN LICENSE.txt",
       "dependencies": {
         "@salesforce/core": "^8.23.4",
-        "@salesforce/sdk-data": "^1.55.0",
+        "@salesforce/sdk-data": "^1.56.0",
         "axios": "^1.7.7",
         "micromatch": "^4.0.8",
         "path-to-regexp": "^8.3.0"

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/webapp-template-base-sfdx-project-experimental",
-  "version": "1.56.0",
+  "version": "1.56.1",
   "description": "Base SFDX project template",
   "private": true,
   "files": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/webapp-template-feature-react-chart-experimental",
-  "version": "1.56.0",
+  "version": "1.56.1",
   "description": "Chart feature with analytics chart components, agent skills, and rules (Recharts)",
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "",
@@ -27,7 +27,7 @@
     "clean": "rm -rf dist"
   },
   "devDependencies": {
-    "@salesforce/webapp-experimental": "^1.56.0",
+    "@salesforce/webapp-experimental": "^1.56.1",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "react-dom": "^19.2.1",
@@ -51,5 +51,5 @@
       }
     }
   },
-  "gitHead": "580bc4db5f0190f3b7345056a9f16454455f3652"
+  "gitHead": "c900d757a03250a770c5312dbef2013de91e7bb3"
 }