@pega/custom-dx-components 26.1.11 → 26.1.12-alpha.0.2

package/src/ai/catalog/references/pcore-rest-data-details.md

@@ -0,0 +1,164 @@
+# REST Client, Data APIs & Cascade — Method Details
+
+> Part of the [PCore / PConnect API Reference skills](../README.md). Companion to [pcore-rest-data-messaging.md](./pcore-rest-data-messaging.md), which covers the top-level `PCore.get*()` accessors. This file catalogs the methods available on the objects those accessors return.
+>
+> Curated subset — internal query-building helpers used only by `fetchData()`'s own pipeline are omitted.
+
+## RestClient (via `PCore.getRestClient()`)
+
+| Method                                                 | Signature                                                                                      | Purpose                                                           |
+| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |
+| `invokeRestApi(routeKey, payload, context?, options?)` | `(routeKey: string, payload: unknown, context?: string, options?: unknown): Promise<unknown>`  | Invokes a Pega REST API by route key.                             |
+| `invokeCustomRestApi(endpointUrl, config, context)`    | `(endpointUrl: string, config: unknown, context: string): Promise<unknown>`                    | Invokes a custom REST API by absolute or relative URL.            |
+| `getCancelTokenSource()`                               | `(): { token: AbortSignal; cancel: () => void }`                                               | Returns a cancel token source to cancel an in-flight request.     |
+| `isRequestCanceled(err)`                               | `(err: unknown): boolean`                                                                      | Checks whether a caught error was caused by request cancellation. |
+| `getHeaderProcessor()`                                 | `(): { registerHeader: Function; unRegisterHeader: Function; getRegisteredHeaders: Function }` | Manages custom headers applied to outgoing requests.              |
+| `getCaseApi()`                                         | `(): unknown`                                                                                  | Returns lower-level case-related REST operations.                 |
+
+**Example:**
+
+```typescript
+const { invokeRestApi, getCancelTokenSource, isRequestCanceled } = PCore.getRestClient();
+const cancelTokenSource = getCancelTokenSource();
+
+invokeRestApi('D_MyDataPage', { cancelTokenSource }).catch((error) => {
+  if (isRequestCanceled(error)) {
+    // ignore — request was canceled
+  }
+});
+```
+
+---
+
+## DataApi (via `PCore.getDataApi()`)
+
+| Method                                          | Signature                                                                          | Purpose                                                                     |
+| ----------------------------------------------- | ---------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `DataApi.init(config, context?)`                | `(config: unknown, context?: string): Promise<DataApi>`                            | Static factory — creates and caches a `DataApi` instance for a data source. |
+| `DataApi.clearContextedCache(context)`          | `(context: string): void`                                                          | Static — clears cached `DataApi` instances for a context.                   |
+| `fetchData(searchText?, isPaginated?, config?)` | `(searchText?: string, isPaginated?: boolean, config?: unknown): Promise<unknown>` | Fetches data with optional pagination and caching.                          |
+| `getData(searchText, config?)`                  | `(searchText: string, config?: unknown): Promise<unknown>`                         | Fetches data matching search text (queryable or non-queryable).             |
+| `registerForBufferedCall(params)`               | `(params: { waitTime?: number; maxSize?: number }): this`                          | Configures batched/debounced fetches for typeahead-style fields.            |
+| `isValidDatasource()`                           | `(): boolean`                                                                      | Returns whether a valid data source is configured.                          |
+
+**Example:**
+
+```typescript
+PCore.getDataApi()
+  .init(dataConfig, contextName)
+  .then((dataApiInstance) => {
+    dataApiInstance.registerForBufferedCall({ waitTime: 50 });
+    return dataApiInstance.fetchData(searchTerm);
+  });
+```
+
+**Notes:** For most list/data-page lookups, prefer the simpler `PCore.getDataApiUtils()` or `PCore.getDataPageUtils()` — reach for a live `DataApi` instance only when you need buffered/typeahead behavior.
+
+---
+
+## DataApiUtils (via `PCore.getDataApiUtils()`)
+
+| Method                                                                             | Signature                                                                                                             | Purpose                                                                          |
+| ---------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| `getData(dataViewName, payload?, context?, options?)`                              | `(dataViewName: string, payload?: unknown, context?: string, options?: unknown): Promise<unknown>`                    | Fetches list data from a data view with columns, filters, and paging.            |
+| `getListDataView(dataViewName, payload?, context?, options?)`                      | same shape as `getData`                                                                                               | Alias for `getData`.                                                             |
+| `getListCount(dataViewName, payload?, context?)`                                   | `(dataViewName: string, payload?: unknown, context?: string): Promise<unknown>`                                       | Returns the count of records matching a query.                                   |
+| `getDataObjectView(dataViewName, viewName, params, context, options?)`             | `(dataViewName: string, viewName: string, params: unknown, context: string, options?: unknown): Promise<unknown>`     | Retrieves a structured view object initialized with data view parameters.        |
+| `getDataViewMetadata(dataViewName, context, associationFilter?, propertyFilter?)` | `(dataViewName: string, context: string \| undefined, associationFilter?: string[] \| null, propertyFilter?: string[]): Promise<unknown>` | Retrieves metadata (fields, `isQueryable`) for a data view.                      |
+| `moveListRecords(payload, context)`                                                | `(payload: unknown, context: string): Promise<{ pyStatus: string }>`                                                  | Moves/reorders records within a list.                                            |
+| `getCaseEditMetadata(caseID, context)`                                             | `(caseID: string, context: string): Promise<unknown>`                                                                 | _Deprecated._ Fetches case edit metadata.                                        |
+| `getCaseEditLock(caseID, context)`                                                 | `(caseID: string, context: string): Promise<unknown>`                                                                 | _Deprecated._ Acquires an exclusive edit lock on a case.                         |
+| `updateCaseEditFieldsData(caseID, changeSet, eTag, context)`                       | `(caseID: string, changeSet: unknown, eTag: string, context: string): Promise<unknown>`                               | _Deprecated._ Updates case field data (requires an eTag from `getCaseEditLock`). |
+
+**Example:**
+
+```typescript
+const { data } = await PCore.getDataApiUtils().getData('D_MyDataPage', { paging: { pageSize: 20 } }, context);
+```
+
+---
+
+## DataPageUtils (via `PCore.getDataPageUtils()`)
+
+| Method                                                                                               | Signature                                           | Purpose                                                                       |
+| ---------------------------------------------------------------------------------------------------- | --------------------------------------------------- | ----------------------------------------------------------------------------- |
+| `getDataAsync(dataPageName, context, parameters?, paging?, query?, options?)`                         | `(...): Promise<unknown>`                           | Fetches list-type data page results with caching, query, and pagination.      |
+| `getPageDataAsync(dataPageName, context?, parameters?, options?)`                                    | `(...): Promise<unknown>`                           | Fetches page-type (single-object) data page results.                          |
+| `subscribeToDataPageUpdates(subscriptionId, callback, dataPageName, parameters?)`                    | `(...): boolean`                                    | Subscribes to server push notifications when a data page updates.             |
+| `unsubscribeToDataPageUpdates(subscriptionId, dataPageName, parameters?)`                            | `(...): boolean`                                    | Unsubscribes from data page update notifications.                             |
+| `subscribeToUpdate(dataPageName, dependentFields, context, pageReference, callback, subscriptionId)` | `(...): void`                                       | Subscribes to cascading updates when dependent fields change.                 |
+| `unsubscribe(dataPageName, dependentFields, context, pageReference, subscriptionId)`                 | `(...): void`                                       | Unsubscribes from cascading field-change notifications.                       |
+| `markDataInstanceDirty(dataPageName, parameters)`                                                    | `(dataPageName: string, parameters: unknown): void` | Marks a cached data page instance as stale, forcing a refresh on next fetch.  |
+| `isDataPage(propertyRef?)`                                                                           | `(propertyRef?: string): boolean`                   | Returns whether a property reference is a data page (`D_`/`Declare_` prefix). |
+| `updateDataPageStore(sharedDataPages?)`                                                              | `(sharedDataPages?: unknown): void`                 | Merges server-pushed shared data page updates into application state.         |
+
+**Example:**
+
+```typescript
+const response = await PCore.getDataPageUtils().getPageDataAsync(
+  'D_MyDataPage',
+  context,
+  { AccountID: accountId },
+  { invalidateCache: true }
+);
+```
+
+---
+
+## DataTypeUtils (via `PCore.getDataTypeUtils()`)
+
+| Method                             | Signature                           | Purpose                                                             |
+| ---------------------------------- | ----------------------------------- | ------------------------------------------------------------------- |
+| `getSavableDataPage(dataClass)`    | `(dataClass: string): string`       | Returns the default save data page for a data class.                |
+| `getLookUpDataPage(dataClass)`     | `(dataClass: string): string`       | Returns the default record-lookup data page for a data class.       |
+| `getLookUpDataPageInfo(dataClass)` | `(dataClass: string): unknown`      | Returns metadata for the lookup data page (key mapping, and so on). |
+| `getDataPageKeys(dataPageName)`    | `(dataPageName: string): unknown[]` | Returns the key definitions for a data page.                        |
+
+**Example:**
+
+```typescript
+const lookupDataPage = PCore.getDataTypeUtils().getLookUpDataPage(classID);
+```
+
+---
+
+## CascadeManager (via `PCore.getCascadeManager()`)
+
+| Method                                                                                        | Signature     | Purpose                                                                |
+| --------------------------------------------------------------------------------------------- | ------------- | ---------------------------------------------------------------------- |
+| `registerFields(context, pageReference, fields, callback, subscriberId)`                      | `(...): void` | Registers fields so a callback runs when their values change.          |
+| `unRegisterFields(context, pageReference, fields, subscriberId)`                              | `(...): void` | Unregisters previously registered fields.                              |
+| `registerListField(context, pageReference, listField, callback, subscriberId)`                | `(...): void` | Registers a page-list field and its parameter dependencies.            |
+| `unRegisterListField(context, pageReference, listField, subscriberId)`                        | `(...): void` | Unregisters a page-list field registration.                            |
+| `registerResetDependencies(context, pageReference, target, dependentProps, fieldType, mode?)` | `(...): void` | Registers a target field to be reset when dependent properties change. |
+| `deregisterResetDependencies(context, pageReference, target, dependentProps, fieldType)`      | `(...): void` | Deregisters a reset-dependency registration.                           |
+
+**Example:**
+
+```typescript
+useEffect(() => {
+  PCore.getCascadeManager().registerFields(contextID, '', dependentProps, onDependentPropsChange, subscriberId);
+  return () => {
+    PCore.getCascadeManager().unRegisterFields(contextID, '', dependentProps, subscriberId);
+  };
+}, []);
+```
+
+---
+
+## MashupApi (via `PCore.getMashupApi()`)
+
+| Method                                                    | Signature                                                                                            | Purpose                                                          |
+| --------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
+| `openCase(caseId, targetContext?, options?)`              | `(caseId: string, targetContext?: string, options?: unknown): Promise<unknown>`                      | Loads and displays a case by ID in a target container.           |
+| `createCase(className, targetContext?, options?)`         | `(className: string, targetContext?: string, options?: unknown): Promise<unknown>`                   | Creates and displays a new case in a target container.           |
+| `getNextWork(targetContext?, options?)`                   | `(targetContext?: string, options?: unknown): Promise<unknown>`                                      | Retrieves and displays the user's highest-priority assignment.   |
+| `openAssignment(assignmentId, targetContext?, options?)`  | `(assignmentId: string, targetContext?: string, options?: unknown): Promise<unknown>`                | Loads and displays an assignment by ID.                          |
+| `openPage(pageName, className, targetContext?, options?)` | `(pageName: string, className: string, targetContext?: string, options?: unknown): Promise<unknown>` | Opens a page view (not a case/assignment) in a target container. |
+| `getCurrentContextAPI(pageReference, targetContext?)`     | `(pageReference: string, targetContext?: string): PConnect`                                          | Returns a `PConnect` object for a given page reference/context.  |
+
+**Example:**
+
+```typescript
+await PCore.getMashupApi().openCase(caseHandle);
+```

