@uipath/skills 1.196.0 → 1.197.0

package/skills/uipath-rpa/references/cli-reference.md

@@ -160,6 +160,34 @@ Rules:
 
 ---
 
+## object-repository
+
+Read the project's UI **Object Repository** — the saved hierarchy of applications, screens, and elements (selectors/targets) that UI Automation activities bind to. Two read commands cover the project's own entries and those exposed by referenced libraries; both require an open project.
+
+- **Project Object Repository** — `uip rpa object-repository get` returns the project's *own* Object Repository as a JSON tree of applications → screens → elements. Entries inherited from referenced libraries are **excluded** (use the library command below for those). Takes no arguments beyond the standard `--project-dir`.
+
+  ```bash
+  uip rpa object-repository get --project-dir "<PROJECT_DIR>" --output json
+  ```
+
+- **Library Object Repository** — `uip rpa object-repository get-library` reads the Object Repository out of one or more library `.nupkg` files and returns the applications, screens, and elements grouped by library. Pass the absolute path(s) to the library packages; packages without an Object Repository are omitted from the result.
+
+  | Parameter | Required | Description |
+  |-----------|----------|-------------|
+  | `--library-paths` | yes | Absolute path(s) to the library `.nupkg` file(s) to read. Pass a single flag with the paths **comma-separated** (e.g. `"a.nupkg,b.nupkg"`) — it is not a repeatable flag. Avoid paths containing commas. |
+
+  ```bash
+  # multiple libraries: one --library-paths flag, comma-separated
+  uip rpa object-repository get-library \
+    --project-dir "<PROJECT_DIR>" \
+    --library-paths "C:\libs\Acme.UiLib.1.2.0.nupkg,C:\libs\Other.UiLib.2.0.0.nupkg" \
+    --output json
+  ```
+
+Read the project repository before authoring UI Automation activities to discover existing screens/elements to reuse instead of re-indicating them; read the library repository to discover targets a referenced UI library already exposes. Confirm the live verb names and flags with `uip rpa object-repository --help`.
+
+---
+
 ## Commands -- Data Fabric Entities
 
 UiPath Data Fabric entities live in the Orchestrator tenant's Data Service. To use them in an RPA project — as typed arguments (`UiPath.DataService.Activities`, test-data bindings) or any generated entity type — they must first be **installed** into the project, which writes a manifest under `.entities/` and compiles a strongly-typed assembly.
@@ -181,9 +209,35 @@ The verbs you'll reach for: list/describe **connectors** and their **activities*
 
 ---
 
-## Test Manager (`uip tm`)
+## Test Manager
+
+Two distinct surfaces — pick by intent:
+
+- **`uip tm` (dedicated tool)** — *runtime* Test Manager operations: browsing manual test cases, runs, results. `uip tm --help`. Do **not** invoke these runtime verbs from `uip rpa`.
+- **`uip rpa tm` (project configuration)** — *authoring/setup*: wire an RPA project to Test Manager by editing its `.tmh/config.json`. Pure file I/O — no Studio or Helm process is needed, so it works with everything closed.
+
+### `uip rpa tm` verbs
+
+| Verb | Purpose |
+|---|---|
+| `uip rpa tm connect --url <url>` | Set the Test Manager **server URL** (`testManagerBasePath`). Switching to a **different** server (different host/org/tenant) also **clears the default project**, since it belonged to the old server. |
+| `uip rpa tm set-default-project --id <guid> [--name <name>] [--key <key>]` | Link the **default Test Manager project** (`defaultProject`). **Requires a connected server** — run `connect` first or it is rejected. |
+| `uip rpa tm clear-default-project` | Unlink the default project; the server URL is kept. |
+| `uip rpa tm status` | Show the current configuration — server URL and linked default project. |
+
+Typical setup flow (all verbs take the standard `--project-dir` and `--output json`):
+
+```
+uip rpa tm connect --url "https://cloud.uipath.com/<org>/<tenant>/testmanager_" --project-dir "<PROJECT_DIR>" --output json
+uip rpa tm set-default-project --id <project-guid> --name "<project-name>" --key "<KEY>" --project-dir "<PROJECT_DIR>" --output json
+uip rpa tm status --project-dir "<PROJECT_DIR>" --output json
+```
+
+`set-default-project` does **not** call the server to validate the id (there is no server round-trip) — pass a real Test Manager project id (and optional name/key). Listing projects from the server is not available here; obtain the id from Test Manager itself. Confirm exact flags via `uip rpa tm --help`.
+
+#### Acting on `reloadHint` in the output
 
