@servicenow/sdk-build-plugins 4.5.0 → 4.6.0

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

@@ -1,10 +1,1050 @@
-import { CallExpressionShape, deleteMultipleDiff, Plugin, Record, UndefinedShape } from '@servicenow/sdk-build-core'
-import { buildVariableRecords, complexObjectMatchesIoRecord } from '../utils/flow-io-to-record'
+import {
+    ArrayShape,
+    CallExpressionShape,
+    deleteMultipleDiff,
+    IdentifierShape,
+    ObjectShape,
+    Plugin,
+    PropertyAccessShape,
+    type Record,
+    TemplateExpressionShape,
+    TemplateSpanShape,
+    TemplateValueShape,
+    UndefinedShape,
+    VariableStatementShape,
+    type Diagnostics,
+    type Source,
+    type Shape,
+} from '@servicenow/sdk-build-core'
+import { buildVariableRecords, buildVariableShapes, complexObjectMatchesIoRecord } from '../utils/flow-io-to-record'
 import { generateXML } from '../utils/flow-to-xml'
-import { slugifyString } from '../utils/flow-constants'
+import {
+    slugifyString,
+    BUILT_IN_STEP_DEFINITIONS,
+    BUILT_IN_STEP_SYS_ID_NAME_MAP,
+    CORE_ACTIONS_SYS_ID_NAME_MAP,
+    ELEMENT_MAPPING_FIELD_ALIASES,
+    getVarEntryName,
+    getVarEntryType,
+} from '../utils/flow-constants'
+import { COLUMN_TYPE_TO_API } from '../../column/column-helper'
+import { getAttributeValue } from '../utils/schema-to-flow-object'
+import { normalizeInputValue } from './flow-instance-plugin'
 import { ArrowFunctionShape } from '../../arrow-function-plugin'
 import { createSdkDocEntry } from '../../utils'