package/src/ai/catalog/references/pcore-rest-data-messaging.md

@@ -0,0 +1,308 @@
+# PCore: REST, Data & Messaging
+
+> Part of the [PCore / PConnect API Reference skills](../README.md). See [pcore-rest-data-details.md](./pcore-rest-data-details.md) and [pcore-messaging-details.md](./pcore-messaging-details.md) for the full method catalogs of the objects these accessors return.
+
+## `getRestClient()`
+
+**Purpose:** Entry point to the REST client, exposing `invokeRestApi`, `getCancelTokenSource`, and `isRequestCanceled`.
+
+**Signature:**
+
+```typescript
+getRestClient(): RestClient
+```
+
+**Example:**
+
+```typescript
+const { invokeRestApi, getCancelTokenSource, isRequestCanceled } = PCore.getRestClient();
+
+const cancelTokenSource = getCancelTokenSource();
+invokeRestApi('D_MyDataPage', { cancelTokenSource })
+  .then((response) => {
+    // handle response
+  })
+  .catch((error) => {
+    if (isRequestCanceled(error)) {
+      // request was canceled — ignore
+    }
+  });
+```
+
+---
+
+## `getDataApi()`
+
+**Purpose:** Creates a live `DataApi` instance for a datasource — used by components that need buffered/typeahead fetches (for example, an autocomplete field backed by a data page).
+
+**Signature:**
+
+```typescript
+getDataApi(): DataApi
+```
+
+**Example:**
+
+```typescript
+PCore.getDataApi()
+  .init(dataConfig, contextName)
+  .then((dataApiInstance) => {
+    dataApiInstance.registerForBufferedCall({ waitTime: 50 });
+    dataApiInstance.fetchData(searchTerm).then((response) => {
+      // handle response
+    });
+  });
+```
+
+**Notes:** `init()` returns a `Promise` that resolves to a `DataApi` instance scoped to the given context. Call `clearContextedCache(contextName)` when tearing down.
+
+---
+
+## `getDataApiUtils()`
+
+**Purpose:** Utility APIs to retrieve information from a data view without managing a live `DataApi` instance.
+
+**Signature:**
+
+```typescript
+getDataApiUtils(): DataApiUtils
+```
+
+**Example:**
+
+```typescript
+PCore.getDataApiUtils()
+  .getDataViewMetadata(dataPageID, context, null, fieldIDs)
+  .then(({ data }) => {
+    // use resolved field metadata
+  });
+```
+
+---
+
+## `getDataPageUtils()`
+
+**Purpose:** Utility methods to retrieve data page data (page-type or list-type), with optional cache control.
+
+**Signature:**
+
+```typescript
+getDataPageUtils(): DataPageUtils
+```
+
+**Example:**
+
+```typescript
+const response = await PCore.getDataPageUtils().getPageDataAsync(
+  'D_MyDataPage',
+  context,
+  { AccountID: accountId },
+  { invalidateCache: true }
+);
+```
+
+---
+
+## `getDataTypeUtils()`
+
+**Purpose:** Utility methods to retrieve information about a data type, such as its lookup data page or class keys.
+
+**Signature:**
+
+```typescript
+getDataTypeUtils(): DataTypeUtils
+```
+
+**Example:**
+
+```typescript
+const lookupDataPage = PCore.getDataTypeUtils().getLookUpDataPage(classID);
+```
+
+---
+
+## `getCascadeManager()`
+
+**Purpose:** Registers a callback to run when a set of properties change — used to build cascading/dependent fields (for example, a country field that resets a state field).
+
+**Signature:**
+
+```typescript
+getCascadeManager(): CascadeManager
+```
+
+**Example:**
+
+```typescript
+useEffect(() => {
+  PCore.getCascadeManager().registerFields(contextID, '', dependentProps, onDependentPropsChange, subscriberId);
+
+  return () => {
+    PCore.getCascadeManager().unRegisterFields(contextID, '', dependentProps, subscriberId);
+  };
+}, []);
+```
+
+**Notes:** Always pair `registerFields` with a matching `unRegisterFields` on cleanup to avoid stale callbacks.
+
+---
+
+## `getMashupApi()`
+
+**Purpose:** Provides APIs to work with cases and pages across a mashup/embedding boundary.
+
+**Signature:**
+
+```typescript
+getMashupApi(): MashupApi
+```
+
+**Example:**
+
+```typescript
+PCore.getMashupApi().openCase(caseHandle);
+```
+
+---
+
+## `getSemanticUrlUtils()`
+
+**Purpose:** Utilities to build and resolve semantic URLs, including the constant names used for supported semantic-URL actions.
+
+**Signature:**
+
+```typescript
+getSemanticUrlUtils(): SemanticUrlUtils
+```
+
+**Example:**
+
+```typescript
+const { ACTION_OPENWORKBYHANDLE, ACTION_SHOWDATA } = PCore.getSemanticUrlUtils().getActions();
+```
+
+---
+
+## `getMessageManager()`
+
+**Purpose:** Adds, reads, and clears case/validation messages stored in the application state.
+
+**Signature:**
+
+```typescript
+getMessageManager(): MessageManager
+```
+
+**Example:**
+
+```typescript
+const { addMessages, clearMessages } = PCore.getMessageManager();
+
+addMessages({
+  messages: [{ type: 'error', message: 'Something went wrong' }],
+  category: 'PAGE',
+  context
+});
+
+clearMessages({ category: 'PAGE', context });
+```
+
+---
+
+## `getPubSubUtils()`
+
+**Purpose:** Entry point to the application-wide publish/subscribe event bus.
+
+**Signature:**
+
+```typescript
+getPubSubUtils(): PubSubUtils
+```
+
+**Example:**
+
+```typescript
+const { subscribe, unsubscribe, publish } = PCore.getPubSubUtils();
+const stageCreatedEvent = PCore.getEvents().getCaseEvent().CREATE_STAGE_DONE;
+
+subscribe(stageCreatedEvent, onStageCreated, 'stageCreatedHandler');
+// later
+unsubscribe(stageCreatedEvent, 'stageCreatedHandler');
+```
+
+---
+
+## `getEvents()`
+
+**Purpose:** Returns the catalog of case-related event names, intended for use as topics with `getPubSubUtils()`.
+
+**Signature:**
+
+```typescript
+getEvents(): Events
+```
+
+**Example:**
+
+```typescript
+const caseCreated = PCore.getEvents().getCaseEvent().CREATE_STAGE_DONE;
+PCore.getPubSubUtils().subscribe(caseCreated, onStageCreated);
+```
+
+---
+
+## `getMessagingServiceManager()`
+
+**Purpose:** Provides WebSocket-based messaging service APIs, including subscribing to case/interaction notifications and reading user presence.
+
+**Signature:**
+
+```typescript
+getMessagingServiceManager(): MessagingServiceManager
+```
+
+**Example:**
+
+```typescript
+const userState = PCore.getMessagingServiceManager().getUserPresence().getUserState(userIdentifier);
+```
+
+---
+
+## `getActionsSequencer()`
+
+**Purpose:** Returns the `ActionsSequencer`, which serializes case actions dispatched through `ActionsApi` to prevent race conditions. Most components don't need to interact with it directly since `ActionsApi` uses it internally.
+
+**Signature:**
+
+```typescript
+getActionsSequencer(): ActionsSequencer
+```
+
+**Example:**
+
+```typescript
+const sequencer = PCore.getActionsSequencer();
+```
+
+---
+
+## `getExpressionEngine()`
+
+**Purpose:** Evaluates an authored expression string against a given data context.
+
+**Signature:**
+
+```typescript
+getExpressionEngine(): ExpressionEngine
+```
+
+**Example:**
+
+```typescript
+// CreateC11nEnv is `{ getPConnect: () => PConnect }`; BootstrapUtils.createC11nEnv(meta) returns one.
+const options = { pConnect: PCore.getBootstrapUtils().createC11nEnv(meta) };
+const result = PCore.getExpressionEngine().evaluate(expressionString, rowData, options);
+```
+
+**Notes:** In the 5.1.0 typedefs `evaluate(expression: string, data: object, options: { pConnect: CreateC11nEnv }): boolean` takes all three arguments and returns a `boolean` (it evaluates a filter expression such as `.HomeNumber != '123'` against `data`). `options` is typed as required, although the typedef's own comment calls it optional.

