@uipath/maestro-builder-sdk 6.31.7 → 6.31.9

package/dist/core/form-field-type.js

@@ -1,63 +1,301 @@
 import { nearestName } from './edit-distance.js';
-const PRODUCT_SPELLINGS = {
-    text: 'text',
-    string: 'text',
-    String: 'text',
-    'System.String': 'text',
-    'System.Char': 'text',
-    Char: 'text',
-    number: 'number',
+import { ownEntry } from './own-entry.js';
+/**
+ * Each canonical type's JSON Schema, as `FIELD_TYPE_TO_JSON_SCHEMA` gives it.
+ * `Record<CanonicalFormFieldType, …>` makes tsc refuse a missing or extra one.
+ * `float` and `double` are both `number`: JSON Schema has no precision; `file`
+ * is `format: 'binary'` (the OpenAPI convention for an upload).
+ */
+const CANONICAL_JSON_SCHEMA = {
+    string: { type: 'string' },
+    number: { type: 'number' },
+    integer: { type: 'integer' },
+    float: { type: 'number' },
+    double: { type: 'number' },
+    boolean: { type: 'boolean' },
+    date: { type: 'string', format: 'date' },
+    datetime: { type: 'string', format: 'date-time' },
+    file: { type: 'string', format: 'binary' },
+    object: { type: 'object' },
+    array: { type: 'array' },
+};
+/** The product's 11 canonical quick-form field types, in its own order. */
+export const CANONICAL_FORM_FIELD_TYPES = Object.keys(CANONICAL_JSON_SCHEMA);
+/**
+ * The SDK's own legacy spellings, accepted in source: `text` (what the SDK,
+ * flow-v1's serializer and `uip maestro flow hitl add` have always written) and
+ * `date-time`. The product resolves both.
+ */
+const SDK_ALIASES = {
+    text: 'string',
+    'date-time': 'datetime',
+};
+/** The SDK's legacy spellings (`text`, `date-time`), for diagnostics that list them. */
+export const LEGACY_FORM_FIELD_TYPES = Object.keys(SDK_ALIASES);
+/**
+ * The product's choice-control spellings (#1235): the data type each holds
+ * (`resolveFieldType`) and the control the form renders it with
+ * (`controlForDeclaredType`, which sets the field's `controlType` when the row
+ * has none). The output schema is the data type's; the choices ride on the
+ * field's `options`, never in the schema.
+ *
+ * Kept as written on the wire — NOT resolved to the data type, which would
+ * drop the control: a `singleSelect` written as `string` renders as a text box.
+ */
+const CONTROL_TYPES = {
+    singleSelect: { data: 'string', control: 'dropdown' },
+    multiSelect: { data: 'array', control: 'multiSelect' },
+    enum: { data: 'string', control: 'dropdown' },
+};
+/** The choice-control spellings, for `check`'s messages and the contract test. */
+export const CONTROL_FORM_FIELD_TYPES = Object.keys(CONTROL_TYPES);
+/**
+ * Every form-field type the SDK accepts in source: the 11 canonical ones, the
+ * SDK's legacy aliases, and the three choice-control spellings.
+ */
+export const FORM_FIELD_TYPES = [
+    ...CANONICAL_FORM_FIELD_TYPES, ...LEGACY_FORM_FIELD_TYPES, ...CONTROL_FORM_FIELD_TYPES,
+];
+/**
+ * The tail of a "Valid: …" diagnostic: the canonical types, then the legacy
+ * spellings and the choice controls in parentheses.
+ *
+ * @example
+ * validFormFieldTypesText() // 'string, …, array (or the older text, date-time; or a choice control: singleSelect, …)'
+ */
+export function validFormFieldTypesText() {
+    return `${CANONICAL_FORM_FIELD_TYPES.join(', ')} (or the older ${LEGACY_FORM_FIELD_TYPES.join(', ')}; `
+        + `or a choice control: ${CONTROL_FORM_FIELD_TYPES.join(', ')})`;
+}
+/**
+ * The data type and control a choice-control spelling names, or `undefined`
+ * for any other type.
+ *
+ * @example
+ * controlFormFieldType('singleSelect') // { data: 'string', control: 'dropdown' }
+ * controlFormFieldType('multiSelect')  // { data: 'array', control: 'multiSelect' }
+ * controlFormFieldType('string')       // undefined
+ */
+export function controlFormFieldType(type) {
+    const entry = typeof type === 'string' ? ownEntry(CONTROL_TYPES, type) : undefined;
+    return entry === undefined ? undefined : { ...entry };
+}
+/**
+ * The product's other data-type spellings, each with the canonical type it
+ * resolves to (`resolveFieldType` in `@uipath/hitl-schema-types` 1.2.0). The
+ * .NET names come from forms built by RPA / agent tooling. The scope-walker
+ * shapes (`union`, `intersection`, `ref`, `any`) reach `field.type` when a
+ * canvas author binds a Flow variable; they carry no narrower shape, so they
+ * resolve to `string`. `T[]` and `a | b` are matched by pattern in
+ * `canonicalFormFieldType`.
+ *
+ * Deliberately left out: the choice-control spellings (`singleSelect`,
+ * `multiSelect`, `enum` — `CONTROL_TYPES` above, kept as written because the
+ * product infers a `controlType` from them).
+ */
+const PRODUCT_ALIASES = {
+    ...SDK_ALIASES,
+    String: 'string',
+    'System.String': 'string',
+    'System.Char': 'string',
+    Char: 'string',
     Number: 'number',
-    boolean: 'boolean',
+    Int32: 'integer',
+    Int64: 'integer',
+    'System.Int32': 'integer',
+    'System.Int64': 'integer',
+    'System.Byte': 'integer',
+    'System.Int16': 'integer',
+    Byte: 'integer',
+    Int16: 'integer',
+    UInt16: 'integer',
+    UInt32: 'integer',
+    UInt64: 'integer',
+    Float: 'float',
+    Single: 'float',
+    'System.Single': 'float',
+    Double: 'double',
+    Decimal: 'double',
+    'System.Double': 'double',
+    'System.Decimal': 'double',
     Boolean: 'boolean',
     'System.Boolean': 'boolean',
-    'date-time': 'date-time',
-    datetime: 'date-time',
-    dateTime: 'date-time',
-    DateTime: 'date-time',
-    'System.DateTime': 'date-time',
+    Date: 'date',
+    'System.DateOnly': 'date',
+    DateOnly: 'date',
+    dateTime: 'datetime',
+    DateTime: 'datetime',
+    'System.DateTime': 'datetime',
+    File: 'file',
+    Object: 'object',
+    DataTable: 'object',
+    QueueItem: 'object',
+    Array: 'array',
+    GenericValue: 'array',
+    list: 'array',
+    List: 'array',
+    union: 'string',
+    intersection: 'string',
+    ref: 'string',
+    any: 'string',
 };
+/** The product aliases, for the contract test. */
+export const FORM_FIELD_TYPE_ALIASES = PRODUCT_ALIASES;
+const isCanonical = (t) => typeof t === 'string' && Object.hasOwn(CANONICAL_JSON_SCHEMA, t);
+/**
+ * The canonical type a wire or source spelling names, or `undefined` when it
+ * names none the SDK models. A choice-control spelling is its own wire
+ * spelling, so it is `undefined` here too — its data type is
+ * `controlFormFieldType(t).data`; resolving it here would let a caller write
+ * `string` for a dropdown.
+ *
+ * @example
+ * canonicalFormFieldType('integer')      // 'integer'
+ * canonicalFormFieldType('text')         // 'string'
+ * canonicalFormFieldType('System.Int32') // 'integer'
+ * canonicalFormFieldType('string[]')     // 'array'
+ * canonicalFormFieldType('string | null') // 'string'
+ * canonicalFormFieldType('singleSelect') // undefined
+ */
+export function canonicalFormFieldType(type) {
+    if (isCanonical(type))
+        return type;
+    if (typeof type !== 'string')
+        return undefined;
+    // The package's own order: the two scope-walker patterns before the names.
+    if (type.endsWith('[]'))
+        return 'array';
+    if (type.includes(' | '))
+        return 'string';
+    return Object.hasOwn(PRODUCT_ALIASES, type) ? PRODUCT_ALIASES[type] : undefined;
+}
 /**
- * The SDK's spelling of a wire form-field type, or `undefined` when the SDK
- * does not model that type.
+ * The spelling decompile writes into source for a wire field type: a canonical
+ * type or an SDK alias stays as written, so a canvas form (`"integer"`,
+ * `"date"`) and a classic-CLI form (`"text"`) both compile back to the bytes
+ * they came from; a product alias the SDK does not accept in source
+ * (`"System.Int32"`, `"string[]"`) becomes its canonical type; anything else
+ * stays verbatim for `check` to report.
  *
  * @example
- * sdkFormFieldType('string')   // 'text'
- * sdkFormFieldType('datetime') // 'date-time'
- * sdkFormFieldType('integer')  // undefined
+ * sourceFormFieldType('date')          // 'date'
+ * sourceFormFieldType('text')          // 'text'
+ * sourceFormFieldType('System.String') // 'string'
+ * sourceFormFieldType('string[]')      // 'array'
+ * sourceFormFieldType('singleSelect')  // 'singleSelect'
  */
-export function sdkFormFieldType(wire) {
-    return typeof wire === 'string' && Object.hasOwn(PRODUCT_SPELLINGS, wire) ? PRODUCT_SPELLINGS[wire] : undefined;
+export function sourceFormFieldType(wire) {
+    if (typeof wire === 'string' && FORM_FIELD_TYPES.includes(wire))
+        return wire;
+    return canonicalFormFieldType(wire) ?? String(wire);
 }
 /**
- * Why a form-field type is refused: a product spelling of a type the SDK
- * models (`"string"` is the platform's own name for text), or a type
- * the SDK does not model at all. `unknownWhy` is the caller's reason for the
- * second case; the default is a human task's.
+ * Why a form-field type is refused: a product alias the SDK does not accept in
+ * source (`"System.Int32"` is the platform's .NET name for `integer`), or a type
+ * the product does not recognize at all. `unknownWhy` is the caller's reason for
+ * the second case; the default is a human task's.
  */
-export function formFieldTypeWhy(type, unknownWhy = `which the platform does not recognize. Older runtimes read it as text, newer ones reject `
-    + `the form`) {
-    const alias = sdkFormFieldType(type);
-    return alias !== undefined
-        ? `which is the platform's spelling of the SDK's '${alias}' — the SDK writes '${alias}'`
+export function formFieldTypeWhy(type, unknownWhy = `which is not a quick-form field type: the platform rejects the form`) {
+    const canonical = canonicalFormFieldType(type);
+    return canonical !== undefined
+        ? `which is the platform's alias of '${canonical}' — the SDK writes '${canonical}'`
         : unknownWhy;
 }
-/** Every FormFieldType, once; `Record<FormFieldType, …>` makes tsc refuse a missing or extra one. */
-const FORM_FIELD_TYPE_SET = { text: true, number: true, boolean: true, 'date-time': true };
-/** The form-field types the SDK models. */
-export const FORM_FIELD_TYPES = Object.keys(FORM_FIELD_TYPE_SET);
-/** The `suggestion` for an unknown form-field type: the nearest valid one, else `type: 'text'`. */
+/** The `suggestion` for an unknown form-field type: its canonical type, the nearest valid one, else `type: 'string'`. */
 export function formFieldTypeHint(type) {
-    const alias = sdkFormFieldType(type);
-    if (alias !== undefined)
-        return `type: '${alias}'`;
+    const canonical = canonicalFormFieldType(type);
+    if (canonical !== undefined)
+        return `type: '${canonical}'`;
     const nearest = nearestName(String(type), FORM_FIELD_TYPES);
-    return nearest !== undefined ? `type: '${nearest}'` : `type: 'text'`;
+    return nearest !== undefined ? `type: '${nearest}'` : `type: 'string'`;
+}
+/**
+ * The JSON Schema of a field's value, for the output (and escalation input)
+ * schemas the serializers write; `undefined` for a type the SDK does not model.
+ *
+ * @example
+ * formFieldJsonSchema('date') // { type: 'string', format: 'date' }
+ * formFieldJsonSchema('text') // { type: 'string' }
+ * formFieldJsonSchema('multiSelect') // { type: 'array' }
+ */
+export function formFieldJsonSchema(type) {
+    const canonical = canonicalFormFieldType(type) ?? controlFormFieldType(type)?.data;
+    const schema = canonical === undefined ? undefined : ownEntry(CANONICAL_JSON_SCHEMA, canonical);
+    return schema === undefined ? undefined : { ...schema };
+}
+/**
+ * A picker field's choices as the form row carries them (`options`, each
+ * `{ id, value, label }` — the product's `optionShape`), copied so the wire
+ * never aliases the author's array. `undefined` when the field has none.
+ * Both serializers (human task, quick-form escalation) write through this.
+ */
+export function formFieldOptionsWire(options) {
+    return options === undefined ? undefined : options.map((o) => ({ id: o.id, value: o.value, label: o.label }));
+}
+/** Whether a value is one well-formed choice: string `id`, `value` and `label`, all three the product requires. */
+function isFormFieldOption(o) {
+    if (o === null || typeof o !== 'object')
+        return false;
+    const r = o;
+    return typeof r.id === 'string' && typeof r.value === 'string' && typeof r.label === 'string';
+}
+/**
+ * A form row's `options` read back for source: the well-formed choices
+ * (string `id`, `value`, `label` — all three the product requires), or
+ * `undefined` when the row has no `options` array. A malformed entry is left
+ * out, not coerced: `{ id: 'o1', value: 1 }` is not rewritten to
+ * `value: '1', label: ''`. Decompile (human task and quick-form escalation)
+ * reads through this, so a canvas dropdown's choices survive an edit.
+ *
+ * @example
+ * liftFormFieldOptions([{ id: 'o1', value: 'a', label: 'A' }, { id: 'o2', value: 2 }])
+ * // [{ id: 'o1', value: 'a', label: 'A' }]
+ */
+export function liftFormFieldOptions(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    return raw.filter(isFormFieldOption).map((o) => ({ id: o.id, value: o.value, label: o.label }));
+}
+/**
+ * What is wrong with a form field's `options`, or `undefined` when nothing is.
+ * `check` reports each (human task and quick-form escalation):
+ *
+ * - `'malformed'`: `options` is there but is not an array of `{ id, value,
+ *   label }` strings. Serialize would throw or write rows the platform refuses.
+ * - `'missing'`: a choice-control type (`singleSelect`, `multiSelect`, `enum`)
+ *   with no choices. The form publishes an empty picker.
+ * - `'ignored'`: choices on a type that is not a choice control. The form
+ *   renders a plain input and never shows them.
+ *
+ * @example
+ * formFieldOptionsProblem('singleSelect', undefined)                         // 'missing'
+ * formFieldOptionsProblem('singleSelect', {})                                // 'malformed'
+ * formFieldOptionsProblem('string', [{ id: 'o1', value: 'a', label: 'A' }]) // 'ignored'
+ * formFieldOptionsProblem('enum', [{ id: 'o1', value: 'a', label: 'A' }])   // undefined
+ */
+export function formFieldOptionsProblem(type, options) {
+    if (options !== undefined && (!Array.isArray(options) || !options.every(isFormFieldOption)))
+        return 'malformed';
+    const isControl = controlFormFieldType(type) !== undefined;
+    if (isControl && (options === undefined || options.length === 0))
+        return 'missing';
+    if (!isControl && options !== undefined && options.length > 0)
+        return 'ignored';
+    return undefined;
+}
+/**
+ * The reason text for a `formFieldOptionsProblem`, worded for a diagnostic
+ * that starts "… the field "<id>" …".
+ */
+export function formFieldOptionsWhy(problem, type) {
+    switch (problem) {
+        case 'malformed':
+            return `has \`options\` that are not a list of { id, value, label } strings. Serialize cannot write them, `
+                + `and the platform requires all three on every choice`;
+        case 'missing':
+            return `is a ${JSON.stringify(type)} picker with no \`options\`, so the form publishes an empty picker`;
+        case 'ignored':
+            return `has \`options\` but its type ${JSON.stringify(type)} is not a choice control, so the form renders a `
+                + `plain input and never shows them. Use 'singleSelect' or 'enum' (a dropdown) or 'multiSelect'`;
+    }
 }
-/** JSON-Schema type per form-field type, as flow-v1's form serializer maps them (quick-form escalations and human tasks). */
-export const FORM_FIELD_JSON_TYPE = {
-    text: { type: 'string' },
-    number: { type: 'number' },
-    boolean: { type: 'boolean' },
-    'date-time': { type: 'string', format: 'date-time' },
-};

package/dist/decompile.js

@@ -50,7 +50,7 @@ import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
 import { contributionPort, forwardFanOut } from './core/definition-handles.js';
 import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
-import { sdkFormFieldType } from './core/form-field-type.js';
+import { liftFormFieldOptions, sourceFormFieldType } from './core/form-field-type.js';
 /**
  * The trigger id of the flow currently being decompiled, so a reference through a
  * RENAMED trigger is still recognized as `input('x')` rather than falling back to
@@ -1304,8 +1304,14 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['description', rPlain(e, 'description') !== undefined ? tsLiteral(rPlain(e, 'description')) : undefined],
             ['fields', rows.length ? `[${rows.map((f) => opts([
                     ['id', tsText(f.id)],
-                    ['type', tsLiteral(sdkFormFieldType(f.type ?? 'text') ?? String(f.type))],
+                    ['type', tsLiteral(sourceFormFieldType(f.type ?? 'string'))],
                     ['direction', tsLiteral(String(f.direction ?? 'output'))],
+                    ['options', (() => {
+                            const options = liftFormFieldOptions(f.options);
+                            return options === undefined ? undefined : `[${options.map((o) => opts([
+                                ['id', tsLiteral(o.id)], ['value', tsLiteral(o.value)], ['label', tsLiteral(o.label)],
+                            ])).join(', ')}]`;
+                        })()],
                 ])).join(', ')}]` : undefined],
             ['app', app === undefined ? undefined : opts([
                     ['key', tsText(app.key)],

package/dist/nodes/hitl/flow/check.js

@@ -1,6 +1,6 @@
 import { Expr } from '../../../core/expr.js';
 import { nearestName } from '../../../core/edit-distance.js';
-import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy } from '../../../core/form-field-type.js';
+import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText } from '../../../core/form-field-type.js';
 import { isAnswerField } from '../../../core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, outcomeIdOf } from '../../../core/hitl-routing.js';
 export const HITL_DIAGNOSTICS = {
@@ -23,6 +23,8 @@ export const HITL_DIAGNOSTICS = {
     HITL_DUP_FIELD: { severity: 'error', summary: 'a form field id declared twice' },
     HITL_FIELD_RESERVED_ID: { severity: 'error', summary: 'a form field id the result already uses' },
     HITL_FIELD_TYPE_UNKNOWN: { severity: 'error', summary: 'a form field type the platform does not recognize' },
+    HITL_FIELD_OPTIONS: { severity: 'error', summary: 'a picker with no choices, or choices that are not { id, value, label } strings' },
+    HITL_FIELD_OPTIONS_IGNORED: { severity: 'warning', summary: 'choices on a field type that does not render them' },
     HITL_FIELD_NO_VALUE: { severity: 'error', summary: 'a shown field with no value' },
     HITL_FIELD_VALUE_NOT_REF: { severity: 'error', summary: 'a shown field filled from a literal' },
     HITL_FIELD_VALUE_NOT_PATH: { severity: 'error', summary: 'a shown field filled from a computed expression' },
@@ -213,7 +215,11 @@ export function checkHitl(inputs, ctx) {
         }
         if (!FORM_FIELD_TYPES.includes(String(f?.type))) {
             at('HITL_FIELD_TYPE_UNKNOWN', `Human task "${step}" gives the form field "${id}" the type ${JSON.stringify(f?.type)}, `
-                + `${formFieldTypeWhy(f?.type)}. Valid: ${FORM_FIELD_TYPES.join(', ')}.`, formFieldTypeHint(f?.type));
+                + `${formFieldTypeWhy(f?.type)}. Valid: ${validFormFieldTypesText()}.`, formFieldTypeHint(f?.type));
+        }
+        const optionsProblem = formFieldOptionsProblem(f?.type, f.options);
+        if (optionsProblem !== undefined) {
+            at(optionsProblem === 'ignored' ? 'HITL_FIELD_OPTIONS_IGNORED' : 'HITL_FIELD_OPTIONS', `Human task "${step}"'s form field "${id}" ${formFieldOptionsWhy(optionsProblem, f?.type)}.`, `options: [{ id: 'opt-1', value: 'high', label: 'High' }, { id: 'opt-2', value: 'low', label: 'Low' }]`);
         }
         if (isAnswerField(f))
             answers++; // an `output`, or an `inOut` whose reviewed value comes back

package/dist/nodes/hitl/flow/node-type.js

@@ -13,11 +13,10 @@
  * every edge out of an outcome-handle node to.
  */
 import { Expr, toExpr } from '../../../core/expr.js';
-import { FORM_FIELD_JSON_TYPE, sdkFormFieldType } from '../../../core/form-field-type.js';
+import { formFieldJsonSchema, formFieldOptionsWire, liftFormFieldOptions, sourceFormFieldType } from '../../../core/form-field-type.js';
 import { isAnswerField } from '../../../core/hitl-answers.js';
 import { OUTCOME_HANDLE_NODE_TYPES, hitlExitModel, outcomeIdOf, outcomeSlug } from '../../../core/hitl-routing.js';
 import { jsonClone } from '../../../core/json-clone.js';
-import { ownEntry } from '../../../core/own-entry.js';
 import { schemaId } from '../../../core/stable-id.js';
 import { wireExprBody } from '../../../core/wire-expr.js';
 import { checkHitl, checkHitlRead } from './check.js';
@@ -87,6 +86,11 @@ function hitlInputs(inputs, nodeType, ctx) {
             if (f.required)
                 base.required = true;
         }
+        // A picker's choices (a `singleSelect` dropdown, a `multiSelect`), as the
+        // canvas stores them on the row (#1235).
+        const options = formFieldOptionsWire(f.options);
+        if (options !== undefined)
+            base.options = options;
         return base;
     });
     const outcomes = (inputs?.outcomes ?? []).map((o, i) => {
@@ -99,7 +103,7 @@ function hitlInputs(inputs, nodeType, ctx) {
         // inOut fields land in the answers too — their reviewed value flows back.
         if (!isAnswerField(f))
             continue;
-        properties[f.id] = { ...ownEntry(FORM_FIELD_JSON_TYPE, String(f.type)) };
+        properties[f.id] = { ...formFieldJsonSchema(f.type) };
     }
     const names = outcomes.map((o) => o.name).filter((n) => typeof n === 'string');
     if (names.length > 0) {
@@ -327,15 +331,18 @@ function liftHitl(node, typeName, ctx) {
         const id = String(f.id ?? '');
         const direction = String(f.direction ?? 'output');
         const value = direction === 'input' || direction === 'inOut' ? bindingExpr(f.binding) : undefined;
+        const options = liftFormFieldOptions(f.options);
         return {
             id,
             // serialize defaults a row's label to its id.
             ...(typeof f.label === 'string' && f.label !== id ? { label: f.label } : {}),
-            // The product's own spelling (`"string"`, `"datetime"`, …) → the SDK's (#1143).
-            type: sdkFormFieldType(f.type ?? 'text') ?? String(f.type),
+            // A type the SDK accepts stays as written, so the form compiles back to
+            // the same bytes; a .NET alias becomes its canonical type (#1143, #1176).
+            type: sourceFormFieldType(f.type ?? 'string'),
             direction,
             ...(value !== undefined ? { value } : {}),
             ...(f.required === true ? { required: true } : {}),
+            ...(options !== undefined ? { options } : {}),
         };
     });
     const outcomeRows = (Array.isArray(schema.outcomes) ? schema.outcomes : []);
@@ -498,6 +505,11 @@ function printHitl({ inputs }, ctx) {
         ['direction', ctx.string(f.direction)],
         ['value', f.value !== undefined ? ctx.value(f.value) : undefined],
         ['required', f.required ? 'true' : undefined],
+        ['options', f.options !== undefined ? `[${f.options.map((o) => obj([
+                ['id', ctx.string(o.id)],
+                ['value', ctx.string(o.value)],
+                ['label', ctx.string(o.label)],
+            ], ctx)).join(', ')}]` : undefined],
     ], ctx));
     const outcomes = h.outcomes.map((o) => (typeof o === 'string' ? ctx.string(o) : obj([
         ['name', ctx.string(o.name)],

package/dist/serialize.js

@@ -20,7 +20,7 @@ import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
 import { resolveVersionCarried } from './core/nodes/versioned.js';
 import { indexCarriedDefinitions } from './core/carried-definitions.js';
-import { FORM_FIELD_JSON_TYPE } from './core/form-field-type.js';
+import { formFieldJsonSchema, formFieldOptionsWire } from './core/form-field-type.js';
 import { ConnectorResolveError } from './core/connector-resolve-error.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
@@ -1362,7 +1362,7 @@ function escalationResourceJson(esc, spec) {
         const fields = esc.fields ?? [];
         const props = (dirs) => Object.fromEntries(fields
             .filter((f) => dirs.includes(f.direction))
-            .map((f) => [f.id, ownEntry(FORM_FIELD_JSON_TYPE, String(f.type)) ?? { type: 'string' }]));
+            .map((f) => [f.id, formFieldJsonSchema(f.type) ?? { type: 'string' }]));
         channel = {
             ...common,
             type: 'actionCenterQuickForm',
@@ -5533,12 +5533,17 @@ export function serialize(built, opts = {}) {
                     const qnode = makeNode(qdef.nodeType, qid, esc.name, { parentId, def: qdef });
                     qnode.display = { ...qnode.display, shape: 'circle' };
                     delete qnode.model;
-                    const rows = (esc.fields ?? []).map((f) => ({
-                        id: f.id,
-                        label: f.label ?? f.id,
-                        type: f.type,
-                        direction: f.direction,
-                    }));
+                    const rows = (esc.fields ?? []).map((f) => {
+                        const options = formFieldOptionsWire(f.options);
+                        return {
+                            id: f.id,
+                            label: f.label ?? f.id,
+                            type: f.type,
+                            direction: f.direction,
+                            // A picker's choices, as the human task's rows carry them (#1235).
+                            ...(options !== undefined ? { options } : {}),
+                        };
+                    });
                     const qsource = fnv1aX4Uuid(`${built.id}/${step.name}/escalation/${esc.name}`);
                     qnode.inputs = {
                         source: qsource,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.31.7",
+  "version": "6.31.9",
   "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": "99f1861467ac06fba1c816f365bf027e1e2c8e05"
+  "gitref": "e812e24ab6455bcc1ffeb6f806e9cd0d09cbe389"
 }