@servicenow/sdk-build-plugins 4.4.1 → 4.6.0

package/src/flow/plugins/flow-data-pill-plugin.ts

@@ -91,10 +91,13 @@ export function determineRootIdentifierAndPath(
     let pathStr = ''
 
     switch (propertyNames[1]) {
-        case 'inputs':
-            rootIdentifier = 'subflow' // <-- Hardcoded: But need to handle if this input is in action/subflow body when we do action body impl.
+        case 'inputs': {
+            // Detect if inside Action() body → emit {{action.xxx}}, otherwise {{subflow.xxx}}
+            const actionAncestor = findAncestorByCalleeName(propertyAccessShape.getOriginalNode(), 'Action')
+            rootIdentifier = actionAncestor ? 'action' : 'subflow'
             pathStr = propertyNames.slice(2).join('.')
             break
+        }
         case 'flowVariables':
             // For params.flowVariables (schema reference), use 'flowVariables' as identifier with empty path
             // For params.flowVariables.someVar (property access), use 'flow_variable' as identifier
@@ -156,6 +159,7 @@ function getForEachParameterName(identifierShape: IdentifierShape): string | nul
 
 export const DataPillPlugin = Plugin.create({
     name: 'DataPillPlugin',
+    docs: [],
     shapes: [
         {
             shape: PropertyAccessShape,

package/src/flow/plugins/flow-definition-plugin.ts

@@ -17,7 +17,6 @@ import {
     type Diagnostics,
     ts,
     deleteMultipleDiff,
-    StringLiteralShape,
     type Logger,
 } from '@servicenow/sdk-build-core'
 import { gzipSync } from 'node:zlib'
@@ -38,7 +37,7 @@ import {
     uuidToSysId,
     validateFlowVariableCall,
 } from '../utils/utils'
-import { getCallExpressionName } from '../../utils'
+import { createSdkDocEntry, getCallExpressionName } from '../../utils'
 import {
     extractLabelCache,
     createDefinitionMap,
@@ -55,6 +54,7 @@ import {
     createPropertyAccessFromPath,
 } from '../utils/pill-string-parser'
 import { isDataPill } from '../utils/complex-object-resolver'
+import { wrapWithDataPillCall, extractDataPillNames } from '../utils/pill-shape-helpers'
 import { ArrayShape } from '@servicenow/sdk-build-core'
 import { processFlowInputs, processFlowOutputs, processFlowVariables } from '../utils/flow-variable-processor'
 import { buildUuidToIdentifierMap, processInstanceForDatapills, uuidToRecordMap } from '../utils/datapill-transformer'
@@ -211,7 +211,7 @@ import { ApprovalDueDateShape, ApprovalRulesShape } from '../utils/flow-shapes'
 
 /**
  * Traverse ancestors to find the topmost ArrowFunction and extract its parameter name
- * This finds the ArrowFunction that's an argument to Flow/SubflowDefinition, ignoring nested
+ * This finds the ArrowFunction that's an argument to Flow/Subflow, ignoring nested
  * ArrowFunctions from control flow APIs like If, ElseIf, ForEach.
  *
  * @param shape - The shape to start traversing from
@@ -446,45 +446,6 @@ function processShapeForDatapills(
  * @param dataType - The data type string (default: 'string')
  * @returns CallExpressionShape wrapping the expression with wfa.dataPill()
  */
-function wrapWithDataPillCall(
-    expression: PropertyAccessShape | IdentifierShape,
-    source: Record,
-    dataType = 'string'
-): CallExpressionShape {
-    return new CallExpressionShape({
-        source,
-        callee: 'wfa.dataPill',
-        args: [expression, new StringLiteralShape({ source, literalText: dataType })],
-    })
-}
-
-/**
- * Extract all datapill names from a string value containing datapill patterns
- * Handles both UUID-based pills ({{uuid.property}}) and semantic pills ({{prefix.path}})
- *
- * @param stringValue - String that may contain datapill patterns
- * @returns Array of datapill names (e.g., ["trigger.table_name", "uuid.record.number"])
- */
-function extractDataPillNames(stringValue: string): string[] {
-    const dataPillNames: string[] = []
-
-    // Match all datapill patterns: {{...}}
-    const pillPattern = /\{\{([^}]+)\}\}/g
-    const matches = Array.from(stringValue.matchAll(pillPattern))
-
-    for (const match of matches) {
-        if (match[1]) {
-            // Extract the content inside {{}} and split by | to get just the name part
-            // (some pills may have type info like {{pill.name|string}})
-            const pillContent = match[1].split('|')[0]
-            if (pillContent) {
-                dataPillNames.push(pillContent)
-            }
-        }
-    }
-
-    return dataPillNames
-}
 
 /**
  * Wrap all PropertyAccessShape expressions in a TemplateExpressionShape with wfa.dataPill()
@@ -610,16 +571,22 @@ function extractAllPills(
         const matchStart = match.index ?? 0
         const matchEnd = matchStart + fullMatch.length
 
-        // Try UUID pattern first (more specific)
-        // UUID format: 8-4-4-4-12 hex digits followed by dot and property path
-        const uuidMatch = content.match(
-            /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.([a-zA-Z_][a-zA-Z0-9_.]*[a-zA-Z0-9_])$/
+        // Strip type annotation if present (e.g., "uuid.field|integer" -> "uuid.field").
+        // ServiceNow stores datapills with type annotations like {{pill.path|datatype}}.
+        const pipeIndex = content.indexOf('|')
+        const cleanContent = pipeIndex !== -1 ? content.substring(0, pipeIndex) : content
+
+        // Match UUID-based pills: both bare UUID (action/subflow outputs) and step[UUID] (action step outputs)
+        // Bare:  {{uuid.property}}           → e.g., action/subflow instance output
+        // Step:  {{step[uuid].property}}     → e.g., action step output
+        const uuidMatch = cleanContent.match(
+            /^(?:step\[([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\]|([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}))\.([a-zA-Z_][a-zA-Z0-9_.]*[a-zA-Z0-9_])$/
         )
 
         if (uuidMatch) {
             // This is a UUID-based pill
-            const uuid = uuidMatch[1]
-            const property = uuidMatch[2]
+            const uuid = uuidMatch[1] ?? uuidMatch[2]
+            const property = uuidMatch[3]
 
             if (!uuid || !property) {
                 continue
@@ -628,7 +595,10 @@ function extractAllPills(
             const identifier = uuidToIdentifierMap.get(uuid)
 
             if (identifier) {
-                // PRESERVE EXISTING LOGIC: Apply forEach parameter handling
+                // PRESERVE EXISTING LOGIC: Apply forEach parameter handling.
+                // Note: With the consolidated regex, this is now called for step[UUID] pills too
+                // (previously only bare UUID pills hit this code). This is harmless since action
+                // step CIDs are never forEach parameters, so isForEachParam will always be false.
                 const isForEachParam = isForEachParameter(identifier, uuid)
                 let expression: PropertyAccessShape | IdentifierShape
 
@@ -1619,6 +1589,7 @@ function postProcessAssignSubflowOutputs(
 
 export const FlowDefinitionPlugin = Plugin.create({
     name: 'FlowDefinitionPlugin',
+    docs: [createSdkDocEntry('Flow', ['sys_hub_flow'])],
     records: {
         sys_hub_flow: {
             relationships: {
@@ -1680,8 +1651,8 @@ export const FlowDefinitionPlugin = Plugin.create({
             getUpdateName(record) {
                 return { success: true, value: `${record.getTable()}_${record.getId().getValue()}` }
             },
-            toFile(record, { config, database }) {
-                return generateXML(record, { config, database })
+            toFile(record, { config, database, self }) {
+                return generateXML(record, { config, database, plugin: self })
             },
             async diff(existing, incoming, descendants, context) {
                 return deleteMultipleDiff(existing, incoming, descendants, context)

package/src/flow/plugins/flow-diagnostics-plugin.ts

@@ -90,11 +90,12 @@ function isInsideFlowContext(node: ts.Node): boolean {
  * - wfa.flowLogic.goBackTo
  * - wfa.flowLogic.tryCatch
  * - wfa.flowLogic.doInParallel
- * - FlowObject (must be within Flow/Subflow/ActionDefinition/SubflowDefinition/TriggerDefinition)
- * - FlowArray (must be within Flow/Subflow/ActionDefinition/SubflowDefinition/TriggerDefinition)
+ * - FlowObject (must be within Flow/Subflow/Action/TriggerDefinition)
+ * - FlowArray (must be within Flow/Subflow/Action/TriggerDefinition)
  */
 export const FlowDiagnosticsPlugin = Plugin.create({
     name: 'FlowDiagnosticsPlugin',
+    docs: [],
     shapes: [
         {
             shape: CallExpressionShape,

package/src/flow/plugins/flow-instance-plugin.ts

@@ -39,7 +39,7 @@ import {
     findCatalogItemBySysId,
     isCatalogAction,
 } from '../utils/service-catalog'
-import { getAttributeValue } from '../utils/schema-to-flow-object'
+import { getAttributeValue, parseAttributesToObject } from '../utils/schema-to-flow-object'
 import {
     ActionSubflowInstanceShape,
     ApprovalRulesShape,
@@ -64,6 +64,8 @@ import {
     ACTION_TYPE_KEY_NAME,
     CATALOG_VARIABLE_TABLE,
     CATALOG_VARIABLE_SET_TABLE,
+    INLINE_SCRIPT_UNSUPPORTED_TYPES,
+    INLINE_SCRIPT_UNSUPPORTED_FIELDS,
 } from '../utils/flow-constants'
 
 import type { ApprovalDueDateType, ApprovalRulesType } from '@servicenow/sdk-core/runtime/flow'
@@ -164,10 +166,13 @@ export function normalizeInputValue(value: string, uiType?: string, source?: Sou
                 // Create a StringShape from the value and use ApprovalRulesShape.from() to parse it
                 return ApprovalRulesShape.from(source, Shape.from(source, value).asString())
             } else if (uiType === APPROVAL_DUE_DATE_DATA_TYPE_VALUE) {
-                // Check if source is a Record before accessing action_type
+                // Check if source is a Record before accessing action_type or step_type.
+                // Flow context uses action_type; action definition context uses step_type.
                 if (source instanceof Record) {
                     const actionType = source.get(ACTION_TYPE_KEY_NAME)?.ifDefined()?.asString()?.getValue()
-                    if (APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS.includes(actionType as string)) {
+                    const stepType = source.get('step_type')?.ifDefined()?.asString()?.getValue()
+                    const typeId = actionType ?? stepType
+                    if (typeId && APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS.includes(typeId)) {
                         // Create a StringShape from the value and use ApprovalDueDateShape.from() to parse it
                         return ApprovalDueDateShape.from(source, Shape.from(source, value).asString())
                     }
@@ -275,10 +280,6 @@ function buildInstanceToShape({
                 }
 
                 const coreActionIdentifier = getCoreActionIdentifier(sysId)
-                if (callee === ACTION_INSTANCE_API_NAME && !coreActionIdentifier) {
-                    logger.warn(`Custom actions are not supported, action = ${sysId}`)
-                    return { success: false }
-                }
 
                 const action = database
                     .query('sys_hub_action_type_definition')
@@ -325,13 +326,12 @@ function buildInstanceToShape({
         if (inputsShape === undefined) {
             return { success: false as const }
         }
-        const waitForCompletion =
-            record.get('wait_for_completion')?.getValue() === true ||
-            record.get('wait_for_completion')?.getValue() === 'true'
-        if (waitForCompletion) {
+        const waitForCompletionValue = record.get('wait_for_completion')?.getValue()
+        const isWaitForCompletionFalse = waitForCompletionValue === false || waitForCompletionValue === 'false'
+        if (isWaitForCompletionFalse) {
             inputsShape = inputsShape
-                ? inputsShape.merge({ waitForCompletion })
-                : Shape.from(record, { waitForCompletion }).asObject()
+                ? inputsShape.merge({ waitForCompletion: false })
+                : Shape.from(record, { waitForCompletion: false }).asObject()
         }
 
         const configArg = new ObjectShape({
@@ -451,6 +451,7 @@ function validateCatalogVariableOutputReferences(
 
 export const FlowInstancePlugin = Plugin.create({
     name: 'FlowInstancePlugin',
+    docs: [],
     records: {
         sys_hub_action_instance_v2: {
             toShape: buildInstanceToShape({
@@ -518,6 +519,7 @@ export const FlowInstancePlugin = Plugin.create({
                         source: callExpression,
                         transform,
                         logger,
+                        diagnostics,
                     })
                 } else if (instanceType === SUBFLOW_INSTANCE_API_NAME) {
                     instanceRecord = await buildSubflowInstance({
@@ -529,6 +531,7 @@ export const FlowInstancePlugin = Plugin.create({
                         factory,
                         source: callExpression,
                         transform,
+                        diagnostics,
                     })
                 }
 
@@ -708,6 +711,7 @@ async function buildActionInstance({
     source,
     transform,
     logger,
+    diagnostics,
 }: {
     actionDef: Record | StringShape | undefined
     inputs: ObjectShape
@@ -718,8 +722,12 @@ async function buildActionInstance({
     source: Source
     transform: Transform
     logger: Logger
+    diagnostics: Diagnostics
 }): Promise<Record | undefined> {
-    const values = actionDef ? await prepareActionInstanceValueJson(inputs, actionDef, transform, logger) : undefined
+    const values = actionDef
+        ? await prepareActionInstanceValueJson(inputs, actionDef, transform, logger, diagnostics)
+        : undefined
+
     const actionDefRecord = actionDef instanceof Record ? actionDef : undefined
     const instanceProps = inputs.transform(({ $ }) => ({
         active: $.val(true),
@@ -759,6 +767,7 @@ async function buildSubflowInstance({
     uuid,
     source,
     transform,
+    diagnostics,
 }: {
     subflowDef: Record | StringShape | undefined
     inputs: ObjectShape
@@ -768,8 +777,11 @@ async function buildSubflowInstance({
     uuid: string | undefined
     source: Source
     transform: Transform
+    diagnostics: Diagnostics
 }): Promise<Record | undefined> {
-    const values = subflowDef ? await prepareSubflowInstanceValueJson(inputs, subflowDef, transform) : undefined
+    const values = subflowDef
+        ? await prepareSubflowInstanceValueJson(inputs, subflowDef, transform, diagnostics)
+        : undefined
 
     const subflowDefRecord = subflowDef instanceof Record ? subflowDef : undefined
     const instanceProps = inputs.transform(({ $ }) => ({
@@ -781,7 +793,7 @@ async function buildSubflowInstance({
         generation_source: $.val(''),
         subflow: $.val(subflowDefRecord?.getId()?.getValue() || subflowDef?.getValue() || ''),
         subflow_inputs: $.val(values),
-        wait_for_completion: $.from('waitForCompletion').def(false),
+        wait_for_completion: $.from('waitForCompletion').def(true),
         sys_class_name: $.val('sys_hub_sub_flow_instance_v2'),
         parent_ui_id: $.def(''),
     }))
@@ -867,7 +879,7 @@ function resolveComplexInput(
     parentDef: Record,
     inputTableName: string,
     logger?: Logger
-): { value: unknown; internalType: unknown } {
+): { value: unknown; internalType: unknown; children?: unknown[] } {
     return _resolveComplexInput(name, value, parentDef, inputTableName, undefined, logger)
 }
 
@@ -943,14 +955,27 @@ function processInputValue(
 }
 
 /**
- * Processes a definition input that was not provided by the user.
+ * Processes a definition input not provided by the user.
  * Handles hidden fields and default values by creating appropriate input objects.
  *
+ * For hidden inputs, all attributes from the input definition are included in the
+ * parameter (e.g., `element_mapping_provider`, `uiType`) so that Flow Designer can
+ * properly handle them at runtime. For reference types, the reference table is also
+ * included. For complex object types (`FlowObject`/`FlowArray`), the complex object
+ * value is generated via `resolveComplexInput`.
+ *
  * @param inputDef - The input definition record from the action/subflow definition
  * @param inputName - The name of the input field
+ * @param actionDefRecord - The parent action definition record (needed for complex object resolution)
+ * @param logger - Logger instance
  * @returns The processed input object if the field is hidden or has a default value, undefined otherwise
  */
-function processDefaultOrHiddenInput(inputDef: Record, inputName: string): unknown | undefined {
+function processDefaultOrHiddenInput(
+    inputDef: Record,
+    inputName: string,
+    actionDefRecord?: Record,
+    logger?: Logger
+): unknown | undefined {
     // Get attributes and check if hidden
     const attributes = inputDef.get('attributes')?.ifString()?.getValue()
     const visibleAttr = attributes ? getAttributeValue(attributes, 'visible') : undefined
@@ -962,16 +987,60 @@ function processDefaultOrHiddenInput(inputDef: Record, inputName: string): unkno
     const hasDefaultValue = defaultValue !== undefined && defaultValue !== null && defaultValue !== ''
     const internalType = inputDef.get('internal_type')?.asString()?.getValue() || 'string'
 
-    // For hidden fields or fields with default values, add them to result
+    // For hidden fields or fields with default values, add them to the result.
     if (isHidden || hasDefaultValue) {
-        const valueToUse = hasDefaultValue ? defaultValue : ''
-        const paramAttributes: { visible?: boolean; visible_in_fd?: boolean } = {}
-        if (visibleAttr === 'false') {
-            paramAttributes.visible = false
+        let valueToUse: unknown = hasDefaultValue ? defaultValue : ''
+
+        // Parse all attributes from the input definition for the parameter.
+        const paramAttributes: globalThis.Record<string, unknown> = {}
+        if (attributes) {
+            const parsedAttributes = parseAttributesToObject(attributes)
+            for (const [key, value] of Object.entries(parsedAttributes)) {
+                if (value !== undefined) {
+                    paramAttributes[key] = value
+                }
+            }
         }
-        if (visibleInFdAttr === 'false') {
-            paramAttributes.visible_in_fd = false
+
+        // Get the reference table for reference type inputs.
+        const reference = inputDef.get('reference')?.ifString()?.getValue()
+
+        // For complex object types (`FlowObject`/`FlowArray`), resolve the value.
+        const coType = paramAttributes['co_type_name'] as string | undefined
+        const uiType = paramAttributes['uiType'] as string | undefined
+
+        if (actionDefRecord && coType && uiType) {
+            const resolvedValue = resolveComplexInput(
+                inputName,
+                typeof valueToUse === 'object' && valueToUse !== null ? valueToUse : {},
+                actionDefRecord,
+                'sys_hub_action_input',
+                logger
+            )
+
+            if (resolvedValue.value !== undefined) {
+                valueToUse = resolvedValue.value
+            }
+
+            const result: globalThis.Record<string, unknown> = {
+                name: inputName,
+                value: valueToUse,
+                displayValue: valueToUse,
+                scriptActive: false,
+                parameter: {
+                    type: resolvedValue.internalType ?? internalType,
+                    ...(Object.keys(paramAttributes).length > 0 && { attributes: paramAttributes }),
+                    ...(reference && { reference }),
+                },
+            }
+
+            if (resolvedValue.children && resolvedValue.children.length > 0) {
+                result['children'] = resolvedValue.children
+            }
+
+            return result
         }
+
         return {
             name: inputName,
             value: valueToUse,
@@ -980,12 +1049,68 @@ function processDefaultOrHiddenInput(inputDef: Record, inputName: string): unkno
             parameter: {
                 type: internalType,
                 ...(Object.keys(paramAttributes).length > 0 && { attributes: paramAttributes }),
+                ...(reference && { reference }),
             },
         }
     }
     return undefined
 }
 
+/**
+ * Validates mandatory fields on raw shapes before datapill or inline script resolution. Only `StringShape`
+ * values are validated for emptiness. Runtime-evaluated shapes (data pills, template expressions, inline
+ * scripts, identifiers) are exempt because their values cannot be determined at build time.
+ *
+ * @param definition - The action or subflow definition record containing input definitions.
+ * @param instanceInputs - The raw ObjectShape of user-provided input values before resolution.
+ * @param diagnostics - Diagnostics instance for reporting validation errors.
+ * @param inputTable - The table name for input definitions (e.g., 'sys_hub_action_input' or 'sys_hub_flow_input').
+ * @param definitionName - Optional name of the action or subflow for more specific error messages.
+ * @returns The filtered input definition records for reuse, or undefined if no definition.
+ */
+function validateMandatoryFields(
+    definition: Record | undefined,
+    instanceInputs: ObjectShape,
+    diagnostics: Diagnostics,
+    inputTable: string,
+    definitionName?: string
+): Record[] | undefined {
+    const inputDefinitions = definition
+        ? definition.flat().filter((record) => record.getTable() === inputTable)
+        : undefined
+
+    if (inputDefinitions) {
+        const rawEntries = new Map(instanceInputs.entries({ resolve: false }))
+
+        for (const inputDefinition of inputDefinitions) {
+            const inputName = inputDefinition.get('element')?.asString()?.getValue() ?? ''
+            if (!inputName) {
+                continue
+            }
+
+            const isMandatory = inputDefinition.get('mandatory')?.ifBoolean()?.getValue() ?? false
+            if (!isMandatory) {
+                continue
+            }
+
+            const rawShape = rawEntries.get(inputName)
+            if (!rawShape) {
+                continue
+            }
+
+            if (rawShape.isString() && rawShape.isEmpty()) {
+                const context = definitionName ? ` in action '${definitionName}'` : ''
+                diagnostics.error(
+                    rawShape,
+                    `Mandatory field '${inputName}'${context} cannot be an empty string. Please provide a non-empty value.`
+                )
+            }
+        }
+    }
+
+    return inputDefinitions
+}
+
 /**
  * Resolve a catalog item record from a Shape (direct Record, TemplateExpressionShape, or IdentifierShape).
  */
@@ -1162,7 +1287,8 @@ async function prepareActionInstanceValueJson(
     instanceInputs: ObjectShape | undefined,
     actionDef: Record | StringShape,
     transform: Transform,
-    logger: Logger
+    logger: Logger,
+    diagnostics: Diagnostics
 ) {
     const actionDefRecord = actionDef.isRecord() ? actionDef.as(Record) : undefined
     if (!instanceInputs) {
@@ -1170,13 +1296,25 @@ async function prepareActionInstanceValueJson(
     }
     const isActionDefString = actionDef instanceof StringShape
 
+    // Resolve action name early for use in validation messages and special handling
+    const actionSysId = actionDefRecord?.getId()?.getValue()
+    const actionName = typeof actionSysId === 'string' ? CORE_ACTIONS_SYS_ID_NAME_MAP[actionSysId] : undefined
+
+    const definitionInputs = validateMandatoryFields(
+        actionDefRecord,
+        instanceInputs,
+        diagnostics,
+        'sys_hub_action_input',
+        actionName
+    )
+
     // Special handling for getCatalogVariables action
     let overrideValues = new Map<string, string>()
     let displayValues = new Map<string, string>()
+    let unsupportedFieldsForAction: string[] | undefined
 
     if (actionDefRecord) {
-        const actionSysId = actionDefRecord.getId().getValue()
-        const actionName = typeof actionSysId === 'string' ? CORE_ACTIONS_SYS_ID_NAME_MAP[actionSysId] : undefined
+        unsupportedFieldsForAction = actionName ? INLINE_SCRIPT_UNSUPPORTED_FIELDS[actionName] : undefined
 
         // Check if this is the getCatalogVariables action or createCatalogTask action
         if (actionName === 'getCatalogVariables' || actionName === 'createCatalogTask') {
@@ -1218,9 +1356,8 @@ async function prepareActionInstanceValueJson(
 
     // When isActionDefString is true, there's no action definition in fluent
     // We expect arbitrary inputs and should process all provided inputs directly
-    if (actionDefRecord) {
-        // When action definition record is present, process only definition inputs
-        const definitionInputs = actionDefRecord.flat().filter((v) => v.getTable() === 'sys_hub_action_input')
+    if (actionDefRecord && definitionInputs) {
+        // When action definition record is present, process only the definition inputs.
         const providedInputNames = new Set(objShape.keys())
 
         for (const inputDef of definitionInputs) {
@@ -1230,6 +1367,26 @@ async function prepareActionInstanceValueJson(
             }
             // If input is provided in objShape(ie provided by user), process it
             if (providedInputNames.has(inputName)) {
+                const internalType = inputDef.get('internal_type')?.asString()?.getValue()
+                const inputValue = objShape.get(inputName)
+                if (
+                    isInlineScriptValue(inputValue?.getValue()) &&
+                    internalType &&
+                    INLINE_SCRIPT_UNSUPPORTED_TYPES.includes(internalType)
+                ) {
+                    diagnostics.error(
+                        inputValue,
+                        `wfa.inlineScript() is not supported for input '${inputName}' of type '${internalType}'. This type uses special parsing that is incompatible with dynamic script execution.`
+                    )
+                    continue
+                }
+                if (isInlineScriptValue(inputValue?.getValue()) && unsupportedFieldsForAction?.includes(inputName)) {
+                    diagnostics.error(
+                        inputValue,
+                        `wfa.inlineScript() is not supported for input '${inputName}'. This field references catalog metadata that must be resolved at design time for the Flow Designer UI.`
+                    )
+                    continue
+                }
                 const processedValue = processInputValue(
                     inputName,
                     objShape,
@@ -1243,7 +1400,7 @@ async function prepareActionInstanceValueJson(
                 result.push(processedValue)
             } else {
                 // Process default or hidden input
-                const processedValue = processDefaultOrHiddenInput(inputDef, inputName)
+                const processedValue = processDefaultOrHiddenInput(inputDef, inputName, actionDefRecord, logger)
                 if (processedValue) {
                     result.push(processedValue)
                 }
@@ -1262,8 +1419,15 @@ async function prepareActionInstanceValueJson(
 async function prepareSubflowInstanceValueJson(
     instanceInputs: ObjectShape,
     subflowDef: Record | StringShape,
-    transform: Transform
+    transform: Transform,
+    diagnostics: Diagnostics
 ) {
+    const subflowDefRecord = subflowDef.isRecord() ? subflowDef.as(Record) : undefined
+    const subflowName = subflowDefRecord?.get('name')?.ifString()?.getValue()
+
+    // Validate mandatory fields on raw shapes before any resolution.
+    validateMandatoryFields(subflowDefRecord, instanceInputs, diagnostics, 'sys_hub_flow_input', subflowName)
+
     // Check for datapills and resolve them
     const dataPillResults = await checkAndResolveDataPills(instanceInputs, transform)
 
@@ -1297,8 +1461,9 @@ async function prepareSubflowInstanceValueJson(
                 value: primitiveValue,
                 internalType: undefined,
             }
-            if (subflowDef.isRecord()) {
-                resolvedValue = resolveComplexInput(key, primitiveValue, subflowDef.as(Record), 'sys_hub_flow_input')
+
+            if (subflowDefRecord) {
+                resolvedValue = resolveComplexInput(key, primitiveValue, subflowDefRecord, 'sys_hub_flow_input')
             }
 
             const result: globalThis.Record<string, unknown> = {

package/src/flow/plugins/flow-trigger-instance-plugin.ts

@@ -24,6 +24,7 @@ import { isArray } from 'lodash'
 
 export const TriggerInstancePlugin = Plugin.create({
     name: 'TriggerInstancePlugin',
+    docs: [],
     records: {
         sys_hub_trigger_instance_v2: {
             toShape(record, { logger, database }) {

package/src/flow/plugins/inline-script-plugin.ts

@@ -47,6 +47,7 @@ export class FDInlineScriptCallShape extends CallExpressionShape {
  */
 export const InlineScriptPlugin = Plugin.create({
     name: 'InlineScriptPlugin',
+    docs: [],
     shapes: [
         {
             shape: CallExpressionShape,

package/src/flow/plugins/step-definition-plugin.ts

@@ -2,11 +2,13 @@ import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
 import { buildVariableShapes } from '../utils/flow-io-to-record'
 import { NowIdShape } from '../../now-id-plugin'
 import { generateXML } from '../utils/flow-to-xml'
+import { createSdkDocEntry } from '../../utils'
 /**
  * Plugin for processing StepDefinition calls
  */
 export const StepDefinitionPlugin = Plugin.create({
     name: 'StepDefinitionPlugin',
+    docs: [createSdkDocEntry('ActionStepDefinition', ['sys_flow_step_definition'])],
     records: {
         sys_flow_step_definition: {
             relationships: {
@@ -53,8 +55,8 @@ export const StepDefinitionPlugin = Plugin.create({
                     }),
                 }
             },
-            toFile(record, { config, database }) {
-                return generateXML(record, { config, database })
+            toFile(record, { config, database, self }) {
+                return generateXML(record, { config, database, plugin: self })
             },
         },
         sys_flow_step_definition_input: {