package/src/ai/catalog/references/pcore-store-context-details.md

@@ -0,0 +1,40 @@
+# State & Context Tree — Method Details
+
+> Part of the [PCore / PConnect API Reference skills](../README.md). Companion to [pcore-store-context-state.md](./pcore-store-context-state.md), which covers the top-level `PCore.get*()` accessors. This file catalogs the methods available on the objects those accessors return.
+
+## StateUtils (via `PCore.getStateUtils()`)
+
+| Method                                       | Signature                                                                                                                                                                                        | Purpose                                                          |
+| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------- |
+| `getSharedState(key)`                        | `(key: string): unknown`                                                                                                                                                                         | Reads a property value from shared application state.            |
+| `setSharedState(key, value)`                 | `(key: string, value: unknown): void`                                                                                                                                                            | Writes a property value to shared application state.             |
+| `updateState(context, key, value, options?)` | `(context: string, key: string, value: unknown, options?: { pageReference?: string; isArrayDeepMerge?: boolean; skipDirtyValidation?: boolean; removePropertyFromChangedList?: boolean }): void` | Updates a property value for a given context with merge options. |
+| `getSuggestionsContext(context)`             | `(context: string): unknown`                                                                                                                                                                     | Returns the Suggestions Context entry point for a given context. |
+| `triggerRefresh(context, pageReference)`     | `(context: string, pageReference: string): void`                                                                                                                                                 | Triggers a refresh of the assignment in the specified context.   |
+
+**Example:**
+
+```typescript
+const stateUtils = PCore.getStateUtils();
+stateUtils.updateState(context, 'caseInfo.ID', caseID, { skipDirtyValidation: true });
+```
+
+---
+
+## ContextTreeManager (via `PCore.getContextTreeManager()`)
+
+| Method                                                                  | Signature                                               | Purpose                                                       |
+| ----------------------------------------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------------- |
+| `onViewMutate(context, pageName, viewName, callback)`                   | `(...): void`                                           | Registers a callback for view-hierarchy mutations.            |
+| `onPageListMutate(context, pageName, viewName, pageListName, callback)` | `(...): void`                                           | Registers a callback for page-list hierarchy mutations.       |
+| `isFieldExists(context, propertyReference)`                             | `(context: string, propertyReference: string): boolean` | Checks whether a field is tracked in the context tree.        |
+| `getFieldsList(context)`                                                | `(context: string): Map<string, unknown>`               | Returns all editable/calculated fields tracked for a context. |
+| `getFieldReferencePreviousValue(context, propertyReference)`            | `(context: string, propertyReference: string): unknown` | Returns the previously stored value of a tracked field.       |
+
+**Example:**
+
+```typescript
+const trackedFields = PCore.getContextTreeManager().getFieldsList(contextName);
+```
+
+**Notes:** This class primarily supports the framework's own refresh/validation tracking; most mutation methods (`mutateField`, `removeFieldNode`, and so on) are invoked internally as part of the component render lifecycle rather than called directly by component code.

