@uipath/maestro-builder-sdk 6.11.1 → 6.11.3

package/dist/check.js

@@ -11,8 +11,9 @@ import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './core/l
 import { EVENT_FILTER_OPERATORS, readEventFilter, eventFilterProblem } from './event-filters.js';
 import { extractRefs } from './core/expr-check.js';
 import { bindingSelfNameMessage, bindingUndeclaredMessage, undeclaredBinding } from './core/binding-messages.js';
+import { isAnswerField } from './core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome } from './core/hitl-routing.js';
-import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
+import { childStepLists, declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
 import { prepareCommand, resolveFlagArg } from './core/cli-spelling.js';
@@ -1644,20 +1645,7 @@ function checkLoopListEnvelope(loop, connectors, opts, diags) {
 }
 /** True if any step on THIS flow's own tree is a `.return()`. */
 function hasReturn(steps) {
-    for (const s of steps) {
-        if (s.kind === 'return')
-            return true;
-        if (s.kind === 'branch' && (hasReturn(s.then) || hasReturn(s.otherwise)))
-            return true;
-        if (s.kind === 'switch'
-            && (s.cases.some((c) => hasReturn(c.body)) || hasReturn(s.default ?? [])))
-            return true;
-        if (s.kind === 'parallel' && s.arms.some(hasReturn))
-            return true;
-        if ((s.kind === 'loop' || s.kind === 'doWhile') && hasReturn(s.body))
-            return true;
-    }
-    return false;
+    return steps.some((s) => s.kind === 'return' || childStepLists(s).some(hasReturn));
 }
 /**
  * Closest of `candidates` to `name`: same word ignoring case, one contained in
@@ -4777,9 +4765,9 @@ function checkHitl(step, inputs, diags) {
                 + `gets a text box and the value comes back as a string. Valid: `
                 + `${FORM_FIELD_TYPES.join(', ')}.`, nearest !== undefined ? `type: '${nearest}'` : `type: 'text'`);
         }
+        if (isAnswerField(f))
+            answers++; // an `output`, or an `inOut` whose reviewed value comes back
         if (f?.direction === 'input' || f?.direction === 'inOut') {
-            if (f.direction === 'inOut')
-                answers++; // the reviewed value comes back
             const value = f.value;
             if (value === undefined || value === null) {
                 at('HITL_FIELD_NO_VALUE', `Human task "${step}" shows the form field "${id}" to the reviewer but gives it no value, `
@@ -4800,10 +4788,7 @@ function checkHitl(step, inputs, diags) {
                     + `Compute it in a script step first and point the field at that step's output.`, `value: out('<scriptStep>')`);
             }
         }
-        else if (f?.direction === 'output') {
-            answers++;
-        }
-        else {
+        else if (f?.direction !== 'output') {
             at('HITL_FIELD_DIRECTION', `Human task "${step}" gives the form field "${id}" the direction `
                 + `${JSON.stringify(f?.direction)}. A field is shown to the `
                 + `reviewer ('input'), filled in by them ('output'), or pre-filled and editable ('inOut'); `
@@ -4926,7 +4911,7 @@ function checkHitlRead(name, field, rest, form, step, diags) {
     if (answer === 'Action')
         return; // which outcome was pressed.
     const answers = (form?.fields ?? [])
-        .filter((f) => f?.direction === 'output' && typeof f?.id === 'string')
+        .filter((f) => isAnswerField(f) && typeof f?.id === 'string')
         .map((f) => f.id);
     if (answers.includes(answer))
         return;
@@ -4938,7 +4923,7 @@ function checkHitlRead(name, field, rest, form, step, diags) {
         level: 'error',
         code: 'HITL_READ_UNKNOWN_FIELD',
         message: `Human task "${name}" has no answer "${answer}" (read as "$vars.${name}.output.${answer}" in `
-            + `"${step}"). Its result carries only the fields the reviewer FILLS IN`
+            + `"${step}"). Its result carries only the fields the reviewer FILLS IN or EDITS`
             + `${answers.length > 0 ? ` (${answers.join(', ')})` : ' (it declares none)'} plus "Action". `
             + (shown.includes(answer)
                 ? `"${answer}" is a field the reviewer only reads, so it is not part of the answer — read the `

package/dist/core/hitl-answers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Which form fields of a human task come back in its answer object — the one
+ * rule `serialize` (the emitted `outputs.output.properties`) and `check` (the
+ * answer count and every `out('<task>', '<field>')` read) all use, so they
+ * cannot drift. They did drift (UV-16855): `serialize` emitted `inOut` fields
+ * as answers and `check` counted them as answers, but the read check listed
+ * `output` fields only, so the documented read of an editable field —
+ * `out('review', 'comment')` for `{ id: 'comment', direction: 'inOut', … }` —
+ * failed `check` and blocked `compile`.
+ *
+ * - `output` — the reviewer fills it in; the value comes back.
+ * - `inOut` — pre-filled and editable; the (possibly changed) value comes back.
+ * - `input` — shown only; NOT an answer. Read the value bound to it instead.
+ */
+export type AnswerDirection = 'output' | 'inOut';
+/** True when the field's value comes back in the task's answer object. */
+export declare function isAnswerField(field: {
+    direction?: unknown;
+} | null | undefined): boolean;

package/dist/core/hitl-answers.js

@@ -0,0 +1,4 @@
+/** True when the field's value comes back in the task's answer object. */
+export function isAnswerField(field) {
+    return field?.direction === 'output' || field?.direction === 'inOut';
+}

package/dist/core/step-ports.d.ts

@@ -42,4 +42,16 @@ export declare function hasExits(r: DeclaredExit[] | NoExits): r is DeclaredExit
  * `.parallel` join waiting: a terminate ends the run, join included.
  */
 export declare function stopsAtEnd(steps: readonly Step[]): boolean;
+/**
+ * The step lists nested DIRECTLY inside `step` — the bodies a walk over this
+ * flow's own tree must descend into. Exhaustive over `Step['kind']`, so a new
+ * container kind fails to compile here instead of being silently skipped by
+ * every walker. That is how `check`'s return scan came to miss `.stepSwitch`
+ * arms and `.stepToList` / `.onError` bodies, and warned NO_RETURN on flows
+ * whose every path ends in `.return()` (UV-16855).
+ *
+ * A subflow's child flow is deliberately NOT a child here: it is another
+ * flow's tree, and its returns say nothing about whether THIS flow ends.
+ */
+export declare function childStepLists(step: Step): readonly Step[][];
 export {};

package/dist/core/step-ports.js

@@ -107,3 +107,40 @@ export function stopsAtEnd(steps) {
         || (st.kind === 'switch' && st.default !== undefined && has(st.default, kinds)));
     return has(steps, new Set(['return'])) && !has(steps, new Set(['terminate', 'break']));
 }
