@uipath/maestro-builder-sdk 6.24.0 → 6.25.0

package/dist/check.js

@@ -10,7 +10,7 @@ import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { actionVersion, bundledActionNodeType, bundledContainerDefinition, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
-import { sdkFormFieldType } from './core/form-field-type.js';
+import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy } from './core/form-field-type.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
 import { checkCookedEscapes } from './flow-expr-check.js';
@@ -18,7 +18,6 @@ import { FLOW_EXPR_DIALECT, checkBindingLabels, checkBindingPresence, checkConne
 import { prepareCommand } from './core/cli-spelling.js';
 import { commentText } from './core/comment-text.js';
 import { nearestName } from './core/edit-distance.js';
-import { isAnswerField } from './core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome, outcomeIdOf } from './core/hitl-routing.js';
 import { hasExits } from './core/step-ports.js';
 import { stopsAtEnd } from './flow-step-tree.js';
@@ -175,10 +174,6 @@ function checkFlow(built, ancestors, opts = {}) {
     // readable result (see TERMINATE_HAS_NO_OUTPUT below) — and it stops the RUN,
     // so anything after it is unreachable (TERMINATE_UNREACHABLE_AFTER).
     const terminateNames = new Set();
-    // Human-task step name → its form. The node's output is an object keyed by the
-    // form's ANSWER fields (plus `Action`), so a read of it is checked against the
-    // form the author wrote rather than waved through (see HITL_READ_* below).
-    const hitlForms = new Map();
     // Agentic-process step name → its call, for the form-field rules below. Its
     // output READS go through OUTPUT_READ_RULES like every `returns` family.
     const agenticProcesses = new Map();
@@ -423,8 +418,6 @@ function checkFlow(built, ancestors, opts = {}) {
                     })));
                 }
                 if (s.spec.kind === 'hitl') {
-                    checkHitl(s.name, s.spec.inputs, diags);
-                    hitlForms.set(s.name, s.spec.inputs);
                     const outcomes = s.spec.inputs?.outcomes ?? [];
                     // `action: 'End'` ends the PROCESS at the node, so a task whose every
                     // outcome ends it has nothing downstream to distinguish — one exit is
@@ -1131,15 +1124,6 @@ function checkFlow(built, ancestors, opts = {}) {
                 checkSubflowRead(name, field, rest, child, step, diags);
                 continue;
             }
-            // A human task's output is an object keyed by the form's ANSWER fields,
-            // plus `Action` (which outcome was pressed). A read of anything else is
-            // undefined at run time, and `.status` is the worst of them — it resolves
-            // deployed, so the mistake only shows up in production.
-            const form = hitlForms.get(name);
-            if (form) {
-                checkHitlRead(name, field, rest, form, step, diags);
-                continue;
-            }
             // Every family that declares its output's fields — the author's `returns`, or
             // a shape the SDK fixes — has its read rule in OUTPUT_READ_RULES, keyed by
             // kind. A read outside the declared set is undefined on every rung and on
@@ -3820,39 +3804,6 @@ function endDiag(join, h) {
  * reference to hide — which is what the checks below enforce for the cases
  * where types have been stripped at run time.
  */
-/**
- * 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.
- */
-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}'`
-        : 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. */
-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'`. */
-function formFieldTypeHint(type) {
-    const alias = sdkFormFieldType(type);
-    if (alias !== undefined)
-        return `type: '${alias}'`;
-    const nearest = nearestName(String(type), FORM_FIELD_TYPES);
-    return nearest !== undefined ? `type: '${nearest}'` : `type: 'text'`;
-}
-/** Names the human task's own result already uses — an answer cannot claim one. */
-const RESERVED_ANSWER_IDS = new Set(['output', 'status', 'Action']);
-/**
- * The human-task node types `variant` can name. `document-validation` resolves
- * from the BUNDLED workbench manifest (the tenant registry does not serve the
- * family — same availability note as do-while).
- */
-const HITL_VARIANTS = ['quick-form', 'action-app', 'document-validation'];
 /**
  * Why a base or quick-form task continues every outcome to the next step, as a
  * clause for a diagnostic. `pinned` is the step's `{ version }`.
@@ -3964,338 +3915,6 @@ function reportUnreachableHitlOutcomes(choices, exprs, diags) {
         });
     }
 }
-/**
- * A human task's form.
- *
- * Everything here is a mistake no later rung can see, which is the test for
- * earning a place in `check` rather than in the docs: the flow compiles, deploys,
- * and shows a person a form with something quietly missing from it. These catch it
- * at rung 1, in the author's own vocabulary.
- */
-function checkHitl(step, inputs, diags) {
-    const at = (code, message, suggestion) => {
-        diags.push({ level: 'error', code, message, step, ...(suggestion ? { suggestion } : {}) });
-    };
-    // 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.
-    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;
-    }
-    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.
-    // Per-outcome exits are not a version question: quick-form draws one handle
-    // per outcome like the base node, so it may ask for them; the two app-backed
-    // variants read their outcomes from the app and leave on `completed`.
-    if (variant !== undefined
-        && (inputs?.exposeError === true || (inputs?.outcomePorts === true && !hitlDerivesOutcomeHandles(variant)))) {
-        at('HITL_OUTCOME_PORTS_VARIANT', inputs?.exposeError === true
-            ? `Human task "${step}" asks for exposeError, but its variant is "${variant}" — the error output `
-                + `exists only on the base node type's 1.2 definition.`
-            : `Human task "${step}" asks for outcomePorts, but its variant is "${variant}", which reads its `
-                + `outcomes from its app and leaves on its single 'completed' exit.`, inputs?.exposeError === true
-            ? 'Omit `variant`, or drop exposeError.'
-            : `Route on out('${step}', 'Action') downstream.`);
-        return;
-    }
-    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 (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} `
-                + `form field(s). The validation station IS the form — these are dropped.`, `Delete \`fields\`.`);
-            return;
-        }
-        const doc = inputs?.document;
-        if (!doc || typeof doc !== 'object') {
-            at('HITL_DOCVAL_NO_DOCUMENT', `Human task "${step}" uses variant 'document-validation' but names no document — the station `
-                + `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'`);
-        }
-        // 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;
-    }
-    if (isApp) {
-        // The app owns the form, so `fields` is not merely unnecessary here — it is a
-        // statement about a form this node does not have, and the platform drops it.
-        if (Array.isArray(inputs?.fields) && inputs.fields.length > 0) {
-            at('HITL_APP_WITH_FIELDS', `Human task "${step}" is backed by an Action App but also declares ${inputs.fields.length} form `
-                + `field(s). The form belongs to the DEPLOYED APP, not to the flow, so these are dropped and `
-                + `the reviewer sees the app's own form instead.`, `Delete \`fields\`; map values into the app with \`app.inputs\` instead.`);
-            return;
-        }
-        const app = inputs?.app;
-        if (!app || typeof app !== 'object') {
-            at('HITL_APP_MISSING', `Human task "${step}" uses variant 'action-app', which takes its form from a deployed Action `
-                + `App — but names no app, so nothing tells the platform which form to show.`, `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
-            return;
-        }
-        for (const k of ['name', 'key', 'folderPath']) {
-            if (typeof app[k] !== 'string' || !app[k].trim()) {
-                at('HITL_APP_INCOMPLETE', `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.`, `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
-                return;
-            }
-        }
-        // 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
-        // outcome rules below rather than returning here.
-    }
-    // An app task legitimately has no form fields of its own — the rules below then
-    // walk an empty list and only the outcome rules bite, which is what we want.
-    const fields = isApp || isDocval ? (inputs?.fields ?? []) : inputs?.fields;
-    if (!Array.isArray(fields)) {
-        at('HITL_NO_FIELDS', `Human task "${step}" has no fields array. Give it the form: what the reviewer reads `
-            + `(direction 'input') and what they fill in (direction 'output').`, `fields: [{ id: 'amount', type: 'number', direction: 'input', value: input('amount') }]`);
-        return;
-    }
-    const seen = new Set();
-    let answers = 0;
-    fields.forEach((f, i) => {
-        const where = `fields[${i}]`;
-        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 (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.`);
-            return;
-        }
-        seen.add(id);
-        if (RESERVED_ANSWER_IDS.has(id)) {
-            at('HITL_FIELD_RESERVED_ID', `Human task "${step}" has a form field named "${id}", which the task's own result already `
-                + `uses (its output object carries "Action", and the node publishes "output" and "status"). `
-                + `The platform drops a field that collides with those.`, `Rename it, e.g. id: '${id}Value'.`);
-            return;
-        }
-        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));
-        }
-        if (isAnswerField(f))
-            answers++; // an `output`, or an `inOut` whose reviewed value comes back
-        if (f?.direction === 'input' || f?.direction === 'inOut') {
-            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, `
-                    + `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>')`);
-            }
-        }
-        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'); `
-                + `anything else appears in the form schema and is neither displayed nor read back.`, `direction: 'output'`);
-        }
-    });
-    const outcomes = inputs?.outcomes;
-    if (!Array.isArray(outcomes) || outcomes.length === 0) {
-        at('HITL_NO_OUTCOMES', `Human task "${step}" declares no outcomes, so the reviewer has no button to complete the `
-            + `task with and the flow waits forever.`, `outcomes: ['Approve', 'Reject']`);
-        return;
-    }
-    const names = new Set();
-    const ids = new Map();
-    outcomes.forEach((o, i) => {
-        const name = (typeof o === 'string' ? o : o?.name)?.trim();
-        // Two outcomes on one id would share one `outcome-<id>` port, so the
-        // second's edge could never be told apart. An explicit `id` can collide
-        // with another outcome's derived slug.
-        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')} }`);
-        }
-        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.
-            at('HITL_DUP_OUTCOME_ID', `Human task "${step}" gives outcomes "${ids.get(id)}" and "${name}" the same id "${id}", so both would `
-                + `leave from one 'outcome-${id}' port. Give one of them a different \`id\`.`);
-        }
-        else {
-            ids.set(id, String(name ?? ''));
-        }
-        if (!name) {
-            at('HITL_OUTCOME_NO_NAME', `Human task "${step}" has an outcome with no name (outcomes[${i}]). The result carries the `
-                + `outcome's NAME — it is what "$vars.${step}.output.Action" holds and what the platform's `
-                + `own routing conditions compare against — so a nameless one can never be matched.`, `outcomes: ['Approve', 'Reject']`);
-            return;
-        }
-        if (names.has(name)) {
-            at('HITL_DUP_OUTCOME', `Human task "${step}" declares the outcome "${name}" twice. Only the name reaches the flow, `
-                + `so two outcomes sharing one are indistinguishable downstream.`, `Rename one of them.`);
-            return;
-        }
-        names.add(name);
-        const action = typeof o === 'string' ? undefined : o?.action;
-        if (action !== undefined && action !== 'Continue' && action !== 'End') {
-            at('HITL_OUTCOME_ACTION', `Human task "${step}" gives the outcome "${name}" the action ${JSON.stringify(action)}. Only `
-                + `the exact string 'End' means "end the process here"; anything else — including 'end' — is `
-                + `read as 'Continue'.`, `action: 'End'`);
-        }
-    });
-    // Delivery: the channel ids and assignee types are closed platform
-    // vocabularies; a typo silently falls back to tenant defaults at run time.
-    const HITL_CHANNELS = ['Slack', 'teams', 'Email', 'ActionCenter'];
-    const HITL_ASSIGNEE_TYPES = ['user', 'group', 'staticEmail', 'staticGroupName', 'workload', 'roundRobin', 'custom'];
-    const rec = inputs?.recipient;
-    if (rec !== undefined) {
-        for (const ch of rec.channels ?? []) {
-            if (!HITL_CHANNELS.includes(String(ch))) {
-                const nearest = nearestName(String(ch), HITL_CHANNELS);
-                at('HITL_CHANNEL_UNKNOWN', `Human task "${step}" delivers over the channel ${JSON.stringify(ch)}, which the platform `
-                    + `does not recognize — valid: ${HITL_CHANNELS.join(', ')} (Microsoft Teams really is the `
-                    + `lowercase 'teams').`, nearest !== undefined ? `channels: ['${nearest}']` : undefined);
-            }
-        }
-        const at2 = rec.assignee?.type;
-        if (!HITL_ASSIGNEE_TYPES.includes(String(at2))) {
-            const nearest = nearestName(String(at2), HITL_ASSIGNEE_TYPES);
-            at('HITL_RECIPIENT_TYPE', `Human task "${step}" assigns its recipient with the type ${JSON.stringify(at2)}. Valid: `
-                + `${HITL_ASSIGNEE_TYPES.join(', ')}.`, nearest !== undefined ? `assignee: { type: '${nearest}' }` : undefined);
-        }
-        else if (at2 === 'custom' && !(typeof rec.assignee?.value === 'string' && rec.assignee.value.trim())) {
-            diags.push({
-                level: 'warning', code: 'HITL_RECIPIENT_VALUE', step,
-                message: `Human task "${step}" uses a custom assignment with no value — the engine gets an `
-                    + `empty custom-assignees expression and falls back to the tenant default.`,
-                suggestion: `assignee: { type: 'custom', value: '<expression>' }`,
-            });
-        }
-    }
-    // A form with nothing to fill in and one outcome is a notification, not a task
-    // — but it is a legitimate one (an acknowledgement step), so this is not an
-    // error. Two or more outcomes with no answer fields is the common approval
-    // shape and equally fine. Nothing to report either way.
-    void answers;
-}
-/**
- * A read of a human task's output: `out('<step>', '<field>')`.
- *
- * The node publishes an object keyed by the form's ANSWER fields plus `Action`.
- * Two mistakes are silent at run time and both are caught here:
- *
- *  - reading a field the form does not answer (a shown field, or a typo) —
- *    `undefined`, offline and deployed;
- *  - reading `$vars.<step>.status`, the platform's own projection of the chosen
- *    outcome. It resolves *deployed*, so the flow works in production and reads
- *    `undefined` on this SDK's offline rungs — a divergence, which is why the read
- *    is redirected rather than merely flagged. (A runner that derives declared
- *    output variables resolves `status` offline as well; the surface still points
- *    at one spelling so a flow reads the same everywhere.)
- */
-function checkHitlRead(name, field, rest, form, step, diags) {
-    if (field === undefined) {
-        // `out('review')` — the whole answer object. Legitimate (a script may want
-        // all of it), same as a subflow's bare read being legitimate.
-        return;
-    }
-    if (field === 'status') {
-        diags.push({
-            level: 'error',
-            code: 'HITL_READ_STATUS',
-            message: `"$vars.${name}.status" (read in "${step}") is the platform's own projection of the chosen `
-                + `outcome, not part of the answer object. Read the outcome from the output instead, which is `
-                + `the spelling flow-v1's routing conditions use and the one every rung here resolves.`,
-            step,
-            suggestion: `out('${name}', 'Action')`,
-        });
-        return;
-    }
-    if (field !== 'output') {
-        diags.push({
-            level: 'error',
-            code: 'HITL_READ_NOT_OUTPUT',
-            message: `Human task "${name}" publishes its result under "output", but "$vars.${name}.${field}" `
-                + `(read in "${step}") asks for "${field}", which is undefined at run time.`,
-            step,
-            suggestion: `out('${name}', '<fieldId>')`,
-        });
-        return;
-    }
-    // `out(name, 'x')` renders as `$vars.<name>.output.x`, so the answer field is
-    // the first segment of `rest` — which arrives with its leading dot
-    // (`.approved`), the same shape `checkSubflowRead` receives.
-    const answer = (rest ?? '').replace(/^\./, '').split('.')[0];
-    if (!answer)
-        return; // `$vars.<name>.output` — the whole object, fine.
-    if (answer === 'Action')
-        return; // which outcome was pressed.
-    const answers = (form?.fields ?? [])
-        .filter((f) => isAnswerField(f) && typeof f?.id === 'string')
-        .map((f) => f.id);
-    if (answers.includes(answer))
-        return;
-    const shown = (form?.fields ?? [])
-        .filter((f) => f?.direction === 'input' && typeof f?.id === 'string')
-        .map((f) => f.id);
-    const nearest = nearestName(answer, [...answers, 'Action']);
-    diags.push({
-        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 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 `
-                    + `value you bound to it instead.`
-                : 'Nothing else resolves at run time.'),
-        step,
-        ...(nearest !== undefined ? { suggestion: `out('${name}', '${nearest}')` } : {}),
-    });
-}
 /**
  * Flag a case value whose type cannot match the discriminant's declared type.
  *
@@ -4490,16 +4109,6 @@ function collectActionExprs(s, out, errorSource) {
         if (val && typeof val === 'object')
             return Object.values(val).forEach(pushDeep);
     };
-    if (s.spec.kind === 'hitl') {
-        // A human task's only expressions are the values its shown fields display.
-        // Without this a typo'd reference inside a form field would reach the
-        // deployed task as an unresolvable path and show the reviewer nothing.
-        for (const f of s.spec.inputs?.fields ?? []) {
-            if (f?.direction === 'input')
-                push(f.value);
-        }
-        return;
-    }
     if (s.spec.kind === 'subflow') {
         // The values passed INTO the child are parent-scope expressions, so they
         // resolve against the parent's declared names like any other reference.