@uipath/maestro-builder-sdk 6.66.6 → 6.66.8

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

@@ -1,4 +1,3 @@
-import { Expr } from '../../../core/expr.js';
 import { nearestName } from '../../../core/edit-distance.js';
 import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldSettingProblems, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText, } from '../../../core/form-field-type.js';
 import { isAnswerField } from '../../../core/hitl-answers.js';
@@ -85,15 +84,18 @@ export function checkHitl(inputs, ctx) {
     // Which of the three human-task node types this step emits. The two suffixed
     // variants differ in exactly one authoring-visible way — who OWNS the form —
     // and that is what the next four rules are about.
+    //
+    // What the serializer cannot write faithfully is refused there, and reported
+    // from there (`refuseUnwritable` in node-type.ts, #1518): HITL_VARIANT_UNKNOWN,
+    // HITL_DOCUMENT_WITHOUT_VARIANT, DOCVAL_NO_EXTRACTION, DOCVAL_TAXONOMY_REQUIRED,
+    // DOCVAL_RENDER_UNKNOWN, HITL_APP_WITHOUT_VARIANT, HITL_APP_INCOMPLETE,
+    // HITL_APP_SCHEMA_INVALID, HITL_APP_OUTCOME_UNKNOWN, HITL_APP_LOCAL_HAS_FOLDER,
+    // HITL_FIELD_NO_ID, HITL_FIELD_VARIABLE, HITL_FIELD_VALUE_NOT_REF,
+    // HITL_FIELD_VALUE_NOT_PATH and HITL_OUTCOME_BAD_ID. The rules below still stop
+    // where those used to, so a task they refuse gets no follow-on findings.
     const variant = inputs?.variant;
-    if (variant !== undefined && variant !== 'quick-form' && variant !== 'action-app'
-        && variant !== 'document-validation') {
-        const nearest = nearestName(String(variant), HITL_VARIANTS);
-        at('HITL_VARIANT_UNKNOWN', `Human task "${step}" names the variant ${JSON.stringify(variant)}, which is not a human-task `
-            + `node type that resolves on this tenant. Valid: ${HITL_VARIANTS.join(', ')} — or omit it for `
-            + `the default node type (uipath.human-in-the-loop).`, nearest !== undefined ? `variant: '${nearest}'` : `Omit \`variant\`.`);
-        return;
-    }
+    if (variant !== undefined && !HITL_VARIANTS.includes(variant))
+        return; // HITL_VARIANT_UNKNOWN
     const isApp = variant === 'action-app';
     const isDocval = variant === 'document-validation';
     // The error output is the BASE node's 1.2 definition, which no variant has.
@@ -127,12 +129,8 @@ export function checkHitl(inputs, ctx) {
             ? 'outcomePorts: false (every outcome continues to the next step), or outcomePorts: true / .stepSwitch (route each one)'
             : 'Drop `legacyCompleted`: one outcome continues to the next step on its own handle.');
     }