+/**
+ * The step lists nested DIRECTLY inside `step` — the bodies a walk over this
+ * flow's own tree must descend into. Exhaustive over `Step['kind']`, so a new
+ * container kind fails to compile here instead of being silently skipped by
+ * every walker. That is how `check`'s return scan came to miss `.stepSwitch`
+ * arms and `.stepToList` / `.onError` bodies, and warned NO_RETURN on flows
+ * whose every path ends in `.return()` (UV-16855).
+ *
+ * A subflow's child flow is deliberately NOT a child here: it is another
+ * flow's tree, and its returns say nothing about whether THIS flow ends.
+ */
+export function childStepLists(step) {
+    switch (step.kind) {
+        case 'branch':
+            return [step.then, step.otherwise];
+        case 'switch':
+            return [...step.cases.map((c) => c.body), ...(step.default ? [step.default] : [])];
+        case 'stepSwitch':
+            return step.cases.map((c) => c.body);
+        case 'loop':
+        case 'doWhile':
+        case 'stepToList':
+            return [step.body];
+        case 'parallel':
+            return step.arms;
+        case 'action':
+        case 'break':
+        case 'terminate':
+        case 'stepToRef':
+        case 'return':
+            return [];
+        default: {
+            const unhandled = step;
+            throw new Error(`childStepLists: unhandled step kind ${JSON.stringify(unhandled.kind)}`);
+        }
+    }
+}

package/dist/registry/library-build/events.js

@@ -294,9 +294,27 @@ export function eventFacts(node, objectRow) {
         eventMode: pyStr(pyOr(get(node, "eventMode"), "polling")),
         byoaConnection: truthy(fact("ByoaConnection", "byoaConnection", false)),
         isWebhookUrlVisible: truthy(fact("IsWebhookUrlVisible", "isWebhookUrlVisible", false)),
-        textBlocks: pyIter(textBlocks).map((t) => pyStr(t)),
+        textBlocks: pyIter(textBlocks).map(textBlockText),
     };
 }
+/**
+ * One `Design.TextBlocks` entry as display text. The tenant answers with
+ * records — `{ Name, Text, Position }` (every Slack event object carries
+ * `{ Name: 'defaultMessage', Text: 'Add this webhook URL to your Slack app. …',
+ * Position: 'top' }`) — so the text is the record's `Text`. A bare string is
+ * kept as is. Anything else still goes through `pyStr`, which refuses it
+ * loudly: the Python's `str(t)` printed a dict repr into the webhook note, and
+ * an unknown shape should fail the same way this one did rather than print
+ * something plausible.
+ */
+function textBlockText(block) {
+    if (isRecord(block)) {
+        const text = pyOr(get(block, "Text"), get(block, "text"));
+        if (typeof text === "string")
+            return text;
+    }
+    return pyStr(block);
+}
 // ---------------------------------------------------------------------------
 // The generator's cached event calls and its event passes
 // ---------------------------------------------------------------------------

package/dist/serialize.js

@@ -14,6 +14,7 @@ import { Expr, toExpr, SCHEDULE_PRESETS, DELAY_PRESETS, parseIxpProjectType, fla
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { dataFabricUnknownInputs } from './core/typed-raw-node.js';
+import { isAnswerField } from './core/hitl-answers.js';
 import { BindingRefusal, GUID_RE, bindingSelfNameMessage, bindingUndeclaredMessage, undeclaredBinding } from './core/binding-messages.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
 import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
@@ -2800,7 +2801,7 @@ function hitlInputs(inputs, nodeId, flowId, label, rename) {
     const properties = {};
     for (const f of inputs?.fields ?? []) {
         // inOut fields land in the answers too — their reviewed value flows back.
-        if (f.direction !== 'output' && f.direction !== 'inOut')
+        if (!isAnswerField(f))
             continue;
         properties[f.id] = { ...FORM_FIELD_JSON_TYPE[f.type] };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.11.1",
+  "version": "6.11.3",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "85e9b8d11773bb7e83aed5deb38eea2ecd25bd2a"
+  "gitref": "e1b0e818f78b7911c691e12ea078d03c851daf76"
 }