@uipath/maestro-builder-sdk 6.66.6 → 6.66.7

package/dist/check.js

@@ -1571,16 +1571,8 @@ function checkSubflow(step, child, inputs, parent, ancestors, diags) {
             + `emitted file at every call site, so a cycle has no base case and cannot be expanded.`);
         return;
     }
-    // A subflow always starts manually — its caller is what starts it. Nothing
-    // schedules a subflow, so a schedule here is silently ignored. `manual()` is
-    // what the child gets anyway, so `.trigger(manual(), { label, version })` is
-    // allowed: it is how the child's start node is labelled (#1050), and the
-    // form decompile writes for a renamed one.
-    if (child.trigger !== undefined && child.trigger.kind !== 'manual') {
-        at('SUBFLOW_CHILD_TRIGGER', `Subflow "${step}" runs a flow with its own \`.trigger(…)\`. A subflow is started by its caller, never by a `
-            + `trigger of its own — the schedule would be dropped. Remove the .trigger() from "${child.id}" `
-            + `(\`.trigger(manual(), { label })\` is allowed, to name the child's start node).`);
-    }
+    // A child's own `.trigger(…)` or `.entryPoint()` is the serializer's
+    // SUBFLOW_CHILD_TRIGGER / SUBFLOW_CHILD_ENTRY_POINT (`refuseChildRoots`).
     // `{ shared }` merges one input across a flow's ROOTS (#924); a subflow has
     // one root, its caller: the serializer's SHARED_INPUT_IN_SUBFLOW.
     const declared = new Map(child.inputs.map((i) => [i.name, String(i.type)]));

package/dist/core/agent-sidecar.d.ts