-import { StepInstanceShape } from './step-instance-plugin'
+import { FDInlineScriptCallShape } from './inline-script-plugin'
+import { StepInstanceShape, StepInstancePlugin } from './step-instance-plugin'
+import { NowIdShape } from '../../now-id-plugin'
+import { NowIncludeShape } from '../../now-include-plugin'
+import { getBuiltInStepIdentifier, getIdentifierFromRecord } from '../utils/utils'
+import { convertPillStringToShape, detectPillPattern } from '../utils/pill-string-parser'
+import { createLableCacheNameToTypeMap } from '../utils/label-cache-parser'
+import { COLUMN_API_TO_TYPE } from '../../column/column-helper'
+import { wrapWithDataPillCall, extractDataPillNames } from '../utils/pill-shape-helpers'
+
+/** Shorthand for plain string-keyed object to avoid name clash with the SDK's Record type. */
+type Props = { [key: string]: unknown }
+
+/**
+ * Resolves inline scripts for a step's inputs by querying sys_hub_input_scripts descendants.
+ * Replaces 'fd-scripted' placeholder values with FDInlineScriptCallShape (wfa.inlineScript()).
+ */
+function resolveInlineScripts(
+    inputsObj: Props,
+    stepSysId: string,
+    allInputScripts: Record[],
+    stepInstance: Record
+): void {
+    const inputScriptRecords = allInputScripts.filter(
+        (r: Record) => r.get('instance')?.asString()?.getValue() === stepSysId
+    )
+
+    for (const scriptRecord of inputScriptRecords) {
+        const inputName = scriptRecord.get('input_name')?.asString()?.getValue()
+        const scriptJson = scriptRecord.get('script')?.asString()?.getValue()
+        if (!inputName || !scriptJson) {
+            continue
+        }
+
+        let scriptData: { [key: string]: { scriptActive?: boolean; script?: string } }
+        try {
+            scriptData = JSON.parse(scriptJson)
+        } catch {
+            continue
+        }
+
+        const currentValue = inputsObj[inputName]
+
+        if (currentValue instanceof TemplateValueShape) {
+            // Replace fd-scripted sub-fields within TemplateValue with inline script shapes
+            const templateObj = currentValue.getTemplateValue()
+            const newProperties: Props = {}
+            const entries = templateObj.getValue() as globalThis.Record<string, unknown>
+            for (const [fieldKey, fieldValue] of Object.entries(entries)) {
+                const fieldScript = scriptData[fieldKey]
+                if (fieldScript?.scriptActive && fieldScript.script) {
+                    newProperties[fieldKey] = new FDInlineScriptCallShape({
+                        source: stepInstance,
+                        scriptContent: fieldScript.script,
+                    })
+                } else {
+                    newProperties[fieldKey] = fieldValue
+                }
+            }
+            // Also add scripted fields not in original template
+            for (const [fieldKey, fieldScript] of Object.entries(scriptData)) {
+                if (fieldScript?.scriptActive && fieldScript.script && !(fieldKey in entries)) {
+                    newProperties[fieldKey] = new FDInlineScriptCallShape({
+                        source: stepInstance,
+                        scriptContent: fieldScript.script,
+                    })
+                }
+            }
+            inputsObj[inputName] = new TemplateValueShape({ source: stepInstance, value: newProperties })
+        }
+    }
+}
+
+/** Parameter name for the action body arrow function — aligned with subflow pattern */
+const ACTION_PILL_PARAM_NAME = 'params'
+
+/** Arrow delimiter used in label_cache labels — matches Flow Designer UI */
+const LABEL_DELIMITER = '➛'
+
+/**
+ * Generates a unique variable name from a label, appending _2, _3, etc. for duplicates.
+ */
+function generateUniqueVarName(label: string, usedNames: Set<string>): string {
+    const base = slugifyString(label)
+    if (!usedNames.has(base)) {
+        return base
+    }
+    let counter = 2
+    while (usedNames.has(`${base}_${counter}`)) {
+        counter++
+    }
+    return `${base}_${counter}`
+}
+
+/** Step pill info collected during toRecord body processing. */
+interface StepPillInfo {
+    cid: string
+    stepLabel: string
+    pillPath: string // e.g., "record.short_description"
+    dataType: string
+}
+
+/** Action dot-walk pill info (e.g., action.incident.description). */
+interface ActionDotWalkPillInfo {
+    fullPath: string // e.g., "incident.description"
+    parentField: string // e.g., "incident"
+    columnName: string // e.g., "description"
+    dataType: string
+}
+
+/**
+ * Resolves a wfa.dataPill() CallExpressionShape to a pill string.
+ * Handles both action pills (params.inputs.xxx → {{action.xxx|type}}) and
+ * step pills (stepVar.prop → {{step[CID].prop|type}}).
+ * Returns undefined for non-pill shapes or unresolvable step references.
+ */
+function resolveAnyPillFromShape(
+    fieldShape: Shape,
+    cidMap: Map<string, string>
+): { pill: string; isStep: boolean } | undefined {
+    if (!(fieldShape instanceof CallExpressionShape) || fieldShape.getCallee() !== 'wfa.dataPill') {
+        return undefined
+    }
+    const expressionArg = fieldShape.getArgument(0, false)
+    if (!(expressionArg instanceof PropertyAccessShape)) {
+        return undefined
+    }
+    const propertyNames: string[] = []
+    expressionArg.getElements().forEach((el: Shape) => {
+        if (el instanceof IdentifierShape) {
+            propertyNames.push(el.getName())
+        }
+    })
+    if (propertyNames.length < 2) {
+        return undefined
+    }
+    const typeArg = fieldShape.getArgument(1)
+    const dataType = typeArg?.ifString()?.getValue()
+    const typeSuffix = dataType ? `|${dataType}` : ''
+
+    if (propertyNames[1] === 'inputs') {
+        // Action pill: params.inputs.xxx → {{action.xxx|type}}
+        const pathParts = propertyNames.slice(2)
+        return { pill: `{{action.${pathParts.join('.')}${typeSuffix}}}`, isStep: false }
+    }
+    // Step pill: stepVar.prop → {{step[CID].prop|type}}
+    const varName = propertyNames[0]
+    const stepCid = varName ? cidMap.get(varName) : undefined
+    if (!stepCid) {
+        return undefined
+    }
+    const pathParts = propertyNames.slice(1)
+    return { pill: `{{step[${stepCid}].${pathParts.join('.')}${typeSuffix}}}`, isStep: true }
+}
+
+/**
+ * Strips the |type suffix from a pill string.
+ * e.g., "{{step[CID].record.number|string}}" → "{{step[CID].record.number}}"
+ * Note: Mirrors stripPillType in step-instance-plugin.ts (kept separate to avoid exporting private functions).
+ */
+function stripPillTypeSuffix(pill: string): string {
+    return pill.replace(/\|[^}]+/, '')
+}
+
+/** Regex for extracting step pill type annotations — same pattern as STEP_PILL_TYPE_REGEX in step-instance-plugin.ts */
+const STEP_PILL_WITH_TYPE_REGEX = /\{\{step\[([^\]]+)\]\.([^|}]+)(?:\|([^}]+))?\}\}/g
+
+/** Extracts the step pill type annotation from a pill string and stores it in pillTypeMap for label_cache. */
+function collectStepPillType(pill: string, pillTypeMap: Map<string, string>): void {
+    for (const match of pill.matchAll(STEP_PILL_WITH_TYPE_REGEX)) {
+        const [, cid, pillPath, dataType] = match
+        if (cid && pillPath && dataType) {
+            pillTypeMap.set(`${cid}::${pillPath}`, dataType)
+        }
+    }
+}
+
+/** Creates a sys_element_mapping record — shared by all cases in resolveUnresolvedStepPills. */
+function createElementMapping(
+    factory: {
+        createRecord: (opts: {
+            source: Shape
+            table: string
+            properties: globalThis.Record<string, unknown>
+        }) => Promise<Record>
+    },
+    source: Shape,
+    field: string,
+    id: string,
+    stepDefinitionSysId: string,
+    value: string
+): Promise<Record> {
+    return factory.createRecord({
+        source,
+        table: 'sys_element_mapping',
+        properties: {
+            field,
+            id,
+            table: `var__m_sys_flow_step_definition_input_${stepDefinitionSysId}`,
+            value,
+        },
+    })
+}
+
+/**
+ * Resolves a TemplateExpressionShape, replacing step pill spans with resolved pill strings.
+ * Action pills and plain text spans are preserved from the original template.
+ * Returns the full resolved string and whether any step pills were resolved.
+ */
+function resolveStepPillsInTemplate(
+    templateShape: TemplateExpressionShape,
+    cidMap: Map<string, string>,
+    pillTypeMap?: Map<string, string>
+): { result: string; hasStepPills: boolean } | undefined {
+    let result = templateShape.getLiteralText()
+    let hasStepPills = false
+    for (const span of templateShape.getSpans()) {
+        const expr = span.getExpression()
+        const resolved = resolveAnyPillFromShape(expr as Shape, cidMap)
+        if (resolved) {
+            if (resolved.isStep) {
+                if (pillTypeMap) {
+                    collectStepPillType(resolved.pill, pillTypeMap)
+                }
+                hasStepPills = true
+            }
+            result += stripPillTypeSuffix(resolved.pill)
+        } else {
+            // Expression may be an already-resolved PillShape (from SDK auto-processing).
+            // Strip type suffix so action pills match the expected format.
+            const val = String(expr.getValue?.() ?? '')
+            result += val.startsWith('{{') ? stripPillTypeSuffix(val) : val
+        }
+        result += span.getLiteralText()
+    }
+    if (!hasStepPills) {
+        return undefined
+    }
+    return { result, hasStepPills }
+}
+
+/**
+ * After the step loop, cidMap is fully populated but auto-processed Records may contain
+ * unresolved step pills (empty sys_variable_value or broken sys_element_mapping values).
+ * This function walks each StepInstanceShape's inputs, re-resolves step pills with the
+ * populated cidMap, and creates correct sys_element_mapping records via factory.
+ * Coalesce on [field, id] ensures these override any broken records from auto-processing.
+ */
+interface StepInfo {
+    shape: StepInstanceShape
+    stepInstanceSysId: string
+    stepDefinitionSysId: string
+}
+
+async function resolveUnresolvedStepPills(
+    steps: StepInfo[],
+    cidMap: Map<string, string>,
+    pillTypeMap: Map<string, string>,
+    factory: {
+        createRecord: (opts: {
+            source: Shape
+            table: string
+            properties: globalThis.Record<string, unknown>
+        }) => Promise<Record>
+    }
+): Promise<Record[]> {
+    if (cidMap.size === 0 || steps.length === 0) {
+        return []
+    }
+    const newRecords: Record[] = []
+
+    for (const { shape: stepShape, stepInstanceSysId, stepDefinitionSysId } of steps) {
+        const inputs = stepShape.getInputs() as ObjectShape | undefined
+        if (!inputs) {
+            continue
+        }
+
+        const valuesProperties = inputs.properties({ resolve: false })
+
+        for (const [key, valueShape] of Object.entries(valuesProperties)) {
+            if (key === 'inputVariables' || key === 'outputVariables' || key === 'errorHandlingType') {
+                continue
+            }
+
+            // Case 1: Simple step pill — wfa.dataPill(stepVar.prop, 'type')
+            const resolved = resolveAnyPillFromShape(valueShape, cidMap)
+            if (resolved?.isStep) {
+                collectStepPillType(resolved.pill, pillTypeMap)
+                newRecords.push(
+                    await createElementMapping(
+                        factory,
+                        stepShape,
+                        key,
+                        stepInstanceSysId,
+                        stepDefinitionSysId,
+                        stripPillTypeSuffix(resolved.pill)
+                    )
+                )
+                continue
+            }
+
+            // Case 2: TemplateExpressionShape with step pills
+            if (valueShape.is(TemplateExpressionShape)) {
+                const templateResolved = resolveStepPillsInTemplate(
+                    valueShape as TemplateExpressionShape,
+                    cidMap,
+                    pillTypeMap
+                )
+                if (templateResolved) {
+                    newRecords.push(
+                        await createElementMapping(
+                            factory,
+                            stepShape,
+                            key,
+                            stepInstanceSysId,
+                            stepDefinitionSysId,
+                            templateResolved.result
+                        )
+                    )
+                }
+                continue
+            }
+
+            // Case 3: TemplateValueShape — scan nested fields for step pills
+            if (valueShape.is(TemplateValueShape)) {
+                const templateObj = (valueShape as TemplateValueShape).getTemplateValue()
+                const entries: string[] = []
+                let hasStepPills = false
+
+                for (const [field, fieldShape] of templateObj.entries({ resolve: false })) {
+                    const fieldResolved = resolveAnyPillFromShape(fieldShape, cidMap)
+                    if (fieldResolved?.isStep) {
+                        collectStepPillType(fieldResolved.pill, pillTypeMap)
+                        entries.push(`${field}=${stripPillTypeSuffix(fieldResolved.pill)}`)
+                        hasStepPills = true
+                    } else if (fieldShape.is(TemplateExpressionShape)) {
+                        const resolved = resolveStepPillsInTemplate(
+                            fieldShape as TemplateExpressionShape,
+                            cidMap,
+                            pillTypeMap
+                        )
+                        if (resolved) {
+                            entries.push(`${field}=${resolved.result}`)
+                            hasStepPills = true
+                        } else {
+                            const val = fieldShape.getValue?.()
+                            entries.push(`${field}=${String(val ?? '')}`)
+                        }
+                    } else {
+                        const val = String(fieldShape.getValue?.() ?? '')
+                        entries.push(`${field}=${val.startsWith('{{') ? stripPillTypeSuffix(val) : val}`)
+                    }
+                }
+
+                if (hasStepPills) {
+                    newRecords.push(
+                        await createElementMapping(
+                            factory,
+                            stepShape,
+                            key,
+                            stepInstanceSysId,
+                            stepDefinitionSysId,
+                            entries.join('^')
+                        )
+                    )
+                }
+            }
+        }
+    }
+    return newRecords
+}
+
+/**
+ * Extracts step pill info from sys_element_mapping records created during step processing.
+ * Scans the `value` field of each sys_element_mapping record for step pill patterns
+ * and deduplicates by (cid, pillPath).
+ *
+ * This follows the same post-processing pattern as flow-definition-plugin which extracts
+ * pills from already-created records rather than during shape transformation.
+ */
+function extractStepPillsFromRecords(
+    records: Record[],
+    cidToLabelMap: Map<string, string>,
+    pillTypeMap?: Map<string, string>
+): StepPillInfo[] {
+    const pills: StepPillInfo[] = []
+    const seen = new Set<string>()
+
+    for (const topRec of records) {
+        // sys_element_mapping records are nested inside step instance records;
+        // flat() expands them so we can scan pill values.
+        for (const rec of topRec.flat()) {
+            if (rec.getTable() !== 'sys_element_mapping') {
+                continue
+            }
+            const value = rec.get('value')?.asString()?.getValue() ?? ''
+            const matches = value.matchAll(STEP_PILL_WITH_TYPE_REGEX)
+            for (const match of matches) {
+                const [, cid, pillPath, dataType] = match
+                if (!cid || !pillPath) {
+                    continue
+                }
+                const key = `${cid}::${pillPath}`
+                if (seen.has(key)) {
+                    continue
+                }
+                seen.add(key)
+                // Prefer type from pillTypeMap (collected from wfa.dataPill() args before stripping),
+                // fall back to regex capture from element_mapping, then default to 'string'
+                const resolvedType = pillTypeMap?.get(key) ?? dataType ?? 'string'
+                pills.push({
+                    cid,
+                    stepLabel: cidToLabelMap.get(cid) ?? '',
+                    pillPath,
+                    dataType: resolvedType,
+                })
+            }
+        }
+    }
+    return pills
+}
+
+/**
+ * Extracts action dot-walk pill info from sys_element_mapping records.
+ * Scans for {{action.X.Y...}} patterns where the path has 2+ segments (i.e., deeper than top-level input).
+ * Deduplicates by full path. Uses pillTypeMap for type resolution.
+ */
+function extractActionDotWalkPills(records: Record[], pillTypeMap?: Map<string, string>): ActionDotWalkPillInfo[] {
+    const pills: ActionDotWalkPillInfo[] = []
+    const seen = new Set<string>()
+    const regex = /\{\{action\.([^|}]+)(?:\|([^}]+))?\}\}/g
+
+    for (const topRec of records) {
+        for (const rec of topRec.flat()) {
+            if (rec.getTable() !== 'sys_element_mapping') {
+                continue
+            }
+            const value = rec.get('value')?.asString()?.getValue() ?? ''
+            for (const match of value.matchAll(regex)) {
+                const [, path, dataType] = match
+                if (!path) {
+                    continue
+                }
+                const segments = path.split('.')
+                // Only dot-walk pills (2+ segments) — top-level ones are already in inputsConfig
+                if (segments.length < 2) {
+                    continue
+                }
+                if (seen.has(path)) {
+                    continue
+                }
+                seen.add(path)
+                const resolvedType = pillTypeMap?.get(`action::${path}`) ?? dataType ?? 'string'
+                pills.push({
+                    fullPath: path,
+                    parentField: segments[0] ?? '',
+                    columnName: segments[segments.length - 1] ?? '',
+                    dataType: resolvedType,
+                })
+            }
+        }
+    }
+    return pills
+}
+
+/** Converts snake_case to Title Case. e.g., "short_description" → "Short Description" */
+function titleCase(s: string): string {
+    return s.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
+}
+
+/**
+ * Builds the label_cache JSON string from action input definitions, step output pills,
+ * action dot-walk pills, and step status entries — matching the format the Flow Designer UI generates.
+ *
+ * @param inputsConfig - The ObjectShape for the action's inputs configuration
+ * @param opts.stepPills - Step output pill info collected during body processing
+ * @param opts.dotWalkPills - Action dot-walk pill info (e.g., action.incident.description)
+ * @param opts.cidToLabelMap - Map of step CID → label, used for __step_status__ entries
+ * @returns JSON string of label cache entries, or empty string if no inputs
+ */
+function buildActionLabelCache(
+    inputsConfig: ObjectShape,
+    opts?: {
+        stepPills?: StepPillInfo[]
+        dotWalkPills?: ActionDotWalkPillInfo[]
+        cidToLabelMap?: Map<string, string>
+    }
+): string {
+    const { stepPills, dotWalkPills, cidToLabelMap } = opts ?? {}
+    const entries: unknown[] = []
+
+    // Action input entries — also build inputLabelMap for dot-walk resolution in a single pass
+    const inputLabelMap = new Map<string, string>()
+    for (const [fieldName, fieldShape] of inputsConfig.entries({ resolve: false })) {
+        if (!(fieldShape instanceof CallExpressionShape)) {
+            continue
+        }
+        const columnApiName = fieldShape.getCallee()
+        const baseType = COLUMN_API_TO_TYPE[columnApiName] ?? 'string'
+        const config = fieldShape.getArgument(0)?.ifObject()?.asObject()
+        const label = config?.get('label')?.ifString()?.getValue() ?? fieldName
+        const referenceTable = config?.get('referenceTable')?.ifString()?.getValue() ?? ''
+        const referenceDisplay = referenceTable ? label : ''
+
+        inputLabelMap.set(fieldName, label)
+
+        entries.push({
+            name: `{{action.${fieldName}}}`,
+            label: `action${LABEL_DELIMITER}${label}`,
+            type: 'action',
+            ref: referenceTable,
+            reference_display: referenceDisplay,
+            base_type: baseType,
+            parent_table_name: '',
+            column_name: '',
+            choices: null,
+            attributes: {},
+        })
+    }
+
+    // Action dot-walk pill entries (e.g., action.incident.description)
+    if (dotWalkPills) {
+        for (const pill of dotWalkPills) {
+            const segments = pill.fullPath.split('.')
+            // Build label with all segments: action➛Incident➛Caller Id➛Email
+            const labelParts = segments.map((seg, i) => (i === 0 ? (inputLabelMap.get(seg) ?? seg) : titleCase(seg)))
+            const displayLabel = titleCase(pill.columnName)
+            entries.push({
+                name: `{{action.${pill.fullPath}}}`,
+                label: `action${LABEL_DELIMITER}${labelParts.join(LABEL_DELIMITER)}`,
+                type: 'action',
+                ref: '',
+                reference_display: displayLabel,
+                base_type: pill.dataType,
+                parent_table_name: pill.parentField,
+                column_name: pill.columnName,
+                choices: null,
+                attributes: {},
+            })
+        }
+    }
+
+    // __step_status__ entries for each step
+    if (cidToLabelMap) {
+        for (const [cid, stepLabel] of cidToLabelMap.entries()) {
+            entries.push({
+                name: `{{step[${cid}].__step_status__}}`,
+                label: `step${LABEL_DELIMITER}${stepLabel}${LABEL_DELIMITER}Step Status`,
+                type: 'step',
+                ref: '',
+                reference_display: '',
+                base_type: 'object',
+                parent_table_name: '',
+                column_name: '',
+                choices: null,
+                attributes: {},
+            })
+        }
+    }
+
+    // Step output pill entries
+    if (stepPills) {
+        for (const pill of stepPills) {
+            // Split path: "record.short_description" → column_name = "short_description"
+            const pathParts = pill.pillPath.split('.')
+            const columnName = pathParts[pathParts.length - 1] ?? ''
+            const displayLabel = titleCase(columnName)
+
+            entries.push({
+                name: `{{step[${pill.cid}].${pill.pillPath}}}`,
+                label: `step${LABEL_DELIMITER}${pill.stepLabel}${LABEL_DELIMITER}${displayLabel}`,
+                type: 'step',
+                ref: '',
+                reference_display: displayLabel,
+                base_type: pill.dataType,
+                parent_table_name: '',
+                column_name: columnName,
+                choices: null,
+                attributes: {},
+            })
+        }
+    }
+
+    return entries.length > 0 ? JSON.stringify(entries) : ''
+}
+
+/**
+ * Converts a string value containing action pills ({{action.xxx}}) into a wfa.dataPill() shape.
+ * Handles both simple pills (entire value is a pill) and template pills (mixed text + pills).
+ *
+ * @returns The converted shape, or undefined if no pills were found/converted.
+ */
+function convertActionPillToShape(
+    value: string,
+    source: Source,
+    diagnostics: Diagnostics,
+    labelCacheMap?: Map<string, string>
+): CallExpressionShape | TemplateExpressionShape | undefined {
+    const pattern = detectPillPattern(value)
+    if (pattern === 'none') {
+        return undefined
+    }
+
+    const shape = convertPillStringToShape(value, source, diagnostics, ACTION_PILL_PARAM_NAME)
+    if (!shape) {
+        return undefined
+    }
+
+    const pillNames = extractDataPillNames(value)
+
+    // Single pill: wrap the PropertyAccessShape with wfa.dataPill()
+    if (shape instanceof PropertyAccessShape) {
+        const pillName = pillNames[0]
+        const dataType = (pillName && labelCacheMap?.get(pillName)) || 'string'
+        return wrapWithDataPillCall(shape, source, dataType)
+    }
+
+    if (shape instanceof IdentifierShape) {
+        return wrapWithDataPillCall(shape, source)
+    }
+
+    // Template expression: wrap each PropertyAccessShape span with wfa.dataPill()
+    if (shape instanceof TemplateExpressionShape) {
+        const originalSpans = shape.getSpans()
+        const wrappedSpans: TemplateSpanShape[] = []
+        let pillIndex = 0
+
+        for (const span of originalSpans) {
+            const expression = span.getExpression()
+            const literalText = span.getLiteralText()
+
+            if (expression instanceof PropertyAccessShape || expression instanceof IdentifierShape) {
+                const pillName = pillNames[pillIndex]
+                const dataType = (pillName && labelCacheMap?.get(pillName)) || 'string'
+                const wrappedExpr = wrapWithDataPillCall(expression, source, dataType)
+                pillIndex++
+
+                wrappedSpans.push(
+                    new TemplateSpanShape({
+                        source,
+                        expression: wrappedExpr,
+                        literalText,
+                    })
+                )
+            } else {
+                wrappedSpans.push(span)
+            }
+        }
+
+        return new TemplateExpressionShape({
+            source,
+            literalText: shape.getLiteralText(),
+            spans: wrappedSpans,
+        })
+    }
+
+    return undefined
+}
+
+/**
+ * Duck-typing check to determine if a value is a Shape instance.
+ * Since Shape is imported as a type-only import, we can't use instanceof.
+ */
+function isShapeInstance(val: unknown): boolean {
+    return (
+        val instanceof TemplateValueShape ||
+        val instanceof CallExpressionShape ||
+        val instanceof ObjectShape ||
+        val instanceof ArrayShape ||
+        val instanceof NowIncludeShape ||
+        val instanceof FDInlineScriptCallShape
+    )
+}
+
+/**
+ * Processes all values in an inputsObj, converting action pill strings to wfa.dataPill() shapes.
+ * Also handles pills inside TemplateValueShape fields and nested objects like inputVariables.
+ */
+function convertActionPillsInInputs(
+    inputsObj: Props,
+    source: Source,
+    diagnostics: Diagnostics,
+    labelCacheMap?: Map<string, string>
+): void {
+    for (const [key, val] of Object.entries(inputsObj)) {
+        if (typeof val === 'string' && detectPillPattern(val) !== 'none') {
+            const converted = convertActionPillToShape(val, source, diagnostics, labelCacheMap)
+            if (converted) {
+                inputsObj[key] = converted
+            }
+        } else if (val instanceof TemplateValueShape) {
+            // Process pills inside TemplateValue fields.
+            // Use .properties() to get Shape instances directly, not .getValue()
+            // which calls base Shape.getValue() returning Symbols for non-primitive shapes.
+            const templateProps = val.getTemplateValue().properties()
+            let hasChanges = false
+            const newTemplateValue: globalThis.Record<string, unknown> = {}
+
+            for (const [field, fieldShape] of Object.entries(templateProps)) {
+                if (fieldShape.isString()) {
+                    const fieldVal = fieldShape.getValue()
+                    if (detectPillPattern(fieldVal) !== 'none') {
+                        const converted = convertActionPillToShape(fieldVal, source, diagnostics, labelCacheMap)
+                        if (converted) {
+                            newTemplateValue[field] = converted
+                            hasChanges = true
+                            continue
+                        }
+                    }
+                }
+                newTemplateValue[field] = fieldShape
+            }
+
+            if (hasChanges) {
+                inputsObj[key] = new TemplateValueShape({ source, value: newTemplateValue })
+            }
+        } else if (val && typeof val === 'object' && !Array.isArray(val) && !isShapeInstance(val)) {
+            // Recursively process nested plain objects (e.g., inputVariables, outputVariables)
+            // This handles script step input variables which are nested objects with 'value' fields
+            const nestedObj = val as Props
+            for (const nestedVal of Object.values(nestedObj)) {
+                if (
+                    nestedVal &&
+                    typeof nestedVal === 'object' &&
+                    !Array.isArray(nestedVal) &&
+                    !isShapeInstance(nestedVal)
+                ) {
+                    const innerObj = nestedVal as Props
+                    // Check if this nested object has a 'value' field with a pill string
+                    if (typeof innerObj['value'] === 'string' && detectPillPattern(innerObj['value']) !== 'none') {
+                        const converted = convertActionPillToShape(
+                            innerObj['value'],
+                            source,
+                            diagnostics,
+                            labelCacheMap
+                        )
+                        if (converted) {
+                            innerObj['value'] = converted
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** Regex to find step[UUID] pills */
+const STEP_PILL_REGEX =
+    /\{\{step\[([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\]\.([^|}]+)(?:\|[^}]*)?\}\}/g
+
+/**
+ * Converts step output datapill strings ({{step[UUID].property}}) in inputsObj to
+ * wfa.dataPill(varName.property, 'type') using the CID-to-identifier map.
+ * Handles both simple pills and template patterns (pill mixed with text).
+ */
+function convertStepPillsInInputs(
+    inputsObj: Props,
+    source: Source,
+    cidToIdentifierMap: Map<string, IdentifierShape>,
+    labelCacheMap?: Map<string, string>
+): void {
+    for (const [key, val] of Object.entries(inputsObj)) {
+        if (typeof val === 'string') {
+            const converted = convertStepPillString(val, source, cidToIdentifierMap, labelCacheMap)
+            if (converted) {
+                inputsObj[key] = converted
+            }
+        } else if (val instanceof TemplateExpressionShape) {
+            // A TemplateExpressionShape may still contain raw {{step[UUID].xxx}} pills in its
+            // literal text segments if convertActionPillsInInputs converted action pills first,
+            // turning the original string into a template expression with step pills left in text.
+            const resolved = resolveStepPillsInTemplateExpression(val, source, cidToIdentifierMap, labelCacheMap)
+            if (resolved) {
+                inputsObj[key] = resolved
+            }
+        } else if (val instanceof TemplateValueShape) {
+            // Recurse into TemplateValue properties to resolve step pills.
+            // Use .properties() to get Shape instances directly, not .getValue()
+            // which calls base Shape.getValue() returning Symbols for non-primitive shapes.
+            const templateProps = val.getTemplateValue().properties()
+            let hasChanges = false
+            const newTemplateValue: globalThis.Record<string, unknown> = {}
+
+            for (const [field, fieldShape] of Object.entries(templateProps)) {
+                if (fieldShape.isString()) {
+                    const strVal = fieldShape.getValue()
+                    const converted = convertStepPillString(strVal, source, cidToIdentifierMap, labelCacheMap)
+                    if (converted) {
+                        newTemplateValue[field] = converted
+                        hasChanges = true
+                        continue
+                    }
+                }
+                // Keep the original Shape instance as-is (already processed by convertActionPillsInInputs)
+                newTemplateValue[field] = fieldShape
+            }
+
+            if (hasChanges) {
+                inputsObj[key] = new TemplateValueShape({ source, value: newTemplateValue })
+            }
+        }
+    }
+}
+
+/**
+ * Resolves a single step pill match to a wfa.dataPill() CallExpressionShape.
+ */
+function resolveStepPillMatch(
+    uuid: string,
+    property: string,
+    source: Source,
+    cidToIdentifierMap: Map<string, IdentifierShape>,
+    labelCacheMap?: Map<string, string>
+): CallExpressionShape | undefined {
+    const identifier = cidToIdentifierMap.get(uuid)
+    if (!identifier) {
+        return undefined
+    }
+
+    const expression = new PropertyAccessShape({
+        source,
+        elements: [identifier, property],
+    })
+
+    const pillName = `step[${uuid}].${property}`
+    const dataType = labelCacheMap?.get(pillName) || 'string'
+
+    return wrapWithDataPillCall(expression, source, dataType)
+}
+
+/**
+ * Resolves step pills remaining in the literal text segments of a TemplateExpressionShape.
+ * This handles the case where convertActionPillsInInputs converted action pills first,
+ * producing a TemplateExpressionShape whose head/span literal texts still contain
+ * raw {{step[UUID].xxx}} pill references that need to be resolved.
+ *
+ * Algorithm: flatten the template into alternating text/expression segments, expand any
+ * step pills found in text segments, then rebuild a TemplateExpressionShape.
+ */
+function resolveStepPillsInTemplateExpression(
+    expr: TemplateExpressionShape,
+    source: Source,
+    cidToIdentifierMap: Map<string, IdentifierShape>,
+    labelCacheMap?: Map<string, string>
+): TemplateExpressionShape | undefined {
+    type Segment = { kind: 'text'; value: string } | { kind: 'expr'; value: Shape }
+
+    // Flatten into alternating text/expression segments
+    const segments: Segment[] = [{ kind: 'text', value: expr.getLiteralText() }]
+    for (const span of expr.getSpans()) {
+        segments.push({ kind: 'expr', value: span.getExpression() })
+        segments.push({ kind: 'text', value: span.getLiteralText() })
+    }
+
+    // Expand step pills in each text segment
+    const expanded: Segment[] = []
+    let resolvedCount = 0
+
+    for (const seg of segments) {
+        if (seg.kind === 'expr') {
+            expanded.push(seg)
+            continue
+        }
+
+        const text = seg.value
+        const matches = Array.from(text.matchAll(STEP_PILL_REGEX))
+        if (matches.length === 0) {
+            expanded.push(seg)
+            continue
+        }
+
+        let lastIdx = 0
+        for (const match of matches) {
+            const uuid = match[1]
+            const property = match[2]
+            if (!uuid || !property) {
+                continue
+            }
+
+            const pillExpr = resolveStepPillMatch(uuid, property, source, cidToIdentifierMap, labelCacheMap)
+            if (!pillExpr) {
+                // Unresolved pill (CID not in identifier map) — leave the raw {{step[UUID].xxx}}
+                // text in the output. This is intentional graceful degradation: the pill text is
+                // preserved as-is rather than silently dropped, so the output remains debuggable.
+                continue
+            }
+
+            resolvedCount++
+            const matchStart = match.index ?? 0
+            expanded.push({ kind: 'text', value: text.substring(lastIdx, matchStart) })
+            expanded.push({ kind: 'expr', value: pillExpr })
+            lastIdx = matchStart + match[0].length
+        }
+        expanded.push({ kind: 'text', value: text.substring(lastIdx) })
+    }
+
+    if (resolvedCount === 0) {
+        return undefined
+    }
+
+    // Merge consecutive text segments
+    const merged: Segment[] = []
+    for (const seg of expanded) {
+        const last = merged[merged.length - 1]
+        if (seg.kind === 'text' && last?.kind === 'text') {
+            last.value += seg.value
+        } else {
+            merged.push(seg)
+        }
+    }
+
+    // Rebuild TemplateExpressionShape: first text is the head, then (expr, text) pairs form spans
+    const head = merged[0]?.kind === 'text' ? merged[0].value : ''
+    const startIdx = merged[0]?.kind === 'text' ? 1 : 0
+    const newSpans: TemplateSpanShape[] = []
+
+    for (let i = startIdx; i < merged.length; i += 2) {
+        const exprSeg = merged[i]
+        const textSeg = merged[i + 1]
+        if (exprSeg?.kind === 'expr') {
+            newSpans.push(
+                new TemplateSpanShape({
+                    source,
+                    expression: exprSeg.value,
+                    literalText: textSeg?.kind === 'text' ? textSeg.value : '',
+                })
+            )
+        }
+    }
+
+    return new TemplateExpressionShape({ source, literalText: head, spans: newSpans })
+}
+
+/**
+ * Converts step pill strings to wfa.dataPill() shapes.
+ * Handles both:
+ * - Simple: "{{step[UUID].record.short_description}}" → wfa.dataPill(varName.record.short_description, 'string')
+ * - Template: "{{step[UUID].record.short_description}} is text" → `${wfa.dataPill(...)} is text`
+ */
+function convertStepPillString(
+    value: string,
+    source: Source,
+    cidToIdentifierMap: Map<string, IdentifierShape>,
+    labelCacheMap?: Map<string, string>
+): CallExpressionShape | TemplateExpressionShape | undefined {
+    // Find all step pill matches
+    const matches = Array.from(value.matchAll(STEP_PILL_REGEX))
+    if (matches.length === 0) {
+        return undefined
+    }
+
+    // Simple case: entire value is a single pill
+    const firstMatch = matches[0]
+    if (matches.length === 1 && firstMatch && firstMatch.index === 0 && firstMatch[0].length === value.length) {
+        const uuid = firstMatch[1]
+        const property = firstMatch[2]
+        if (uuid && property) {
+            return resolveStepPillMatch(uuid, property, source, cidToIdentifierMap, labelCacheMap)
+        }
+        return undefined
+    }
+
+    // Template case: mixed text + pills → TemplateExpressionShape
+    const spans: TemplateSpanShape[] = []
+    let head = ''
+    let lastIndex = 0
+
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i]
+        const uuid = match?.[1]
+        const property = match?.[2]
+        if (!match || !uuid || !property) {
+            continue
+        }
+
+        const pillExpr = resolveStepPillMatch(uuid, property, source, cidToIdentifierMap, labelCacheMap)
+        if (!pillExpr) {
+            continue
+        }
+
+        const matchStart = match.index ?? 0
+        const textBefore = value.substring(lastIndex, matchStart)
+
+        if (spans.length === 0) {
+            head = textBefore
+        }
+
+        // Find text after this pill (until next pill or end of string)
+        const matchEnd = matchStart + match[0].length
+        const nextMatch = matches[i + 1]
+        const textAfter = nextMatch ? value.substring(matchEnd, nextMatch.index) : value.substring(matchEnd)
+
+        spans.push(
+            new TemplateSpanShape({
+                source,
+                expression: pillExpr,
+                literalText: textAfter,
+            })
+        )
+
+        lastIndex = matchEnd
+    }
+
+    if (spans.length === 0) {
+        return undefined
+    }
+
+    return new TemplateExpressionShape({
+        source,
+        literalText: head,
+        spans,
+    })
+}
 
 const actionDefRelationships = {
     sys_hub_step_instance: {
@@ -105,11 +1145,15 @@ const actionDefRelationships = {
             },
         },
     },
+    sys_hub_pill_compound: {
+        via: 'attached_to',
+        descendant: true,
+    },
 }
 
 export const ActionDefinitionPlugin = Plugin.create({
     name: 'ActionDefinitionPlugin',
-    docs: [createSdkDocEntry('ActionDefinition', ['sys_hub_action_type_definition'])],
+    docs: [createSdkDocEntry('Action', ['sys_hub_action_type_definition'])],
     records: {
         sys_hub_action_type_definition: {
             relationships: {
@@ -150,47 +1194,451 @@ export const ActionDefinitionPlugin = Plugin.create({
                     descendant: true,
                 },
             },
-            toShape(record, { logger }) {
-                logger.warn(`Unsupported record type: ${record.getTable()}, Action definition is not implemented yet`)
-                return { success: false }
-                // TODO Uncomment this in next release
-                // const inputs = buildVariableShapes(descendants.query('sys_hub_action_input'), descendants)
-                // const outputs = buildVariableShapes(descendants.query('sys_hub_action_output'), descendants)
-
-                // // Create the CallExpressionShape for the action definition
-                // const callExpression = new CallExpressionShape({
-                //     source: record,
-                //     callee: 'ActionDefinition',
-                //     args: [
-                //         record.transform(({ $ }) => ({
-                //             $id: $.val(NowIdShape.from(record)),
-                //             name: $,
-                //             annotation: $.def(''),
-                //             description: $.def(''),
-                //             natlang: $.def(''),
-                //             access: $.def('public'),
-                //             category: $.def(''),
-                //             protection: $.from('sys_policy').def(''),
-                //             inputs: $.val(inputs),
-                //             outputs: $.val(outputs),
-                //         })),
-                //     ],
-                // })
-
-                // // Try to get the existing identifier from the record source, fallback to slugified name
-                // const actionName =
-                //     getIdentifierFromRecord(record) ??
-                //     slugifyString(String(record.get('internal_name')?.getValue() || record.get('name')?.getValue()))
-
-                // return {
-                //     success: true,
-                //     value: new VariableStatementShape({
-                //         source: record,
-                //         variableName: actionName,
-                //         initializer: callExpression,
-                //         isExported: true,
-                //     }),
-                // }
+            async toShape(record, { descendants, diagnostics, logger }) {
+                const actionSysId = record.getId().getValue()
+
+                // Fall back to Record API for actions with error evaluation conditions (not yet fully supported).
+                // We check for sys_hub_status_condition records (the actual conditions) rather than
+                // sys_hub_action_status_metadata (which can exist as empty shells without conditions).
+                const actionStatusMetadataIds = descendants
+                    .query('sys_hub_action_status_metadata')
+                    .filter((r) => r.get('action_type_id')?.asString()?.getValue() === actionSysId)
+                    .map((r) => r.getId().getValue())
+                const hasErrorEvaluation = descendants
+                    .query('sys_hub_status_condition')
+                    .some((r) =>
+                        actionStatusMetadataIds.includes(
+                            r.get('action_status_metadata_id')?.asString()?.getValue() ?? ''
+                        )
+                    )
+                if (hasErrorEvaluation) {
+                    const actionName = record.get('name')?.getValue() ?? actionSysId
+                    logger.warn(`Action '${actionName}' has error evaluation — falling back to Record API`)
+                    return { success: false }
+                }
+
+                // Filter inputs/outputs to only those belonging to this action definition,
+                // excluding snapshot-parented records
+                const actionInputs = descendants
+                    .query('sys_hub_action_input')
+                    .filter((r) => r.get('model')?.asString()?.getValue() === actionSysId)
+                const actionOutputs = descendants
+                    .query('sys_hub_action_output')
+                    .filter((r) => r.get('model')?.asString()?.getValue() === actionSysId)
+
+                // Fall back to Record API for custom actions with user-defined outputs (not yet fully supported).
+                // Core actions (in CORE_ACTIONS_SYS_ID_NAME_MAP) are fully supported and should not fall back.
+                // System-generated outputs (__action_status__, __dont_treat_as_error__) are excluded —
+                // every action has these automatically, they are not custom outputs.
+                const isCoreAction = actionSysId in CORE_ACTIONS_SYS_ID_NAME_MAP
+                const customOutputs = actionOutputs.filter((r) => {
+                    const element = r.get('element')?.asString()?.getValue() ?? ''
+                    return element !== '__action_status__' && element !== '__dont_treat_as_error__'
+                })
+                if (!isCoreAction && customOutputs.length > 0) {
+                    const actionName = record.get('name')?.getValue() ?? actionSysId
+                    logger.warn(`Custom action '${actionName}' has outputs — falling back to Record API`)
+                    return { success: false }
+                }
+
+                // Build snapshot output value map: element name → assigned value
+                // Output values are stored in two places on the snapshot:
+                // 1. sys_variable_value records (plain text values)
+                // 2. sys_element_mapping records (datapill/template values)
+                const snapshotOutputValues = new Map<string, string>()
+                const snapshots = descendants.query('sys_hub_action_type_snapshot')
+                if (snapshots.length > 0) {
+                    const snapshotId = snapshots[0]?.getId()?.getValue()
+
+                    // Check sys_element_mapping for datapill values (field=element name, id=snapshot id)
+                    const elementMappings = descendants
+                        .query('sys_element_mapping')
+                        .filter((r) => r.get('id')?.asString()?.getValue() === snapshotId)
+                    for (const mapping of elementMappings) {
+                        const fieldName = mapping.get('field')?.asString()?.getValue()
+                        const value = mapping.get('value')?.ifString()?.getValue()
+                        if (fieldName && value !== undefined && value !== '') {
+                            snapshotOutputValues.set(fieldName, value)
+                        }
+                    }
+
+                    // Check sys_variable_value for plain text values (on snapshot outputs)
+                    const snapshotOutputs = descendants
+                        .query('sys_hub_action_output')
+                        .filter((r) => r.get('model')?.asString()?.getValue() === snapshotId)
+                    for (const snapshotOutput of snapshotOutputs) {
+                        const elementName = snapshotOutput.get('element')?.asString()?.getValue()
+                        if (!elementName || snapshotOutputValues.has(elementName)) {
+                            continue
+                        }
+                        const snapshotOutputSysId = snapshotOutput.getId().getValue()
+                        const varValues = descendants
+                            .query('sys_variable_value')
+                            .filter((v) => v.get('variable')?.asString()?.getValue() === snapshotOutputSysId)
+                        if (varValues.length > 0) {
+                            const value = varValues[0]?.get('value')?.ifString()?.getValue()
+                            if (value !== undefined && value !== '') {
+                                snapshotOutputValues.set(elementName, value)
+                            }
+                        }
+                    }
+                }
+
+                const inputs = buildVariableShapes(actionInputs, descendants)
+                const outputs = buildVariableShapes(actionOutputs, descendants, undefined, snapshotOutputValues)
+
+                // Extract label_cache from action definition for datapill type info
+                let labelCacheMap: Map<string, string> | undefined
+                try {
+                    const labelCacheValue = record.get('label_cache')?.asString()?.getValue()
+                    if (labelCacheValue) {
+                        labelCacheMap = createLableCacheNameToTypeMap(labelCacheValue, logger)
+                    }
+                } catch {
+                    labelCacheMap = undefined
+                }
+
+                // Build step instance shapes for the action body
+                // Filter to only step instances belonging to this action definition,
+                // excluding snapshot-parented step instances
+                const stepInstances = descendants
+                    .query('sys_hub_step_instance')
+                    .filter((s) => s.get('action')?.asString()?.getValue() === actionSysId)
+                const stepShapes: Shape[] = []
+                const cidToIdentifierMap = new Map<string, IdentifierShape>()
+
+                if (stepInstances.length > 0) {
+                    const sortedSteps = [...stepInstances].sort((a, b) => {
+                        const orderA = Number(a.get('order')?.getValue() ?? 0)
+                        const orderB = Number(b.get('order')?.getValue() ?? 0)
+                        return orderA - orderB
+                    })
+
+                    const allVariableValues = descendants.query('sys_variable_value')
+                    const allElementMappings = descendants.query('sys_element_mapping')
+                    const usedVarNames = new Set<string>()
+                    const allInputScripts = descendants.query('sys_hub_input_scripts')
+                    const allExtInputs = descendants.query('sys_hub_step_ext_input')
+                    const allExtOutputs = descendants.query('sys_hub_step_ext_output')
+                    const allDocumentation = descendants.query('sys_documentation')
+
+                    for (const stepInstance of sortedSteps) {
+                        const stepSysId = stepInstance.getId().getValue()
+                        const stepTypeSysId = stepInstance.get('step_type')?.asString()?.getValue()
+                        if (!stepTypeSysId) {
+                            continue
+                        }
+
+                        const builtInDef = BUILT_IN_STEP_DEFINITIONS[stepTypeSysId]
+                        if (!builtInDef) {
+                            logger.warn(
+                                `Unsupported action step type ${stepTypeSysId} found, falling back to Record() api. Action = ${actionSysId}`
+                            )
+                            return { success: false }
+                        }
+
+                        // Filter variable values for this step instance
+                        const stepVarValues = allVariableValues.filter(
+                            (v) => v.get('document_key')?.asString()?.getValue() === stepSysId
+                        )
+
+                        // Build reverse lookup: element name → uiType
+                        const elementNameToUiType: globalThis.Record<string, string | undefined> = {}
+                        for (const entry of Object.values(builtInDef.inputs)) {
+                            elementNameToUiType[getVarEntryName(entry)] = getVarEntryType(entry)
+                        }
+                        for (const entry of Object.values(builtInDef.outputs)) {
+                            elementNameToUiType[getVarEntryName(entry)] = getVarEntryType(entry)
+                        }
+
+                        const inputsObj: Props = {}
+
+                        // Process sys_variable_value records (simple scalar values)
+                        for (const varValue of stepVarValues) {
+                            const variableSysId = varValue.get('variable')?.asString()?.getValue()
+                            const value = varValue.get('value')?.asString()?.getValue()
+                            if (variableSysId) {
+                                const entry = builtInDef.inputs[variableSysId] ?? builtInDef.outputs[variableSysId]
+                                const elementName = entry ? getVarEntryName(entry) : undefined
+                                const uiType = entry ? getVarEntryType(entry) : undefined
+                                if (elementName && value != null) {
+                                    inputsObj[elementName] = uiType
+                                        ? normalizeInputValue(value, uiType, stepInstance)
+                                        : value
+                                }
+                            }
+                        }
+
+                        // Process sys_element_mapping records (datapill/template values)
+                        // Build a lookup of ext input datapill values from element_mappings
+                        const extInputMappingValues: globalThis.Record<string, string> = {}
+                        const stepElementMappings = allElementMappings.filter(
+                            (m) => m.get('id')?.asString()?.getValue() === stepSysId
+                        )
+                        for (const mapping of stepElementMappings) {
+                            const rawFieldName = mapping.get('field')?.asString()?.getValue()
+                            const value = mapping.get('value')?.asString()?.getValue()
+                            const table = mapping.get('table')?.asString()?.getValue() ?? ''
+                            if (!rawFieldName || !value) {
+                                continue
+                            }
+                            // Ext input element_mappings have table var__m_sys_hub_step_ext_input_*
+                            // Collect their values but don't add to inputsObj (they go under inputVariables)
+                            if (table.startsWith('var__m_sys_hub_step_ext_input_')) {
+                                extInputMappingValues[rawFieldName] = value
+                                continue
+                            }
+                            // 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 fieldName = ELEMENT_MAPPING_FIELD_ALIASES[rawFieldName] ?? rawFieldName
+                            const uiType = elementNameToUiType[fieldName]
+                            inputsObj[fieldName] = uiType ? normalizeInputValue(value, uiType, stepInstance) : value
+                        }
+
+                        // Default platform-omitted boolean/choice inputs when the step definition supports them
+                        const allElementNames = Object.values(builtInDef.inputs).map(getVarEntryName)
+                        if (allElementNames.includes('sort_type') && inputsObj['sort_type'] === undefined) {
+                            inputsObj['sort_type'] = 'sort_asc'
+                        }
+                        if (allElementNames.includes('set_workflow') && inputsObj['set_workflow'] === undefined) {
+                            inputsObj['set_workflow'] = true
+                        }
+                        if (
+                            allElementNames.includes('set_autosysfields') &&
+                            inputsObj['set_autosysfields'] === undefined
+                        ) {
+                            inputsObj['set_autosysfields'] = true
+                        }
+                        if (allElementNames.includes('log_level') && inputsObj['log_level'] === undefined) {
+                            inputsObj['log_level'] = 'info'
+                        }
+
+                        // Map error_handling_type number to Fluent string
+                        const errorHandlingRaw = stepInstance.get('error_handling_type')
+                        const errorHandlingType =
+                            errorHandlingRaw?.ifNumber()?.getValue() ?? Number(errorHandlingRaw?.ifString()?.getValue())
+                        inputsObj['errorHandlingType'] =
+                            errorHandlingType === 2 ? 'dont_stop_the_action' : 'stop_the_action'
+
+                        // For script steps, ensure required_run_time is set (default to 'instance' if missing)
+                        if (
+                            BUILT_IN_STEP_SYS_ID_NAME_MAP[stepTypeSysId] === 'script' &&
+                            !inputsObj['required_run_time']
+                        ) {
+                            inputsObj['required_run_time'] = 'instance'
+                        }
+
+                        // Resolve inline scripts: replace fd-scripted placeholders with wfa.inlineScript()
+                        resolveInlineScripts(inputsObj, stepSysId, allInputScripts, stepInstance)
+
+                        // Externalize script field to a separate .js file via Now.include()
+                        if (typeof inputsObj['script'] === 'string' && inputsObj['script']) {
+                            // Strip &#13; (XML carriage return entities) that the platform embeds in script values
+                            const cleanScript = (inputsObj['script'] as string).replace(/&#13;/g, '')
+                            inputsObj['script'] = new NowIncludeShape({
+                                source: stepInstance,
+                                path: `./scripts/${stepSysId}.js`,
+                                includedText: cleanScript,
+                            })
+                        }
+
+                        // Build inputVariables from sys_hub_step_ext_input records
+                        const stepExtInputs = allExtInputs.filter(
+                            (r) => r.get('model_id')?.asString()?.getValue() === stepSysId
+                        )
+                        if (stepExtInputs.length > 0) {
+                            const inputVariablesObj: Props = {}
+                            for (const extInput of stepExtInputs) {
+                                const elementName = extInput.get('element')?.asString()?.getValue()
+                                if (!elementName) {
+                                    continue
+                                }
+                                const extInputSysId = extInput.getId().getValue()
+                                const label = extInput.get('label')?.asString()?.getValue() || elementName
+                                // Find value from sys_variable_value or element_mapping (datapill)
+                                // Prioritize pills from sys_element_mapping over static values from sys_variable_value
+                                const varValueRecord = stepVarValues.find(
+                                    (v) => v.get('variable')?.asString()?.getValue() === extInputSysId
+                                )
+                                const value =
+                                    extInputMappingValues[elementName] ||
+                                    varValueRecord?.get('value')?.asString()?.getValue() ||
+                                    ''
+                                const inputEntry: Props = { label }
+                                if (value) {
+                                    inputEntry['value'] = value
+                                }
+                                const inputDefault = extInput.get('default_value')?.asString()?.getValue()
+                                if (inputDefault) {
+                                    inputEntry['defaultValue'] = inputDefault
+                                }
+                                inputVariablesObj[elementName] = inputEntry
+                            }
+                            inputsObj['inputVariables'] = inputVariablesObj
+                        }
+
+                        // Build outputVariables from sys_hub_step_ext_output records
+                        const stepExtOutputs = allExtOutputs.filter(
+                            (r) => r.get('model_id')?.asString()?.getValue() === stepSysId
+                        )
+                        if (stepExtOutputs.length > 0) {
+                            const outputVariablesObj: Props = {}
+                            for (const extOutput of stepExtOutputs) {
+                                const elementName = extOutput.get('element')?.asString()?.getValue()
+                                if (!elementName) {
+                                    continue
+                                }
+                                const label = extOutput.get('label')?.asString()?.getValue() || elementName
+                                const mandatory = extOutput.get('mandatory')?.asString()?.getValue() === 'true'
+                                const internalType = extOutput.get('internal_type')?.asString()?.getValue() ?? 'string'
+                                // Check attributes for uiType to handle cases where internal_type is generic
+                                const attributes = extOutput.get('attributes')?.asString()?.getValue() ?? ''
+                                const uiType = getAttributeValue(attributes, 'uiType') ?? internalType
+                                const columnApiName = COLUMN_TYPE_TO_API[uiType] ?? 'StringColumn'
+                                const columnProps: Props = { label }
+                                if (mandatory) {
+                                    columnProps['mandatory'] = true
+                                }
+                                const maxLength = extOutput.get('max_length')?.asString()?.getValue()
+                                if (maxLength) {
+                                    columnProps['maxLength'] = Number(maxLength)
+                                }
+                                // Hint is stored in sys_documentation, not on the ext_output record
+                                const extOutputName = extOutput.get('name')?.asString()?.getValue()
+                                const docRecord = allDocumentation.find(
+                                    (d) =>
+                                        d.get('name')?.asString()?.getValue() === extOutputName &&
+                                        d.get('element')?.asString()?.getValue() === elementName
+                                )
+                                const hint = docRecord?.get('hint')?.asString()?.getValue()
+                                if (hint) {
+                                    columnProps['hint'] = hint
+                                }
+                                const referenceTable = extOutput.get('reference')?.asString()?.getValue()
+                                if (
+                                    referenceTable &&
+                                    (columnApiName === 'ReferenceColumn' || columnApiName === 'ListColumn')
+                                ) {
+                                    columnProps['referenceTable'] = referenceTable
+                                }
+                                const defaultValue = extOutput.get('default_value')?.asString()?.getValue()
+                                if (defaultValue) {
+                                    columnProps['default'] = defaultValue
+                                }
+                                outputVariablesObj[elementName] = new CallExpressionShape({
+                                    source: extOutput,
+                                    callee: columnApiName,
+                                    args: [
+                                        new ObjectShape({
+                                            source: extOutput,
+                                            properties: columnProps,
+                                        }),
+                                    ],
+                                })
+                            }
+                            inputsObj['outputVariables'] = outputVariablesObj
+                        }
+
+                        // Convert action input pills ({{action.xxx}}) to wfa.dataPill(params.inputs.xxx, 'type')
+                        convertActionPillsInInputs(inputsObj, stepInstance, diagnostics, labelCacheMap)
+
+                        // Convert step output pills ({{step[UUID].xxx}}) to wfa.dataPill(varName.xxx, 'type')
+                        // Earlier steps are already in cidToIdentifierMap since steps are processed in order
+                        convertStepPillsInInputs(inputsObj, stepInstance, cidToIdentifierMap, labelCacheMap)
+
+                        const configProperties: Props = {
+                            $id: NowIdShape.from(stepInstance),
+                        }
+                        const label = stepInstance.get('label')?.asString()?.getValue()
+                        if (label && label !== builtInDef.name) {
+                            configProperties['label'] = label
+                        }
+
+                        // Built-in/OOB step: emit actionStep.xxx reference
+                        const stepIdentifier = getBuiltInStepIdentifier(stepTypeSysId)
+                        // Built-in/OOB step: emit actionStep.xxx identifier reference
+                        const stepDefShape = stepIdentifier
+                            ? new IdentifierShape({ source: stepInstance, name: stepIdentifier })
+                            : new IdentifierShape({ source: stepInstance, name: builtInDef.name })
+
+                        // Map CID → variable identifier for step datapill resolution in later steps
+                        const cid = stepInstance.get('cid')?.asString()?.getValue()
+                        const varName = generateUniqueVarName(label || builtInDef.name, usedVarNames)
+                        usedVarNames.add(varName)
+                        if (cid) {
+                            cidToIdentifierMap.set(cid, new IdentifierShape({ source: stepInstance, name: varName }))
+                        }
+
+                        const stepCallExpr = new CallExpressionShape({
+                            source: stepInstance,
+                            callee: 'wfa.actionStep',
+                            args: [
+                                stepDefShape,
+                                new ObjectShape({
+                                    source: stepInstance,
+                                    properties: configProperties,
+                                }),
+                                new ObjectShape({
+                                    source: stepInstance,
+                                    properties: inputsObj,
+                                }),
+                            ],
+                        })
+
+                        stepShapes.push(
+                            new VariableStatementShape({
+                                source: stepInstance,
+                                variableName: varName,
+                                initializer: stepCallExpr,
+                            })
+                        )
+                    }
+                }
+
+                // Build args: config + optional body with step instances
+                const actionConfig = record.transform(({ $ }) => ({
+                    $id: $.val(NowIdShape.from(record)),
+                    name: $,
+                    annotation: $.def(''),
+                    description: $.def(''),
+                    access: $.def('public'),
+                    category: $.def(''),
+                    protection: $.from('sys_policy').def(''),
+                    inputs: $.val(inputs),
+                    outputs: $.val(outputs),
+                }))
+
+                const args: unknown[] = [actionConfig]
+                if (stepShapes.length > 0) {
+                    args.push(
+                        new ArrowFunctionShape({
+                            source: record,
+                            parameters: [ACTION_PILL_PARAM_NAME],
+                            statements: stepShapes,
+                        })
+                    )
+                }
+
+                const callExpression = new CallExpressionShape({
+                    source: record,
+                    callee: 'Action',
+                    args,
+                })
+
+                // Try to get the existing identifier from the record source, fallback to slugified name
+                const actionName =
+                    getIdentifierFromRecord(record) ??
+                    slugifyString(String(record.get('internal_name')?.getValue() || record.get('name')?.getValue()))
+
+                return {
+                    success: true,
+                    value: new VariableStatementShape({
+                        source: record,
+                        variableName: actionName,
+                        initializer: callExpression,
+                        isExported: true,
+                    }),
+                }
             },
             async diff(existing, incoming, descendants, context) {
                 return deleteMultipleDiff(existing, incoming, descendants, context)
@@ -211,18 +1659,28 @@ export const ActionDefinitionPlugin = Plugin.create({
         sys_complex_object: {
             coalesce: ['name'],
         },
+        sys_hub_action_status_metadata: {
+            coalesce: ['action_type_id'],
+        },
+        sys_hub_status_condition: {
+            coalesce: ['action_status_metadata_id', 'order'],
+        },
     },
     shapes: [
         {
             shape: CallExpressionShape,
             fileTypes: ['fluent'],
-            async toRecord(callExpression, { factory, diagnostics }) {
-                if (callExpression.getCallee() !== 'ActionDefinition') {
+            async toRecord(callExpression, { factory, diagnostics, transform }) {
+                const callee = callExpression.getCallee()
+                if (callee !== 'Action') {
                     return { success: false }
                 }
                 const relatedRecords: Record[] = []
                 const actionConfiguration = callExpression.getArgument(0).asObject()
-                const actionDefinitionRecord = await factory.createRecord({
+
+                const inputsConfig = actionConfiguration.get('inputs').ifObject()?.asObject()
+
+                let actionDefinitionRecord = await factory.createRecord({
                     source: callExpression,
                     table: 'sys_hub_action_type_definition',
                     explicitId: actionConfiguration.get('$id'),
@@ -240,7 +1698,6 @@ export const ActionDefinitionPlugin = Plugin.create({
                     })),
                 })
 
-                const inputsConfig = actionConfiguration.get('inputs').ifObject()?.asObject()
                 if (inputsConfig) {
                     const { variableRecords: inputRecords, complexObjectRecords: inputComplexObjects } =
                         await buildVariableRecords({
@@ -270,20 +1727,83 @@ export const ActionDefinitionPlugin = Plugin.create({
                     relatedRecords.push(...outputRecords, ...outputComplexObjects)
                 }
 
-                let actionBody: ArrowFunctionShape | undefined
-                actionBody = !callExpression.getArgument(1)?.if(UndefinedShape)
-                    ? callExpression.getArgument(1)?.as(ArrowFunctionShape)
-                    : undefined
+                // arg[1] is the optional body (ArrowFunction) containing step instances
+                const arg1 = callExpression.getArgument(1)
+                const actionBody: ArrowFunctionShape | undefined =
+                    arg1 && !arg1.if(UndefinedShape) ? arg1.as(ArrowFunctionShape) : undefined
                 const allInstances = actionBody?.getStatements()
 
+                const cidMap = new Map<string, string>()
+                const cidToLabelMap = new Map<string, string>()
+                const pillTypeMap = new Map<string, string>()
+
+                const stepInfos: StepInfo[] = []
+                let order = 1
                 for (const [, v] of (allInstances ?? []).entries()) {
-                    const source = v.getSource()
-                    if (source instanceof StepInstanceShape) {
-                        const instanceRecord = v.as(Record)
-                        const record = instanceRecord.merge({
-                            action: actionDefinitionRecord.getId().getValue(),
-                        })
-                        relatedRecords.push(record)
+                    const isVarStatement = v instanceof VariableStatementShape
+                    const innerShape = isVarStatement ? v.getInitializer() : v
+
+                    if (innerShape.getSource() instanceof StepInstanceShape) {
+                        const stepShape = innerShape.getSource() as StepInstanceShape
+                        stepShape.setCidMap(cidMap)
+                        stepShape.setPillTypeMap(pillTypeMap)
+
+                        const stepResult = await transform.toRecord(innerShape, StepInstancePlugin)
+                        if (stepResult.success) {
+                            const record = stepResult.value.merge({
+                                action: actionDefinitionRecord.getId().getValue(),
+                                order: order,
+                            })
+                            relatedRecords.push(record)
+                            stepInfos.push({
+                                shape: stepShape,
+                                stepInstanceSysId: record.getId().getValue(),
+                                stepDefinitionSysId: stepShape.getStepDefinitionSysId(),
+                            })
+
+                            if (isVarStatement) {
+                                const varName = (v as VariableStatementShape).getVariableName().getName()
+                                const stepCid = record.get('cid')?.asString()?.getValue() ?? ''
+                                const stepLabel = record.get('label')?.asString()?.getValue() || varName || 'Step'
+                                if (varName && stepCid) {
+                                    cidMap.set(varName, stepCid)
+                                    cidToLabelMap.set(stepCid, stepLabel)
+                                }
+                            }
+                            order++
+                        } else if (isVarStatement) {
+                            // Step processing failed - log diagnostic to help debug cascading failures
+                            const varName = (v as VariableStatementShape).getVariableName().getName()
+                            diagnostics.error(
+                                innerShape,
+                                `Step '${varName}' failed to process. Subsequent steps referencing this step's outputs may not resolve correctly.`
+                            )
+                        }
+                    }
+                }
+
+                // Re-resolve step pills that couldn't be resolved during auto-processing
+                // (cidMap was empty). Now cidMap is fully populated — walk StepInstanceShape
+                // inputs directly and create correct sys_element_mapping records.
+                const resolvedStepPillRecords = await resolveUnresolvedStepPills(
+                    stepInfos,
+                    cidMap,
+                    pillTypeMap,
+                    factory
+                )
+                relatedRecords.push(...resolvedStepPillRecords)
+
+                const collectedStepPills = extractStepPillsFromRecords(relatedRecords, cidToLabelMap, pillTypeMap)
+                const dotWalkPills = extractActionDotWalkPills(relatedRecords, pillTypeMap)
+
+                if (inputsConfig) {
+                    const labelCacheJson = buildActionLabelCache(inputsConfig, {
+                        stepPills: collectedStepPills,
+                        dotWalkPills,
+                        cidToLabelMap,
+                    })
+                    if (labelCacheJson) {
+                        actionDefinitionRecord = actionDefinitionRecord.merge({ label_cache: labelCacheJson })
                     }
                 }