-    if (inputs?.document !== undefined && !isDocval) {
-        at('HITL_DOCUMENT_WITHOUT_VARIANT', `Human task "${step}" names a document to validate, but its variant is `
-            + `${variant === undefined ? 'the default node type' : `"${variant}"`} — only the validation `
-            + `station reads it, so it would be emitted and ignored.`, `variant: 'document-validation'`);
-        return;
-    }
+    if (inputs?.document !== undefined && !isDocval)
+        return; // HITL_DOCUMENT_WITHOUT_VARIANT
     if (isDocval) {
         if (Array.isArray(inputs?.fields) && inputs.fields.length > 0) {
             at('HITL_DOCVAL_WITH_FIELDS', `Human task "${step}" is a Document Validation task but also declares ${inputs.fields.length} `
@@ -145,31 +143,12 @@ export function checkHitl(inputs, ctx) {
                 + `has nothing to validate.`, `document: { extractionResult: out('<extractStep>', 'ExtractionResult') }`);
             return;
         }
-        const er = doc.extractionResult;
-        const erEmpty = er === undefined || er === null || (typeof er === 'string' && !er.trim());
-        if (erEmpty) {
-            at('DOCVAL_NO_EXTRACTION', `Human task "${step}" gives the validation station no extractionResult. Bind the `
-                + `ExtractionResult output of the upstream extract step — the platform's own validator `
-                + `rejects the node without it.`, `extractionResult: out('<extractStep>', 'ExtractionResult')`);
-        }
-        if (doc.render === 'custom') {
-            const tx = doc.taxonomy;
-            if (tx === undefined || tx === null || (typeof tx === 'string' && !tx.trim())) {
-                at('DOCVAL_TAXONOMY_REQUIRED', `Human task "${step}" renders validation in a custom app (render: 'custom') but names no `
-                    + `taxonomy — the platform requires one for the app's Validation Control.`, `taxonomy: out('<classifyStep>', 'taxonomy')  // or the taxonomy id string`);
-            }
-        }
-        else if (doc.render !== undefined && doc.render !== 'standard') {
-            at('DOCVAL_RENDER_UNKNOWN', `Human task "${step}" gives the validation render type ${JSON.stringify(doc.render)}. Valid: `
-                + `'standard' (the native station, the default) or 'custom' (an app with a Validation Control).`, `render: 'standard'`);
-        }
+        // Its extractionResult, render and taxonomy are the serializer's
+        // DOCVAL_NO_EXTRACTION, DOCVAL_RENDER_UNKNOWN and DOCVAL_TAXONOMY_REQUIRED.
         // No inline form — skip the field rules; outcomes still route, fall through.
     }
     if (!isApp && !(isDocval && inputs?.document?.render === 'custom') && inputs?.app !== undefined) {
-        at('HITL_APP_WITHOUT_VARIANT', `Human task "${step}" names a deployed app, but its variant is `
-            + `${variant === undefined ? 'the default node type' : `"${variant}"`}, whose form lives in the `
-            + `flow. The app would be emitted and then ignored — the reviewer still gets the inline form.`, `variant: 'action-app'`);
-        return;
+        return; // HITL_APP_WITHOUT_VARIANT
     }
     if (isApp) {
         // The app owns the form, so `fields` is not merely unnecessary here — it is a
@@ -186,25 +165,11 @@ export function checkHitl(inputs, ctx) {
                 + `App — but names no app, so nothing tells the platform which form to show.`, `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
             return;
         }
-        // An in-solution app has no folder to author. A published one does: with
-        // none it is serialized as an inline app, and on a serializer before
-        // flow-v1 #4076 the task loses its folderPath context and fails at run
-        // time (170004, "Invalid input for the HITL task").
+        // A missing name, key or folder is the serializer's HITL_APP_INCOMPLETE.
         const inSolution = app.location === 'in-solution';
         for (const k of inSolution ? ['name', 'key'] : ['name', 'key', 'folderPath']) {
-            if (typeof app[k] !== 'string' || !app[k].trim()) {
-                at('HITL_APP_INCOMPLETE', inSolution
-                    ? `Human task "${step}" names an in-solution Action App with no ${k}. An in-solution app is `
-                        + `resolved by its key (\`resource.key\` in resources/solution_folder/app/codedAction/<App>.json), `
-                        + `with the name shown to the reviewer — both are needed for the platform to find it.`
-                    : `Human task "${step}" names an Action App with no ${k}. An app is resolved by its key plus `
-                        + `the folder it is deployed in, with the name shown to the reviewer — all three are needed `
-                        + `for the platform to find it. If the app is in the same solution as the flow, set `
-                        + `\`location: 'in-solution'\` instead of a folder.`, inSolution
-                    ? `app: { name: 'InvoiceReview', key: '<resource.key>', location: 'in-solution' }`
-                    : `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
+            if (typeof app[k] !== 'string' || !app[k].trim())
                 return;
-            }
         }
         // The app's action schema: what types its inputs, and what it answers.
         const bound = Object.keys(app.inputs ?? {});
@@ -218,10 +183,7 @@ export function checkHitl(inputs, ctx) {
             }
         }
         else if (typeof contract === 'string') {
-            at('HITL_APP_SCHEMA_INVALID', `Human task "${step}" gives its Action App a schema that is not usable: ${contract}. `
-                + `Pass the app's action-schema.json verbatim, or the platform's action schema (its `
-                + `inputs/outputs/inOuts/outcomes arrays).`);
-            return;
+            return; // HITL_APP_SCHEMA_INVALID
         }
         else {
             const names = contract.inputs;
@@ -237,22 +199,8 @@ export function checkHitl(inputs, ctx) {
                 at('HITL_APP_INPUT_REQUIRED', `Human task "${step}" leaves the Action App's required input(s) ${missing.join(', ')} unbound, `
                     + `so the task's arguments fail the app's own schema.`, `inputs: { ${missing.map((m) => `${JSON.stringify(m)}: …`).join(', ')} }`);
             }
-            if (contract.outcomes.length > 0) {
-                for (const o of Array.isArray(inputs?.outcomes) ? inputs.outcomes : []) {
-                    const name = typeof o === 'string' ? o : o?.name;
-                    if (typeof name === 'string' && name !== '' && !contract.outcomes.includes(name)) {
-                        const nearest = nearestName(name, contract.outcomes);
-                        at('HITL_APP_OUTCOME_UNKNOWN', `Human task "${step}" routes on the outcome "${name}", but its Action App completes only with `
-                            + `${contract.outcomes.join(', ')}. The reviewer can never pick it.`, nearest !== undefined ? `'${nearest}'` : undefined);
-                    }
-                }
-            }
-        }
-        if (inSolution && app.folderPath !== undefined && app.folderPath !== '') {
-            at('HITL_APP_LOCAL_HAS_FOLDER', `Human task "${step}" names an in-solution Action App with folderPath ${JSON.stringify(app.folderPath)}. `
-                + `An in-solution app has no folder — it is emitted with the empty folder the platform's app picker `
-                + `writes for an app inline to the solution — so the value would be dropped. Remove it, or drop `
-                + `\`location: 'in-solution'\` to call an app published to that folder.`, `Delete \`folderPath\`.`);
+            // An outcome the app does not declare is the serializer's HITL_APP_OUTCOME_UNKNOWN,
+            // and an in-solution app's folderPath its HITL_APP_LOCAL_HAS_FOLDER.
         }
         // Outcomes still matter for an app task: the flow's own routing and its
         // `Action`/`status` outputs are derived from them, so fall through to the
@@ -268,14 +216,10 @@ export function checkHitl(inputs, ctx) {
     }
     const seen = new Set();
     let answers = 0;
-    fields.forEach((f, i) => {
-        const where = `fields[${i}]`;
+    fields.forEach((f) => {
         const id = typeof f?.id === 'string' ? f.id.trim() : '';
-        if (!id) {
-            at('HITL_FIELD_NO_ID', `Human task "${step}" has a form field with no id (${where}). The id is the key the `
-                + `reviewer's answer comes back under, so a field without one is dropped.`, `id: 'amount'`);
-            return;
-        }
+        if (!id)
+            return; // HITL_FIELD_NO_ID
         if (seen.has(id)) {
             at('HITL_DUP_FIELD', `Human task "${step}" declares the form field "${id}" twice. The answer object is keyed `
                 + `by field id, so the second silently replaces the first.`, `Rename one of them.`);
@@ -299,20 +243,8 @@ export function checkHitl(inputs, ctx) {
         for (const problem of formFieldSettingProblems(f)) {
             at('HITL_FIELD_SETTING_INVALID', `Human task "${step}" gives the form field "${id}" ${problem}. The platform refuses the form.`);
         }
-        // The landing variable is read as `$vars.<variable>`, so it has to be one
-        // identifier — not a path, not a `vars.` prefix — and only an asked field
-        // has one: a shown field's row is written without it (#1309).
-        const variable = f?.variable;
-        if (variable !== undefined) {
-            if (f?.direction !== 'output') {
-                at('HITL_FIELD_VARIABLE', `Human task "${step}"'s form field "${id}" sets \`variable\` on a ${f?.direction === 'inOut' ? 'pre-filled' : 'shown'} field. `
-                    + `Only an asked field (direction 'output') lands its answer in a variable; the SDK writes the row without one.`, 'Drop `variable`, or make the field direction: \'output\'.');
-            }
-            else if (typeof variable !== 'string' || !/^[A-Za-z_$][\w$]*$/.test(variable)) {
-                at('HITL_FIELD_VARIABLE', `Human task "${step}"'s form field "${id}" has variable ${JSON.stringify(variable)}, which is not one identifier. `
-                    + `It is read as $vars.<variable>, so give the name only — no \`vars.\` prefix, no dots.`, typeof variable === 'string' && variable.startsWith('vars.') ? `variable: '${variable.slice(5)}'` : `variable: '${step}_${id}'`);
-            }
-        }
+        // A `variable` on a row that has none, or one that is no identifier, is the
+        // serializer's HITL_FIELD_VARIABLE (#1309).
         if (isAnswerField(f))
             answers++; // an `output`, or an `inOut` whose reviewed value comes back
         if (f?.direction === 'input' || f?.direction === 'inOut') {
@@ -321,20 +253,8 @@ export function checkHitl(inputs, ctx) {
                 at('HITL_FIELD_NO_VALUE', `Human task "${step}" shows the form field "${id}" to the reviewer but gives it no value, `
                     + `so the field renders empty — the flow says "show them this" and shows them nothing.`, `value: input('<flowInput>')  // or out('<step>', '<field>')`);
             }
-            else if (!(value instanceof Expr)) {
-                at('HITL_FIELD_VALUE_NOT_REF', `Human task "${step}" gives the form field "${id}" a raw `
-                    + `${Array.isArray(value) ? 'array' : typeof value} as its value. A shown field is filled `
-                    + `from a variable PATH, not a constant — the platform reads the string as a lookup, so a `
-                    + `literal resolves to nothing on the form.`, `value: input('<flowInput>')`);
-            }
-            else if (value.literal || !/^\$vars\.[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/.test(value.js.trim())) {
-                // Same trap as a transform's `collection`: a computed expression resolves
-                // locally and to nothing once deployed, where it is used as a path.
-                at('HITL_FIELD_VALUE_NOT_PATH', `Human task "${step}" fills the form field "${id}" from the expression `
-                    + `"${value.literal ? String(value.value) : value.js.trim().slice(0, 60)}". A field binding is `
-                    + `a variable PATH, so a computed expression resolves to nothing on the deployed form. `
-                    + `Compute it in a script step first and point the field at that step's output.`, `value: out('<scriptStep>')`);
-            }
+            // A value that is no `$vars.` path is the serializer's HITL_FIELD_VALUE_NOT_REF
+            // (a constant) or HITL_FIELD_VALUE_NOT_PATH (an expression).
         }
         else if (f?.direction !== 'output') {
             at('HITL_FIELD_DIRECTION', `Human task "${step}" gives the form field "${id}" the direction `
@@ -359,8 +279,7 @@ export function checkHitl(inputs, ctx) {
         const id = outcomeIdOf(o, i);
         const explicitId = typeof o === 'object' && o !== null ? o.id : undefined;
         if (explicitId !== undefined && (typeof explicitId !== 'string' || explicitId === '')) {
-            at('HITL_OUTCOME_BAD_ID', `Human task "${step}" outcome ${JSON.stringify(name ?? i)} has an id that is not a non-empty string. `
-                + `Leave \`id\` out to use the slug of the name.`, `{ name: ${JSON.stringify(name ?? 'Approve')} }`);
+            // The serializer's HITL_OUTCOME_BAD_ID; the id it would get is no clash to report.
         }
         else if (ids.has(id) && ids.get(id) !== String(name ?? '')) {
             // Same name, same id: HITL_DUP_OUTCOME below reports it once, as a name clash.

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

@@ -17,9 +17,10 @@ import { formFieldJsonSchema, formFieldRowLoss, formFieldRowLossMessage, formFie
 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 { nearestName } from '../../../core/edit-distance.js';
 import { schemaId } from '../../../core/stable-id.js';
 import { wireExprBody } from '../../../core/wire-expr.js';
-import { appAnswerSchemas, appInputSchema, liftActionSchema, normalizeActionSchema } from './action-schema.js';
+import { appAnswerSchemas, appContract, appInputSchema, liftActionSchema, normalizeActionSchema } from './action-schema.js';
 import { checkHitl, checkHitlRead } from './check.js';
 import { CompileRefusal } from '../../../core/compile-refusal.js';
 import { processResourceBindings } from '../../../core/process-resource.js';
@@ -287,7 +288,7 @@ function appBindingExpr(value, ctx) {
  * A shown field's `binding`: the platform resolves it as a path against the
  * workflow's variables (`vars.<flowInput>`, `vars.<node>.output.<field>`), so the
  * `$vars.` prefix our expressions carry is dropped. A computed expression cannot
- * be a path — `check` rejects one (HITL_FIELD_VALUE_NOT_PATH) before we get here.
+ * be a path — `refuseUnwritable` refuses one (HITL_FIELD_VALUE_NOT_PATH) before we get here.
  */
 function bindingPath(value, ctx) {
     if (!(value instanceof Expr))
@@ -300,6 +301,171 @@ function bindingPath(value, ctx) {
     // `__hitlInputBindings` the designer reads back stores the binding verbatim.
     return path.startsWith('vars.') ? path : `vars.${path}`;
 }
+/**
+ * The human-task shapes this serializer cannot write faithfully, refused while
+ * the node is emitted (#1518). `compile` no longer runs `check` (#1497), so
+ * without these each one compiled clean into a `.flow` that dropped, rewrote or
+ * invented what the author wrote. For instance an unknown `variant: 'quik-form'`
+ * became a plain base node, `document: {}` became the extraction result
+ * `"undefined"`, and an asked field with no id landed in `vars.undefined`.
+ * `check` reports the same refusals, on the step, from this one place (collect
+ * mode). Every condition each code names is refused, the lossy shape and the
+ * rest alike: the rest are tasks the platform cannot run as written (a blank
+ * extraction result, an app it cannot find, a computed field binding that
+ * resolves to nothing), and `compile` refused all of them before #1497.
+ * The checks run in `checkHitl`'s order, so the first refusal is the one
+ * `check` used to report first.
+ */
+function refuseUnwritable(inputs, typeName, step) {
+    const variant = inputs?.variant;
+    const isApp = typeName === ACTION_APP;
+    const isDocval = typeName === DOC_VALIDATION;
+    const variantText = variant === undefined ? 'the default node type' : `"${variant}"`;
+    // An unknown variant resolves to the base node type (`matches`), so the
+    // variant the author named would leave no trace in the `.flow`.
+    if (variant !== undefined && !VARIANTS.includes(variant)) {
+        const nearest = nearestName(String(variant), [...VARIANTS]);
+        throw new CompileRefusal('HITL_VARIANT_UNKNOWN', `Human task "${step}" names the variant ${JSON.stringify(variant)}, which is not a human-task `
+            + `node type that resolves on this tenant. Valid: ${VARIANTS.join(', ')} — or omit it for `
+            + `the default node type (uipath.human-in-the-loop).`, nearest !== undefined ? `variant: '${nearest}'` : `Omit \`variant\`.`);
+    }
+    // Only the station's node type writes `document` (`docvalInputs`).
+    if (inputs?.document !== undefined && !isDocval) {
+        throw new CompileRefusal('HITL_DOCUMENT_WITHOUT_VARIANT', `Human task "${step}" names a document to validate, but its variant is ${variantText} — only the validation `
+            + `station reads it, so it would be emitted and ignored.`, `variant: 'document-validation'`);
+    }
+    const doc = inputs?.document;
+    if (isDocval && doc && typeof doc === 'object') {
+        // A missing one was written as the text "undefined" (or "null").
+        const er = doc.extractionResult;
+        if (er === undefined || er === null || (typeof er === 'string' && !er.trim())) {
+            throw new CompileRefusal('DOCVAL_NO_EXTRACTION', `Human task "${step}" gives the validation station no extractionResult. Bind the `
+                + `ExtractionResult output of the upstream extract step — the platform's own validator `
+                + `rejects the node without it.`, `extractionResult: out('<extractStep>', 'ExtractionResult')`);
+        }
+        const render = doc.render;
+        if (render === 'custom') {
+            // A null taxonomy was written as the text "null".
+            const tx = doc.taxonomy;
+            if (tx === undefined || tx === null || (typeof tx === 'string' && !tx.trim())) {
+                throw new CompileRefusal('DOCVAL_TAXONOMY_REQUIRED', `Human task "${step}" renders validation in a custom app (render: 'custom') but names no `
+                    + `taxonomy — the platform requires one for the app's Validation Control.`, `taxonomy: out('<classifyStep>', 'taxonomy')  // or the taxonomy id string`);
+            }
+        }
+        else if (render !== undefined && render !== 'standard') {
+            // A null render was written as 'standard'.
+            throw new CompileRefusal('DOCVAL_RENDER_UNKNOWN', `Human task "${step}" gives the validation render type ${JSON.stringify(render)}. Valid: `
+                + `'standard' (the native station, the default) or 'custom' (an app with a Validation Control).`, `render: 'standard'`);
+        }
+    }
+    // Only an app task and a custom-render station write `app` (`emitsApp`).
+    if (!isApp && !(isDocval && doc?.render === 'custom') && inputs?.app !== undefined) {
+        throw new CompileRefusal('HITL_APP_WITHOUT_VARIANT', `Human task "${step}" names a deployed app, but its variant is ${variantText}, whose form lives in the `
+            + `flow. The app would be emitted and then ignored — the reviewer still gets the inline form.`, `variant: 'action-app'`);
+    }
+    const app = inputs?.app;
+    if (isApp && app && typeof app === 'object') {
+        // A published app with no folder was written with folderPath '', byte for
+        // byte an in-solution app.
+        const inSolution = app.location === 'in-solution';
+        for (const k of inSolution ? ['name', 'key'] : ['name', 'key', 'folderPath']) {
+            if (typeof app[k] !== 'string' || !app[k].trim()) {
+                throw new CompileRefusal('HITL_APP_INCOMPLETE', inSolution
+                    ? `Human task "${step}" names an in-solution Action App with no ${k}. An in-solution app is `
+                        + `resolved by its key (\`resource.key\` in resources/solution_folder/app/codedAction/<App>.json), `
+                        + `with the name shown to the reviewer — both are needed for the platform to find it.`
+                    : `Human task "${step}" names an Action App with no ${k}. An app is resolved by its key plus `
+                        + `the folder it is deployed in, with the name shown to the reviewer — all three are needed `
+                        + `for the platform to find it. If the app is in the same solution as the flow, set `
+                        + `\`location: 'in-solution'\` instead of a folder.`, inSolution
+                    ? `app: { name: 'InvoiceReview', key: '<resource.key>', location: 'in-solution' }`
+                    : `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
+            }
+        }
+        // An unusable actionSchema was dropped; with an inputSchema too, the
+        // inputSchema was replaced by the lowered actionSchema.
+        const contract = appContract(app);
+        if (typeof contract === 'string') {
+            throw new CompileRefusal('HITL_APP_SCHEMA_INVALID', `Human task "${step}" gives its Action App a schema that is not usable: ${contract}. `
+                + `Pass the app's action-schema.json verbatim, or the platform's action schema (its `
+                + `inputs/outputs/inOuts/outcomes arrays).`);
+        }
+        // The schema's outcome list is not written, so the mismatch would be gone.
+        if (contract !== undefined && contract.outcomes.length > 0) {
+            for (const o of Array.isArray(inputs?.outcomes) ? inputs.outcomes : []) {
+                const name = typeof o === 'string' ? o : o?.name;
+                if (typeof name === 'string' && name !== '' && !contract.outcomes.includes(name)) {
+                    const nearest = nearestName(name, contract.outcomes);
+                    throw new CompileRefusal('HITL_APP_OUTCOME_UNKNOWN', `Human task "${step}" routes on the outcome "${name}", but its Action App completes only with `
+                        + `${contract.outcomes.join(', ')}. The reviewer can never pick it.`, nearest !== undefined ? `'${nearest}'` : undefined);
+                }
+            }
+        }
+        // An in-solution app is written with folderPath '' whatever the source says.
+        if (inSolution && app.folderPath !== undefined && app.folderPath !== '') {
+            throw new CompileRefusal('HITL_APP_LOCAL_HAS_FOLDER', `Human task "${step}" names an in-solution Action App with folderPath ${JSON.stringify(app.folderPath)}. `
+                + `An in-solution app has no folder — it is emitted with the empty folder the platform's app picker `
+                + `writes for an app inline to the solution — so the value would be dropped. Remove it, or drop `
+                + `\`location: 'in-solution'\` to call an app published to that folder.`, `Delete \`folderPath\`.`);
+        }
+    }
+    // An app task or a validation station drops `fields` (check's
+    // HITL_APP_WITH_FIELDS / HITL_DOCVAL_WITH_FIELDS), so its rows are never
+    // written and the field rules do not apply — matching `checkHitl`.
+    const fields = !isApp && !isDocval && Array.isArray(inputs?.fields) ? inputs.fields : [];
+    fields.forEach((f, i) => {
+        // An asked field with no id landed in `vars.undefined`.
+        const id = typeof f?.id === 'string' ? f.id.trim() : '';
+        if (!id) {
+            throw new CompileRefusal('HITL_FIELD_NO_ID', `Human task "${step}" has a form field with no id (fields[${i}]). The id is the key the `
+                + `reviewer's answer comes back under, so a field without one is dropped.`, `id: 'amount'`);
+        }
+        // Only an asked row is written with a `variable`, as `vars.<variable>`.
+        const variable = f.variable;
+        if (variable !== undefined) {
+            if (f.direction !== 'output') {
+                throw new CompileRefusal('HITL_FIELD_VARIABLE', `Human task "${step}"'s form field "${id}" sets \`variable\` on a ${f.direction === 'inOut' ? 'pre-filled' : 'shown'} field. `
+                    + `Only an asked field (direction 'output') lands its answer in a variable; the SDK writes the row without one.`, 'Drop `variable`, or make the field direction: \'output\'.');
+            }
+            if (typeof variable !== 'string' || !/^[A-Za-z_$][\w$]*$/.test(variable)) {
+                throw new CompileRefusal('HITL_FIELD_VARIABLE', `Human task "${step}"'s form field "${id}" has variable ${JSON.stringify(variable)}, which is not one identifier. `
+                    + `It is read as $vars.<variable>, so give the name only — no \`vars.\` prefix, no dots.`, typeof variable === 'string' && variable.startsWith('vars.') ? `variable: '${variable.slice(5)}'` : `variable: '${step}_${id}'`);
+            }
+        }
+        // A shown row's value is written as a variable path (`bindingPath`): a
+        // constant `'hello'` became the path `hello`, and `lit('hello')` or an
+        // expression not rooted in `$vars.` became `vars.<it>`.
+        if (f.direction === 'input' || f.direction === 'inOut') {
+            const value = f.value;
+            if (value === undefined || value === null)
+                return; // check's HITL_FIELD_NO_VALUE
+            if (!(value instanceof Expr)) {
+                throw new CompileRefusal('HITL_FIELD_VALUE_NOT_REF', `Human task "${step}" gives the form field "${id}" a raw `
+                    + `${Array.isArray(value) ? 'array' : typeof value} as its value. A shown field is filled `
+                    + `from a variable PATH, not a constant — the platform reads the string as a lookup, so a `
+                    + `literal resolves to nothing on the form. If the value already is an \`input(...)\` or `
+                    + `\`out(...)\` reference, two copies of the SDK are loaded: an expression built by the other `
+                    + `copy is not recognised as one — import every helper from one SDK install.`, `value: input('<flowInput>')`);
+            }
+            if (value.literal || !/^\$vars\.[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/.test(value.js.trim())) {
+                throw new CompileRefusal('HITL_FIELD_VALUE_NOT_PATH', `Human task "${step}" fills the form field "${id}" from the expression `
+                    + `"${value.literal ? String(value.value) : value.js.trim().slice(0, 60)}". A field binding is `
+                    + `a variable PATH, so a computed expression resolves to nothing on the deployed form. `
+                    + `Compute it in a script step first and point the field at that step's output.`, `value: out('<scriptStep>')`);
+            }
+        }
+    });
+    // An id that is not a non-empty string was replaced by the name's slug (`outcomeIdOf`).
+    const outcomes = Array.isArray(inputs?.outcomes) ? inputs.outcomes : [];
+    outcomes.forEach((o, i) => {
+        const explicitId = typeof o === 'object' && o !== null ? o.id : undefined;
+        if (explicitId !== undefined && (typeof explicitId !== 'string' || explicitId === '')) {
+            const name = (typeof o === 'string' ? o : o?.name)?.trim();
+            throw new CompileRefusal('HITL_OUTCOME_BAD_ID', `Human task "${step}" outcome ${JSON.stringify(name ?? i)} has an id that is not a non-empty string. `
+                + `Leave \`id\` out to use the slug of the name.`, `{ name: ${JSON.stringify(name ?? 'Approve')} }`);
+        }
+    });
+}
 /**
  * The exits `.stepSwitch` routes over, or why the task has none — read off the
  * same model the task's tails come from.
@@ -639,6 +805,7 @@ function hitlAt(typeName, version, factory) {
                 throw new CompileRefusal('HITL_EXPOSE_ERROR_VERSION', `"${ctx.step}": exposeError needs the task's 1.2 definition, but { version: '${pinned}' } pins it. `
                     + `Drop the pin or match it.`);
             }
+            refuseUnwritable(inputs, typeName, ctx.step);
             const { inputs: nodeInputs, outputs } = hitlInputs(inputs, typeName, ctx);
             // The definition's `outputDefinition` gives the two output SLOTS; the form
             // gives their shape (see hitlInputs), so the instance's outputs replace it.
@@ -696,7 +863,7 @@ function hitlType(typeName, versions, factory, variant) {
         kind: 'hitl', typeName, factory: 'hitl', defaultVersion: '1.0',
         versions: Object.fromEntries(versions.map((v) => [v, hitlAt(typeName, v, factory)])),
         // The base node is the one an absent or UNKNOWN variant resolves to, as it
-        // always has: `check` reports the unknown one (HITL_VARIANT_UNKNOWN).
+        // always has: its serialize refuses the unknown one (HITL_VARIANT_UNKNOWN).
         matches: ({ inputs }) => (variant === undefined
             ? !VARIANTS.includes(inputs?.variant)
             : inputs?.variant === variant),

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

@@ -2,7 +2,7 @@ import { AGENTIC_PROCESS_FORMS } from '../../../core/agentic-process-forms.js';
 import { GUID_RE } from '../../../core/binding-messages.js';
 import { nearestName } from '../../../core/edit-distance.js';
 import { ownEntry } from '../../../core/own-entry.js';
-import { renamedFieldMessage } from '../../../core/process-resource.js';
+import { blank } from '../../../core/process-resource.js';
 export const PROCESS_DIAGNOSTICS = {
     AGENT_EMPTY_INPUT_FLOOR: { severity: 'warning', summary: 'an agent step that binds no inputs' },
     AGENT_EMPTY_RETURNS: { severity: 'warning', summary: 'an agent step with returns: {}' },
@@ -90,16 +90,8 @@ export const PROCESS_DIAGNOSTICS = {
 export function checkRpaWorkflow(inputs, ctx) {
     const step = ctx.step;
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    if (blank(inputs?.key) && !blank(inputs?.process)) {
-        at('RPA_NO_KEY', renamedFieldMessage('RPA', step, 'process'), `key: ${JSON.stringify(inputs.process)}`);
-    }
-    else if (blank(inputs?.key)) {
-        at('RPA_NO_KEY', `RPA step "${step}" has no \`key\`. That is the published process's release key (a GUID), and `
-            + `it becomes part of the node's type — without it there is no process to start. Find it with `
-            + `\`uip or processes list --all-folders --process-type Process\` (the row's \`Key\`).`, `key: '486edc26-0658-4ac1-92c9-1ef953927151'`);
-    }
-    else if (!GUID_RE.test(String(inputs.key).trim())) {
+    // A blank key is the serializer's RPA_NO_KEY (refusals.ts).
+    if (!blank(inputs?.key) && !GUID_RE.test(String(inputs.key).trim())) {
         at('RPA_KEY_NOT_KEY', `RPA step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not a release key. `
             + `\`key\` is the GUID the tenant gives the published process (it becomes the node type's suffix); `
             + `the process's NAME goes in \`name\` and its folder in \`folderPath\`.`, `key: '<guid>', name: ${JSON.stringify(inputs.key)}`);
@@ -121,12 +113,7 @@ export function checkRpaWorkflow(inputs, ctx) {
         at('RPA_LOCAL_PROJECT_ID_NOT_GUID', `In-solution RPA step "${step}" has projectId ${JSON.stringify(inputs.projectId)}, which is not `
             + `the sibling project's GUID. Read \`resource.projectKey\` from the generated resource file.`, `projectId: '<resource.projectKey>'`);
     }
-    if (inSolution && !blank(inputs?.folderPath)) {
-        at('RPA_LOCAL_HAS_FOLDER', `In-solution RPA step "${step}" also sets \`folderPath\` ${JSON.stringify(inputs.folderPath)}. An `
-            + `in-solution sibling has no folder until the solution is deployed — the platform's own manifest `
-            + `writes \`""\` — so the value would be dropped. Remove it, or drop \`location: 'in-solution'\` to `
-            + `call the published copy.`);
-    }
+    // A folderPath beside in-solution is the serializer's RPA_LOCAL_HAS_FOLDER (refusals.ts).
     // The two are swappable by shape, and swapping them is invisible until
     // Orchestrator answers "Folder does not exist or the user does not have access".
     const name = typeof inputs?.name === 'string' ? inputs.name.trim() : '';
@@ -160,16 +147,8 @@ export function checkRpaWorkflow(inputs, ctx) {
 export function checkApiWorkflow(inputs, ctx) {
     const step = ctx.step;
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    if (blank(inputs?.key) && !blank(inputs?.workflow)) {
-        at('APIWF_NO_KEY', renamedFieldMessage('API workflow', step, 'workflow'), `key: ${JSON.stringify(inputs.workflow)}`);
-    }
-    else if (blank(inputs?.key)) {
-        at('APIWF_NO_KEY', `API workflow step "${step}" has no \`key\`. That is the published workflow's key (a GUID), and `
-            + `it becomes part of the node's type — without it there is no workflow to invoke. Find it with `
-            + `\`uip or processes list --all-folders\` (an API workflow's ProcessKey reads "<name>.api.<name>").`, `key: 'ce857908-ee1d-4392-b552-38bcea0be29c'`);
-    }
-    else if (!GUID_RE.test(String(inputs.key).trim())) {
+    // A blank key is the serializer's APIWF_NO_KEY (refusals.ts).
+    if (!blank(inputs?.key) && !GUID_RE.test(String(inputs.key).trim())) {
         at('APIWF_KEY_NOT_KEY', `API workflow step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not a key. `
             + `\`key\` is the GUID the tenant gives the published workflow (it becomes the node type's suffix); `
             + `the workflow's NAME goes in \`name\` and its folder in \`folderPath\`.`, `key: '<guid>', name: ${JSON.stringify(inputs.key)}`);
@@ -208,13 +187,8 @@ export function checkApiWorkflow(inputs, ctx) {
 export function checkPublishedFunction(inputs, ctx) {
     const step = ctx.step;
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    if (blank(inputs?.key)) {
-        at('FUNCTION_NO_KEY', `Function step "${step}" has no \`key\`. That is the published function's key (a GUID), and it becomes `
-            + `part of the node's type — without it there is no function to invoke. Find it with `
-            + `\`uip maestro flow registry search "uipath.core.function"\`.`, `key: '7059bdb5-fdd7-4e13-9d7b-1748aaeb129d'`);
-    }
-    else if (!GUID_RE.test(String(inputs.key).trim())) {
+    // A blank key is the serializer's FUNCTION_NO_KEY (refusals.ts).
+    if (!blank(inputs?.key) && !GUID_RE.test(String(inputs.key).trim())) {
         at('FUNCTION_KEY_NOT_KEY', `Function step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not a key. \`key\` is the `
             + `GUID the tenant gives the published function (it becomes the node type's suffix); the function's NAME `
             + `goes in \`name\` and its folder in \`folderPath\`.`, `key: '<guid>', name: ${JSON.stringify(inputs.key)}`);
@@ -238,12 +212,7 @@ export function checkPublishedFunction(inputs, ctx) {
         at('FUNCTION_LOCAL_PROJECT_ID_NOT_GUID', `In-solution function step "${step}" has projectId ${JSON.stringify(inputs.projectId)}, which is not `
             + `the sibling project's GUID. Read \`resource.projectKey\` from the generated resource file.`, `projectId: '<resource.projectKey>'`);
     }
-    if (inSolution && !blank(inputs?.folderPath)) {
-        at('FUNCTION_LOCAL_HAS_FOLDER', `In-solution function step "${step}" also sets \`folderPath\` ${JSON.stringify(inputs.folderPath)}. An `
-            + `in-solution sibling has no folder until the solution is deployed — the platform's own manifest `
-            + `writes \`""\` — so the value would be dropped. Remove it, or drop \`location: 'in-solution'\` to `
-            + `call the published copy.`);
-    }
+    // A folderPath beside in-solution is the serializer's FUNCTION_LOCAL_HAS_FOLDER (refusals.ts).
     const name = typeof inputs?.name === 'string' ? inputs.name.trim() : '';
     if (name.includes('/')) {
         at('FUNCTION_NAME_IS_PATH', `Function step "${step}"'s \`name\` is ${JSON.stringify(inputs.name)}, which is a folder path. \`name\` is `
@@ -282,17 +251,8 @@ export function checkPublishedFunction(inputs, ctx) {
 export function checkAgenticProcess(inputs, ctx) {
     const step = ctx.step;
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
-    if (blank(inputs?.key) && !blank(inputs?.process)) {
-        at('AGENTIC_NO_KEY', renamedFieldMessage('Agentic process', step, 'process'), `key: ${JSON.stringify(inputs.process)}`);
-    }
-    else if (blank(inputs?.key)) {
-        at('AGENTIC_NO_KEY', `Agentic process step "${step}" has no \`key\`. That is the published process's key (a GUID), `
-            + `and it becomes part of the node's type — without it there is no process to start. Find it with `
-            + `\`uip or processes list --all-folders --limit 100\` (an agentic process's ProcessKey reads `
-            + `"<name>.agentic.<name>"; the listing paginates at 50, so pass a limit or scope it to a folder).`, `key: '4fc450ab-89be-4462-8fc8-21ac4c1d6fb9'`);
-    }
-    else if (!GUID_RE.test(String(inputs.key).trim())) {
+    // A blank key is the serializer's AGENTIC_NO_KEY (refusals.ts).
+    if (!blank(inputs?.key) && !GUID_RE.test(String(inputs.key).trim())) {
         at('AGENTIC_KEY_NOT_KEY', `Agentic process step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not a key. `
             + `\`key\` is the GUID the tenant gives the published process (it becomes the node type's suffix); `
             + `the process's NAME goes in \`name\` and its folder in \`folderPath\`.`, `key: '<guid>', name: ${JSON.stringify(inputs.key)}`);
@@ -337,29 +297,14 @@ export function checkAgenticProcess(inputs, ctx) {
         at('AGENTIC_LOCAL_PROJECT_ID_NOT_GUID', `In-solution agentic process step "${step}" has projectId ${JSON.stringify(inputs.projectId)}, which is not `
             + `the sibling project's GUID. Read \`resource.projectKey\` from the generated resource file.`, `projectId: '<resource.projectKey>'`);
     }
-    if (inSolution && !blank(inputs?.folderPath)) {
-        at('AGENTIC_LOCAL_HAS_FOLDER', `In-solution agentic process step "${step}" also sets \`folderPath\` ${JSON.stringify(inputs.folderPath)}. An `
-            + `in-solution sibling has no folder until the solution is deployed — the platform's own manifest `
-            + `writes \`""\` — so the value would be dropped. Remove it, or drop \`location: 'in-solution'\` to `
-            + `call the published copy.`);
-    }
+    // A folderPath beside in-solution is the serializer's AGENTIC_LOCAL_HAS_FOLDER (refusals.ts).
     const name = typeof inputs?.name === 'string' ? inputs.name.trim() : '';
     if (name.includes('/')) {
         at('AGENTIC_NAME_IS_PATH', `Agentic process step "${step}"'s \`name\` is ${JSON.stringify(inputs.name)}, which is a folder path. `
             + `\`name\` is the process's own name in Orchestrator; the path it lives in goes in \`folderPath\`. `
             + `Together they form the resourceKey "<folderPath>.<name>", so swapping them points the job at nothing.`);
     }
-    // The platform's own design-time input, which its serializer strips before the
-    // node is emitted — so a process argument by this name is dropped on the way to
-    // the tenant and nothing local notices.
-    if (inputs?.inputs && Object.prototype.hasOwnProperty.call(inputs.inputs, 'fireAndForget')) {
-        at('AGENTIC_RESERVED_INPUT', `Agentic process step "${step}" passes an input called \`fireAndForget\`. That name is RESERVED: it is `
-            + `the platform's design-time switch for starting the process without waiting, and its serializer `
-            + `removes the key from the node's inputs before emitting — so a process argument of that name never `
-            + `arrives. Locally it would appear to work, because this engine passes the whole envelope through. `
-            + `Rename the argument, and note that this surface cannot author fire-and-forget at all (the engine `
-            + `always waits for the job).`);
-    }
+    // An argument called `fireAndForget` is the serializer's AGENTIC_RESERVED_INPUT (refusals.ts).
     // An empty `returns: {}` is a statement that the process returns nothing, which is
     // legal — but it is almost always a half-finished edit, and the difference between
     // it and a missing `returns` is invisible in the emitted file.
@@ -500,19 +445,9 @@ export function checkAgenticProcessRead({ node: name, field, rest, reader: step
 export function checkAgent(inputs, ctx) {
     const step = ctx.step;
     const at = (code, message, suggestion) => ctx.report(code, message, suggestion);
-    const blank = (v) => v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
     const inSolution = inputs?.location === 'in-solution';
-    if (blank(inputs?.key) && !blank(inputs?.agent)) {
-        at('AGENT_NO_KEY', renamedFieldMessage('Agent', step, 'agent'), `key: ${JSON.stringify(inputs.agent)}`);
-    }
-    else if (blank(inputs?.key)) {
-        at('AGENT_NO_KEY', `Agent step "${step}" has no \`key\`. It is a GUID and becomes part of the node's `
-            + `type — without it there is no agent to start. For a published agent, find the Orchestrator `
-            + `release with \`uip or processes list --all-folders --limit 200\` (take the row's \`Key\`) or `
-            + `\`uip maestro flow registry search uipath.core.agent\`. For an in-solution agent, read `
-            + `\`resource.key\` from \`resources/solution_folder/process/agent/<project>.json\`.`, `key: '6a47dc5b-5fd4-461f-b97d-6c1817abcaaa'`);
-    }
-    else if (!GUID_RE.test(String(inputs.key).trim())) {
+    // A blank key is the serializer's AGENT_NO_KEY (refusals.ts).
+    if (!blank(inputs?.key) && !GUID_RE.test(String(inputs.key).trim())) {
         at('AGENT_KEY_NOT_GUID', `Agent step "${step}"'s \`key\` is ${JSON.stringify(inputs.key)}, which is not a key. \`key\` is `
             + `the GUID the tenant gives the published agent (it becomes the node type's suffix); the agent's NAME `
             + `goes in \`name\` and its folder in \`folderPath\`. Passing a ProcessKey like `

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

@@ -17,6 +17,7 @@ import { ownEntry } from '../../../core/own-entry.js';
 import { resourceNodeSortOrder } from '../../../core/process-resource-sort-order.js';
 import { processResourceBindings, processResourceLocation } from '../../../core/process-resource.js';
 import { checkAgent, checkAgentRead, checkAgenticProcess, checkAgenticProcessRead, checkApiWorkflow, checkApiWorkflowRead, checkPublishedFunction, checkPublishedFunctionRead, checkRpaWorkflow, rpaWorkflowRead, } from './check.js';
+import { refuseLossyProcess } from './refusals.js';
 /** The RPA-workflow node type family. The process's release key is the suffix. */
 const RPA_WORKFLOW_PREFIX = 'uipath.core.rpa-workflow.';
 /**
@@ -635,6 +636,9 @@ export function processDefinition(spec) {
  * are identical, and the DATA paths that differ are all downstream in the engine.
  */
 function serializeProcess(spec, ctx) {
+    // A missing key, a folder beside in-solution, a reserved `fireAndForget`
+    // argument: each would be written wrong, so it is refused here (#1518).
+    refuseLossyProcess(spec.kind, spec.inputs, ctx.step);
     const s = spec.inputs;
     const fireAndForget = spec.kind === 'agenticProcess' && s.completion === 'fire-and-forget';
     const def = processDefinition(spec);