@servicenow/sdk-build-plugins 4.6.0 → 4.7.0

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

@@ -159,7 +159,6 @@ function getForEachParameterName(identifierShape: IdentifierShape): string | nul
 
 export const DataPillPlugin = Plugin.create({
     name: 'DataPillPlugin',
-    docs: [],
     shapes: [
         {
             shape: PropertyAccessShape,
@@ -207,12 +206,11 @@ export const DataPillPlugin = Plugin.create({
                     const expr = span.getExpression()
                     const literalText = span.getLiteralText()
 
-                    const pillShapeResult = expr.is([PropertyAccessShape, IdentifierShape])
+                    const pillShape = expr.is([PropertyAccessShape, IdentifierShape])
                         ? await transform.toSubclass(expr, DataPillPlugin) // In case of PropertyAccessShape call the toSubclass() again, which calls above handler
-                        : { success: false, value: undefined }
+                        : undefined
 
-                    if (pillShapeResult.success) {
-                        const pillShape = pillShapeResult.value
+                    if (pillShape) {
                         if (pillShape instanceof PillShape) {
                             // do not call getValue() for trigger, as this will be handled in flow-instance-plugin
                             if (pillShape.getRootIdentifier() === 'trigger') {

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

@@ -24,9 +24,34 @@ import { gzipSync } from 'node:zlib'
 import { ArrowFunctionShape } from '../../arrow-function-plugin'
 import { NowIdShape } from '../../now-id-plugin'
 import { buildVariableShapes, complexObjectMatchesIoRecord } from '../utils/flow-io-to-record'
-import { FLOW_API_NAME, slugifyString, SUBFLOW_API_NAME, TRIGGER_INSTANCE_API_NAME } from '../utils/flow-constants'
+import {
+    FLOW_API_NAME,
+    STAGE_API_NAME,
+    slugifyString,
+    SUBFLOW_API_NAME,
+    SUBFLOW_INSTANCE_API_NAME,
+    TRIGGER_INSTANCE_API_NAME,
+} from '../utils/flow-constants'
+import {
+    buildStageInsertionMap,
+    buildStageShapes,
+    collectSubflowDefName,
+    createStageCallShape,
+    createSubflowStageRecords,
+    extractStageKey,
+    finalizeStageRecords,
+    insertNestedStageShapes,
+    processHeaderStages,
+    resolveNestedStagesInline,
+    resolveNestedStagesForTryCatch,
+} from '../utils/flow-stage-processor'
 import { generateXML } from '../utils/flow-to-xml'
-import { DO_IN_PARALLEL_BLOCK_SYS_ID, FLOW_LOGIC, FlowLogicSysId } from '../flow-logic/flow-logic-constants'
+import {
+    DO_IN_PARALLEL_BLOCK_SYS_ID,
+    FLOW_LOGIC,
+    FlowLogicSysId,
+    TRY_CATCH_CATCH_SYS_ID,
+} from '../flow-logic/flow-logic-constants'
 import { TriggerInstancePlugin } from './flow-trigger-instance-plugin'
 import { FlowLogicPlugin } from '../flow-logic/flow-logic-plugin'
 import { FlowInstancePlugin } from './flow-instance-plugin'
@@ -37,7 +62,7 @@ import {
     uuidToSysId,
     validateFlowVariableCall,
 } from '../utils/utils'
-import { createSdkDocEntry, getCallExpressionName } from '../../utils'
+import { getCallExpressionName } from '../../utils'
 import {
     extractLabelCache,
     createDefinitionMap,
@@ -1589,7 +1614,6 @@ function postProcessAssignSubflowOutputs(
 
 export const FlowDefinitionPlugin = Plugin.create({
     name: 'FlowDefinitionPlugin',
-    docs: [createSdkDocEntry('Flow', ['sys_hub_flow'])],
     records: {
         sys_hub_flow: {
             relationships: {
@@ -1681,6 +1705,11 @@ export const FlowDefinitionPlugin = Plugin.create({
 
                 const flowVariables = buildVariableShapes(descendants.query('sys_hub_flow_variable'), descendants)
 
+                // Build stage shapes from sys_hub_flow_stage records
+                const stageRecords = descendants.query('sys_hub_flow_stage', { flow: record.getId().getValue() })
+                const stages = buildStageShapes(stageRecords)
+                const stageInsertionMap = buildStageInsertionMap(stageRecords)
+
                 //Check if flow has unsupported descendants are present
                 if (checkForUnsupportedFlowDescendants(descendants, record, logger)) {
                     return { success: false }
@@ -1742,37 +1771,64 @@ export const FlowDefinitionPlugin = Plugin.create({
                 // Use recordToShapeMap to access ui_id from records (datapills reference ui_id, not $id)
                 const uuidToIdentifierMap = buildUuidToIdentifierMap(recordToShapeMap)
 
-                // For the flow body, only use top-level instances (those without parent_ui_id)
+                // For the flow body, only use top-level instances (those without parent_ui_id). Also exclude Catch
+                // records — they are subsumed into their paired Try's `wfa.flowLogic.tryCatch(...)` shape via
+                // `connected_to`, and emitting them separately would produce a duplicate top-level statement.
                 const topLevelInstances = allInstances
                     .filter(
                         (instance) =>
-                            !instance.get('parent_ui_id').isDefined() || instance.get('parent_ui_id').getValue() === ''
+                            (!instance.get('parent_ui_id').isDefined() ||
+                                instance.get('parent_ui_id').getValue() === '') &&
+                            !(
+                                instance.getTable() === 'sys_hub_flow_logic_instance_v2' &&
+                                instance.get('logic_definition').asString().getValue() === TRY_CATCH_CATCH_SYS_ID
+                            )
                     )
                     .sort((a, b) => order(a) - order(b))
 
-                const instanceShapes: Shape[] = []
+                // Build instance shapes (without stages) first to resolve paramName
+                const rawInstanceShapes: Array<{ shape: Shape; record: Record }> = []
                 for (const instance of topLevelInstances) {
                     const shape = recordToShapeMap.get(instance)
                     if (!shape) {
                         logger.error(`Failed to find shape for instance ${instance.getId().getValue()}`)
                         return { success: false }
                     }
+                    rawInstanceShapes.push({ shape, record: instance })
+                }
+
+                // Extract parameter name from the topmost ArrowFunction
+                // This allows us to use the actual parameter name instead of hardcoding "_params"
+                let paramName = DEFAULT_PARAM_NAME // Default fallback
+                const firstRealShape = rawInstanceShapes[0]?.shape
+                if (firstRealShape) {
+                    paramName = getArrowFunctionParamName(firstRealShape) || DEFAULT_PARAM_NAME
+                }
+
+                // Insert top-level wfa.stage() calls before matching instances
+                const instanceShapes: Shape[] = []
+                for (const { shape, record: inst } of rawInstanceShapes) {
+                    const instanceOrder = order(inst)
+                    const stageKeys = stageInsertionMap.get(instanceOrder)
+                    if (stageKeys && stageKeys.length > 0) {
+                        for (const key of stageKeys) {
+                            instanceShapes.push(createStageCallShape(key, paramName, record))
+                        }
+                        stageInsertionMap.delete(instanceOrder)
+                    }
                     instanceShapes.push(shape)
                 }
 
+                // Insert nested wfa.stage() calls inside flow logic bodies (if/elseIf/else)
+                if (stageInsertionMap.size > 0) {
+                    insertNestedStageShapes(instanceShapes, stageInsertionMap, paramName, order)
+                }
+
                 // Transform datapill expressions in instance props
                 // This section handles TWO types of datapills:
                 // 1. UUID-based pills: {{uuid.property}} → references to previous action/subflow instances (e.g., {{f56a03c1-18f6-4f7b-9c61-0d4ff472b334.name}} → actionInstance_1.name)
                 // 2. Semantic pills: {{trigger.property}}, {{flow_variable.name}} → references to flow parameters (e.g., {{trigger.table_name}} → params.trigger.table_name)
 
-                // Extract parameter name from the topmost ArrowFunction
-                // This allows us to use the actual parameter name instead of hardcoding "params"
-                let paramName = DEFAULT_PARAM_NAME // Default fallback
-                const firstInstance = instanceShapes[0]
-                if (firstInstance) {
-                    paramName = getArrowFunctionParamName(firstInstance) || DEFAULT_PARAM_NAME
-                }
-
                 // Process all instances (Action, Subflow, and Flow Logic) recursively
                 // This handles datapill transformation for all instance types and their nested children
                 instanceShapes.forEach((instanceShape: Shape, index) => {
@@ -1807,7 +1863,7 @@ export const FlowDefinitionPlugin = Plugin.create({
                             $id: $.val(NowIdShape.from(record)),
                             name: $,
                             description: $.def(EMPTY_STRING),
-                            protection: $.from('sys_policy').def(EMPTY_STRING),
+                            protectionPolicy: $.from('sys_policy').def(EMPTY_STRING),
                             runAs: $.from('run_as').def(RUN_AS_DEFAULT),
                             runWithRoles: $.from('run_with_roles')
                                 .map((r) => {
@@ -1831,6 +1887,7 @@ export const FlowDefinitionPlugin = Plugin.create({
                                   }
                                 : {}),
                             flowVariables: $.val(flowVariables).def({}),
+                            ...(Object.keys(stages).length > 0 ? { stages: $.val(stages) } : {}),
                         })),
                         ...(isFlow ? [triggerShape, flowBody] : [flowBody]),
                     ],
@@ -1924,12 +1981,11 @@ export const FlowDefinitionPlugin = Plugin.create({
                     explicitId: flowConfiguration.get('$id'),
                     properties: flowConfiguration.transform(({ $ }) => ({
                         name: $,
-                        internal_name: $.from('name').map((n) => slugifyString(n.getValue())),
                         annotation: $.def(EMPTY_STRING),
                         description: $.def(EMPTY_STRING),
                         access: $.def(ACCESS_DEFAULT),
                         category: $.def(EMPTY_STRING),
-                        sys_policy: $.from('protection').def(EMPTY_STRING),
+                        sys_policy: $.from('protectionPolicy').def(EMPTY_STRING),
                         run_as: $.from('runAs').def(RUN_AS_DEFAULT),
                         generation_source: $.def(GENERATION_SOURCE),
                         show_draft_actions: $.def(BOOLEAN_FALSE_STRING),
@@ -1955,6 +2011,10 @@ export const FlowDefinitionPlugin = Plugin.create({
                     )
                 }
 
+                // Phase 1 — create sys_hub_flow_stage records for each declared stage.
+                // component_indexes is not set here; computed after the body loop.
+                const headerStageRecords = await processHeaderStages(flowConfiguration, flowDefinitionRecord, factory)
+
                 // ------------------------------------------------------------
                 // Handle FlowVariables() argument (flow-level variables)
                 // Each variable becomes a separate sys_hub_flow_variable record
@@ -2033,6 +2093,9 @@ export const FlowDefinitionPlugin = Plugin.create({
                 let forEachMetadataMap = new Map<string, { stepNumber: number; tableName: string | null }>()
 
                 let order = 1
+                const pendingStages: Array<{ startActionIndex: number; key: string }> = []
+                const subflowDefNames = new Map<string, string>()
+
                 for (const [, v] of (allInstances ?? []).entries()) {
                     // Validate trigger placement: triggers must be the second argument to Flow(), not in the body
                     const callExpr = v instanceof VariableStatementShape ? v.getInitializer() : v
@@ -2043,10 +2106,66 @@ export const FlowDefinitionPlugin = Plugin.create({
                         )
                         continue
                     }
+
+                    // Top-level wfa.stage() — record component_index and skip
+                    if (callExpr instanceof CallExpressionShape && callExpr.getCallee() === STAGE_API_NAME) {
+                        const stageKey = extractStageKey(callExpr)
+                        if (!stageKey) {
+                            diagnostics.error(
+                                callExpr,
+                                'wfa.stage() argument must be a stage reference like params.stages.<key>.'
+                            )
+                        } else if (!headerStageRecords.has(stageKey)) {
+                            diagnostics.error(
+                                callExpr,
+                                `wfa.stage() references stage '${stageKey}' which is not declared in the stages config.`
+                            )
+                        } else {
+                            pendingStages.push({ startActionIndex: order - 1, key: stageKey })
+                        }
+                        continue
+                    }
+
                     const instanceRecord = await getRecordFromFlowInstaceShape(v, transform)
 
                     if (instanceRecord) {
-                        instanceRecord.flat().forEach((rec) => {
+                        const flatRecs = instanceRecord.flat()
+
+                        // Resolve nested stages and collect subflow def names inline
+                        if (callExpr instanceof CallExpressionShape) {
+                            const callee = callExpr.getCallee()
+                            if (
+                                callee === FLOW_LOGIC.IF ||
+                                callee === FLOW_LOGIC.ELSEIF ||
+                                callee === FLOW_LOGIC.ELSE
+                            ) {
+                                resolveNestedStagesInline(
+                                    callExpr,
+                                    flatRecs,
+                                    order,
+                                    headerStageRecords,
+                                    pendingStages,
+                                    subflowDefNames,
+                                    diagnostics
+                                )
+                            }
+                            if (callee === FLOW_LOGIC.TRY_CATCH) {
+                                resolveNestedStagesForTryCatch(
+                                    callExpr,
+                                    flatRecs,
+                                    order,
+                                    headerStageRecords,
+                                    pendingStages,
+                                    subflowDefNames,
+                                    diagnostics
+                                )
+                            }
+                            if (callee === SUBFLOW_INSTANCE_API_NAME) {
+                                collectSubflowDefName(callExpr, subflowDefNames)
+                            }
+                        }
+
+                        flatRecs.forEach((rec) => {
                             // For subflow instances, values will be in subflow_inputs, for other instances (action/flow logic) it will be in values
                             const inputsKey =
                                 rec.getTable() === 'sys_hub_sub_flow_instance_v2' ? 'subflow_inputs' : 'values'
@@ -2109,13 +2228,13 @@ export const FlowDefinitionPlugin = Plugin.create({
                                 forEachMetadataMap
                             )
 
-                            relatedRecords.push(
-                                rec.merge({
-                                    flow: flowDefinitionRecord.getId().getValue(),
-                                    order: finalOrder,
-                                    [inputsKey]: gzipSync(JSON.stringify(valuesJSON)).toString('base64'),
-                                })
-                            )
+                            const mergedRec = rec.merge({
+                                flow: flowDefinitionRecord.getId().getValue(),
+                                order: finalOrder,
+                                [inputsKey]: gzipSync(JSON.stringify(valuesJSON)).toString('base64'),
+                            })
+                            relatedRecords.push(mergedRec)
+
                             order++
                         })
                     } else {
@@ -2126,6 +2245,20 @@ export const FlowDefinitionPlugin = Plugin.create({
                     }
                 }
 
+                // Finalise all stage records
+                const finalisedStages = finalizeStageRecords(pendingStages, headerStageRecords)
+                relatedRecords.push(...finalisedStages)
+
+                relatedRecords.push(
+                    ...(await createSubflowStageRecords(
+                        relatedRecords,
+                        finalisedStages.length,
+                        flowDefinitionRecord,
+                        factory,
+                        subflowDefNames
+                    ))
+                )
+
                 const labelCacheData = Array.from(labelCacheMap.values())
                 const flowDefWithMetadata =
                     labelCacheData.length > 0

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

@@ -16,6 +16,7 @@ import {
     TemplateExpressionShape,
     PropertyAccessShape,
     IdentifierShape,
+    DATA_HELPER_NAMES,
     type Shape,
 } from '@servicenow/sdk-build-core'
 import { isDataPillShape } from '../flow-logic/flow-logic-plugin-helpers'
@@ -45,13 +46,18 @@ import {
     TRIGGER_INSTANCE_API_NAME,
     ACTION_DEFINITION_API_NAME,
     TRIGGER_DEFINITION_API_NAME,
+    STAGE_API_NAME,
+    FLOW_STAGE_CALLEE,
 } from '../utils/flow-constants'
 
+import { FLOW_LOGIC } from '../flow-logic/flow-logic-constants'
+import { createFlowLogicInstanceShape } from '../flow-logic/flow-logic-shapes'
+
 // sendEmail action sys_id for validation
 const SEND_EMAIL_ACTION_SYS_ID = 'c1806bf4a70323008299b39f087901cb'
 
-import { FLOW_LOGIC } from '../flow-logic/flow-logic-constants'
-import { createFlowLogicInstanceShape } from '../flow-logic/flow-logic-shapes'
+// Branching constructs where a trailing wfa.stage() is invalid
+const BRANCHING_CONSTRUCTS: string[] = [FLOW_LOGIC.IF, FLOW_LOGIC.ELSEIF, FLOW_LOGIC.ELSE, FLOW_LOGIC.TRY_CATCH]
 
 /**
  * Helper function to check if a node is inside a Flow or Subflow body
@@ -95,7 +101,6 @@ function isInsideFlowContext(node: ts.Node): boolean {
  */
 export const FlowDiagnosticsPlugin = Plugin.create({
     name: 'FlowDiagnosticsPlugin',
-    docs: [],
     shapes: [
         {
             shape: CallExpressionShape,
@@ -277,5 +282,86 @@ export const FlowDiagnosticsPlugin = Plugin.create({
                 return { success: false }
             },
         },
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            toSubclass(expr, { diagnostics }) {
+                if (expr.getCallee() !== STAGE_API_NAME) {
+                    return { success: false }
+                }
+                const node = expr.getOriginalNode()
+
+                const parentForEach = findAncestorByCalleeName(node, FLOW_LOGIC.FOR_EACH)
+                if (parentForEach) {
+                    diagnostics.error(
+                        expr,
+                        'wfa.stage() cannot be used inside a forEach block. Move stage markers to the top level of the flow body.'
+                    )
+                }
+                const parentDoInParallel = findAncestorByCalleeName(node, FLOW_LOGIC.DO_IN_PARALLEL)
+                if (parentDoInParallel) {
+                    diagnostics.error(
+                        expr,
+                        'wfa.stage() cannot be used inside a doInParallel block. Move stage markers to the top level of the flow body.'
+                    )
+                }
+
+                // Stage must not be the last statement in a branching logic block or the flow body.
+                // A stage that trails with nothing after it has no effect.
+                if (!parentForEach && !parentDoInParallel) {
+                    const stmtNode = node.getParent()
+                    if (stmtNode) {
+                        const isLastStatement = !stmtNode
+                            .getNextSiblings()
+                            .some((n: ts.Node) => !ts.Node.isCommentStatement(n))
+                        if (isLastStatement) {
+                            const containingArrowFn = stmtNode.getFirstAncestorByKind(ts.SyntaxKind.ArrowFunction)
+                            if (containingArrowFn) {
+                                const parentCallExpr = containingArrowFn.getFirstAncestorByKind(
+                                    ts.SyntaxKind.CallExpression
+                                )
+                                if (parentCallExpr) {
+                                    const callName = getCallExpressionName(parentCallExpr)
+                                    if (BRANCHING_CONSTRUCTS.includes(callName)) {
+                                        diagnostics.error(
+                                            expr,
+                                            'wfa.stage() cannot be the last statement in a branching logic block (if/elseIf/else/tryCatch). A stage must be followed by at least one action or flow logic step.'
+                                        )
+                                    } else if (callName === FLOW_API_NAME || callName === SUBFLOW_API_NAME) {
+                                        diagnostics.error(
+                                            expr,
+                                            'wfa.stage() cannot be the last statement in the flow body. A stage must be followed by at least one action or flow logic step.'
+                                        )
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return { success: false }
+            },
+        },
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            toSubclass(expr, { diagnostics }) {
+                if (expr.getCallee() !== FLOW_STAGE_CALLEE) {
+                    return { success: false }
+                }
+                const durationShape = expr.getArgument(0).asObject().get('duration', false)
+                const isDefined = !durationShape.if(UndefinedShape)
+                const isDurationCall =
+                    durationShape.if(CallExpressionShape) &&
+                    durationShape.as(CallExpressionShape).getCallee() === DATA_HELPER_NAMES.DURATION
+                if (isDefined && !isDurationCall) {
+                    diagnostics.error(
+                        durationShape,
+                        "FlowStage 'duration' must use the Duration() helper, e.g. Duration({ hours: 4 }). Plain objects are not supported."
+                    )
+                }
+                return { success: false }
+            },
+        },
     ],
 })

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

@@ -30,6 +30,7 @@ import {
     getDirectVariableIdentifier,
     getIdentifierFromRecord,
     getIdentifierFromShape,
+    getOrderSuffix,
     resolveDataPillShape,
     sysIdToUuid,
 } from '../utils/utils'
@@ -42,8 +43,8 @@ import {
 import { getAttributeValue, parseAttributesToObject } from '../utils/schema-to-flow-object'
 import {
     ActionSubflowInstanceShape,
-    ApprovalRulesShape,
     ApprovalDueDateShape,
+    ApprovalRulesShape,
     InlineScriptShape,
 } from '../utils/flow-shapes'
 import { FDInlineScriptCallShape } from './inline-script-plugin'
@@ -51,21 +52,22 @@ import { FDInlineScriptCallShape } from './inline-script-plugin'
 import {
     ACTION_DEF_COLUMN_NAME,
     ACTION_INSTANCE_API_NAME,
-    APPROVAL_RULES_DATA_TYPE_VALUE,
+    ACTION_TYPE_KEY_NAME,
     APPROVAL_DUE_DATE_DATA_TYPE_VALUE,
+    APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS,
+    APPROVAL_RULES_DATA_TYPE_VALUE,
+    CATALOG_VARIABLE_SET_TABLE,
+    CATALOG_VARIABLE_TABLE,
     CORE_ACTIONS_SYS_ID_NAME_MAP,
     DURATION_DATA_TYPE_VALUE,
+    INLINE_SCRIPT_UNSUPPORTED_FIELDS,
+    INLINE_SCRIPT_UNSUPPORTED_TYPES,
     SUBFLOW_INSTANCE_API_NAME,
     TEMPLATE_DATA_TYPE_VALUE,
     TIME_DATA_TYPE_VALUE,
     UNSUPPORTED_DATA_TYPES,
     UTC_TIMEZONE_VALUE,
-    APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS,
-    ACTION_TYPE_KEY_NAME,
-    CATALOG_VARIABLE_TABLE,
-    CATALOG_VARIABLE_SET_TABLE,
-    INLINE_SCRIPT_UNSUPPORTED_TYPES,
-    INLINE_SCRIPT_UNSUPPORTED_FIELDS,
+    ELEMENT_MAPPING_FIELD_ALIASES,
 } from '../utils/flow-constants'
 
 import type { ApprovalDueDateType, ApprovalRulesType } from '@servicenow/sdk-core/runtime/flow'
@@ -350,8 +352,11 @@ function buildInstanceToShape({
             args: [identifierShapeOrSysId, configArg, inputsShape],
         })
 
-        // Generate variable name from existing source or fallback to callee + ID
-        const order = record.get('order')?.getValue()
+        // Generate a variable name from an existing source or fallback to callee + ID.
+        // Actions inside a DoInParallel branch use composite orders like `2➛3`; strip the separator so the identifier
+        // stays valid JS.
+        const order = getOrderSuffix((record.get('order')?.getValue() as string | undefined) ?? '')
+
         let identifierPrefix = ''
         if (callee.toLowerCase() === ACTION_INSTANCE_API_NAME) {
             identifierPrefix = 'action'
@@ -451,7 +456,6 @@ function validateCatalogVariableOutputReferences(
 
 export const FlowInstancePlugin = Plugin.create({
     name: 'FlowInstancePlugin',
-    docs: [],
     records: {
         sys_hub_action_instance_v2: {
             toShape: buildInstanceToShape({
@@ -488,6 +492,9 @@ export const FlowInstancePlugin = Plugin.create({
                 const instanceInputs = callExpression.getInstanceProps()
                 const instanceAnnotation = callExpression.getAnnotation()?.getValue()
                 const instanceUUID = callExpression.getInstanceUUID()?.getValue()
+                const instanceConfigObj = callExpression.getArgument(1).as(ObjectShape)
+                const instanceShowSubflowStage =
+                    instanceConfigObj.get('showSubflowStage').ifBoolean()?.getValue() ?? false
 
                 if (!instanceInputs || !instanceSysId || !instanceParentDef) {
                     diagnostics.error(
@@ -528,6 +535,7 @@ export const FlowInstancePlugin = Plugin.create({
                         sysId: instanceSysId,
                         annotation: instanceAnnotation,
                         uuid: instanceUUID,
+                        showSubflowStage: instanceShowSubflowStage,
                         factory,
                         source: callExpression,
                         transform,
@@ -628,7 +636,10 @@ function buildInputsShapeFromZipped({
             }
         }
 
-        for (const { name, value, scriptActive, script, parameter } of values) {
+        for (const { name: rawName, value, scriptActive, script, parameter } of values) {
+            // Translate platform-internal field names (e.g. __snc_dont_fail_on_error)
+            // to their Fluent API names (e.g. dont_fail_flow_on_error)
+            const name = ELEMENT_MAPPING_FIELD_ALIASES[rawName] ?? rawName
             const attributes = definitionInputs
                 ?.find((v) => v.get('element').asString()?.getValue() === name)
                 ?.get('attributes')
@@ -765,6 +776,7 @@ async function buildSubflowInstance({
     annotation,
     factory,
     uuid,
+    showSubflowStage,
     source,
     transform,
     diagnostics,
@@ -775,6 +787,7 @@ async function buildSubflowInstance({
     annotation: string | undefined
     factory: Factory
     uuid: string | undefined
+    showSubflowStage: boolean
     source: Source
     transform: Transform
     diagnostics: Diagnostics
@@ -794,6 +807,7 @@ async function buildSubflowInstance({
         subflow: $.val(subflowDefRecord?.getId()?.getValue() || subflowDef?.getValue() || ''),
         subflow_inputs: $.val(values),
         wait_for_completion: $.from('waitForCompletion').def(true),
+        show_stages: $.val(showSubflowStage),
         sys_class_name: $.val('sys_hub_sub_flow_instance_v2'),
         parent_ui_id: $.def(''),
     }))

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

@@ -24,7 +24,6 @@ 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,7 +47,6 @@ 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,13 +2,11 @@ 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: {