@@ -17,9 +17,9 @@ export interface AgentInputPlan {
  *    value is INLINED into the agent.json prompt instead.
  *  - `expression` — a computed expression spanning zero or several references.
  *    No single JobArgument can exist, so there is no honest name to emit, and
- *    the author's placeholder has nothing to point at — `check`'s
- *    `INLINE_AGENT_COMPOSITE_INPUT` says so and names the fix (compute it in a
- *    script step first).
+ *    the author's placeholder has nothing to point at. When a prompt references
+ *    one, the inline agent's serialize refuses it (`INLINE_AGENT_COMPOSITE_INPUT`)
+ *    and names the fix (compute it in a script step first).
  */
 export type AgentInputBinding = {
     kind: 'ref';
@@ -129,6 +129,16 @@ export declare function inlineAgentJson(spec: {
     /** The agent's display name (the step's label). */
     name: string;
 }): any;
+/**
+ * The input names an agent's prompts reference as `{{input.<name>}}`, system
+ * prompt first, in order (repeats kept). Both prompts are searched, because
+ * flow-v1's pre-pass scans both. For instance `{ systemPrompt: 'Use {{input.a}}',
+ * userPrompt: '{{input.b}} and {{input.a}}' }` gives `['a', 'b', 'a']`.
+ */
+export declare function promptPlaceholders(s: {
+    systemPrompt?: unknown;
+    userPrompt?: unknown;
+}): string[];
 /** Which writer produced an `agent.json`: the inline, conversational or voice agent's. */
 export type AgentSidecarDialect = 'inline' | 'conversational' | 'voice';
 /**

package/dist/core/agent-sidecar.js

@@ -263,6 +263,16 @@ export function inlineAgentJson(spec) {
 }
 /** `{{input.<name>}}` — the agent-template placeholder, in both prompt directions. */
 const INPUT_PLACEHOLDER = /\{\{\s*input\.([A-Za-z_$][A-Za-z0-9_$]*)\s*\}\}/g;
+/**
+ * The input names an agent's prompts reference as `{{input.<name>}}`, system
+ * prompt first, in order (repeats kept). Both prompts are searched, because
+ * flow-v1's pre-pass scans both. For instance `{ systemPrompt: 'Use {{input.a}}',
+ * userPrompt: '{{input.b}} and {{input.a}}' }` gives `['a', 'b', 'a']`.
+ */
+export function promptPlaceholders(s) {
+    const prompts = `${String(s.systemPrompt ?? '')}\n${String(s.userPrompt ?? '')}`;
+    return [...prompts.matchAll(INPUT_PLACEHOLDER)].map((m) => m[1]);
+}
 /**
  * Split an agent prompt into the `contentTokens` the designer renders it from.
  *

package/dist/core/refusals.d.ts

@@ -197,7 +197,7 @@ export declare const REFUSALS: {
     readonly DATAFABRIC_NO_ENTITY: "lint";
     readonly DATAFABRIC_QUERY_OPTS_WITHOUT_MULTIPLE: "lint";
     readonly DATAFABRIC_RECORD_REF: "lowering";
-    readonly DATAFABRIC_RESOURCE_KEY_NO_FOLDER: "lint";
+    readonly DATAFABRIC_RESOURCE_KEY_NO_FOLDER: "lowering";
     readonly DATAFABRIC_RESULT_MODE_VERSION: "lowering";
     readonly DATAFABRIC_SYSTEM_COLUMN: "lint";
     readonly DEAD_END: "lint";
@@ -212,9 +212,9 @@ export declare const REFUSALS: {
     readonly DELAY_NO_DURATION: "lint";
     readonly DELAY_UNTIL_NOT_ISO: "lint";
     readonly DELAY_ZERO: "lint";
-    readonly DOCVAL_NO_EXTRACTION: "lint";
-    readonly DOCVAL_RENDER_UNKNOWN: "lint";
-    readonly DOCVAL_TAXONOMY_REQUIRED: "lint";
+    readonly DOCVAL_NO_EXTRACTION: "lowering";
+    readonly DOCVAL_RENDER_UNKNOWN: "lowering";
+    readonly DOCVAL_TAXONOMY_REQUIRED: "lowering";
     readonly DOC_NO_FILEREF: "lint";
     readonly DOWHILE_CONST_COND: "lint";
     readonly DOWHILE_LIMIT: "lint";
@@ -303,19 +303,19 @@ export declare const REFUSALS: {
     readonly GUARDRAIL_NO_SCOPE: "lint";
     readonly GUARDRAIL_NO_VALIDATOR: "lint";
     readonly GUARDRAIL_TYPE_UNKNOWN: "lint";
-    readonly HITL_APP_INCOMPLETE: "lint";
+    readonly HITL_APP_INCOMPLETE: "lowering";
     readonly HITL_APP_INPUT_REQUIRED: "lint";
     readonly HITL_APP_INPUT_UNKNOWN: "lint";
-    readonly HITL_APP_LOCAL_HAS_FOLDER: "lint";
+    readonly HITL_APP_LOCAL_HAS_FOLDER: "lowering";
     readonly HITL_APP_MISSING: "lint";
     readonly HITL_APP_NO_SCHEMA: "lint";
-    readonly HITL_APP_OUTCOME_UNKNOWN: "lint";
-    readonly HITL_APP_SCHEMA_INVALID: "lint";
-    readonly HITL_APP_WITHOUT_VARIANT: "lint";
+    readonly HITL_APP_OUTCOME_UNKNOWN: "lowering";
+    readonly HITL_APP_SCHEMA_INVALID: "lowering";
+    readonly HITL_APP_WITHOUT_VARIANT: "lowering";
     readonly HITL_APP_WITH_FIELDS: "lint";
     readonly HITL_CHANNEL_UNKNOWN: "lint";
     readonly HITL_COMPLETED_PORT_GONE: "lowering";
-    readonly HITL_DOCUMENT_WITHOUT_VARIANT: "lint";
+    readonly HITL_DOCUMENT_WITHOUT_VARIANT: "lowering";
     readonly HITL_DOCVAL_NO_DOCUMENT: "lint";
     readonly HITL_DOCVAL_WITH_FIELDS: "lint";
     readonly HITL_DUP_FIELD: "lint";
@@ -325,16 +325,16 @@ export declare const REFUSALS: {
     readonly HITL_EXPOSE_ERROR_VERSION: "lowering";
     readonly HITL_FAN_OUT_INTO_JOIN: "lowering";
     readonly HITL_FIELD_DIRECTION: "lint";
-    readonly HITL_FIELD_NO_ID: "lint";
+    readonly HITL_FIELD_NO_ID: "lowering";
     readonly HITL_FIELD_NO_VALUE: "lint";
     readonly HITL_FIELD_OPTIONS: "lint";
     readonly HITL_FIELD_OPTIONS_IGNORED: "lint";
     readonly HITL_FIELD_RESERVED_ID: "lint";
     readonly HITL_FIELD_SETTING_INVALID: "lint";
     readonly HITL_FIELD_TYPE_UNKNOWN: "lint";
-    readonly HITL_FIELD_VALUE_NOT_PATH: "lint";
-    readonly HITL_FIELD_VALUE_NOT_REF: "lint";
-    readonly HITL_FIELD_VARIABLE: "lint";
+    readonly HITL_FIELD_VALUE_NOT_PATH: "lowering";
+    readonly HITL_FIELD_VALUE_NOT_REF: "lowering";
+    readonly HITL_FIELD_VARIABLE: "lowering";
     readonly HITL_LEGACY_COMPLETED: "lint";
     readonly HITL_LEGACY_COMPLETED_CONFLICT: "lowering";
     readonly HITL_LEGACY_COMPLETED_NO_EFFECT: "lint";
@@ -343,7 +343,7 @@ export declare const REFUSALS: {
     readonly HITL_NO_OUTCOMES: "lint";
     readonly HITL_OUTCOMES_UNREACHABLE: "lint";
     readonly HITL_OUTCOME_ACTION: "lint";
-    readonly HITL_OUTCOME_BAD_ID: "lint";
+    readonly HITL_OUTCOME_BAD_ID: "lowering";
     readonly HITL_OUTCOME_NO_NAME: "lint";
     readonly HITL_OUTCOME_PORTS_NONE: "lowering";
     readonly HITL_OUTCOME_PORTS_OFF: "lowering";
@@ -359,7 +359,7 @@ export declare const REFUSALS: {
     readonly HITL_RECIPIENT_TYPE: "lint";
     readonly HITL_RECIPIENT_VALUE: "lint";
     readonly HITL_UNREACHABLE_AFTER: "lint";
-    readonly HITL_VARIANT_UNKNOWN: "lint";
+    readonly HITL_VARIANT_UNKNOWN: "lowering";
     readonly HTTP_BINDING_REQUIRES_MANAGED: "lowering";
     readonly HTTP_BRANCH_CONST: "lint";
     readonly HTTP_BRANCH_DUP: "lint";
@@ -378,10 +378,10 @@ export declare const REFUSALS: {
     readonly HTTP_TIMEOUT_NOT_DURATION: "lint";
     readonly HTTP_V1_RETIRED: "lint";
     readonly IMPLICIT_SPLIT: "lint";
-    readonly INLINE_AGENT_COMPOSITE_INPUT: "lint";
+    readonly INLINE_AGENT_COMPOSITE_INPUT: "lowering";
     readonly INLINE_AGENT_EMPTY_RETURNS: "lint";
     readonly INLINE_AGENT_ESCALATION_APP_KEY_NOT_GUID: "lint";
-    readonly INLINE_AGENT_ESCALATION_APP_WITH_FIELDS: "lint";
+    readonly INLINE_AGENT_ESCALATION_APP_WITH_FIELDS: "lowering";
     readonly INLINE_AGENT_ESCALATION_FIELD_OPTIONS: "lint";
     readonly INLINE_AGENT_ESCALATION_FIELD_OPTIONS_IGNORED: "lint";
     readonly INLINE_AGENT_ESCALATION_FIELD_SETTING_INVALID: "lint";
@@ -389,8 +389,8 @@ export declare const REFUSALS: {
     readonly INLINE_AGENT_ESCALATION_NO_APP: "lint";
     readonly INLINE_AGENT_ESCALATION_NO_FIELDS: "lint";
     readonly INLINE_AGENT_ESCALATION_NO_NAME: "lint";
-    readonly INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP: "lint";
-    readonly INLINE_AGENT_ESCALATION_VARIANT: "lint";
+    readonly INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP: "lowering";
+    readonly INLINE_AGENT_ESCALATION_VARIANT: "lowering";
     readonly INLINE_AGENT_INPUT_NAME_AMBIGUOUS: "lint";
     readonly INLINE_AGENT_MEMORY_ID_NOT_GUID: "lint";
     readonly INLINE_AGENT_MEMORY_INCOMPLETE: "lint";
@@ -430,7 +430,7 @@ export declare const REFUSALS: {
     readonly INTSVC_OPERATION_NOT_IDENTIFIER: "lint";
     readonly INTSVC_PATH_NOT_ABSOLUTE: "lint";
     readonly INTSVC_PATH_PARAM_UNBOUND: "lint";
-    readonly IXP_FORBIDDEN_INPUT: "lint";
+    readonly IXP_FORBIDDEN_INPUT: "lowering";
     readonly IXP_NO_FILE: "lint";
     readonly IXP_NO_FOLDER: "lint";
     readonly IXP_NO_MODEL_NAME: "lint";
@@ -602,7 +602,8 @@ export declare const REFUSALS: {
     readonly STICKY_NOTE_NO_CONTENT: "lowering";
     readonly STICKY_NOTE_POSITION: "lowering";
     readonly STICKY_NOTE_SIZE: "lowering";
-    readonly SUBFLOW_CHILD_TRIGGER: "lint";
+    readonly SUBFLOW_CHILD_ENTRY_POINT: "lowering";
+    readonly SUBFLOW_CHILD_TRIGGER: "lowering";
     readonly SUBFLOW_CYCLE: "lint";
     readonly SUBFLOW_HAS_NO_OUTPUT: "lint";
     readonly SUBFLOW_MISSING_INPUT: "lint";

package/dist/core/refusals.js

@@ -238,7 +238,7 @@ export const REFUSALS = {
     DATAFABRIC_NO_ENTITY: 'lint',
     DATAFABRIC_QUERY_OPTS_WITHOUT_MULTIPLE: 'lint',
     DATAFABRIC_RECORD_REF: 'lowering',
-    DATAFABRIC_RESOURCE_KEY_NO_FOLDER: 'lint',
+    DATAFABRIC_RESOURCE_KEY_NO_FOLDER: 'lowering',
     DATAFABRIC_RESULT_MODE_VERSION: 'lowering',
     DATAFABRIC_SYSTEM_COLUMN: 'lint',
     DEAD_END: 'lint',
@@ -253,9 +253,9 @@ export const REFUSALS = {
     DELAY_NO_DURATION: 'lint',
     DELAY_UNTIL_NOT_ISO: 'lint',
     DELAY_ZERO: 'lint',
-    DOCVAL_NO_EXTRACTION: 'lint',
-    DOCVAL_RENDER_UNKNOWN: 'lint',
-    DOCVAL_TAXONOMY_REQUIRED: 'lint',
+    DOCVAL_NO_EXTRACTION: 'lowering',
+    DOCVAL_RENDER_UNKNOWN: 'lowering',
+    DOCVAL_TAXONOMY_REQUIRED: 'lowering',
     DOC_NO_FILEREF: 'lint',
     DOWHILE_CONST_COND: 'lint',
     DOWHILE_LIMIT: 'lint',
@@ -344,19 +344,19 @@ export const REFUSALS = {
     GUARDRAIL_NO_SCOPE: 'lint',
     GUARDRAIL_NO_VALIDATOR: 'lint',
     GUARDRAIL_TYPE_UNKNOWN: 'lint',
-    HITL_APP_INCOMPLETE: 'lint',
+    HITL_APP_INCOMPLETE: 'lowering',
     HITL_APP_INPUT_REQUIRED: 'lint',
     HITL_APP_INPUT_UNKNOWN: 'lint',
-    HITL_APP_LOCAL_HAS_FOLDER: 'lint',
+    HITL_APP_LOCAL_HAS_FOLDER: 'lowering',
     HITL_APP_MISSING: 'lint',
     HITL_APP_NO_SCHEMA: 'lint',
-    HITL_APP_OUTCOME_UNKNOWN: 'lint',
-    HITL_APP_SCHEMA_INVALID: 'lint',
-    HITL_APP_WITHOUT_VARIANT: 'lint',
+    HITL_APP_OUTCOME_UNKNOWN: 'lowering',
+    HITL_APP_SCHEMA_INVALID: 'lowering',
+    HITL_APP_WITHOUT_VARIANT: 'lowering',
     HITL_APP_WITH_FIELDS: 'lint',
     HITL_CHANNEL_UNKNOWN: 'lint',
     HITL_COMPLETED_PORT_GONE: 'lowering',
-    HITL_DOCUMENT_WITHOUT_VARIANT: 'lint',
+    HITL_DOCUMENT_WITHOUT_VARIANT: 'lowering',
     HITL_DOCVAL_NO_DOCUMENT: 'lint',
     HITL_DOCVAL_WITH_FIELDS: 'lint',
     HITL_DUP_FIELD: 'lint',
@@ -366,16 +366,16 @@ export const REFUSALS = {
     HITL_EXPOSE_ERROR_VERSION: 'lowering',
     HITL_FAN_OUT_INTO_JOIN: 'lowering',
     HITL_FIELD_DIRECTION: 'lint',
-    HITL_FIELD_NO_ID: 'lint',
+    HITL_FIELD_NO_ID: 'lowering',
     HITL_FIELD_NO_VALUE: 'lint',
     HITL_FIELD_OPTIONS: 'lint',
     HITL_FIELD_OPTIONS_IGNORED: 'lint',
     HITL_FIELD_RESERVED_ID: 'lint',
     HITL_FIELD_SETTING_INVALID: 'lint',
     HITL_FIELD_TYPE_UNKNOWN: 'lint',
-    HITL_FIELD_VALUE_NOT_PATH: 'lint',
-    HITL_FIELD_VALUE_NOT_REF: 'lint',
-    HITL_FIELD_VARIABLE: 'lint',
+    HITL_FIELD_VALUE_NOT_PATH: 'lowering',
+    HITL_FIELD_VALUE_NOT_REF: 'lowering',
+    HITL_FIELD_VARIABLE: 'lowering',
     HITL_LEGACY_COMPLETED: 'lint',
     HITL_LEGACY_COMPLETED_CONFLICT: 'lowering',
     HITL_LEGACY_COMPLETED_NO_EFFECT: 'lint',
@@ -384,7 +384,7 @@ export const REFUSALS = {
     HITL_NO_OUTCOMES: 'lint',
     HITL_OUTCOMES_UNREACHABLE: 'lint',
     HITL_OUTCOME_ACTION: 'lint',
-    HITL_OUTCOME_BAD_ID: 'lint',
+    HITL_OUTCOME_BAD_ID: 'lowering',
     HITL_OUTCOME_NO_NAME: 'lint',
     HITL_OUTCOME_PORTS_NONE: 'lowering',
     HITL_OUTCOME_PORTS_OFF: 'lowering',
@@ -400,7 +400,7 @@ export const REFUSALS = {
     HITL_RECIPIENT_TYPE: 'lint',
     HITL_RECIPIENT_VALUE: 'lint',
     HITL_UNREACHABLE_AFTER: 'lint',
-    HITL_VARIANT_UNKNOWN: 'lint',
+    HITL_VARIANT_UNKNOWN: 'lowering',
     HTTP_BINDING_REQUIRES_MANAGED: 'lowering',
     HTTP_BRANCH_CONST: 'lint',
     HTTP_BRANCH_DUP: 'lint',
@@ -419,10 +419,10 @@ export const REFUSALS = {
     HTTP_TIMEOUT_NOT_DURATION: 'lint',
     HTTP_V1_RETIRED: 'lint',
     IMPLICIT_SPLIT: 'lint',
-    INLINE_AGENT_COMPOSITE_INPUT: 'lint',
+    INLINE_AGENT_COMPOSITE_INPUT: 'lowering',
     INLINE_AGENT_EMPTY_RETURNS: 'lint',
     INLINE_AGENT_ESCALATION_APP_KEY_NOT_GUID: 'lint',
-    INLINE_AGENT_ESCALATION_APP_WITH_FIELDS: 'lint',
+    INLINE_AGENT_ESCALATION_APP_WITH_FIELDS: 'lowering',
     INLINE_AGENT_ESCALATION_FIELD_OPTIONS: 'lint',
     INLINE_AGENT_ESCALATION_FIELD_OPTIONS_IGNORED: 'lint',
     INLINE_AGENT_ESCALATION_FIELD_SETTING_INVALID: 'lint',
@@ -430,8 +430,8 @@ export const REFUSALS = {
     INLINE_AGENT_ESCALATION_NO_APP: 'lint',
     INLINE_AGENT_ESCALATION_NO_FIELDS: 'lint',
     INLINE_AGENT_ESCALATION_NO_NAME: 'lint',
-    INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP: 'lint',
-    INLINE_AGENT_ESCALATION_VARIANT: 'lint',
+    INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP: 'lowering',
+    INLINE_AGENT_ESCALATION_VARIANT: 'lowering',
     INLINE_AGENT_INPUT_NAME_AMBIGUOUS: 'lint',
     INLINE_AGENT_MEMORY_ID_NOT_GUID: 'lint',
     INLINE_AGENT_MEMORY_INCOMPLETE: 'lint',
@@ -471,7 +471,7 @@ export const REFUSALS = {
     INTSVC_OPERATION_NOT_IDENTIFIER: 'lint',
     INTSVC_PATH_NOT_ABSOLUTE: 'lint',
     INTSVC_PATH_PARAM_UNBOUND: 'lint',
-    IXP_FORBIDDEN_INPUT: 'lint',
+    IXP_FORBIDDEN_INPUT: 'lowering',
     IXP_NO_FILE: 'lint',
     IXP_NO_FOLDER: 'lint',
     IXP_NO_MODEL_NAME: 'lint',
@@ -643,7 +643,8 @@ export const REFUSALS = {
     STICKY_NOTE_NO_CONTENT: 'lowering',
     STICKY_NOTE_POSITION: 'lowering',
     STICKY_NOTE_SIZE: 'lowering',
-    SUBFLOW_CHILD_TRIGGER: 'lint',
+    SUBFLOW_CHILD_ENTRY_POINT: 'lowering',
+    SUBFLOW_CHILD_TRIGGER: 'lowering',
     SUBFLOW_CYCLE: 'lint',
     SUBFLOW_HAS_NO_OUTPUT: 'lint',
     SUBFLOW_MISSING_INPUT: 'lint',

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

@@ -1,8 +1,9 @@
 import { Expr } from '../../../core/expr.js';
 import { GUID_RE } from '../../../core/binding-messages.js';
+import { promptPlaceholders } from '../../../core/agent-sidecar.js';
 import { prepareCommand } from '../../../core/cli-spelling.js';
 import { nearestName } from '../../../core/edit-distance.js';
-import { FLAT_SEP, flatNameOf, flatNameSegmentsOf } from '../../../core/expr.js';
+import { FLAT_SEP, flatNameSegmentsOf } from '../../../core/expr.js';
 import { FORM_FIELD_TYPES, formFieldOptionsProblem, formFieldOptionsWhy, formFieldSettingProblems, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText, } from '../../../core/form-field-type.js';
 import { ownEntry } from '../../../core/own-entry.js';
 export const AGENT_DIAGNOSTICS = {
@@ -473,9 +474,7 @@ export function checkInlineAgent(inputs, ctx) {
     }
     // The prompts-vs-variables agreement, in both directions. Both prompts are
     // searched, because flow-v1's pre-pass scans both.
-    const prompts = `${String(inputs?.systemPrompt ?? '')}\n${String(inputs?.userPrompt ?? '')}`;
-    const placeholders = [...prompts.matchAll(/\{\{\s*input\.([A-Za-z_$][A-Za-z0-9_$]*)\s*\}\}/g)]
-        .map((m) => m[1]);
+    const placeholders = promptPlaceholders(inputs ?? {});
     const declaredInputs = Object.keys(inputs?.inputs ?? {});
     // Direction 1: a declared input no prompt references. The platform may prune it,
     // in which case the agent receives nothing and the authored list sits unused.
@@ -508,30 +507,10 @@ export function checkInlineAgent(inputs, ctx) {
             ? `inputs: { ${undeclared[0]}: input('${undeclared[0]}'), … }`
             : `inputs: { ${undeclared[0]}: input('${undeclared[0]}') }`);
     }
-    // Direction 3: an input bound to a COMPUTED EXPRESSION rather than to one
-    // reference. The platform names each of an agent's arguments after the
-    // reference path it is bound to (the shell node's `agentInputVariables`), so
-    // an expression spanning zero or several references has no single argument —
-    // and therefore no name a `{{input.<x>}}` token could address. The compiler
-    // declares no argument for it, so its value does not reach the agent, and the
-    // placeholder reaches the model as literal text. An error rather than a
-    // warning, and for the same reason `INLINE_AGENT_UNDECLARED_PLACEHOLDER` is
-    // one: the value never arrives.
-    for (const [name, val] of Object.entries(inputs?.inputs ?? {})) {
-        if (!(val instanceof Expr) || val.literal)
-            continue;
-        if (flatNameOf(val.js) !== undefined)
-            continue;
-        if (!placeholders.includes(name))
-            continue;
-        at('INLINE_AGENT_COMPOSITE_INPUT', `Inline agent step "${step}"'s input \`${name}\` is bound to a computed expression `
-            + `(\`${val.js.length > 60 ? `${val.js.slice(0, 60)}…` : val.js}\`), and a prompt references it as `
-            + `\`{{input.${name}}}\`. The platform does not send the agent the names you declared: it names each `
-            + `argument after the REFERENCE PATH the input is bound to (\`$vars.a.output.b\` → \`a__output__b\`). `
-            + `A computed expression is not one reference, so it gets no argument: its value does not reach the `
-            + `agent, and the placeholder reaches the model as that literal text.`, `compute it in a script step first, then bind the step's output: `
-            + `.step('${name}Value', script({ code: 'return …;' })) … inputs: { ${name}: out('${name}Value') }`);
-    }
+    // Direction 3, an input bound to a COMPUTED EXPRESSION that a prompt
+    // references, is the serializer's INLINE_AGENT_COMPOSITE_INPUT
+    // (`compositeInputRefusal`, inline-agent.ts): the binding has no argument
+    // name, so writing the flow would drop it.
     // A step id containing `__` makes the flat name AMBIGUOUS on the platform: the
     // encoding joins path segments with `__` and v1's own inverse (`decodeFlatName`)
     // documents that it round-trips only while ids "disallow `__`". A warning, not
@@ -694,18 +673,15 @@ export function checkInlineAgent(inputs, ctx) {
             at('INLINE_AGENT_ESCALATION_NO_NAME', `Inline agent step "${step}" declares an escalation without a \`name\`. The node's definition requires one `
                 + `(\`minLength: 1\`).`);
         }
-        if (e?.variant !== undefined && e.variant !== 'quick-form') {
-            at('INLINE_AGENT_ESCALATION_VARIANT', `Inline agent step "${step}"'s escalation names the variant ${JSON.stringify(e.variant)}. Valid: `
-                + `'quick-form' — or omit it for the app-backed default.`);
+        // An unknown variant, a quick form naming an app, and an app task with
+        // inline fields are the serializer's INLINE_AGENT_ESCALATION_VARIANT /
+        // _QUICKFORM_WITH_APP / _APP_WITH_FIELDS (`refuseLossyEscalation`,
+        // inline-agent.ts): the emitter would rewrite or drop them. An unknown
+        // variant has no rules of its own to check here.
+        if (e?.variant !== undefined && e.variant !== 'quick-form')
             continue;
-        }
         if (e?.variant === 'quick-form') {
-            // The form lives INLINE: an app would be emitted and ignored, and a form
-            // with nothing to fill in is a notification nobody can answer.
-            if (e.app !== undefined) {
-                at('INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP', `Inline agent step "${step}"'s quick-form escalation also names an app. The form lives in the flow — `
-                    + `drop \`app\`, or drop the variant for the app-backed escalation.`);
-            }
+            // A form with nothing to fill in is a notification nobody can answer.
             if (!Array.isArray(e.fields) || e.fields.length === 0) {
                 at('INLINE_AGENT_ESCALATION_NO_FIELDS', `Inline agent step "${step}"'s quick-form escalation declares no \`fields\` — the reviewer gets an `
                     + `empty form.`);
@@ -733,10 +709,6 @@ export function checkInlineAgent(inputs, ctx) {
             }
             continue;
         }
-        if (e?.fields !== undefined) {
-            at('INLINE_AGENT_ESCALATION_APP_WITH_FIELDS', `Inline agent step "${step}"'s escalation declares inline \`fields\`, but its form belongs to the deployed `
-                + `app. Use variant: 'quick-form' for an inline form.`);
-        }
         if (blank(e?.app?.key) || blank(e?.app?.name)) {
             at('INLINE_AGENT_ESCALATION_NO_APP', `Inline agent step "${step}"'s escalation needs \`app.key\` and \`app.name\` — the deployed Action Center app `
                 + `that carries the review task. An escalation with no app is a task nobody can open.`);

package/dist/nodes/agent/flow/inline-agent.js

@@ -1,4 +1,5 @@
-import { agentInputPlan, inlineAgentJson } from '../../../core/agent-sidecar.js';
+import { agentInputPlan, inlineAgentJson, promptPlaceholders } from '../../../core/agent-sidecar.js';
+import { Expr } from '../../../core/expr.js';
 import { derivedContextSource, derivedEscalationSource, derivedToolSource } from '../../../core/agent-resource-identity.js';
 import { GUID_RE } from '../../../core/binding-messages.js';
 import { formFieldSettingsWire, wireFormFieldType } from '../../../core/form-field-type.js';
@@ -68,6 +69,10 @@ export function serializeInlineAgent(s, ctx) {
     // What the PLATFORM will call each of these — computed once and shared by the
     // descriptor array below and the sidecar. See `agentInputPlan`.
     const plan = agentInputPlan(s.inputs ?? {}, render);
+    // A composite input is held, not thrown here: the agent's tools, context,
+    // escalations and memory are still judged, so `check` (one refusal per
+    // step) shows their errors in the same round. Thrown at the end.
+    const compositeInput = compositeInputRefusal(s, plan.byName, step);
     // A SHELL node (#927): the prompts and the model live only in the
     // `<source>/agent.json` sidecar written below, never on the node. Studio Web
     // decides which copy wins by `hasEmbeddedAgentContent` (@uipath/flow-schema):
@@ -406,6 +411,7 @@ export function serializeInlineAgent(s, ctx) {
     // the author's values — the exact shape the deployed corpus carries.
     const escalations = s.escalation === undefined ? [] : Array.isArray(s.escalation) ? s.escalation : [s.escalation];
     for (const esc of escalations) {
+        refuseLossyEscalation(esc, step);
         const where = `inline agent "${step}": escalation "${esc.name}"`;
         const channelId = fnv1aX4Uuid(`${ctx.flowId}/${step}/escalation/${esc.name}/channel`);
         if (esc.variant === 'quick-form') {
@@ -530,6 +536,8 @@ export function serializeInlineAgent(s, ctx) {
         // (AGENT_MEMORY_NOT_AUTHORABLE); its shape maps cleanly off `AgentMemoryRef`
         // but cannot be exercised while the handle does not exist.
     }
+    if (compositeInput)
+        throw compositeInput;
     return {
         definition: { source: 'snapshot', nodeType: def.nodeType, version: def.version, manifest: def },
         // Unlike the published families the inline agent KEEPS no node-level model:
@@ -552,3 +560,56 @@ function unknownToolKind(step, kind) {
         + "kinds: 'builtin', 'connector', 'process', 'agent', 'api', 'flow', 'maestro', 'function', 'ixp', 'mcp', 'a2a', "
         + "'clientside', 'httpRequest'.");
 }
+/**
+ * The refusal for an input bound to a COMPUTED EXPRESSION that a prompt references as
+ * `{{input.<name>}}` (#1518). The platform names each agent argument after the
+ * reference path it is bound to (`agentInputPlan`), so an expression spanning
+ * zero or several references gets no argument: writing the flow anyway would
+ * drop the binding from `agentInputVariables` and `inputSchema`, and the
+ * placeholder would reach the model as literal text.
+ *
+ * For instance `inputs: { body: js\`${input('body')} + '!'\` }` with the prompt
+ * `Reply to {{input.body}}` is refused; bind a script step's output instead.
+ * An unreferenced one is `check`'s INLINE_AGENT_UNREFERENCED_INPUT warning.
+ */
+function compositeInputRefusal(s, byName, step) {
+    const placeholders = new Set(promptPlaceholders(s));
+    for (const [name, val] of Object.entries(s.inputs ?? {})) {
+        if (byName.get(name)?.kind !== 'expression' || !placeholders.has(name))
+            continue;
+        const js = val instanceof Expr ? val.js : String(val).replace(/^=js:/, '');
+        return new CompileRefusal('INLINE_AGENT_COMPOSITE_INPUT', `Inline agent step "${step}"'s input \`${name}\` is bound to a computed expression `
+            + `(\`${js.length > 60 ? `${js.slice(0, 60)}…` : js}\`), and a prompt references it as `
+            + `\`{{input.${name}}}\`. The platform does not send the agent the names you declared: it names each `
+            + `argument after the REFERENCE PATH the input is bound to (\`$vars.a.output.b\` → \`a__output__b\`). `
+            + `A computed expression is not one reference, so it gets no argument: its value does not reach the `
+            + `agent, and the placeholder reaches the model as that literal text.`, `compute it in a script step first, then bind the step's output: `
+            + `.step('${name}Value', script({ code: 'return …;' })) … inputs: { ${name}: out('${name}Value') }`);
+    }
+    return undefined;
+}
+/**
+ * Refuse an escalation the emitter below would rewrite or strip (#1518): it
+ * writes `'quick-form'` as the inline form and everything else as an app task,
+ * so an unknown variant would become an app task, a quick form's \`app\` would
+ * be dropped, and an app task's inline \`fields\` would be dropped.
+ */
+function refuseLossyEscalation(e, step) {
+    const esc = e;
+    if (esc.variant !== undefined && esc.variant !== 'quick-form') {
+        throw new CompileRefusal('INLINE_AGENT_ESCALATION_VARIANT', `Inline agent step "${step}"'s escalation names the variant ${JSON.stringify(esc.variant)}. Valid: `
+            + `'quick-form' — or omit it for the app-backed default.`);
+    }
+    if (esc.variant === 'quick-form') {
+        // The form lives INLINE: an app would be emitted nowhere.
+        if (esc.app !== undefined) {
+            throw new CompileRefusal('INLINE_AGENT_ESCALATION_QUICKFORM_WITH_APP', `Inline agent step "${step}"'s quick-form escalation also names an app. The form lives in the flow — `
+                + `drop \`app\`, or drop the variant for the app-backed escalation.`);
+        }
+        return;
+    }
+    if (esc.fields !== undefined) {
+        throw new CompileRefusal('INLINE_AGENT_ESCALATION_APP_WITH_FIELDS', `Inline agent step "${step}"'s escalation declares inline \`fields\`, but its form belongs to the deployed `
+            + `app. Use variant: 'quick-form' for an inline form.`);
+    }
+}

package/dist/nodes/agent/flow/spec.d.ts

@@ -250,7 +250,7 @@ export interface InlineAgentInputs {
      *
      *  - a **literal** (`{ tier: 'Enterprise' }`) is INLINED into both prompts — there
      *    is no argument for one, so a token could never substitute;
-     *  - a **computed expression** is refused by `check`
+     *  - a **computed expression** a prompt references is refused by `compile`
      *    (`INLINE_AGENT_COMPOSITE_INPUT`): the platform names one argument per
      *    reference, so an expression spanning several has none. Compute it in a
      *    `script` step first and bind that step's output.

package/dist/nodes/data-fabric/flow/check.js

@@ -91,10 +91,8 @@ function checkScope(inputs, ctx) {
             + 'breaks on deploy to another one.', 'resolve the key with `uip solution resources list --kind Entity`, or drop { folderKey } and keep '
             + 'the entity tenant-scoped');
     }
-    if (inputs.resourceKey !== undefined && inputs.folderKey === undefined) {
-        ctx.report('DATAFABRIC_RESOURCE_KEY_NO_FOLDER', `"${ctx.step}" sets { resourceKey } without { folderKey }. The pair exists to scope a FOLDER entity; a `
-            + 'tenant-scoped entity needs neither and serializes as a dotted literal.');
-    }
+    // A resourceKey without a folderKey is the serializer's
+    // DATAFABRIC_RESOURCE_KEY_NO_FOLDER (`applyScope`): it would be dropped.
 }
 /**
  * The query options, none of which the node's `inputDefinition` declares — they

package/dist/nodes/data-fabric/flow/shared.d.ts

@@ -47,10 +47,15 @@ export declare function fieldRows(values: Record<string, string | Expr> | undefi
 export declare function filterRows(filters: ReadonlyArray<DataFabricFilter>, ctx: FlowSerializeContext): Array<Record<string, unknown>>;
 /**
  * The folder scope, last in `entityConfig`. A folder-scoped entity is portable
- * only with its `Entity` bindings; the half-authored form is refused by check(),
- * so reaching here with both means emit both. Same id for the same (entity,
- * resourceKey), so two steps on one entity share one pair rather than
- * duplicating it.
+ * only with its `Entity` bindings, so both keys means emit both. Same id for
+ * the same (entity, resourceKey), so two steps on one entity share one pair
+ * rather than duplicating it.
+ *
+ * A `resourceKey` alone has nowhere to go: `_resourceKey` and the bindings are
+ * written only with a folder, so it would be dropped from the `.flow` without a
+ * word. `compile` does not run `check` (#1497), so it is refused here (#1518).
+ * A `folderKey` alone is written (`_folderKey`, a source-org literal), so its
+ * half (DATAFABRIC_FOLDER_NO_RESOURCE_KEY) stays `check`'s.
  */
 export declare function applyScope(cfg: EntityConfig, inputs: ScopeInputs, ctx: FlowSerializeContext): void;
 /**

package/dist/nodes/data-fabric/flow/shared.js

@@ -8,6 +8,7 @@
  * decision came with the code.
  */
 import { Expr } from '../../../core/expr.js';
+import { CompileRefusal } from '../../../core/compile-refusal.js';
 export function entityConfigOf(node) {
     const inputs = node?.inputs ?? {};
     return (inputs.entityConfig ?? {});
@@ -63,12 +64,21 @@ export function filterRows(filters, ctx) {
 }
 /**
  * The folder scope, last in `entityConfig`. A folder-scoped entity is portable
- * only with its `Entity` bindings; the half-authored form is refused by check(),
- * so reaching here with both means emit both. Same id for the same (entity,
- * resourceKey), so two steps on one entity share one pair rather than
- * duplicating it.
+ * only with its `Entity` bindings, so both keys means emit both. Same id for
+ * the same (entity, resourceKey), so two steps on one entity share one pair
+ * rather than duplicating it.
+ *
+ * A `resourceKey` alone has nowhere to go: `_resourceKey` and the bindings are
+ * written only with a folder, so it would be dropped from the `.flow` without a
+ * word. `compile` does not run `check` (#1497), so it is refused here (#1518).
+ * A `folderKey` alone is written (`_folderKey`, a source-org literal), so its
+ * half (DATAFABRIC_FOLDER_NO_RESOURCE_KEY) stays `check`'s.
  */
 export function applyScope(cfg, inputs, ctx) {
+    if (inputs.resourceKey !== undefined && inputs.folderKey === undefined) {
+        throw new CompileRefusal('DATAFABRIC_RESOURCE_KEY_NO_FOLDER', `"${ctx.step}" sets { resourceKey } without { folderKey }, and compile writes the resource key only with a folder key. `
+            + 'Add { folderKey } to scope a folder entity, or drop { resourceKey } for a tenant-scoped one.', "folderKey: '<folder key>'");
+    }
     if (inputs.folderKey !== undefined)
         cfg._folderKey = inputs.folderKey;
     if (inputs.folderKey !== undefined && inputs.resourceKey !== undefined) {

package/dist/nodes/document/flow/ixp.js

@@ -216,10 +216,27 @@ function ixpDeploymentBindings(spec, existing) {
  * definition does not have.
  *
  * They are not reachable through `ixpExtract()`'s typed surface, which is the
- * point of having one; this check exists for the JS caller and for a
+ * point of having one; this refusal exists for the JS caller and for a
  * hand-written spec object, where TypeScript is not in the way.
  */
 const IXP_FORBIDDEN_INPUTS = ['digitizationMode', 'documentTaxonomy', 'attachmentId', 'fileName', 'mimeType'];
+/**
+ * Refuse an input of the prior schema (IXP_FORBIDDEN_INPUT). The node's inputs
+ * are the definition's `inputDefaults` plus `fileRef` and `pageRange`, so
+ * writing the step anyway would silently drop the field (#1518). One refusal
+ * per step names every such field, each with where its value went.
+ */
+function refuseForbiddenInputs(s, step) {
+    const set = IXP_FORBIDDEN_INPUTS.filter((f) => s[f] !== undefined);
+    if (set.length === 0)
+        return;
+    const why = (f) => `\`${f}\`, which the current node does not declare — it belonged to a prior schema. `
+        + (f === 'documentTaxonomy' ? 'The taxonomy travels in the resolved `model` blob.'
+            : f === 'digitizationMode' ? 'The serializer defaults it to `fileUpload` internally.'
+                : 'It is derived from `fileRef` upstream.');
+    throw new CompileRefusal('IXP_FORBIDDEN_INPUT', `IxP step "${step}" sets ${set.map(why).join(' It also sets ')} Remove ${set.length === 1 ? 'it' : 'them'}: `
+        + `the \`.flow\` would drop ${set.length === 1 ? 'it' : 'them'}.`);
+}
 /**
  * `ixpExtract(...)`-specific checks.
  *
@@ -255,14 +272,7 @@ function checkIxpExtract(inputs, ctx) {
         at('IXP_NO_FILE', `IxP step "${step}" has no \`fileRef\`. It is the node's only required INPUT (\`inputDefinition.required\`) `
             + `and it takes a whole Flow Attachment object — normally a \`file\`-typed flow input.`, `fileRef: out('start', 'invoiceFile')   // .input({ invoiceFile: types.file })`);
     }
-    for (const f of IXP_FORBIDDEN_INPUTS) {
-        if (inputs?.[f] !== undefined) {
-            at('IXP_FORBIDDEN_INPUT', `IxP step "${step}" sets \`${f}\`, which the current node does not declare — it belonged to a prior `
-                + `schema. ${f === 'documentTaxonomy' ? 'The taxonomy travels in the resolved `model` blob.'
-                    : f === 'digitizationMode' ? 'The serializer defaults it to `fileUpload` internally.'
-                        : 'It is derived from `fileRef` upstream.'}`);
-        }
-    }
+    // An input of the prior schema is the serializer's IXP_FORBIDDEN_INPUT.
 }
 /**
  * The extractor's node: the definition's `inputDefaults` with the file the
@@ -270,6 +280,7 @@ function checkIxpExtract(inputs, ctx) {
  */
 function serializeIxpExtract(s, ctx) {
     const def = ixpExtractDef(s, ctx.step); // throws on an unparseable project
+    refuseForbiddenInputs(s, ctx.step);
     const { versionId } = parseIxpProjectType(s.project); // ixpExtractDef threw if it could not parse
     // The bindings first: two steps on the same project share ONE pair, and the
     // definition's `model.bindings.resourceKey` names the key they hang off.

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

@@ -2244,6 +2244,34 @@ function serializeFlow(built, opts) {
             || scope.pendingEdges.some((p) => p.from.node === node && isOutcome(p.from.port));
         return tails.filter((t) => capsOpenTail.has(t.node) && !hasOutcomeEdge(t.node));
     }
+    /**
+     * A subflow body is started by its caller, through the one manual Start node
+     * `emitSubflowBodyIn` writes. So a child's own way of starting has nowhere to
+     * go in the `.flow`, and writing the body without it would silently drop what
+     * the author wrote (#1067): a `.trigger(scheduled(…))` would never fire, and an
+     * `.entryPoint()` root and its steps would vanish. Both are refused.
+     * `.trigger(manual(), { label, version })` is allowed: it names the child's
+     * Start node (#1050), and it is the form decompile writes for a renamed one.
+     */
+    function refuseChildRoots(child, step) {
+        // `subflow(undefined, …)` is `check`'s SUBFLOW_NO_CHILD.
+        if (!child || !Array.isArray(child.steps))
+            return;
+        const kind = child.trigger?.kind;
+        if (child.trigger !== undefined && kind !== 'manual') {
+            const noun = kind === 'scheduled' ? 'schedule' : kind === 'event' ? 'event subscription' : 'trigger';
+            throw new CompileRefusal('SUBFLOW_CHILD_TRIGGER', `Subflow "${step}" runs a flow with its own \`.trigger(…)\`. A subflow is started by its caller, never by a `
+                + `trigger of its own — the ${noun} would be dropped. Remove the .trigger() from "${child.id}" `
+                + `(\`.trigger(manual(), { label })\` is allowed, to name the child's start node).`);
+        }
+        const roots = child.entryPoints ?? [];
+        if (roots.length > 0) {
+            throw new CompileRefusal('SUBFLOW_CHILD_ENTRY_POINT', `Subflow "${step}" runs a flow with ${roots.length === 1 ? 'an entry point' : 'entry points'} `
+                + `(${roots.map((r) => `"${r.id}"`).join(', ')}). A subflow has one root, its caller, so the entry `
+                + `${roots.length === 1 ? 'point and its steps' : 'points and their steps'} would be dropped. Call a flow `
+                + `without .entryPoint(), or move each entry point's steps into a flow of its own.`);
+        }
+    }
     /**
      * Emit a child flow into its own scope and register it under the calling
      * node's id — that key is how the format names a subflow body, and how
@@ -2252,7 +2280,7 @@ function serializeFlow(built, opts) {
      * The child gets its own manual Start node (a subflow always starts manually
      * — nothing schedules a subflow; its caller is the trigger) and its own
      * variables. A child's `.trigger(manual(), { label, version })` sets that
-     * node's canvas label and exact version; `check` refuses any other kind.
+     * node's canvas label and exact version; `refuseChildRoots` refuses any other kind.
      * Every `in` variable carries `triggerNodeId` pointing at that
      * Start: it is what binds the caller's value, and omitting it is the single
      * defect that makes a subflow validate clean and then fault at run time with
@@ -3026,6 +3054,7 @@ function serializeFlow(built, opts) {
         if (registered)
             return emitRegistered(registered, step, tails, scope, parentId);
         if (spec.kind === 'subflow') {
+            refuseChildRoots(spec.child, step.name);
             const id = stepUid(scope, step.name);
             // `subflows` is ONE flat map for the whole file, keyed by the calling
             // node's id. `stepUid` draws from the file-wide allocator, including in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.66.6",
+  "version": "6.66.7",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "108478742e5fc426dc26ba07020d85a3fdbcaa66"
+  "gitref": "00764f58249484b8ee341c2cc0d24b38eee8ec14"
 }