-Test Manager integration lives in the dedicated `uip tm` tool — `uip tm --help`. Do not document or invoke Test Manager verbs from `uip rpa`.
+A `connect` / `set-default-project` / `clear-default-project` response may include a **`reloadHint`** field. It appears only when the project is currently **open in a Studio older than 26.0.197**, which reads `.tmh/config.json` *only on project open*. When you see it, tell the user to **close and reopen the project in Studio** for the change to take effect — the CLI cannot do this for them. No `reloadHint` means nothing to do: either the project isn't open in Studio, or it's open in Studio 26.0.197+, which applies the change live.
 
 ---
 
@@ -210,7 +264,7 @@ Diagnose by error category, apply the recovery, retry **once** — do not loop t
 |--------|-----|
 | **Explore project files** | `Glob` `**/*.xaml` |
 | **Search XAML content** | `Grep` regex across `.xaml` |
-| **Explore Object Repository** | `Glob` `**/*` under `{PROJECT_DIR}/.objects/` + `Read` metadata |
+| **Explore Object Repository** | `uip rpa object-repository get` for the project's apps/screens/elements as JSON, `uip rpa object-repository get-library` for a referenced library's (see [object-repository](#object-repository)); or `Glob` `**/*` under `{PROJECT_DIR}/.objects/` + `Read` metadata for raw files |
 | **Get JIT type definitions** | `Read` `{PROJECT_DIR}/.project/JitCustomTypesSchema.json` |
 | **Activity docs** | See [Installed package activity documentation](#installed-package-activity-documentation) above |
 | **Inspect a NuGet package's API** | `uip rpa packages inspect` — see [coded/inspect-package-guide.md](coded/inspect-package-guide.md) |

package/skills/uipath-rpa/references/common-activity-card.md

@@ -140,7 +140,7 @@ Snippets use the property-element form with `<VisualBasicValue>` / `<VisualBasic
 </TryCatch>
 ```
 
-**Notes:** `Try`, every `Catch.Action`, and `Finally` must wrap their body in `<Sequence>` per Rule 24. Each `Catch` requires its own `<ActivityAction x:TypeArguments="...">` holding a `<DelegateInArgument x:TypeArguments="..." Name="exception" />` — the `Name` is the variable name the handler body uses. Place specific exception types before `s:Exception`. Omit `<TryCatch.Finally>` entirely when not needed.
+**Notes:** `Try`, every `Catch.Action`, and `Finally` must wrap their body in `<Sequence>` per Rule 24. Each `Catch` requires its own `<ActivityAction x:TypeArguments="...">` holding a `<DelegateInArgument x:TypeArguments="..." Name="exception" />` — the `Name` is the variable name the handler body uses. Place specific exception types before `s:Exception`. Omit `<TryCatch.Finally>` entirely when not needed. For strategy — exception taxonomy, Retry Scope, ContinueOnError, screenshot-on-error, Global Exception Handler — see [error-handling-guide.md](error-handling-guide.md).
 
 **Long-form:** [`activity-docs/UiPath.System.Activities/26.4/activities/TryCatch.md`](activity-docs/UiPath.System.Activities/26.4/activities/TryCatch.md)
 

package/skills/uipath-rpa/references/connector-capabilities.md

@@ -54,6 +54,8 @@ uip rpa activities get-default-xaml \
 
 **`--activity-type-id` is mandatory for IS dynamic activities** — without it, the default XAML comes back empty (`Configuration={x:Null}`, no fields) and isn't runnable.
 
+`get-default-xaml` also accepts repeatable `--field-values name=value` pairs: the values are pre-bound as literals in the returned `FieldObjects`, and when they cover the operation's prerequisite criteria fields (e.g. Jira's `project` + `issuetype`), the returned `Configuration` blob is re-resolved with the full expanded field schema — the same expansion Studio's designer performs when those fields are committed in the canvas. Full usage pattern: [is-connector-xaml-guide.md § Step 4](is-connector-xaml-guide.md).
+
 ## Connection Management
 
 **Check if a connection exists:**

package/skills/uipath-rpa/references/data-manipulation-guide.md

@@ -0,0 +1,311 @@
+# Data Manipulation Guide
+
+Expression/code patterns for transforming data in modern projects: DataTable LINQ, strings, RegEx, DateTime, type conversion, collections, JSON — the layer **not wrapped in activities**.
+
+**Boundary — these own their topics, link don't reinvent:**
+- DataTable *activity* mechanics (BuildDataTable `TableInfo` trap + inline build, FilterDataTable type-compat, LookupDataTable, GetRowItem) → [xaml/common-pitfalls.md § DataTable Activity Gotchas](xaml/common-pitfalls.md).
+- C# XAML expression *binding* form (`CSharpValue`/`CSharpReference`) → [xaml/csharp-activity-binding-guide.md](xaml/csharp-activity-binding-guide.md).
+- Config.xlsx row/field access in REFramework → [reframework-guide.md](reframework-guide.md).
+- Per-activity property surfaces (ForEachRow, AddDataRow, JoinDataTables, SortDataTable, …) → `{PROJECT_DIR}/.local/docs/packages/UiPath.System.Activities/` or `references/activity-docs/UiPath.System.Activities/`.
+- Coded-mode `using` directives → [coded/coding-guidelines.md](coded/coding-guidelines.md).
+
+## Where each snippet goes — read first
+
+Each code block below is tagged. **A DataTable LINQ chain is a single value — it belongs in one `Assign`. A `For Each`/`Dim`/object-mutation block is NOT an expression — it cannot go in an `Assign`.** Putting statement-style VB into an `Assign` is the most common paste error.
+
+| Tag | Where it goes |
+|-----|---------------|
+| `[expr]` | One `Assign.Value` — a single expression. Examples are **VB**; in a C#-expression project translate per the VB↔C# key AND wrap in `CSharpValue` — the VB text is not valid C# as-is. |
+| `[seq]` | An XAML **activity sequence** — `For Each` / `Add Data Row` / multiple `Assign`s. Not one expression. |
+| `[coded]` | Coded `.cs` workflow (or `Invoke Code`) only — statement blocks, `Dim`, mutation loops. |
+
+When a transform needs more than ~2 chained `[seq]` steps or a real helper, **stop hand-assembling XAML and write a coded workflow** — see § When to move to coded.
+
+## Required imports & references
+
+A DataTable LINQ chain needs ALL of the following in `TextExpression` (XAML). Don't infer — set them:
+
+- **Namespace imports** (`NamespacesForImplementation`): `System.Data`, `System.Linq`
+- **Assembly references** (`ReferencesForImplementation`): `System.Data`, `System.Data.Common`, `System.Data.DataSetExtensions`
+
+A scaffolded project (`uip rpa init`) already has all of these — untouched, the LINQ family just works. Add them only when hand-authoring a XAML file or after trimming imports. Coded (`.cs`): `using System.Data;` + `using System.Linq;` ([coded/coding-guidelines.md](coded/coding-guidelines.md)).
+
+Notes:
+- `AsEnumerable` / `CopyToDataTable` / `DataRowComparer`: in modern (Windows / cross-platform) they resolve via `System.Data` (the `System.Data.DataSetExtensions` reference is harmless and present by default); **legacy (.NET Framework 4.6.1) requires `System.Data.DataSetExtensions`** — there they live in that assembly, not `System.Data`. Including it in both is the safe default.
+- Drop the `System.Linq` import and `AsEnumerable` won't resolve — the break surfaces at **run** (runtime JIT), not at `uip rpa validate` or even `uip rpa build` packaging.
+
+## VB ↔ C# translation key
+
+Examples are **VB** (default expression language; bracket `[expr]` in XAML attributes). VB→C# is mechanical (`Function(r) r("Col")` → `r => r["Col"]`, `()`→`[]` indexing, `If(c,a,b)` → `c ? a : b`); coded (`.cs`) uses the C# form directly and C#-expression XAML uses it too — **except** the coded-only constructs below.
+
+**Coded-only — these do NOT compile in any XAML expression:** the C# `out` **parameter** keyword (e.g. `int.TryParse(s, out int n)` — this is the C# `out` keyword, *not* a workflow/XAML `OutArgument`), null-propagation `?.` / `?[]`, the null-coalescing `??`, and collection initializers (`new Dictionary<…>{ … }`). They work only in coded (`.cs`) workflows. They fail in a VB XAML `Assign`, and — despite being "C#" — also fail **inside `CSharpValue`** in a C#-expression XAML project, because XAML binds expressions as expression trees that forbid them (CS8198 `out`, CS8072 `?.`, CS8074 initializer; statement-body lambdas/IIFEs fail CS0834).
+
+**XAML-safe forms instead** (both VB and C# expression projects):
+- Parse: pre-declare `n`, use the composite VB `If(Integer.TryParse(s, n), n, 0)` (C#-expression XAML: there is no `out`-free `TryParse`, so do the parse in a coded workflow or accept the VB form — `out` cannot appear in `CSharpValue`).
+- Null-safe: `If(x Is Nothing, "", x.ToString())` (VB) — not `?.`/`??`.
+- Build a dictionary across `Assign`s / `Invoke Method`, not an inline initializer.
+
+See [csharp-activity-binding-guide.md](xaml/csharp-activity-binding-guide.md).
+
+## Choose the approach
+
+| Task | Use | Notes |
+|------|-----|-------|
+| Simple single-condition filter | **Filter Data Table** activity | GUI, no expression |
+| Expression filter, no new columns | `dt.Select("[Amount] > 1000")` | returns `DataRow()`; string match is **case-INSENSITIVE** by default; SQL-ish syntax |
+| Filter/sort/group/join/project | **LINQ** in one `Assign` | most flexible; ~2× faster than Join Data Tables on large sets |
+| Heavy multi-step transforms, unit-tested logic, safe accessors | **coded** (`.cs`) | C# LINQ inline; see § When to move to coded |
+| Key-value config / counters | `Dictionary(Of K,V)` | |
+| Tabular data | `DataTable` | typed columns; LINQ via `.AsEnumerable()` |
+
+### When to move to coded
+
+**Default in VB projects: native expressions (`Assign`) for LINQ and JSON — not `Invoke Code`.** Inline `Invoke Code` adds assembly/import/version pitfalls (it compiles against a separately-resolved set, drifts from the project's references, and isn't checked by `validate`); native expressions reuse the project's imports and round-trip in the designer. The `[expr]` snippets here are all native.
+
+When a transform genuinely outgrows expressions — >2 statement steps, a reusable safe accessor/helper, mutating rows in a loop, real try/catch around a parse, or an unreadable one-liner — move to a **coded (`.cs`) workflow** ([coded/operations-guide.md](coded/operations-guide.md)), still not `Invoke Code`. Coded gives `?.`, `out var`, multi-statement logic, and unit tests.
+
+**Source file vs workflow — and how to call it:** a bare **Coded Source File** (helper class, no entry point) is callable only from other code. To invoke the logic from a XAML process, make it a **Coded Workflow** (`[Workflow]` + `Execute`) and call it via **Invoke Workflow File** (from XAML) or `RunWorkflow` / the typed `workflows` property (from coded) — see [coded/operations-guide.md](coded/operations-guide.md).
+
+Tabular *source/sink*: modern projects use the **Use Excel File** scope (not classic Excel Application Scope) — route to the Excel activity docs.
+
+## Safe data access first
+
+Production data (Excel, scraping, UI, queues) is full of `DBNull`, blanks, localized numbers, and bad dates. A `DBNull` cell's `.ToString()` returns `""` (no error) — so **bare reads silently propagate blanks**, and `CDbl`/`Convert.ToDateTime`/`ParseExact` then **throw on the resulting blank/garbage**; a genuinely `Nothing` value throws `Object reference not set`. Use direct casts only on **typed, known-non-null** columns (e.g. a Decimal column you built). For String/Excel/scraped columns, read safely.
+
+**Inline safe reads** `[expr]`:
+```vb
+' string cell (never throws)
+If(IsDBNull(r("Name")), "", r("Name").ToString().Trim())
+' number cell -> Decimal, invariant, default 0 on bad/blank/null (n is a Decimal out-var)
+If(Decimal.TryParse(If(IsDBNull(r("Amount")), "", r("Amount").ToString()), Globalization.NumberStyles.Any, Globalization.CultureInfo.InvariantCulture, n), n, 0D)
+```
+
+**Reusable safe accessor** `[coded]` — the maintainable form once more than a couple of fields are involved (Coded Source File, plain `.cs`, no `CodedWorkflow` base):
+```csharp
+public static class Row
+{
+    public static string Str(DataRow r, string c) => r.IsNull(c) ? "" : r[c].ToString().Trim();
+    public static decimal Dec(DataRow r, string c) =>
+        decimal.TryParse(Str(r, c), NumberStyles.Any, CultureInfo.InvariantCulture, out var d) ? d : 0m;
+    public static DateTime? Date(DataRow r, string c, string fmt) =>
+        DateTime.TryParseExact(Str(r, c), fmt, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dt) ? dt : (DateTime?)null;
+}
+```
+Throw a `BusinessRuleException` (not a crash) when invalid business data must stop the item — e.g. `If String.IsNullOrWhiteSpace(Row.Str(r,"Id")) Then Throw New BusinessRuleException("Missing Id at row " & i)`.
+
+## DataTable transforms (LINQ)
+
+`.AsEnumerable()` first; `.CopyToDataTable()` to produce a DataTable. Casts below assume a **typed/clean** column — for String/Excel data wrap fields per § Safe data access first.
+
+**Rule — guard `CopyToDataTable()` against empty results (MANDATORY).** It throws `InvalidOperationException: "The source contains no DataRows"` on an empty sequence:
+```vb
+[If(q.Any(), q.CopyToDataTable(), dt.Clone())]
+```
+`dt.Clone()` = empty table, same schema (`dt.Copy()` = schema + all rows).
+
+### Filter, sort, dedup, paginate — each `[expr]`
+```vb
+' filter — explicit case-insensitive + trimmed. dt.Select / Filter Data Table string
+' match is case-INSENSITIVE by default; use StringComparison.Ordinal for case-sensitive.
+dt.AsEnumerable().Where(Function(r) r("Status").ToString().Trim().Equals("active", StringComparison.OrdinalIgnoreCase))
+
+' sort descending
+dt.AsEnumerable().OrderByDescending(Function(r) CDbl(r("Amount"))).CopyToDataTable()
+
+' distinct whole rows
+dt.AsEnumerable().Distinct(DataRowComparer.Default).CopyToDataTable()
+
+' dedup by a SUBSET of columns — GroupBy + first row per key
+dt.AsEnumerable().GroupBy(Function(r) r("Id").ToString()).Select(Function(g) g.First()).CopyToDataTable()
+
+' pagination
+dt.AsEnumerable().Skip(10).Take(10).CopyToDataTable()
+```
+Wrap each `…CopyToDataTable()` in the empty-guard when the filter may match nothing. C#: `r => r["Status"]…`, `g => g.First()`.
+
+### Aggregate — each `[expr]`
+```vb
+dt.AsEnumerable().Sum(Function(r) CDbl(r("Amount")))
+dt.AsEnumerable().Count(Function(r) r("Status").ToString().Trim().Equals("active", StringComparison.OrdinalIgnoreCase))
+dt.AsEnumerable().Any(Function(r) CDbl(r("Amount")) > 10000)
+```
+
+### Compare two DataTables (diff) — each `[expr]`
+```vb
+' rows in A not in B — whole-row (guard + CopyToDataTable)
+dtA.AsEnumerable().Except(dtB.AsEnumerable(), DataRowComparer.Default)
+' rows in A whose key is absent from B
+dtA.AsEnumerable().Where(Function(a) Not dtB.AsEnumerable().Any(Function(b) b("Id").ToString() = a("Id").ToString()))
+```
+
+### Join two DataTables (VLOOKUP equivalent) — `[expr]`
+
+| Need | Use |
+|------|-----|
+| Pull one value from a lookup table | **Lookup Data Table** activity |
+| Combine columns from both, simple | **Join Data Tables** activity (slower at scale) |
+| Combine/filter/shape in one pass | **LINQ join** |
+
+```vb
+(From a In dtA.AsEnumerable()
+ Join b In dtB.AsEnumerable() On a("Id").ToString() Equals b("Id").ToString()
+ Select New Object(){ a("Id"), a("Name"), b("Region") }).ToList()
+```
+`Select New Object(){…}` makes each element an `Object()`, so the result is **`List(Of Object())`** — type the receiving variable accordingly (or project to an anonymous type for named fields).
+
+### Remove blank rows — `[expr]`
+Excel/scraping leave trailing all-empty rows; left in, they pollute counts/output and break downstream numeric/date casts (blank → failed parse). Drop them:
+```vb
+dt.AsEnumerable().Where(Function(r) Not r.ItemArray.All(Function(f) f Is DBNull.Value OrElse String.IsNullOrWhiteSpace(f.ToString())))
+```
+(guard + `CopyToDataTable()`).
+
+### Group-by-sum into a NEW DataTable — `[seq]` (or `[coded]`)
+Not an `Assign` — a `For Each` over the groups feeding `Add Data Row`:
+```vb
+' grouped: pre-built DataTable with columns Category(String), Total(Decimal)
+For Each g In dt.AsEnumerable().GroupBy(Function(r) r("Category").ToString())
+    grouped.Rows.Add(g.Key, g.Sum(Function(r) CDec(r("Amount"))))
+Next
+```
+In XAML: `ui:ForEach` (with `<ui:ForEach.Body>`) over `…GroupBy(...).Select(Function(g) New Object(){g.Key, g.Sum(...)}).ToList()`, body = `Add Data Row` into `grouped`.
+
+### Convert DataTable ↔ collections / JSON — `[expr]`
+```vb
+' first row -> Dictionary(Of String,String)
+dt.Columns.Cast(Of DataColumn)().ToDictionary(Function(c) c.ColumnName, Function(c) dt.Rows(0)(c.ColumnName).ToString())
+' DataTable -> JSON
+Newtonsoft.Json.JsonConvert.SerializeObject(dt)
+' JSON array of objects -> DataTable
+Newtonsoft.Json.JsonConvert.DeserializeObject(Of System.Data.DataTable)(jsonString)
+```
+`CollectionToDataTable` activity builds a DataTable from a `List(Of T)`.
+
+## Iterating rows & common errors
+
+- **For Each Row in Data Table** for row-by-row work; the row var (`CurrentRow`) is a `DataRow`. Does **not** support persistence — inside a Long Running Workflow use a coded path ([xaml/long-running-workflow-guide.md](xaml/long-running-workflow-guide.md)).
+- **Modify-during-iteration trap (MANDATORY).** Never add/remove rows on the table you are iterating — throws `Collection was modified; enumeration operation may not execute`. Iterate a fresh array (`dt.Select()` returns one) and `AcceptChanges()` after `[seq]`/`[coded]`:
+  ```vb
+  For Each r In dt.Select()            ' fresh DataRow array — safe to Delete during the loop
+      If r("Status").ToString() = "drop" Then r.Delete()
+  Next
+  dt.AcceptChanges()
+  ```
+- **Null cells.** A cell may be `DBNull.Value` (not `Nothing`) — see § Safe data access first.
+- **`Input array is longer than the number of columns in this table`** (Add Data Row). Cause: passing a wider source row's `ItemArray` into a narrower table. Fix: add the missing columns first, or build the `Object()` array to match the target's column count/order.
+
+## Strings & RegEx
+
+- Always `Trim()` text from UI/web/Excel; check `String.IsNullOrWhiteSpace(s)` before use.
+- Build strings in loops with `System.Text.StringBuilder` (`sb.AppendLine(...)` then `sb.ToString()`) `[seq]`/`[coded]`, not `&`.
+- Split on multiple delimiters: `s.Split(New Char(){";"c, ","c})`; format numbers: `value.ToString("N2", Globalization.CultureInfo.InvariantCulture)` (bare `ToString("N2")` follows the machine locale).
+
+RegEx via `System.Text.RegularExpressions.Regex` (no package needed) — each `[expr]`:
+```vb
+System.Text.RegularExpressions.Regex.IsMatch(input, "\d{3}-\d{2}-\d{4}")
+System.Text.RegularExpressions.Regex.Match(input, "INV-\d+").Value
+System.Text.RegularExpressions.Regex.Matches(input, "\$[\d,]+\.?\d{0,2}")   ' MatchCollection — iterate
+System.Text.RegularExpressions.Regex.Replace(input, "\s+", " ")
+```
+
+| Pattern | RegEx |
+|---|---|
+| Email | `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}` |
+| Phone (US) | `\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}` |
+| Date `MM/DD/YYYY` | `\d{2}/\d{2}/\d{4}` |
+| Currency (USD) | `\$[\d,]+\.?\d{0,2}` |
+| Invoice | `INV-\d{4,10}` |
+| ZIP (US) | `\d{5}(-\d{4})?` |
+| Decimal | `-?\d+\.?\d*` |
+
+Patterns are **unanchored** (extraction — `IsMatch`/`Match` find them anywhere in the string). For full-string *validation*, anchor: `^…$` (e.g. ZIP `^\d{5}(-\d{4})?$`).
+
+**Escaping the pattern string differs by mode:**
+- **VB** (XAML `Assign` or coded VB): single-escaped, `"\d+"`.
+- **C# coded**: verbatim `@"\d+"` or doubled `"\\d+"` (bare `"\d+"` is a compile error).
+- **Any XAML attribute** (VB or C# expression): `<` and `>` are illegal raw XML — escape as `&lt;`/`&gt;`. So a named group is `(?&lt;amt&gt;…)` in XAML; raw `(?<amt>…)` only in coded `.cs`.
+
+Named-group extraction:
+```vb
+' XAML Assign (note &lt; &gt;):  Groups("amt").Value
+System.Text.RegularExpressions.Regex.Match(input, "(?&lt;amt&gt;\$[\d,.]+)").Groups("amt").Value
+```
+```csharp
+// coded C#: raw <, >, verbatim string
+Regex.Match(input, @"(?<amt>\$[\d,.]+)").Groups["amt"].Value
+```
+Prefer named over positional groups; escape literal dots (`\.`); for untrusted/long input set a timeout — `New Regex(pattern, RegexOptions.None, TimeSpan.FromSeconds(5))` — against catastrophic backtracking. The `Matches` activity doesn't support persistence; use the code form in a Long Running Workflow.
+
+## DateTime & type conversion
+
+Parse with an EXPLICIT format + invariant culture (uppercase `MM` = month, lowercase `mm` = minutes) — each `[expr]`:
+```vb
+DateTime.ParseExact("01/15/2025", "MM/dd/yyyy", System.Globalization.CultureInfo.InvariantCulture)
+' wrong case SILENTLY misparses (does not throw): "mm/dd/yyyy" on "06/15/2025" -> January, "06" read as minutes. Only a test catches it.
+' multiple accepted formats:
+DateTime.ParseExact(s, New String(){"dd/MM/yyyy", "dd.MM.yyyy"}, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None)
+' SAFE (no throw) for external dates — uses TryParseExact, see § Safe data access first
+```
+
+**Parse safely** — pick by data trust:
+
+| Method | On bad input | Use when |
+|---|---|---|
+| `CInt(v)` / `Integer.Parse(v)` | throws | known-good data |
+| `Convert.ToInt32(v)` | throws (`Nothing`→0) | known-good; a literal `Nothing` needs `CObj(Nothing)` in VB XAML (overload ambiguity) |
+| `Integer.TryParse(v, n)` / `Decimal.TryParse` / `DateTime.TryParseExact` | returns `False`, out=default | **external/user/Excel input (default choice)** |
+
+**TryParse out-var:** read it in the SAME composite expression — `If(Integer.TryParse(v, n), n, 0)`, `n` pre-declared. A standalone `Integer.TryParse(v, n)` in one `Assign` does NOT reliably write `n` back for a later step (WF expression evaluation binds the ByRef arg to a copy). Same for `Dictionary.TryGetValue`.
+
+Specify culture for external numbers/dates: `Double.Parse("1,234.56", System.Globalization.CultureInfo.InvariantCulture)` — bare `CDbl` follows machine locale (US vs German flips `.`/`,`).
+
+Traps: `CInt("12.5")` rounds (banker's, to even) not truncates → `CInt(Math.Floor(...))`; `CBool("yes")` throws (only `"True"`/`"False"`); comparing `GenericValue` strings is lexical, not numeric → cast first.
+
+## Collections
+
+`[expr]` — init & reads:
+```vb
+New List(Of String) From {"a", "b"}
+New Dictionary(Of String, Integer) From {{"a", 1}, {"b", 2}}
+myDict.ContainsKey("k")
+If(myDict.TryGetValue("k", value), value, 0)        ' value is a pre-declared out-var
+```
+`[seq]`/`[coded]` — iterate & mutate:
+```vb
+For Each kvp As KeyValuePair(Of String, Object) In myDict
+    ' kvp.Key, kvp.Value
+Next
+For Each kvp In dict2 : dict1(kvp.Key) = kvp.Value : Next     ' merge (dict2 wins)
+```
+Nested config `[expr]`: `DirectCast(configDict("DatabaseSettings"), Dictionary(Of String, String))("ConnectionString")`.
+
+C# coded adds collection initializers (`{ ["a"]=1 }`), null-conditional (`dict.GetValueOrDefault("k")?.Trim()`), null-coalescing (`?? ""`).
+
+## JSON (JObject / JArray)
+
+`Newtonsoft.Json` ships with UiPath projects; use `Newtonsoft.Json.Linq`. (The `Deserialize JSON` / `Deserialize JSON Array` activities wrap these; `System.Text.Json` is the modern BCL alternative for coded.)
+
+`[expr]` — parse & read:
+```vb
+Newtonsoft.Json.Linq.JObject.Parse(jsonString)
+Newtonsoft.Json.Linq.JArray.Parse(jsonArrayString)
+jObj("name").ToString()                              ' top-level
+jObj("address")("city").ToString()                  ' nested
+jArr(0)("name").ToString()                           ' array element
+jObj("count").Value(Of Integer)()                    ' typed
+' safe nested access — VB ?. does NOT compile in a XAML Assign (BC37240); use an If guard:
+If(jObj("optional") IsNot Nothing AndAlso jObj("optional")("nested") IsNot Nothing, jObj("optional")("nested").ToString(), Nothing)
+jArr.Where(Function(i) i("status").ToString() = "active")           ' LINQ-to-JSON
+jArr.Select(Function(i) i("name").ToString()).ToList()
+```
+`[coded]`/`[seq]` — build/modify (statement block, not one `Assign`):
+```vb
+Dim o = New Newtonsoft.Json.Linq.JObject()
+o("name") = "John" : o("age") = 30
+o.ToString()                                          ' or Newtonsoft.Json.JsonConvert.SerializeObject(o)
+```
+API-response pattern: parse `responseBody`, `If response("error") IsNot Nothing` → `Throw New BusinessRuleException(...)`, then read `DirectCast(response("data")("items"), Newtonsoft.Json.Linq.JArray)`.
+
+## Coded (`.cs`) note
+
+Coded workflows use the C# forms directly (`r => r["Col"]`, ternary, `out`, `?.`, `??`, collection initializers, verbatim `@"\d+"` regex, query or method LINQ). Add the `using`s (`System.Data`, `System.Linq`, `System.Text.RegularExpressions`, `System.Globalization`) per [coded/coding-guidelines.md](coded/coding-guidelines.md). The XAML C# *binding* wrapper is separate — [xaml/csharp-activity-binding-guide.md](xaml/csharp-activity-binding-guide.md).

package/skills/uipath-rpa/references/environment-setup.md

@@ -12,8 +12,6 @@ Studio Desktop is only required for two interactive UI tools:
 
 For these two, see [§ Edge case: requiring Studio Desktop](#edge-case-requiring-studio-desktop) below.
 
-> **Coded UI automation caveat.** One non-interactive task also needs Studio Desktop: regenerating `ObjectRepository.cs` — the `Descriptors.*` class consumed by coded `uiAutomation.*` workflows. `uip rpa build` alone does NOT produce it; Studio Desktop reconciles the coded workflow against the Object Repository to generate it. A headless flow can author and validate coded UIA, but populating `Descriptors.*` requires a Studio Desktop pass. See [ui-automation-guide.md](ui-automation-guide.md) § Finding Descriptors.
-
 > **First call is slow.** On a cold NuGet cache, the very first `uip rpa` invocation triggers a silent `dotnet restore` of the headless Studio package and may sit near-silent for 30–90 seconds (longer behind a slow feed). A heartbeat line every 15s confirms it's still working. The default shell timeout covers this; bump `timeoutSeconds` only behind a slow feed.
 
 ## Step 0.1: Establish Project Root