@uipath/maestro-builder-sdk 6.31.2 → 6.31.4

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/dist/serialize.js

@@ -8,6 +8,7 @@
  */
 import ixpDefinition from './ixp-definition.json' with { type: 'json' };
 import { BUNDLED_DEFINITIONS, bundledVersions } from './flow-definitions.js';
+import { LOOP_DEFAULT_VERSION, bodyUsesBreak, loopHasInnerHandles, loopVersion, loopVersionRefusal } from './loop-version.js';
 import { Expr, toExpr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf } from './flow-sdk.js';
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
 import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexType } from './core/context-index.js';
@@ -75,15 +76,6 @@ const defByType = new Map();
 for (const d of Object.values(DEFS))
     if (!defByType.has(d.nodeType))
         defByType.set(d.nodeType, d);
-/** True when a container body (or an arm/handler inside it, but not a NESTED container's body) breaks. */
-function bodyUsesBreak(steps) {
-    return steps.some((s) => s.kind === 'break'
-        || (s.kind === 'branch' && (bodyUsesBreak(s.then) || bodyUsesBreak(s.otherwise)))
-        || (s.kind === 'switch' && (s.cases.some((c) => bodyUsesBreak(c.body)) || (s.default ? bodyUsesBreak(s.default) : false)))
-        || (s.kind === 'stepSwitch' && s.cases.some((c) => bodyUsesBreak(c.body)))
-        || (s.kind === 'parallel' && s.arms.some(bodyUsesBreak))
-        || (s.kind === 'stepToList' && bodyUsesBreak(s.body)));
-}
 const NODE_TYPE = {
     trigger: 'core.trigger.manual',
     scheduledTrigger: 'core.trigger.scheduled',
@@ -3448,8 +3440,6 @@ export function actionVersion(spec, explicit) {
 export function bundledDefinition(nodeType, requestedVersion) {
     return requestedVersion !== undefined ? DEFS[`${nodeType}@${requestedVersion}`] : defByType.get(nodeType);
 }
-/** The `core.logic.loop` version `.loop()` emits unless `{ version }` pins another. */
-const LOOP_DEFAULT_VERSION = '2.4';
 /**
  * The bundled definition a `.loop()` or `.doWhile()` container emits, at the
  * version serialize writes (`.loop()` defaults to `@2.4`, `.doWhile()` to the
@@ -6342,15 +6332,14 @@ export function serialize(built, opts = {}) {
                 // designer authors (inner start/continue/break handles, `currentIteration`
                 // output). 1.0.0 is the legacy shape the canvas shows in its old form; it
                 // is emitted only when { version: '1.0.0' } is pinned explicitly (#868).
-                // An explicit 1.0.0 plus a rich option is a contradiction the author must
-                // resolve, not a silent drop.
-                const rich = o.parallel !== undefined || o.completionCondition !== undefined || o.breakEnabled !== undefined || usesBreak;
-                const version = o.version ?? LOOP_DEFAULT_VERSION;
-                if (rich && version === '1.0.0') {
-                    throw new Error(`loop "${step.name}": parallel/completionCondition/breakEnabled/break() need the loop's 2.4 `
-                        + `definition, but { version: '1.0.0' } was requested. Drop the version or request 2.4.`);
-                }
-                const v24 = version !== '1.0.0';
+                // An option or a .break() the pinned version's definition cannot express
+                // is a contradiction the author must resolve, not a silent drop; `check`
+                // reports the same refusal from the same helper (#1186).
+                const refusal = loopVersionRefusal(step.name, o, usesBreak);
+                if (refusal)
+                    throw new Error(refusal);
+                const version = loopVersion(o);
+                const v24 = loopHasInnerHandles(version);
                 const id = stepUid(scope, step.name);
                 const node = makeNode(NODE_TYPE.loop, id, step.options?.label ?? step.label ?? step.name, { parentId, requestedVersion: version });
                 node.inputs = v24
@@ -6362,7 +6351,7 @@ export function serialize(built, opts = {}) {
                             : {}),
                         breakEnabled: (o.breakEnabled ?? false) || usesBreak,
                     }
-                    : { collection: renderValue(step.collection, scope.rename), parallel: false };
+                    : { collection: renderValue(step.collection, scope.rename), parallel: o.parallel ?? false };
                 scope.nodes.push(node);
                 for (const t of tails)
                     addEdge(scope, t, id);

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": "",