package/src/ai/catalog/references/pcore-store-context-state.md

@@ -0,0 +1,130 @@
+# PCore: Store, Context & State
+
+> Part of the [PCore / PConnect API Reference skills](../README.md). See [pcore-store-context-details.md](./pcore-store-context-details.md) for the full method catalogs of `StateUtils` and `ContextTreeManager`.
+
+## `getStore()`
+
+**Purpose:** Returns the Redux store instance backing the entire application state.
+
+**Signature:**
+
+```typescript
+getStore(): Store
+```
+
+**Example:**
+
+```typescript
+useEffect(() => {
+  const store = PCore.getStore();
+  return store.subscribe(() => {
+    // react to any store change
+  });
+}, []);
+```
+
+**Notes:** The returned object is a standard Redux store (`getState()`, `dispatch()`, `subscribe()`). Prefer `pConn.getValue()`/`PCore.getStoreValue()` for reading specific values rather than reading raw state directly.
+
+---
+
+## `getStoreValue(propReference, pageReference, context)`
+
+**Purpose:** Returns the value of a property from the store, without needing a `PConnect` instance.
+
+**Signature:**
+
+```typescript
+getStoreValue(propReference: string, pageReference: string, context: string): unknown
+```
+
+**Example:**
+
+```typescript
+const firstName = PCore.getStoreValue('.FirstName', 'caseInfo.content', 'app/primary_1');
+```
+
+**Notes:** `propReference` is the property path (e.g. `.FirstName`), `pageReference` is the page path (e.g. `caseInfo.content`), and `context` scopes the lookup to a specific container/view context.
+
+---
+
+## `getStateUtils()`
+
+**Purpose:** Returns `StateUtils`, a set of utilities for reading and updating shared application state.
+
+**Signature:**
+
+```typescript
+getStateUtils(): StateUtils
+```
+
+**Example:**
+
+```typescript
+const stateUtils = PCore.getStateUtils();
+stateUtils.updateState(context, 'caseInfo.ID', caseID, { skipDirtyValidation: true });
+```
+
+---
+
+## `createPConnect(config)`
+
+**Purpose:** Creates a `PConnect` object from a component configuration — useful for rendering a component dynamically outside the normal `getPConnect()` prop chain (for example, a cell renderer inside a custom table).
+
+**Signature:**
+
+```typescript
+createPConnect(config: {
+  meta: { type: string; config?: Record<string, unknown> };
+  options?: { context?: string; pageReference?: string; referenceList?: string };
+}): { getPConnect: () => PConnect }
+```
+
+**Example:**
+
+```typescript
+const cellComponent = PCore.createPConnect({
+  meta: { type: 'TextInput', config: { label: 'Name', value: '.FirstName' } },
+  options: { context: 'app/primary_1', pageReference: 'caseInfo.content' }
+});
+const pConn = cellComponent.getPConnect();
+```
+
+**Notes:** `meta.type` is required; `options.context`/`options.pageReference` are only needed when the component must render under a context different from its parent's.
+
+---
+
+## `getContextTreeManager()`
+
+**Purpose:** Returns the `ContextTreeManager`, which tracks view/field dependencies confined to a view and its children (used to support refresh and validation behavior).
+
+**Signature:**
+
+```typescript
+getContextTreeManager(): ContextTreeManager
+```
+
+**Example:**
+
+```typescript
+const viewNode = PCore.getContextTreeManager().getViewNode(contextName, pageReference, viewName);
+```
+
+---
+
+## `isDeepEqual(oldValue, newValue)`
+
+**Purpose:** Determines whether two objects are equal via a deep comparison.
+
+**Signature:**
+
+```typescript
+isDeepEqual(oldValue: object, newValue: object): boolean
+```
+
+**Example:**
+
+```typescript
+if (!PCore.isDeepEqual(previousMetadata, updatedMetadata)) {
+  // only re-dispatch when the metadata actually changed
+}
+```