@uipath/maestro-builder-sdk 6.31.3 → 6.31.5

package/README.md

@@ -372,7 +372,11 @@ read the same copy. The worked examples named by those guides travel with them.
 
 The connector library is not bundled: `uip maestro registry pull` downloads it
 and caches it per machine. The package does carry the curated overlay that pull
-applies on top — corrections and the definitions the raw registry dump omits.
+applies on top. It adds the definitions the downloaded library lacks (connector
+start triggers, for example) and never replaces one the library carries, except
+for the patches listed in `lib/library-json.samples/overlay-corrections.json`,
+which only add the fields they name. Pull prints one line saying what it added,
+corrected and kept.
 
 ## License
 

package/dist/decompile-cli.js

@@ -117,6 +117,23 @@ const BASELINE = ${JSON.stringify(join(base + '.baseline', basename(base) + '.fl
 const EDITED   = ${JSON.stringify(join(base + '.edited', basename(base) + '.flow'))};
 const MERGED   = ${JSON.stringify(base + '.merged.flow')};
 
+// Options. \`--strict\` goes to step 2's merge: refuse, writing nothing, when the
+// no-edit round trip (BASELINE) differs from ORIGINAL anywhere, instead of
+// warning and writing. An unknown option stops the run: silently ignoring one
+// would run a merge the caller did not ask for.
+const USAGE = 'usage: node ' + ${JSON.stringify(basename(pipelinePath))} + ' [--strict]';
+const argv = process.argv.slice(2);
+if (argv.includes('-h') || argv.includes('--help')) {
+  console.log(USAGE + '\\n  --strict  merge refuses (exit 1, nothing written) when the no-edit round trip differs from the original');
+  process.exit(0);
+}
+const unknown = argv.find((a) => a !== '--strict');
+if (unknown !== undefined) {
+  console.error(${JSON.stringify(basename(pipelinePath))} + ': unknown option ' + JSON.stringify(unknown) + '\\n' + USAGE);
+  process.exit(2);
+}
+const STRICT = argv.includes('--strict');
+
 // Ensure the decompiled source exists (a fresh clone may have only the .flow).
 if (!existsSync(TS)) run('decompile', [ORIGINAL, '-o', TS, '--no-pipeline']);
 
@@ -128,14 +145,6 @@ if (!existsSync(BASELINE)) {
   console.log('\\n>>> Baseline captured. Now EDIT ' + ${JSON.stringify(basename(tsPath))} + ', then re-run this script to compile + merge.');
 } else {
   // ── Step 2: compile your edits, then merge them back into the original. ──
-  mkdirSync(dirname(EDITED), { recursive: true });
-  run('compile', [TS, '-o', EDITED, '--no-check']);
-
-  // ── DIFF GATE (seam) ──────────────────────────────────────────────────────
-  // A future step can diff ORIGINAL vs the about-to-be-written MERGED here and
-  // ask for confirmation before the write. Left as a no-op for now.
-  // ---------------------------------------------------------------------------
-
   // \`merge <edited> --original <original>\` is the grammar; the positional
   // \`merge <original> <edited>\` pair is deprecated. A \`uip\` from before
   // UiPath/cli#4526 knows only the pair, so ask its \`merge --help\` first.
@@ -144,10 +153,27 @@ if (!existsSync(BASELINE)) {
   const mergeHelp = frontDoor.via === 'uip'
     ? spawnSync(frontDoor.file, [...frontDoor.prefix, 'merge', '--help'], { encoding: 'utf8' })
     : undefined;
-  const namedOriginal = mergeHelp === undefined
-    || \`\${mergeHelp.stdout ?? ''}\${mergeHelp.stderr ?? ''}\`.includes('--original');
+  const mergeHelpText = mergeHelp === undefined ? undefined : \`\${mergeHelp.stdout ?? ''}\${mergeHelp.stderr ?? ''}\`;
+  const namedOriginal = mergeHelpText === undefined || mergeHelpText.includes('--original');
+  // A \`uip\` from before \`merge --strict\` existed would reject the flag with a
+  // bare "unknown option"; name the remedy instead, and never drop the flag.
+  // Both checks run before the compile, so a run that cannot merge does no work.
+  if (STRICT && mergeHelpText !== undefined && !mergeHelpText.includes('--strict')) {
+    console.error(${JSON.stringify(basename(pipelinePath))} + ': --strict was asked for, but this uip has no \`maestro flow merge --strict\`. '
+      + 'Update uip, or run without --strict.');
+    process.exit(2);
+  }
+  mkdirSync(dirname(EDITED), { recursive: true });
+  run('compile', [TS, '-o', EDITED, '--no-check']);
+
+  // ── DIFF GATE (seam) ──────────────────────────────────────────────────────
+  // A future step can diff ORIGINAL vs the about-to-be-written MERGED here and
+  // ask for confirmation before the write. Left as a no-op for now.
+  // ---------------------------------------------------------------------------
+
   const args = namedOriginal ? [EDITED, '--original', ORIGINAL, '-o', MERGED] : [ORIGINAL, EDITED, '-o', MERGED];
   if (existsSync(BASELINE)) args.push('--baseline', BASELINE);
+  if (STRICT) args.push('--strict');
   run('merge', args);
   console.log('\\n>>> Wrote ' + ${JSON.stringify(base + '.merged.flow')}
     + '. Replace the original with it, together with every <source>/ file merge reports writing beside it,'

package/dist/decompile.js

@@ -2132,8 +2132,10 @@ function droppedEdgeMessage(e) {
  */
 function droppedEdgesSeg(node, ctx) {
     const dropped = ctx.graph.outEdges(node.id).filter((e) => !ctx.graph.accounted.has(e));
-    if (dropped.length === 0)
-        return undefined;
+    return dropped.length === 0 ? undefined : dropEdges(dropped, ctx);
+}
+/** Account `dropped` as dropped: warn each once, remember it for strict mode, and return the site's `/* TODO *\/`. */
+function dropEdges(dropped, ctx) {
     for (const e of dropped) {
         ctx.graph.accounted.add(e);
         runDropped.push(e);
@@ -2200,11 +2202,12 @@ function commonPostDominator(targets, ipdom) {
  * decompiles to that `.parallel(...)`, then the region continues from the
  * merge's output (flow-builder-sdk#1155).
  *
- * Every edge in `edges` is accounted (edge accounting, #1125): the fold
- * recreates each one. A fork whose arms never meet at a merge node has no
- * builder spelling. Like the same shape mid-flow (`region`), it throws under
- * `bestEffort: false`, and otherwise keeps the first arm behind a
- * `TODO: unstructured fan-out` marker, which is what reports the other edges.
+ * When the arms meet at a merge node, every edge in `edges` is accounted
+ * (edge accounting, #1125): the fold recreates each one. A fork whose arms
+ * never meet at a merge node has no builder spelling. Like the same shape
+ * mid-flow (`region`), it throws under `bestEffort: false`, and otherwise keeps
+ * the first arm behind a `TODO: unstructured fan-out` marker. Only the kept
+ * first edge is accounted; the others are reported as dropped at the marker.
  */
 function forkRegion(edges, stop, scope, ipdom, ctx, refInto) {
     if (edges.length <= 1)
@@ -2215,10 +2218,10 @@ function forkRegion(edges, stop, scope, ipdom, ctx, refInto) {
     if (join === undefined || join === stop || joinNode?.type !== T.merge) {
         if (ctx.o.bestEffort === false)
             throw new Error(`decompile: unstructured fan-out (${edges.length} edges).`);
-        for (const e of edges)
-            ctx.graph.accounted.add(e);
+        ctx.graph.accounted.add(edges[0]);
         return [
             `/* TODO: unstructured fan-out (${commentText(edges.length)} edges) */`,
+            dropEdges(edges.slice(1), ctx),
             ...region(targets[0], stop, scope, ipdom, ctx, refInto),
         ];
     }
@@ -2617,13 +2620,11 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             cursor = fork.next.cursor;
             continue;
         }
-        // Unstructured fan-out we can't fold — best-effort marker. Its successor
-        // edges are what the marker reports, so they are not reported twice.
+        // Unstructured fan-out we can't fold — best-effort marker.
+        // No successor is walked: leave the edges unaccounted so `flagDropped` names each.
         if (ctx.o.bestEffort === false)
             throw new Error(`decompile: unstructured fan-out at "${node.id}".`);
         segs.push(`/* TODO: unstructured fan-out at ${commentText(node.id)} (${commentText(succ.length)} successors) */`);
-        for (const t of succ)
-            follow(ctx.graph, node.id, t);
         flagDropped(node, ctx, segs);
         return segs;
     }

package/dist/merge.d.ts

@@ -28,7 +28,9 @@
  * preserved from the original; `subflows` and edges (with their ids) come from
  * `edited`; `definitions` and `bindings` are unioned
  * (original wins on conflict, since the original's are the tenant-resolved
- * authority). A binding row's identity is what it binds, not its row id. Node ids are stable by construction (decompile names every step by
+ * authority). A binding row's identity is what it binds, not its row id, and a
+ * row the no-edit recompile minted only for nodes merge kept from the original
+ * is not carried (see withoutRowsMintedForKeptNodes). Node ids are stable by construction (decompile names every step by
  * its node id), which is what lets every re-attach key on id.
  *
  * ## Definitions are keyed by `nodeType@version`, not by `nodeType`

package/dist/merge.js

@@ -28,7 +28,9 @@
  * preserved from the original; `subflows` and edges (with their ids) come from
  * `edited`; `definitions` and `bindings` are unioned
  * (original wins on conflict, since the original's are the tenant-resolved
- * authority). A binding row's identity is what it binds, not its row id. Node ids are stable by construction (decompile names every step by
+ * authority). A binding row's identity is what it binds, not its row id, and a
+ * row the no-edit recompile minted only for nodes merge kept from the original
+ * is not carried (see withoutRowsMintedForKeptNodes). Node ids are stable by construction (decompile names every step by
  * its node id), which is what lets every re-attach key on id.
  *
  * ## Definitions are keyed by `nodeType@version`, not by `nodeType`
@@ -212,12 +214,17 @@ function mergeFlowFindings(original, edited, options) {
     // ── Nodes: the edited graph decides which nodes exist and in what order; the
     //    original decides their look (and, for untouched nodes, their content). ──
     const finalNodes = [];
+    // The edited nodes the merge replaced with the original's: their bindings
+    // references are the original's now, not the recompile's
+    // (see withoutRowsMintedForKeptNodes).
+    const keptFromOriginal = new Set();
     for (const e of edited.nodes ?? []) {
         const orig = origNodes.get(e.id);
         if (isKept(e, origNodes, baseNodes, options.baseline) && orig) {
             // Untouched by the user (equal to the faithful baseline) → keep the
             // original node exactly, placeholder-safe.
             finalNodes.push(jsonClone(orig));
+            keptFromOriginal.add(e.id);
         }
         else {
             // Added or edited → take the edited node, re-attaching original layout.
@@ -266,9 +273,11 @@ function mergeFlowFindings(original, edited, options) {
     ];
     result.definitions = mergeDefinitions(original.definitions, edited.definitions, allNodes, originalNodes, options.warn);
     // ── Bindings: union by what each row binds (original wins), so resources for
-    //    newly-added nodes come from `edited` while the original's stay intact. ──
+    //    newly-added nodes come from `edited` while the original's stay intact.
+    //    A row the no-edit recompile minted only for nodes the merge kept from the
+    //    original is not carried (#1133). ──
     result.bindings = mergeBindings(original.bindings, edited.bindings);
-    result.bindings = withoutRowsKeyedOnlyByKeptNodes(result.bindings, original, edited, options.baseline);
+    result.bindings = withoutRowsMintedForKeptNodes(result.bindings, original, edited, options.baseline, keptFromOriginal);
     // metadata / solutionId / projectId / layout / runtime were carried by the
     // initial clone of `original` and are intentionally left untouched.
     //
@@ -379,12 +388,14 @@ function mergeDefinitions(orig, edited, nodes, originalNodes, warn) {
  * holds it, in which case it gets a fresh one — ids are unreferenced labels, but
  * two rows with one id are not a valid file.
  *
- * Rows no surviving node uses are NOT pruned. The file has no uniform
+ * Rows of the ORIGINAL are never pruned. The canvas file has no uniform
  * node-to-row reference to decide "unused" by: an in-solution Flow is named by
  * the node TYPE's suffix, a connection by an id in the node's inputs, a published
  * process by a folder-qualified key that no node field spells. A wrong prune
  * drops a row a kept node needs, and the run fails to resolve its resource; an
- * orphan row is accepted by `validate` and ignored at run time.
+ * orphan row is accepted by `validate` and ignored at run time. Added rows the
+ * round trip minted only for kept nodes are dropped afterwards, by
+ * {@link withoutRowsMintedForKeptNodes}.
  */
 function mergeBindings(orig, edited) {
     const out = (orig ?? []).map((b) => jsonClone(b));
@@ -409,41 +420,70 @@ function mergeBindings(orig, edited) {
     return out;
 }
 /**
- * Drop each added row that the no-edit recompile minted for a resource only
- * nodes kept from the original spell. A row qualifies when the original lacks
- * it, the baseline has it, and its `resourceKey` appears in at least one edited
- * root node, every one of which the merge replaced with the original's: the kept
- * node is the original's, and it reaches the resource without that row.
+ * Drop each added row that the no-edit recompile minted only for nodes the merge
+ * kept from the original (#1133). A row qualifies when the original lacks it, the
+ * baseline has it, and at least one edited node references it, every one of
+ * which is in `keptFromOriginal`: the kept node is the original's, which reaches
+ * its resource without that row.
  *
- * Example: a classic-CLI IxP extract carries its model inline and has no
- * binding rows. It decompiles to `ixpExtract(...)`, whose compile mints
- * `ixpDeployment` `name` / `folderPath` rows keyed by the model id, and an
- * untouched node would carry them into the merged file.
+ * Examples:
+ * - A classic-CLI IxP extract carries its model inline and has no rows. It
+ *   decompiles to `ixpExtract(...)`, whose compile mints `ixpDeployment` rows
+ *   keyed by the model id.
+ * - A classic-CLI `core.action.http.v2` with no connection decompiles to
+ *   `http({ managed: true })`, whose compile mints `""`-keyed rows for
+ *   `<bindings.uipath-uipath-http connection>` and `<bindings.FolderKey>`.
  *
- * A row whose key no edited node spells is kept, as are rows a subflow node or
- * an edited node spells.
+ * "References" is read off the EDITED file, which the SDK wrote. A node
+ * references a row when it spells the row's `resourceKey`, or when it spells the
+ * row's `<bindings.NAME>` placeholder (in the node, or in its type's definition)
+ * and points at that row's resource. Names are not unique: a Slack step on
+ * connection X and a connection-less http step both use `<bindings.FolderKey>`,
+ * each with its own `FolderKey` row. So a placeholder counts for a keyed row
+ * only when no other row has that name, and for a `""`-keyed row only when the
+ * node spells none of the other same-named rows' keys.
+ *
+ * Kept: a row no edited node references (one a sidecar file uses, say), a row
+ * a subflow node or an edited node references, and every row without a baseline.
  */
-function withoutRowsKeyedOnlyByKeptNodes(rows, original, edited, baseline) {
-    if (!baseline || !rows)
+function withoutRowsMintedForKeptNodes(rows, original, edited, baseline, keptFromOriginal) {
+    if (!baseline || !rows || keptFromOriginal.size === 0)
         return rows;
-    const origNodes = byId(original.nodes);
-    const baseNodes = byId(baseline.nodes);
+    const contextByType = new Map();
+    for (const d of (edited.definitions ?? [])) {
+        if (typeof d?.nodeType !== 'string' || d.model?.context === undefined)
+            continue;
+        contextByType.set(d.nodeType, (contextByType.get(d.nodeType) ?? '') + JSON.stringify(d.model.context));
+    }
+    const describe = (n, kept) => ({ kept, text: JSON.stringify(n) + (contextByType.get(n.type) ?? '') });
     const nodes = [
-        ...(edited.nodes ?? []).map((n) => ({ kept: origNodes.has(n.id) && nodeUnchanged(n, baseNodes.get(n.id)), text: JSON.stringify(n) })),
-        ...Object.values(edited.subflows ?? {}).flatMap((sf) => (sf?.nodes ?? []).map((n) => ({ kept: false, text: JSON.stringify(n) }))),
+        ...(edited.nodes ?? []).map((n) => describe(n, keptFromOriginal.has(n.id))),
+        ...Object.values(edited.subflows ?? {}).flatMap((sf) => (sf?.nodes ?? []).map((n) => describe(n, false))),
     ];
-    if (!nodes.some((n) => n.kept))
-        return rows;
+    const spelled = (s) => JSON.stringify(s).slice(1, -1);
+    const keyOf = (b) => (typeof b.resourceKey === 'string' ? b.resourceKey : '');
+    const all = (edited.bindings ?? []);
     const fromOriginal = new Set((original.bindings ?? []).map(bindingIdentity));
     const inBaseline = new Set((baseline.bindings ?? []).map(bindingIdentity));
     return rows.filter((b) => {
         const identity = bindingIdentity(b);
         if (fromOriginal.has(identity) || !inBaseline.has(identity))
             return true;
-        if (typeof b.resourceKey !== 'string' || b.resourceKey === '')
-            return true;
-        const spelled = JSON.stringify(b.resourceKey).slice(1, -1);
-        const spellers = nodes.filter((n) => n.text.includes(spelled));
-        return !(spellers.length > 0 && spellers.every((n) => n.kept));
+        const key = keyOf(b);
+        const others = typeof b.name === 'string'
+            ? all.filter((o) => o.name === b.name && keyOf(o) !== key)
+            : [];
+        const placeholder = typeof b.name === 'string' ? spelled(`<bindings.${b.name}>`) : undefined;
+        const references = (text) => {
+            if (key !== '' && text.includes(spelled(key)))
+                return true;
+            if (placeholder === undefined || !text.includes(placeholder))
+                return false;
+            return key === ''
+                ? !others.some((o) => text.includes(spelled(keyOf(o))))
+                : others.length === 0;
+        };
+        const referencers = nodes.filter((n) => references(n.text));
+        return !(referencers.length > 0 && referencers.every((n) => n.kept));
     });
 }

package/dist/registry/curated-overlay.d.ts

@@ -3,46 +3,81 @@ import { type Reporter } from "./reporter.js";
 export declare function bundledOverlayPath(): string;
 /** Stable identity of the curated data, so a changed overlay gets a new cache entry. */
 export declare function curatedOverlayIdentity(overlayPath?: string): Promise<string>;
+/** The ledger of deliberate patches; read here, never copied into a library. */
+export declare const CORRECTIONS_FILE = "overlay-corrections.json";
+/** One row of {@link CORRECTIONS_FILE}. */
+export interface OverlayCorrection {
+    path: string;
+    since: string;
+    reason: string;
+    /** Added to the entry's `inputSchema.fields` and the sidecar's `inputDefinition.fields` when absent. */
+    inputFields?: string[];
+    /** Top-level sidecar keys added when absent. */
+    sidecarKeys?: string[];
+}
 export interface CuratedOverlayResult {
-    /** Overlay files copied into the library. */
+    /** Files written into the library: definitions added, corrections patched, side-tables. */
     files: number;
     /** Index rows added for identities the library did not already carry. */
     entries: number;
     /**
      * Overlay entry files NOT copied, because the library resolves their
-     * identity to a different path. POSIX-relative to the overlay, sorted. Each
-     * one is also reported through the reporter — see {@link applyCuratedOverlay}.
+     * identity to a different path. POSIX-relative to the overlay, sorted.
      */
     skipped: string[];
+    /** Overlay entries added because the library lacked their identity. Sorted. */
+    added: string[];
+    /** Corrections patched into the library's own definition. Sorted. */
+    corrected: string[];
+    /**
+     * Overlay entries the library already carries at the same path, so its
+     * published definition was kept. Sorted. Not a problem: these are the
+     * directory's test fixtures, which the overlay must never copy over a
+     * published file (#1148).
+     */
+    kept: string[];
 }
 /**
- * Apply the SDK's curated corrections after extracting the raw registry dump.
+ * The bundled corrections, checked against the overlay they ship in. A row
+ * that names no indexed overlay entry, or a field that entry does not define,
+ * is a fault in the SDK's own data, so it throws rather than patching nothing.
+ */
+export declare function readOverlayCorrections(overlayPath: string): Promise<OverlayCorrection[]>;
+/**
+ * Apply the SDK's curated overlay after extracting the raw registry dump.
  *
- * Files replace the dump's copy, while index rows are a union where the dump
- * wins collisions. This is the same contract as the former unpack script: a
- * correction changes the referenced file, and a definition absent from the
- * dump (notably connector triggers) is made resolvable by its added index row.
+ * THE RULE. The overlay ADDS what the library lacks and never replaces what it
+ * carries, apart from the deliberate patches listed in {@link CORRECTIONS_FILE}:
  *
- * WHEN THE LIBRARY ALREADY RESOLVES THE IDENTITY ELSEWHERE, the file is not
- * copied at all and the skip is reported. That case is not hypothetical: four
- * of the bundled `event-*@1.0.0.json` files carry a (nodeType, version) the
- * raw dump lacks TODAY but a refreshed catalog serves at its own path — the
- * per-object event variants land under `<connector>/events/<object>/`, keeping
- * the template's nodeType. Since the union keeps the library's row, copying
- * anyway left a file no index row pointed at, which `--check-orphans` (the
- * image build passes it) rejects. The three ways out are not equal:
+ *   - an overlay entry whose (nodeType, version) the library does not index is
+ *     copied with its sidecar, and its index row is added. This is what makes
+ *     the connector start triggers resolvable, which the raw dump lacks;
+ *   - an entry the library indexes at the SAME path is kept as published. The
+ *     overlay's copy is a snapshot, and the published library moves on: until
+ *     #1148 every such file was copied over the download while the download's
+ *     index row stayed, so nine 2026-07 snapshots replaced newer definitions and
+ *     Outlook `send-email` read `send-mail` (no `saveAsDraft`, no multipart
+ *     parts) under an index row that said `send-mail-v2`. The entry files carry
+ *     no date or build number to compare, so "is the published one newer?" is
+ *     not answerable per file; the answer is that the overlay never decides it;
+ *   - a listed correction is PATCHED into the library's own definition: the
+ *     named input fields and sidecar keys are added when absent, and nothing
+ *     else is touched. It cannot change the operation's object or endpoint, so
+ *     index row and entry file cannot be made to disagree. When the published
+ *     definition already has everything, the correction is reported as no
+ *     longer needed so its row can be removed;
+ *   - an entry the library indexes at a DIFFERENT path is not copied: the copy
+ *     would be a file no index row points at, which `--check-orphans` (the
+ *     image build passes it) rejects, and stamping the flat curated file over
+ *     each per-object variant the library serves would destroy their schemas.
+ *     A correction in that position is warned about, since it no longer takes
+ *     effect;
+ *   - the SDK's side-tables (`list-envelopes.json`, `invariant-collections.json`)
+ *     are the SDK's own data and are always copied.
  *
- *   - copying and teaching the orphan check to tolerate the file would keep
- *     the build green and hide the real loss, which is that the hand-verified
- *     CORRECTION never takes effect once the index points somewhere else;
- *   - redirecting the correction onto the indexed path cannot be done safely
- *     here, because ONE event identity maps to MANY per-object paths in a
- *     refreshed library, and stamping the flat curated definition over each
- *     per-object variant would destroy the per-object schema the library just
- *     served — a worse regression than the one being fixed;
- *   - so the copy is skipped and said out loud. The library keeps the
- *     definition it resolves, the tree gains no unreachable file, and the
- *     operator is told which overlay row has been overtaken and needs
- *     re-verifying. The image build is then green before AND after a refresh.
+ * What was done is reported in one line, and recorded in `.curated-overlay.json`
+ * beside the index, so a second application recognises its own patches: the
+ * record keeps a sha256 of each patched entry and sidecar, and a correction
+ * whose files no longer match it is patched again.
  */
 export declare function applyCuratedOverlay(libraryPath: string, overlayPath?: string, reporter?: Reporter): Promise<CuratedOverlayResult>;

package/dist/registry/curated-overlay.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
-import { cp, mkdir, readdir, readFile } from "node:fs/promises";
+import { access, cp, mkdir, readdir, readFile } from "node:fs/promises";
 import { dirname, join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { sortedStrings } from "./compat/compare.js";
+import { jsonClone } from "../core/json-clone.js";
 import { writeJsonFile } from "../core/json-file.js";
 import { consoleReporter } from "./reporter.js";
 /** The corrections and definitions that the raw registry dump does not carry. */
@@ -33,39 +34,182 @@ export async function curatedOverlayIdentity(overlayPath = bundledOverlayPath())
 function entryIdentity(entry) {
     return `${String(entry.nodeType)}\0${String(entry.version)}`;
 }
+/** The ledger of deliberate patches; read here, never copied into a library. */
+export const CORRECTIONS_FILE = "overlay-corrections.json";
+/**
+ * What the overlay did to one library, written beside it as a dotfile so a
+ * second application (`unpack-library.mjs` applies it twice, once per verb)
+ * does not mistake its own patch for "the published library caught up".
+ */
+const RECORD_FILE = ".curated-overlay.json";
+/** SDK-owned side-tables the published library does not carry; always copied. */
+const SIDE_TABLES = new Set(["list-envelopes.json", "invariant-collections.json"]);
 /** The sidecar that travels with an entry file, and has no index row of its own. */
 function sidecarOf(rel) {
     return `${rel.slice(0, -".json".length)}.v1def.json`;
 }
+function isDict(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A sidecar is either the definition itself or a one-element array of it. */
+function sidecarBody(sidecar) {
+    const body = Array.isArray(sidecar) ? sidecar[0] : sidecar;
+    return isDict(body) ? body : undefined;
+}
+/** `holder[key].fields`, created when absent, so a patch has an array to add to. */
+function fieldList(holder, key) {
+    const section = isDict(holder[key]) ? holder[key] : (holder[key] = {});
+    if (!Array.isArray(section.fields))
+        section.fields = [];
+    return section.fields;
+}
+function fieldNames(fields) {
+    return new Set((Array.isArray(fields) ? fields : [])
+        .filter(isDict)
+        .map((field) => String(field.name)));
+}
+async function readJson(path) {
+    return JSON.parse(await readFile(path, "utf8"));
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The bundled corrections, checked against the overlay they ship in. A row
+ * that names no indexed overlay entry, or a field that entry does not define,
+ * is a fault in the SDK's own data, so it throws rather than patching nothing.
+ */
+export async function readOverlayCorrections(overlayPath) {
+    const file = join(overlayPath, CORRECTIONS_FILE);
+    if (!(await exists(file)))
+        return [];
+    const ledger = (await readJson(file));
+    const overlayIndex = (await readJson(join(overlayPath, "index.json")));
+    const indexed = new Set((overlayIndex.entries ?? []).map((row) => row.path));
+    const corrections = ledger.corrections ?? [];
+    for (const correction of corrections) {
+        const where = `${CORRECTIONS_FILE}: correction ${JSON.stringify(correction.path)}`;
+        if (!indexed.has(correction.path)) {
+            throw new Error(`${where} names no entry in the overlay's index.json.`);
+        }
+        if (!correction.inputFields?.length && !correction.sidecarKeys?.length) {
+            throw new Error(`${where} patches nothing: give it inputFields or sidecarKeys.`);
+        }
+        const entry = (await readJson(join(overlayPath, correction.path)));
+        const sidecar = sidecarBody(await readJson(join(overlayPath, sidecarOf(correction.path)))) ?? {};
+        const entryFields = fieldNames(entry.inputSchema?.fields);
+        const sidecarFields = fieldNames(sidecar.inputDefinition?.fields);
+        for (const name of correction.inputFields ?? []) {
+            if (!entryFields.has(name) || !sidecarFields.has(name)) {
+                throw new Error(`${where}: the overlay's copy does not define input field ${JSON.stringify(name)} in both files.`);
+            }
+        }
+        for (const key of correction.sidecarKeys ?? []) {
+            if (!(key in sidecar)) {
+                throw new Error(`${where}: the overlay's sidecar has no ${JSON.stringify(key)}.`);
+            }
+        }
+    }
+    return corrections;
+}
+/**
+ * sha256 of a correction's entry file and sidecar as they are on disk now (a
+ * missing sidecar hashes as absent). The record keeps this for each patch it
+ * made, so a later application trusts its own patch only while both files are
+ * still the ones it wrote.
+ */
+async function correctionDigest(libraryPath, path) {
+    const hash = createHash("sha256");
+    hash.update(await readFile(join(libraryPath, path)));
+    const sidecarPath = join(libraryPath, sidecarOf(path));
+    hash.update("\0");
+    hash.update((await exists(sidecarPath)) ? await readFile(sidecarPath) : "<no sidecar>");
+    return hash.digest("hex");
+}
 /**
- * Apply the SDK's curated corrections after extracting the raw registry dump.
+ * Add what `correction` names to the library's own entry and sidecar, from the
+ * overlay's copy. Returns the names it added (empty means the published
+ * definition already carries every one of them) and how many files it wrote.
+ * A library with no sidecar for the entry gets none: only the entry is patched.
+ */
+async function patchCorrection(libraryPath, overlayPath, correction) {
+    const sourceEntry = (await readJson(join(overlayPath, correction.path)));
+    const sourceSidecar = sidecarBody(await readJson(join(overlayPath, sidecarOf(correction.path)))) ?? {};
+    const entryPath = join(libraryPath, correction.path);
+    const sidecarPath = join(libraryPath, sidecarOf(correction.path));
+    const entry = (await readJson(entryPath));
+    const sidecarRaw = (await exists(sidecarPath)) ? await readJson(sidecarPath) : undefined;
+    const sidecar = sidecarRaw === undefined ? undefined : sidecarBody(sidecarRaw);
+    const added = [];
+    const addFields = (target, source, label) => {
+        const have = fieldNames(target);
+        const byName = new Map((Array.isArray(source) ? source : []).filter(isDict).map((field) => [String(field.name), field]));
+        for (const name of correction.inputFields ?? []) {
+            if (have.has(name))
+                continue;
+            target.push(jsonClone(byName.get(name)));
+            added.push(`${label}:${name}`);
+        }
+    };
+    addFields(fieldList(entry, "inputSchema"), sourceEntry.inputSchema?.fields, "inputSchema");
+    if (sidecar) {
+        addFields(fieldList(sidecar, "inputDefinition"), sourceSidecar.inputDefinition?.fields, "inputDefinition");
+        for (const key of correction.sidecarKeys ?? []) {
+            if (key in sidecar)
+                continue;
+            sidecar[key] = jsonClone(sourceSidecar[key]);
+            added.push(`sidecar:${key}`);
+        }
+    }
+    if (added.length === 0)
+        return { added, files: 0 };
+    writeJsonFile(entryPath, entry);
+    if (sidecar)
+        writeJsonFile(sidecarPath, sidecarRaw);
+    return { added, files: sidecar ? 2 : 1 };
+}
+/**
+ * Apply the SDK's curated overlay after extracting the raw registry dump.
  *
- * Files replace the dump's copy, while index rows are a union where the dump
- * wins collisions. This is the same contract as the former unpack script: a
- * correction changes the referenced file, and a definition absent from the
- * dump (notably connector triggers) is made resolvable by its added index row.
+ * THE RULE. The overlay ADDS what the library lacks and never replaces what it
+ * carries, apart from the deliberate patches listed in {@link CORRECTIONS_FILE}:
  *
- * WHEN THE LIBRARY ALREADY RESOLVES THE IDENTITY ELSEWHERE, the file is not
- * copied at all and the skip is reported. That case is not hypothetical: four
- * of the bundled `event-*@1.0.0.json` files carry a (nodeType, version) the
- * raw dump lacks TODAY but a refreshed catalog serves at its own path — the
- * per-object event variants land under `<connector>/events/<object>/`, keeping
- * the template's nodeType. Since the union keeps the library's row, copying
- * anyway left a file no index row pointed at, which `--check-orphans` (the
- * image build passes it) rejects. The three ways out are not equal:
+ *   - an overlay entry whose (nodeType, version) the library does not index is
+ *     copied with its sidecar, and its index row is added. This is what makes
+ *     the connector start triggers resolvable, which the raw dump lacks;
+ *   - an entry the library indexes at the SAME path is kept as published. The
+ *     overlay's copy is a snapshot, and the published library moves on: until
+ *     #1148 every such file was copied over the download while the download's
+ *     index row stayed, so nine 2026-07 snapshots replaced newer definitions and
+ *     Outlook `send-email` read `send-mail` (no `saveAsDraft`, no multipart
+ *     parts) under an index row that said `send-mail-v2`. The entry files carry
+ *     no date or build number to compare, so "is the published one newer?" is
+ *     not answerable per file; the answer is that the overlay never decides it;
+ *   - a listed correction is PATCHED into the library's own definition: the
+ *     named input fields and sidecar keys are added when absent, and nothing
+ *     else is touched. It cannot change the operation's object or endpoint, so
+ *     index row and entry file cannot be made to disagree. When the published
+ *     definition already has everything, the correction is reported as no
+ *     longer needed so its row can be removed;
+ *   - an entry the library indexes at a DIFFERENT path is not copied: the copy
+ *     would be a file no index row points at, which `--check-orphans` (the
+ *     image build passes it) rejects, and stamping the flat curated file over
+ *     each per-object variant the library serves would destroy their schemas.
+ *     A correction in that position is warned about, since it no longer takes
+ *     effect;
+ *   - the SDK's side-tables (`list-envelopes.json`, `invariant-collections.json`)
+ *     are the SDK's own data and are always copied.
  *
- *   - copying and teaching the orphan check to tolerate the file would keep
- *     the build green and hide the real loss, which is that the hand-verified
- *     CORRECTION never takes effect once the index points somewhere else;
- *   - redirecting the correction onto the indexed path cannot be done safely
- *     here, because ONE event identity maps to MANY per-object paths in a
- *     refreshed library, and stamping the flat curated definition over each
- *     per-object variant would destroy the per-object schema the library just
- *     served — a worse regression than the one being fixed;
- *   - so the copy is skipped and said out loud. The library keeps the
- *     definition it resolves, the tree gains no unreachable file, and the
- *     operator is told which overlay row has been overtaken and needs
- *     re-verifying. The image build is then green before AND after a refresh.
+ * What was done is reported in one line, and recorded in `.curated-overlay.json`
+ * beside the index, so a second application recognises its own patches: the
+ * record keeps a sha256 of each patched entry and sidecar, and a correction
+ * whose files no longer match it is patched again.
  */
 export async function applyCuratedOverlay(libraryPath, overlayPath = bundledOverlayPath(), 
 // The public materializer API does not forward one, and a warning nobody
@@ -74,6 +218,14 @@ reporter = consoleReporter) {
     const indexPath = join(libraryPath, "index.json");
     const destination = JSON.parse(await readFile(indexPath, "utf8"));
     const overlay = JSON.parse(await readFile(join(overlayPath, "index.json"), "utf8"));
+    const corrections = new Map((await readOverlayCorrections(overlayPath)).map((correction) => [correction.path, correction]));
+    const recordPath = join(libraryPath, RECORD_FILE);
+    const previous = (await exists(recordPath))
+        ? (await readJson(recordPath))
+        : {};
+    const previouslyAdded = new Set(previous.added ?? []);
+    const previousDigests = previous.correctedSha256 ?? {};
+    const digests = {};
     const entries = destination.entries ?? [];
     // Every path the library resolves each identity to. A `GenericExpanded` or
     // per-object entry shares its nodeType with its siblings, so an identity
@@ -91,46 +243,110 @@ reporter = consoleReporter) {
     }
     const additions = [];
     const skipped = new Set();
+    const added = [];
+    const corrected = [];
+    const kept = [];
+    const toCopy = new Set();
+    // Every entry file and sidecar the overlay's index accounts for; anything
+    // else in the directory is a side-table or the corrections ledger.
+    const rowFiles = new Set();
+    let written = 0;
     for (const row of overlay.entries ?? []) {
+        if (typeof row.path !== "string")
+            continue;
+        rowFiles.add(row.path);
+        rowFiles.add(sidecarOf(row.path));
         const identity = entryIdentity(row);
-        if (!resolvedPaths.has(identity)) {
+        const correction = corrections.get(row.path);
+        const paths = resolvedPaths.get(identity);
+        if (paths === undefined) {
             additions.push(row);
+            added.push(row.path);
+            toCopy.add(row.path);
+            toCopy.add(sidecarOf(row.path));
             continue;
         }
-        const paths = resolvedPaths.get(identity);
-        if (typeof row.path !== "string" || paths.includes(row.path))
+        if (!paths.includes(row.path)) {
+            skipped.add(row.path);
+            if (correction) {
+                reporter.warn([
+                    `  WARN: curated overlay correction NOT applied: ${row.path} (${correction.since})`,
+                    `        ${String(row.nodeType)}@${String(row.version)} is in the library's index at`,
+                    ...paths.map((path) => `          ${path}`),
+                    "        instead, so the library's own definition stands without this correction.",
+                    `        Re-verify it there and update ${CORRECTIONS_FILE}.`,
+                ].join("\n"));
+            }
             continue;
-        skipped.add(row.path);
-        reporter.warn([
-            `  WARN: curated overlay SKIPPED ${row.path}`,
-            `        ${String(row.nodeType)}@${String(row.version)} is already in the library's index, at`,
-            ...paths.map((path) => `          ${path}`),
-            "        so the copied file would resolve for nobody. The library's own definition stands and",
-            "        this correction does NOT take effect. Re-verify it against the current library and drop",
-            "        its row from typescript/sdk/lib/library-json.samples/index.json once the library carries it.",
-        ].join("\n"));
-    }
-    // A skipped entry's sidecar goes with it: it is only ever read beside the
-    // entry file, so leaving it behind would state a correction nothing reads.
-    const notCopied = new Set(["index.json"]);
-    for (const rel of skipped) {
-        notCopied.add(rel);
-        notCopied.add(sidecarOf(rel));
+        }
+        if (!correction) {
+            // A row this overlay added on an earlier application is still its own.
+            (previouslyAdded.has(row.path) ? added : kept).push(row.path);
+            continue;
+        }
+        // Our own earlier patch, as long as neither file changed since: a refreshed
+        // entry (an `unzip -o` over the same directory, say) is patched again.
+        const digest = await correctionDigest(libraryPath, row.path);
+        if (previousDigests[row.path] === digest) {
+            corrected.push(row.path);
+            digests[row.path] = digest;
+            continue;
+        }
+        const patched = await patchCorrection(libraryPath, overlayPath, correction);
+        if (patched.added.length === 0) {
+            kept.push(row.path);
+            reporter.warn([
+                `  WARN: curated overlay correction no longer needed: ${row.path} (${correction.since})`,
+                "        The published definition already carries every field and key it adds.",
+                `        Remove its row from typescript/sdk/lib/library-json.samples/${CORRECTIONS_FILE}.`,
+            ].join("\n"));
+            continue;
+        }
+        corrected.push(row.path);
+        digests[row.path] = await correctionDigest(libraryPath, row.path);
+        written += patched.files;
     }
     const overlayFiles = await jsonFiles(overlayPath);
-    let copied = 0;
     for (const source of overlayFiles) {
         const rel = relative(overlayPath, source).split(sep).join("/");
-        if (notCopied.has(rel))
+        if (rel === "index.json" || rel === CORRECTIONS_FILE)
+            continue;
+        const accounted = rowFiles.has(rel);
+        // An entry or sidecar goes only where its row decided; a side-table always;
+        // any other file only into a library that lacks it, so a stray file here
+        // can never replace a published one either.
+        if (accounted && !toCopy.has(rel))
+            continue;
+        if (!accounted && !SIDE_TABLES.has(rel) && (await exists(join(libraryPath, rel))))
             continue;
         const target = join(libraryPath, rel);
         await mkdir(dirname(target), { recursive: true });
         await cp(source, target);
-        copied += 1;
+        written += 1;
     }
     if (additions.length > 0) {
         destination.entries = [...entries, ...additions];
         writeJsonFile(indexPath, destination);
     }
-    return { files: copied, entries: additions.length, skipped: sortedStrings([...skipped]) };
+    const result = {
+        files: written,
+        entries: additions.length,
+        skipped: sortedStrings([...skipped]),
+        added: sortedStrings(added),
+        corrected: sortedStrings(corrected),
+        kept: sortedStrings(kept),
+    };
+    writeJsonFile(recordPath, {
+        $comment: "What the SDK's curated overlay did to this library (registry pull). See curated-overlay.ts.",
+        added: result.added,
+        corrected: result.corrected,
+        correctedSha256: digests,
+        kept: result.kept,
+        skipped: result.skipped,
+    });
+    reporter.info(`curated overlay: added ${result.added.length} definition(s) the library lacks, ` +
+        `corrected ${result.corrected.length}` +
+        (result.corrected.length ? ` (${result.corrected.join(", ")})` : "") +
+        `, kept ${result.kept.length + result.skipped.length} published definition(s) unchanged.`);
+    return result;
 }

package/dist/registry/orphans.js

@@ -35,10 +35,12 @@ import { sortedStrings } from "./compat/compare.js";
  * `list-envelopes.json` is the LIST-ENVELOPE LEDGER (a side-table keyed by
  * nodeType, flow-builder-sdk#156); `invariant-collections.json` is the second
  * such side-table, keyed by a reference's `objectName` instead
- * (CONNECTOR_LOOKUP_DESIGN.md §5.3). Asking either for an index row is the
- * wrong question. Dotfiles are excluded separately — see {@link isDotfile}.
+ * (CONNECTOR_LOOKUP_DESIGN.md §5.3). `overlay-corrections.json` is the
+ * curated overlay's ledger of deliberate patches (#1148); the overlay never
+ * copies it, but a test library copied from the samples carries it. Asking any
+ * of them for an index row is the wrong question. Dotfiles are excluded separately — see {@link isDotfile}.
  */
-const SIDE_TABLES = new Set(["index.json", "list-envelopes.json", "invariant-collections.json"]);
+const SIDE_TABLES = new Set(["index.json", "list-envelopes.json", "invariant-collections.json", "overlay-corrections.json"]);
 /**
  * A dotfile is never an operation entry, so it can never have an index row.
  *

package/lib/library-json.samples/index.json

@@ -133,7 +133,7 @@
       "connectorKey": "uipath-microsoft-outlook365",
       "label": "Send Email",
       "activityType": "Curated",
-      "objectName": "send-mail",
+      "objectName": "send-mail-v2",
       "path": "uipath-microsoft-outlook365/send-email@1.0.0.json"
     },
     {

package/lib/library-json.samples/overlay-corrections.json

@@ -0,0 +1,43 @@
+{
+  "schemaVersion": "1",
+  "$comment": [
+    "THE CORRECTIONS LEDGER: which files in this directory deliberately patch a published definition.",
+    "",
+    "This directory has two jobs. It is the small connector library the tests and the examples read,",
+    "and it is the curated overlay `registry pull` applies to a freshly downloaded library. Only the",
+    "second job can damage a user's library, and only through the rows listed here.",
+    "",
+    "THE RULE (`src/registry/curated-overlay.ts`). An overlay entry whose (nodeType, version) the",
+    "downloaded library does NOT carry is added, with its index row. An entry the library DOES carry is",
+    "left alone: the published definition wins, because a copy here is a snapshot that goes stale the",
+    "day the library is republished (builder-sdk#1148: nine 2026-07 snapshots were replacing newer",
+    "published definitions, Outlook `send-email` among them). The one exception is a row in",
+    "`corrections` below, and a correction is a PATCH, never a replacement: it adds the named input",
+    "fields and sidecar keys the published definition lacks, taking them from this directory's copy,",
+    "and touches nothing else. It cannot change `operation.objectName` or the endpoint, so the index",
+    "row and the entry file keep agreeing.",
+    "",
+    "A correction the published library has caught up with (it already has every field and key) is",
+    "reported as no longer needed. Remove its row here once a published build carries it.",
+    "",
+    "FIELDS. `path`: the entry file, as in index.json. `since`: the change that made it. `reason`:",
+    "why the published definition is wrong. `inputFields`: names added to `inputSchema.fields` (entry)",
+    "and `inputDefinition.fields` (sidecar) when absent. `sidecarKeys`: top-level sidecar keys added",
+    "when absent."
+  ],
+  "corrections": [
+    {
+      "path": "uipath-atlassian-jira/create-issue@1.0.0.json",
+      "since": "builder-sdk#108",
+      "reason": "Jira refuses a create without fields.summary (400). The published definition leaves the body fields to design-time schema generation, so a flow authored without `registry prepare` could not set summary or description, and nothing typed the created issue's key.",
+      "inputFields": [
+        "fields.summary",
+        "fields.description",
+        "key"
+      ],
+      "sidecarKeys": [
+        "outputResponseDefinition"
+      ]
+    }
+  ]
+}

package/lib/library-json.samples/uipath-microsoft-outlook365/send-email@1.0.0.json

@@ -10,23 +10,66 @@
   ],
   "connector": {
     "key": "uipath-microsoft-outlook365",
-    "name": "Microsoft Outlook 365"
+    "name": "Microsoft Outlook 365",
+    "tier": "1",
+    "discovery": {
+      "type": "static",
+      "hasObjectDiscovery": false,
+      "hasFieldDiscovery": false,
+      "hasCustomObjectDiscovery": false,
+      "hasCustomFieldDiscovery": false
+    }
   },
   "operation": {
     "name": "Create",
-    "objectName": "send-mail",
+    "objectName": "send-mail-v2",
     "objectDisplayName": "Send Email",
     "httpMethod": "POST",
-    "path": "/hubs/productivity/send-mail",
+    "path": "/hubs/productivity/send-mail-v2",
     "subType": "standard",
     "supportsStreaming": false,
     "activityType": "Curated",
-    "pathTemplate": "/hubs/productivity/send-mail",
-    "parameters": []
+    "pathTemplate": "/hubs/productivity/send-mail-v2",
+    "parameters": [
+      {
+        "name": "saveAsDraft",
+        "type": "query",
+        "dataType": "boolean",
+        "required": false,
+        "displayName": "Save as draft",
+        "description": "Send an email message. By default, the email will be saved as draft.",
+        "defaultValue": true
+      },
+      {
+        "name": "includeMessageDetails",
+        "type": "query",
+        "dataType": "boolean",
+        "required": false,
+        "displayName": "Include message details",
+        "description": "Returns the sent message's identifiers (message ID, conversation ID, internet message ID, status) when set to true. If set to false, response only contains status.",
+        "defaultValue": false
+      },
+      {
+        "name": "file",
+        "type": "multipart",
+        "dataType": "file",
+        "required": false,
+        "displayName": "Attachment",
+        "description": "The file to attach to the email"
+      },
+      {
+        "name": "body",
+        "type": "multipart",
+        "dataType": "string",
+        "required": false,
+        "displayName": "Body",
+        "description": "The object body"
+      }
+    ]
   },
   "display": {
     "label": "Send Email",
-    "description": "(Microsoft Outlook 365) Send an email message based on the input parameters",
+    "description": "Send an email message based on the input parameters",
     "icon": "https://alpha.uipath.com/311c6049-4966-4ef2-a6f3-8ceccaf38d54/studio_/typecache/icons/160499b52f7cea190b530fe6f40da7ee03455a8d3fb72dd7f4f68d61e7865a3a.svg",
     "iconBackground": "",
     "iconBackgroundDark": "",

package/lib/library-json.samples/uipath-microsoft-outlook365/send-email@1.0.0.v1def.json

@@ -7,13 +7,14 @@
     "activity",
     "API.File.Upload.Optional"
   ],
-  "sortOrder": 515,
+  "sortOrder": 520,
   "supportsErrorHandling": true,
-  "description": "(Microsoft Outlook 365) Send an email message based on the input parameters",
+  "description": "Send an email message based on the input parameters",
   "display": {
     "label": "Send Email",
-    "description": "(Microsoft Outlook 365) Send an email message based on the input parameters",
-    "icon": "https://alpha.uipath.com/311c6049-4966-4ef2-a6f3-8ceccaf38d54/studio_/typecache/icons/160499b52f7cea190b530fe6f40da7ee03455a8d3fb72dd7f4f68d61e7865a3a.svg"
+    "description": "Send an email message based on the input parameters",
+    "icon": "https://alpha.uipath.com/311c6049-4966-4ef2-a6f3-8ceccaf38d54/studio_/typecache/icons/160499b52f7cea190b530fe6f40da7ee03455a8d3fb72dd7f4f68d61e7865a3a.svg",
+    "sourceDisplayName": "Microsoft Outlook 365"
   },
   "handleConfiguration": [
     {
@@ -78,7 +79,7 @@
       },
       {
         "name": "objectName",
-        "value": "send-mail",
+        "value": "send-mail-v2",
         "type": "string"
       },
       {
@@ -138,11 +139,11 @@
                 "packageId": "196656",
                 "svgIconUrl": "icons/160499b52f7cea190b530fe6f40da7ee03455a8d3fb72dd7f4f68d61e7865a3a.svg",
                 "displayName": "Send Email",
-                "assemblyQualifiedName": "UiPath.IntegrationService.Activities.Runtime.Activities.ConnectorActivity, UiPath.IntegrationService.Activities.Runtime, Version=1.30.0.0, Culture=neutral, PublicKeyToken=null",
+                "assemblyQualifiedName": "UiPath.IntegrationService.Activities.Runtime.Activities.ConnectorActivity, UiPath.IntegrationService.Activities.Runtime, Version=1.34.0.0, Culture=neutral, PublicKeyToken=null",
                 "description": "Send an email message based on the input parameters",
                 "category": "",
                 "activityColor": "#E56D5C",
-                "configuration": "{\"connectorKey\":\"uipath-microsoft-outlook365\",\"objectName\":\"send-mail\",\"httpMethod\":\"POST\",\"activityType\":\"Curated\",\"version\":\"1.0.0\",\"supportsStreaming\":false,\"subType\":\"standard\"}",
+                "configuration": "{\"connectorKey\":\"uipath-microsoft-outlook365\",\"objectName\":\"send-mail-v2\",\"httpMethod\":\"POST\",\"activityType\":\"Curated\",\"version\":\"1.0.0\",\"supportsStreaming\":false,\"subType\":\"standard\"}",
                 "uiPathActivityTypeId": "c7ce0a96-2091-3d94-b16f-706ebb1eb351",
                 "isExperimental": false,
                 "helpUrlTemplate": "https://docs.uipath.com/{0}/activities/other/latest/integration-service/uipath-microsoft-outlook365-Send-Email",
@@ -165,89 +166,71 @@
     "fields": [
       {
         "name": "message.importance",
-        "displayName": "Importance",
         "type": "string",
-        "dataType": "string",
-        "required": false,
+        "displayName": "Importance",
         "description": "The importance of the email",
         "enum": [
-          {
-            "name": "High",
-            "value": "high"
-          },
-          {
-            "name": "Normal",
-            "value": "normal"
-          },
-          {
-            "name": "Low",
-            "value": "low"
-          }
-        ]
+          "high",
+          "normal",
+          "low"
+        ],
+        "required": false
       },
       {
         "name": "message.ccRecipients",
-        "displayName": "CC",
         "type": "string",
-        "dataType": "string",
-        "required": false,
-        "description": "The secondary recipients of the email, separated by comma (,)"
+        "displayName": "CC",
+        "description": "The secondary recipients of the email, separated by comma (,)",
+        "required": false
       },
       {
         "name": "message.body.contentType",
-        "displayName": "Message body content type",
         "type": "string",
-        "dataType": "string",
-        "required": false,
-        "description": "Specifies the format of the email body, such as plain text or HTML."
+        "displayName": "Message body content type",
+        "description": "Specifies the format of the email body, such as plain text or HTML.",
+        "required": false
       },
       {
         "name": "message.bccRecipients",
-        "displayName": "BCC",
         "type": "string",
-        "dataType": "string",
-        "required": false,
-        "description": "The hidden recipients of the email, separated by comma (,)"
+        "displayName": "BCC",
+        "description": "The hidden recipients of the email, separated by comma (,)",
+        "required": false
       },
       {
         "name": "message.body.content",
-        "displayName": "Body",
         "type": "string",
-        "dataType": "string",
-        "required": false,
-        "description": "The body of the email"
+        "displayName": "Body",
+        "description": "The body of the email",
+        "required": false
       },
       {
         "name": "saveToSentItems",
-        "displayName": "Save to sent items",
         "type": "boolean",
-        "dataType": "boolean",
-        "required": false,
-        "description": "Indicates if the email should be saved in the sent items folder."
+        "displayName": "Save to sent items",
+        "description": "Indicates if the email should be saved in the sent items folder.",
+        "required": false
       },
       {
         "name": "message.toRecipients",
-        "displayName": "To",
         "type": "string",
-        "dataType": "string",
-        "required": true,
-        "description": "The main recipients of the email, separated by comma(,)"
+        "displayName": "To",
+        "description": "The main recipients of the email, separated by comma(,)",
+        "required": true
       },
       {
         "name": "message.subject",
-        "displayName": "Subject",
         "type": "string",
-        "dataType": "string",
-        "required": false,
-        "description": "The subject of the email"
+        "displayName": "Subject",
+        "description": "The subject of the email",
+        "required": false
       },
       {
         "name": "message.replyTo",
-        "displayName": "Reply to",
         "type": "string",
-        "dataType": "string",
-        "required": false,
-        "description": "The email addresses to use when replying, separated by comma (,)"
+        "displayName": "Reply to",
+        "description": "The email addresses to use when replying, separated by comma (,)",
+        "required": false
       }
     ]
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.31.3",
+  "version": "6.31.5",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "312d113c6d6ed072f209ca7faab413317d551880"
+  "gitref": "19700f105da9eae840ec05cd3796c28a96f1a4ed"
 }