@servicenow/sdk-build-plugins 4.6.0 → 4.7.0

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

@@ -17,27 +17,34 @@ import {
     type Shape,
 } from '@servicenow/sdk-build-core'
 import { buildVariableRecords, buildVariableShapes, complexObjectMatchesIoRecord } from '../utils/flow-io-to-record'
+import { builtInComplexObjects } from '../utils/built-in-complex-objects'
 import { generateXML } from '../utils/flow-to-xml'
 import {
     slugifyString,
     BUILT_IN_STEP_DEFINITIONS,
     BUILT_IN_STEP_SYS_ID_NAME_MAP,
-    CORE_ACTIONS_SYS_ID_NAME_MAP,
     ELEMENT_MAPPING_FIELD_ALIASES,
+    ASSIGN_ACTION_OUTPUTS_CALLEE,
+    ERROR_EVALUATION_CALLEE,
+    STEP_DEF_INPUT_TABLE_PREFIX,
+    EXT_INPUT_TABLE_PREFIX,
+    ACTION_OUTPUT_TABLE_PREFIX,
     getVarEntryName,
     getVarEntryType,
 } from '../utils/flow-constants'
+import { STEP_PILL_TYPE_REGEX, stripPillType, collectPillTypes } from '../utils/flow-pill-utils'
 import { COLUMN_TYPE_TO_API } from '../../column/column-helper'
 import { getAttributeValue } from '../utils/schema-to-flow-object'
 import { normalizeInputValue } from './flow-instance-plugin'
+import { ApprovalRulesShape, ApprovalDueDateShape } from '../utils/flow-shapes'
 import { ArrowFunctionShape } from '../../arrow-function-plugin'
-import { createSdkDocEntry } from '../../utils'
 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 { PillShape } from '../utils/data-pill-shapes'
 import { createLableCacheNameToTypeMap } from '../utils/label-cache-parser'
 import { COLUMN_API_TO_TYPE } from '../../column/column-helper'
 import { wrapWithDataPillCall, extractDataPillNames } from '../utils/pill-shape-helpers'
@@ -187,27 +194,7 @@ function resolveAnyPillFromShape(
     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)
-        }
-    }
-}
+// stripPillType, collectPillTypes, and STEP_PILL_TYPE_REGEX are imported from ../utils/flow-pill-utils
 
 /** Creates a sys_element_mapping record — shared by all cases in resolveUnresolvedStepPills. */
 function createElementMapping(
@@ -221,7 +208,7 @@ function createElementMapping(
     source: Shape,
     field: string,
     id: string,
-    stepDefinitionSysId: string,
+    mappingTable: string,
     value: string
 ): Promise<Record> {
     return factory.createRecord({
@@ -230,47 +217,46 @@ function createElementMapping(
         properties: {
             field,
             id,
-            table: `var__m_sys_flow_step_definition_input_${stepDefinitionSysId}`,
+            table: mappingTable,
             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.
+ * Resolves ALL pills in a TemplateExpressionShape — both action pills (PillShape) and
+ * step pills (wfa.dataPill CallExpressionShape). Returns the full resolved pill string
+ * with type suffixes stripped. Plain text spans are preserved verbatim.
  */
-function resolveStepPillsInTemplate(
+function resolveAllPillsInTemplate(
     templateShape: TemplateExpressionShape,
     cidMap: Map<string, string>,
     pillTypeMap?: Map<string, string>
-): { result: string; hasStepPills: boolean } | undefined {
+): string {
     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
+        if (expr instanceof PillShape) {
+            const raw = expr.getValue()
+            if (pillTypeMap) {
+                collectPillTypes(raw, pillTypeMap)
             }
-            result += stripPillTypeSuffix(resolved.pill)
+            result += stripPillType(raw)
         } 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
+            const resolved = resolveAnyPillFromShape(expr as Shape, cidMap)
+            if (resolved) {
+                if (resolved.isStep && pillTypeMap) {
+                    collectPillTypes(resolved.pill, pillTypeMap)
+                }
+                result += stripPillType(resolved.pill)
+            } else {
+                const val = String(expr.getValue?.() ?? '')
+                result += val.startsWith('{{') ? stripPillType(val) : val
+            }
         }
         result += span.getLiteralText()
     }
-    if (!hasStepPills) {
-        return undefined
-    }
-    return { result, hasStepPills }
+    return result
 }
 
 /**
@@ -311,6 +297,58 @@ async function resolveUnresolvedStepPills(
 
         const valuesProperties = inputs.properties({ resolve: false })
 
+        // Handle inputVariables — nested object where each entry's `value` may contain step pills.
+        // Ext inputs use a different element_mapping table than regular step definition inputs.
+        const inputVariablesShape = valuesProperties['inputVariables']
+        if (inputVariablesShape) {
+            const inputVarObj = inputVariablesShape.asObject()
+            const inputVarProps = inputVarObj.properties({ resolve: false })
+            const extInputTableName = `${EXT_INPUT_TABLE_PREFIX}${stepInstanceSysId}`
+
+            for (const [varName, configShapeRaw] of Object.entries(inputVarProps)) {
+                const configObj = configShapeRaw.asObject()
+                const varValueShape = configObj.properties({ resolve: false })['value']
+                if (!varValueShape) {
+                    continue
+                }
+
+                const resolved = resolveAnyPillFromShape(varValueShape, cidMap)
+                if (resolved?.isStep) {
+                    collectPillTypes(resolved.pill, pillTypeMap)
+                    newRecords.push(
+                        await createElementMapping(
+                            factory,
+                            stepShape,
+                            varName,
+                            stepInstanceSysId,
+                            extInputTableName,
+                            stripPillType(resolved.pill)
+                        )
+                    )
+                } else if (varValueShape.is(TemplateExpressionShape)) {
+                    const resolvedText = resolveAllPillsInTemplate(
+                        varValueShape as TemplateExpressionShape,
+                        cidMap,
+                        pillTypeMap
+                    )
+                    if (resolvedText.includes('{{step[')) {
+                        newRecords.push(
+                            await createElementMapping(
+                                factory,
+                                stepShape,
+                                varName,
+                                stepInstanceSysId,
+                                extInputTableName,
+                                resolvedText
+                            )
+                        )
+                    }
+                }
+            }
+        }
+
+        const stepDefTableName = `${STEP_DEF_INPUT_TABLE_PREFIX}${stepDefinitionSysId}`
+
         for (const [key, valueShape] of Object.entries(valuesProperties)) {
             if (key === 'inputVariables' || key === 'outputVariables' || key === 'errorHandlingType') {
                 continue
@@ -319,15 +357,15 @@ async function resolveUnresolvedStepPills(
             // Case 1: Simple step pill — wfa.dataPill(stepVar.prop, 'type')
             const resolved = resolveAnyPillFromShape(valueShape, cidMap)
             if (resolved?.isStep) {
-                collectStepPillType(resolved.pill, pillTypeMap)
+                collectPillTypes(resolved.pill, pillTypeMap)
                 newRecords.push(
                     await createElementMapping(
                         factory,
                         stepShape,
                         key,
                         stepInstanceSysId,
-                        stepDefinitionSysId,
-                        stripPillTypeSuffix(resolved.pill)
+                        stepDefTableName,
+                        stripPillType(resolved.pill)
                     )
                 )
                 continue
@@ -335,20 +373,22 @@ async function resolveUnresolvedStepPills(
 
             // Case 2: TemplateExpressionShape with step pills
             if (valueShape.is(TemplateExpressionShape)) {
-                const templateResolved = resolveStepPillsInTemplate(
+                const resolvedText = resolveAllPillsInTemplate(
                     valueShape as TemplateExpressionShape,
                     cidMap,
                     pillTypeMap
                 )
-                if (templateResolved) {
+                // Only emit if step pills were resolved — action-only pills are already
+                // handled by SDK auto-processing.
+                if (resolvedText.includes('{{step[')) {
                     newRecords.push(
                         await createElementMapping(
                             factory,
                             stepShape,
                             key,
                             stepInstanceSysId,
-                            stepDefinitionSysId,
-                            templateResolved.result
+                            stepDefTableName,
+                            resolvedText
                         )
                     )
                 }
@@ -364,25 +404,22 @@ async function resolveUnresolvedStepPills(
                 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)}`)
+                        collectPillTypes(fieldResolved.pill, pillTypeMap)
+                        entries.push(`${field}=${stripPillType(fieldResolved.pill)}`)
                         hasStepPills = true
                     } else if (fieldShape.is(TemplateExpressionShape)) {
-                        const resolved = resolveStepPillsInTemplate(
+                        const resolvedText = resolveAllPillsInTemplate(
                             fieldShape as TemplateExpressionShape,
                             cidMap,
                             pillTypeMap
                         )
-                        if (resolved) {
-                            entries.push(`${field}=${resolved.result}`)
+                        entries.push(`${field}=${resolvedText}`)
+                        if (resolvedText.includes('{{step[')) {
                             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}`)
+                        entries.push(`${field}=${val.startsWith('{{') ? stripPillType(val) : val}`)
                     }
                 }
 
@@ -393,11 +430,120 @@ async function resolveUnresolvedStepPills(
                             stepShape,
                             key,
                             stepInstanceSysId,
-                            stepDefinitionSysId,
+                            stepDefTableName,
                             entries.join('^')
                         )
                     )
                 }
+                continue
+            }
+
+            // Case 4: ApprovalDueDateShape — resolve step pill in 'date' field
+            // During initial auto-processing, cidMap was empty so the step pill in 'date'
+            // couldn't be resolved. Now cidMap is populated, so resolve and create element_mapping.
+            if (valueShape.is(ApprovalDueDateShape)) {
+                const dueDateShape = valueShape as ApprovalDueDateShape
+                const dateFieldShape = dueDateShape.get('date', false)
+                const dateResolved = resolveAnyPillFromShape(dateFieldShape, cidMap)
+                if (dateResolved?.isStep) {
+                    collectPillTypes(dateResolved.pill, pillTypeMap)
+                    // Build the full JSON with the resolved step pill in the date field.
+                    // getApprovalDueDate() resolves all properties (turning the unresolvable
+                    // CallExpressionShape into a Symbol that JSON.stringify drops).
+                    // Override the date field with the resolved pill string.
+                    const dueDate = dueDateShape.getApprovalDueDate()
+                    const correctedShape = new ApprovalDueDateShape({
+                        source: dueDateShape.getSource(),
+                        value: { ...dueDate, date: stripPillType(dateResolved.pill) },
+                    })
+                    const jsonValue = correctedShape.toString().getValue()
+                    newRecords.push(
+                        await createElementMapping(
+                            factory,
+                            stepShape,
+                            key,
+                            stepInstanceSysId,
+                            stepDefTableName,
+                            jsonValue
+                        )
+                    )
+                }
+                continue
+            }
+
+            // Case 5: ApprovalRulesShape — resolve step pills in users/groups arrays.
+            // Uses the same structural walk as resolveApprovalRulesPills in step-instance-plugin
+            // but with resolveAnyPillFromShape (which has access to cidMap).
+            if (valueShape.is(ApprovalRulesShape)) {
+                const rulesShape = valueShape as ApprovalRulesShape
+                const rules = rulesShape.getApprovalRules()
+                let hasStepPills = false
+
+                const ruleSetsShape = rulesShape.get('ruleSets', false).ifArray()
+                ruleSetsShape?.getElements(false).forEach((ruleSetShape, rsIdx) => {
+                    const rulesArrayShape = ruleSetShape.ifObject()?.get('rules', false).ifArray()
+                    rulesArrayShape?.getElements(false).forEach((ruleShape, rIdx) => {
+                        ruleShape
+                            .ifArray()
+                            ?.getElements(false)
+                            .forEach((conditionShape, cIdx) => {
+                                const conditionObj = conditionShape.ifObject()
+                                if (!conditionObj) {
+                                    return
+                                }
+                                const condition = rules.ruleSets?.[rsIdx]?.rules?.[rIdx]?.[cIdx]
+                                if (!condition) {
+                                    return
+                                }
+
+                                // Resolve step pills in users array
+                                conditionObj
+                                    .get('users', false)
+                                    .ifArray()
+                                    ?.getElements(false)
+                                    .forEach((userShape, uIdx) => {
+                                        const resolved = resolveAnyPillFromShape(userShape, cidMap)
+                                        if (resolved?.isStep && condition.users) {
+                                            collectPillTypes(resolved.pill, pillTypeMap)
+                                            condition.users[uIdx] = stripPillType(resolved.pill)
+                                            hasStepPills = true
+                                        }
+                                    })
+
+                                // Resolve step pills in groups array
+                                conditionObj
+                                    .get('groups', false)
+                                    .ifArray()
+                                    ?.getElements(false)
+                                    .forEach((groupShape, gIdx) => {
+                                        const resolved = resolveAnyPillFromShape(groupShape, cidMap)
+                                        if (resolved?.isStep && condition.groups) {
+                                            collectPillTypes(resolved.pill, pillTypeMap)
+                                            condition.groups[gIdx] = stripPillType(resolved.pill)
+                                            hasStepPills = true
+                                        }
+                                    })
+                            })
+                    })
+                })
+
+                if (hasStepPills) {
+                    const correctedShape = new ApprovalRulesShape({
+                        source: rulesShape.getSource(),
+                        value: rules,
+                    })
+                    const jsonValue = correctedShape.toString().getValue()
+                    newRecords.push(
+                        await createElementMapping(
+                            factory,
+                            stepShape,
+                            key,
+                            stepInstanceSysId,
+                            stepDefTableName,
+                            jsonValue
+                        )
+                    )
+                }
             }
         }
     }
@@ -405,13 +551,34 @@ async function resolveUnresolvedStepPills(
 }
 
 /**
- * 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.
+ * Collects all pill-bearing text strings from records.
+ * Scans sys_element_mapping.value, sys_hub_status_condition.condition and .status fields.
  */
+function collectPillTextsFromRecords(records: Record[]): string[] {
+    const texts: string[] = []
+    for (const topRec of records) {
+        for (const rec of topRec.flat()) {
+            const table = rec.getTable()
+            if (table === 'sys_element_mapping') {
+                const value = rec.get('value')?.asString()?.getValue() ?? ''
+                if (value) {
+                    texts.push(value)
+                }
+            } else if (table === 'sys_hub_status_condition') {
+                const condition = rec.get('condition')?.asString()?.getValue() ?? ''
+                if (condition) {
+                    texts.push(condition)
+                }
+                const status = rec.get('status')?.asString()?.getValue() ?? ''
+                if (status) {
+                    texts.push(status)
+                }
+            }
+        }
+    }
+    return texts
+}
+
 function extractStepPillsFromRecords(
     records: Record[],
     cidToLabelMap: Map<string, string>,
@@ -420,42 +587,38 @@ function extractStepPillsFromRecords(
     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') {
+    for (const text of collectPillTextsFromRecords(records)) {
+        const matches = text.matchAll(STEP_PILL_TYPE_REGEX)
+        for (const match of matches) {
+            const [, cid, pillPath, dataType] = match
+            if (!cid || !pillPath) {
                 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,
-                })
+            // Skip base __step_status__ — already handled in buildActionLabelCache via cidToLabelMap
+            if (pillPath === '__step_status__') {
+                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.
+ * Extracts action dot-walk pill info from 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.
  */
@@ -464,34 +627,28 @@ function extractActionDotWalkPills(records: Record[], pillTypeMap?: Map<string,
     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') {
+    for (const text of collectPillTextsFromRecords(records)) {
+        for (const match of text.matchAll(regex)) {
+            const [, path, dataType] = match
+            if (!path) {
                 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,
-                })
+            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
@@ -778,6 +935,73 @@ function convertActionPillsInInputs(
     }
 }
 
+/**
+ * Converts pill strings buried inside ApprovalRulesShape and ApprovalDueDateShape values
+ * to wfa.dataPill() shapes. These structured shapes are created by normalizeInputValue()
+ * before convertActionPillsInInputs runs, so their nested pill strings are unreachable
+ * by the normal string-based pill conversion.
+ */
+function convertPillsInStructuredShapes(
+    inputsObj: Props,
+    source: Source,
+    diagnostics: Diagnostics,
+    labelCacheMap?: Map<string, string>
+): void {
+    for (const [key, val] of Object.entries(inputsObj)) {
+        if (val instanceof ApprovalRulesShape) {
+            const rules = val.getApprovalRules()
+            let changed = false
+            const newRuleSets = rules.ruleSets?.map((ruleSet) => ({
+                ...ruleSet,
+                rules: ruleSet.rules?.map((rule) =>
+                    rule.map((condition) => ({
+                        ...condition,
+                        users: condition.users?.map((user) => {
+                            const s = String(user)
+                            if (detectPillPattern(s) !== 'none') {
+                                const shape = convertActionPillToShape(s, source, diagnostics, labelCacheMap)
+                                if (shape) {
+                                    changed = true
+                                    return shape
+                                }
+                            }
+                            return user
+                        }),
+                        groups: condition.groups?.map((group) => {
+                            const s = String(group)
+                            if (detectPillPattern(s) !== 'none') {
+                                const shape = convertActionPillToShape(s, source, diagnostics, labelCacheMap)
+                                if (shape) {
+                                    changed = true
+                                    return shape
+                                }
+                            }
+                            return group
+                        }),
+                    }))
+                ),
+            }))
+            if (changed && newRuleSets) {
+                inputsObj[key] = new ApprovalRulesShape({
+                    source,
+                    value: { ...rules, ruleSets: newRuleSets },
+                })
+            }
+        } else if (val instanceof ApprovalDueDateShape) {
+            const dueDate = val.getApprovalDueDate()
+            if (dueDate.date && detectPillPattern(dueDate.date) !== 'none') {
+                const shape = convertActionPillToShape(dueDate.date, source, diagnostics, labelCacheMap)
+                if (shape) {
+                    inputsObj[key] = new ApprovalDueDateShape({
+                        source,
+                        value: { ...dueDate, date: shape as unknown as string },
+                    })
+                }
+            }
+        }
+    }
+}
+
 /** 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
@@ -832,6 +1056,89 @@ function convertStepPillsInInputs(
             if (hasChanges) {
                 inputsObj[key] = new TemplateValueShape({ source, value: newTemplateValue })
             }
+        } else if (val instanceof ApprovalDueDateShape) {
+            const dueDate = val.getApprovalDueDate()
+            if (dueDate.date && typeof dueDate.date === 'string' && detectPillPattern(dueDate.date) !== 'none') {
+                const shape = convertStepPillString(dueDate.date, source, cidToIdentifierMap, labelCacheMap)
+                if (shape) {
+                    inputsObj[key] = new ApprovalDueDateShape({
+                        source,
+                        value: { ...dueDate, date: shape as unknown as string },
+                    })
+                }
+            }
+        } else if (val instanceof ApprovalRulesShape) {
+            const rules = val.getApprovalRules()
+            let changed = false
+            const newRuleSets = rules.ruleSets?.map((ruleSet) => ({
+                ...ruleSet,
+                rules: ruleSet.rules?.map((rule) =>
+                    rule.map((condition) => ({
+                        ...condition,
+                        users: condition.users?.map((user) => {
+                            const s = String(user)
+                            if (detectPillPattern(s) !== 'none') {
+                                const shape = convertStepPillString(s, source, cidToIdentifierMap, labelCacheMap)
+                                if (shape) {
+                                    changed = true
+                                    return shape
+                                }
+                            }
+                            return user
+                        }),
+                        groups: condition.groups?.map((group) => {
+                            const s = String(group)
+                            if (detectPillPattern(s) !== 'none') {
+                                const shape = convertStepPillString(s, source, cidToIdentifierMap, labelCacheMap)
+                                if (shape) {
+                                    changed = true
+                                    return shape
+                                }
+                            }
+                            return group
+                        }),
+                    }))
+                ),
+            }))
+            if (changed && newRuleSets) {
+                inputsObj[key] = new ApprovalRulesShape({
+                    source,
+                    value: { ...rules, ruleSets: newRuleSets },
+                })
+            }
+        } else if (val && typeof val === 'object' && !Array.isArray(val) && !isShapeInstance(val)) {
+            // Recursively process nested plain objects (e.g., inputVariables)
+            // This handles script step input variables which have 'value' fields with step pills
+            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
+                    const innerValue = innerObj['value']
+                    if (typeof innerValue === 'string') {
+                        const converted = convertStepPillString(innerValue, source, cidToIdentifierMap, labelCacheMap)
+                        if (converted) {
+                            innerObj['value'] = converted
+                        }
+                    } else if (innerValue instanceof TemplateExpressionShape) {
+                        // Handle case where convertActionPillsInInputs already converted action pills,
+                        // leaving step pills in the template literal text segments
+                        const resolved = resolveStepPillsInTemplateExpression(
+                            innerValue,
+                            source,
+                            cidToIdentifierMap,
+                            labelCacheMap
+                        )
+                        if (resolved) {
+                            innerObj['value'] = resolved
+                        }
+                    }
+                }
+            }
         }
     }
 }
@@ -851,9 +1158,12 @@ function resolveStepPillMatch(
         return undefined
     }
 
+    // Split dot-walk property path into individual segments (e.g., "record.manager.email" → ["record", "manager", "email"])
+    // PropertyAccessShape needs each path segment as a separate element for correct code generation
+    const pathParts = property.split('.')
     const expression = new PropertyAccessShape({
         source,
-        elements: [identifier, property],
+        elements: [identifier, ...pathParts] as unknown as readonly [unknown, unknown, ...unknown[]],
     })
 
     const pillName = `step[${uuid}].${property}`
@@ -1151,9 +1461,131 @@ const actionDefRelationships = {
     },
 }
 
+/**
+ * Resolves any shape (string literal, number, template expression, dataPill call)
+ * to its final string representation with pill references resolved.
+ */
+function resolveToString(shape: Shape, cidMap: Map<string, string>, pillTypeMap: Map<string, string>): string {
+    if (shape instanceof TemplateExpressionShape) {
+        return resolveAllPillsInTemplate(shape, cidMap, pillTypeMap)
+    }
+    if (shape instanceof PillShape) {
+        const raw = shape.getValue()
+        collectPillTypes(raw, pillTypeMap)
+        return stripPillType(raw)
+    }
+    const resolved = resolveAnyPillFromShape(shape, cidMap)
+    if (resolved) {
+        if (resolved.isStep) {
+            collectPillTypes(resolved.pill, pillTypeMap)
+        }
+        return stripPillType(resolved.pill)
+    }
+    return String(shape.getValue?.() ?? '')
+}
+
+/**
+ * Builds the complex JSON `status` field for a sys_hub_status_condition record.
+ * The status contains complexObject (runtime values), complexObjectSchema
+ * (FlowDesigner:FDACTIONSTATUS with SimpleMapFacet field descriptors), and type facets.
+ *
+ * When a field value contains datapill references ({{...}}), it goes into the
+ * `mapped` field of the SimpleMapFacet; otherwise static values go into
+ * complexObject.$cv.$v and mapped is "{}".
+ */
+function buildStatusConditionJson(codeValue: string, messageValue: string): string {
+    const hasPillInCode = codeValue.includes('{{')
+    const hasPillInMessage = messageValue.includes('{{')
+
+    const codeMapped = hasPillInCode ? JSON.stringify({ code: codeValue }) : '{}'
+    const messageMapped = hasPillInMessage ? JSON.stringify({ message: messageValue }) : '{}'
+
+    const codeCV = hasPillInCode ? '' : codeValue
+    const messageCV = hasPillInMessage ? '' : messageValue
+
+    // Derive the complexObjectSchema from the built-in FDACTIONSTATUS definition
+    // rather than hardcoding it, so it stays in sync with the canonical schema.
+    const fdActionStatus = builtInComplexObjects['FDACTIONSTATUS']
+    if (!fdActionStatus) {
+        throw new Error('FDACTIONSTATUS not found in builtInComplexObjects')
+    }
+    const baseSchema = JSON.parse(fdActionStatus.data.serialized_content)
+    const fdSchema = baseSchema['FlowDesigner:FDACTIONSTATUS']
+
+    // Inject `mapped` into the field facets for code and message
+    for (const [fieldName, mapped] of [
+        ['code', codeMapped],
+        ['message', messageMapped],
+    ] as const) {
+        const facetKey = `${fieldName}.$field_facets`
+        const facets = JSON.parse(fdSchema[facetKey].SimpleMapFacet)
+        facets.mapped = mapped
+        fdSchema[facetKey].SimpleMapFacet = JSON.stringify(facets)
+    }
+
+    return JSON.stringify({
+        version: '1.0',
+        complexObject: {
+            code: { $cv: { $c: 'java.lang.String', $v: codeCV } },
+            message: { $cv: { $c: 'java.lang.String', $v: messageCV } },
+        },
+        complexObjectSchema: baseSchema,
+        serializationFormat: 'JSON',
+    })
+}
+
+/**
+ * Parses a status JSON blob from a sys_hub_status_condition record and extracts
+ * the code and message values. Datapill references live in the `mapped` field
+ * of the SimpleMapFacet; static values live in complexObject.$cv.$v.
+ */
+function parseStatusConditionJson(
+    statusJson: string,
+    logger?: { warn: (msg: string) => void }
+): { code: string; message: string } {
+    try {
+        const parsed = JSON.parse(statusJson)
+        const co = parsed?.complexObject ?? {}
+        const schema = parsed?.complexObjectSchema ?? {}
+        const fdSchema = schema['FlowDesigner:FDACTIONSTATUS'] ?? {}
+
+        // Extract code
+        let code = co?.code?.$cv?.$v ?? ''
+        const codeFacetsRaw = fdSchema['code.$field_facets']?.SimpleMapFacet
+        if (codeFacetsRaw) {
+            const codeFacets = typeof codeFacetsRaw === 'string' ? JSON.parse(codeFacetsRaw) : codeFacetsRaw
+            const codeMapped = codeFacets?.mapped
+            if (codeMapped && codeMapped !== '{}') {
+                const mappedObj = typeof codeMapped === 'string' ? JSON.parse(codeMapped) : codeMapped
+                if (mappedObj?.code) {
+                    code = mappedObj.code
+                }
+            }
+        }
+
+        // Extract message
+        let message = co?.message?.$cv?.$v ?? ''
+        const msgFacetsRaw = fdSchema['message.$field_facets']?.SimpleMapFacet
+        if (msgFacetsRaw) {
+            const msgFacets = typeof msgFacetsRaw === 'string' ? JSON.parse(msgFacetsRaw) : msgFacetsRaw
+            const msgMapped = msgFacets?.mapped
+            if (msgMapped && msgMapped !== '{}') {
+                const mappedObj = typeof msgMapped === 'string' ? JSON.parse(msgMapped) : msgMapped
+                if (mappedObj?.message) {
+                    message = mappedObj.message
+                }
+            }
+        }
+
+        return { code, message }
+    } catch (e) {
+        logger?.warn(`parseStatusConditionJson: failed to parse status JSON — ${e}`)
+        return { code: '', message: '' }
+    }
+}
+
 export const ActionDefinitionPlugin = Plugin.create({
     name: 'ActionDefinitionPlugin',
-    docs: [createSdkDocEntry('Action', ['sys_hub_action_type_definition'])],
     records: {
         sys_hub_action_type_definition: {
             relationships: {
@@ -1163,6 +1595,10 @@ export const ActionDefinitionPlugin = Plugin.create({
                     descendant: true,
                     relationships: {
                         ...actionDefRelationships,
+                        sys_variable_value: {
+                            via: 'document_key',
+                            descendant: true,
+                        },
                         sys_element_mapping: {
                             via: 'id',
                             descendant: true,
@@ -1197,95 +1633,38 @@ export const ActionDefinitionPlugin = Plugin.create({
             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 error evaluation descendants for this action.
+                // sys_hub_action_status_metadata is the parent container;
+                // sys_hub_status_condition holds the individual conditions.
+                const actionStatusMetadata = 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
+                const actionStatusMetadataIds = actionStatusMetadata.map((r) => r.getId().getValue())
+                const statusConditions = descendants
                     .query('sys_hub_status_condition')
-                    .some((r) =>
+                    .filter((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
+                // excluding snapshot-parented records, and sort by <order> to preserve
+                // the order defined in the XML (instance document order is not guaranteed)
+                const sortByOrder = (a: Record, b: Record) =>
+                    Number(a.get('order')?.asString()?.getValue() ?? 0) -
+                    Number(b.get('order')?.asString()?.getValue() ?? 0)
                 const actionInputs = descendants
                     .query('sys_hub_action_input')
                     .filter((r) => r.get('model')?.asString()?.getValue() === actionSysId)
+                    .sort(sortByOrder)
                 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)
-                            }
-                        }
-                    }
-                }
+                    .sort(sortByOrder)
 
                 const inputs = buildVariableShapes(actionInputs, descendants)
-                const outputs = buildVariableShapes(actionOutputs, descendants, undefined, snapshotOutputValues)
+                const outputs = buildVariableShapes(actionOutputs, descendants)
 
                 // Extract label_cache from action definition for datapill type info
                 let labelCacheMap: Map<string, string> | undefined
@@ -1384,7 +1763,7 @@ export const ActionDefinitionPlugin = Plugin.create({
                             }
                             // 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_')) {
+                            if (table.startsWith(EXT_INPUT_TABLE_PREFIX)) {
                                 extInputMappingValues[rawFieldName] = value
                                 continue
                             }
@@ -1461,8 +1840,8 @@ export const ActionDefinitionPlugin = Plugin.create({
                                     (v) => v.get('variable')?.asString()?.getValue() === extInputSysId
                                 )
                                 const value =
-                                    extInputMappingValues[elementName] ||
-                                    varValueRecord?.get('value')?.asString()?.getValue() ||
+                                    extInputMappingValues[elementName] ??
+                                    varValueRecord?.get('value')?.asString()?.getValue() ??
                                     ''
                                 const inputEntry: Props = { label }
                                 if (value) {
@@ -1489,17 +1868,17 @@ export const ActionDefinitionPlugin = Plugin.create({
                                     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'
+                                const mandatory = extOutput.get('mandatory')?.ifString()?.getValue() === 'true'
+                                const internalType = extOutput.get('internal_type')?.ifString()?.getValue() ?? 'string'
                                 // Check attributes for uiType to handle cases where internal_type is generic
-                                const attributes = extOutput.get('attributes')?.asString()?.getValue() ?? ''
+                                const attributes = extOutput.get('attributes')?.ifString()?.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()
+                                const maxLength = extOutput.get('max_length')?.ifString()?.getValue()
                                 if (maxLength) {
                                     columnProps['maxLength'] = Number(maxLength)
                                 }
@@ -1514,14 +1893,14 @@ export const ActionDefinitionPlugin = Plugin.create({
                                 if (hint) {
                                     columnProps['hint'] = hint
                                 }
-                                const referenceTable = extOutput.get('reference')?.asString()?.getValue()
+                                const referenceTable = extOutput.get('reference')?.ifString()?.getValue()
                                 if (
                                     referenceTable &&
                                     (columnApiName === 'ReferenceColumn' || columnApiName === 'ListColumn')
                                 ) {
                                     columnProps['referenceTable'] = referenceTable
                                 }
-                                const defaultValue = extOutput.get('default_value')?.asString()?.getValue()
+                                const defaultValue = extOutput.get('default_value')?.ifString()?.getValue()
                                 if (defaultValue) {
                                     columnProps['default'] = defaultValue
                                 }
@@ -1542,6 +1921,10 @@ export const ActionDefinitionPlugin = Plugin.create({
                         // Convert action input pills ({{action.xxx}}) to wfa.dataPill(params.inputs.xxx, 'type')
                         convertActionPillsInInputs(inputsObj, stepInstance, diagnostics, labelCacheMap)
 
+                        // Convert pills buried inside ApprovalRulesShape/ApprovalDueDateShape
+                        // (these were already parsed by normalizeInputValue before pill conversion)
+                        convertPillsInStructuredShapes(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)
@@ -1595,6 +1978,174 @@ export const ActionDefinitionPlugin = Plugin.create({
                     }
                 }
 
+                // Reconstruct wfa.errorEvaluation([...]) from sys_hub_status_condition records.
+                // This must appear before wfa.assignActionOutputs in the generated Fluent file.
+                if (statusConditions.length > 0) {
+                    const sortedConditions = [...statusConditions].sort(sortByOrder)
+                    const conditionShapes: Shape[] = []
+
+                    for (const cond of sortedConditions) {
+                        const label = cond.get('label')?.asString()?.getValue() ?? ''
+                        const condition = cond.get('condition')?.asString()?.getValue() ?? ''
+                        const dontTreatAsError = cond.get('dont_treat_as_error')?.asString()?.getValue() === 'true'
+                        const statusJson = cond.get('status')?.asString()?.getValue() ?? '{}'
+                        const { code, message } = parseStatusConditionJson(statusJson, logger)
+
+                        // Build status props as plain object, resolve pills, then wrap
+                        const statusProps: Props = {}
+                        statusProps['code'] = /^\d+$/.test(code) ? Number(code) : code
+                        statusProps['message'] = message
+                        convertActionPillsInInputs(statusProps, cond, diagnostics, labelCacheMap)
+                        convertStepPillsInInputs(statusProps, cond, cidToIdentifierMap, labelCacheMap)
+
+                        // Build condition props as plain object, resolve pills on condition only.
+                        // label is a display name and must NOT be pill-converted;
+                        // status pills are already resolved above via statusProps.
+                        const conditionProps: Props = { condition }
+                        convertActionPillsInInputs(conditionProps, cond, diagnostics, labelCacheMap)
+                        convertStepPillsInInputs(conditionProps, cond, cidToIdentifierMap, labelCacheMap)
+
+                        const condProps: Props = {
+                            label,
+                            condition: conditionProps['condition'],
+                            status: new ObjectShape({ source: cond, properties: statusProps }),
+                        }
+                        if (dontTreatAsError) {
+                            condProps['dontTreatAsError'] = true
+                        }
+
+                        conditionShapes.push(new ObjectShape({ source: cond, properties: condProps }))
+                    }
+
+                    const statusSource = actionStatusMetadata[0] ?? record
+                    stepShapes.push(
+                        new CallExpressionShape({
+                            source: statusSource,
+                            callee: ERROR_EVALUATION_CALLEE,
+                            args: [
+                                new ArrayShape({
+                                    source: statusSource,
+                                    elements: conditionShapes,
+                                }),
+                            ],
+                        })
+                    )
+                }
+
+                // Reconstruct wfa.assignActionOutputs() from output element_mappings.
+                // Element mappings for output assignments can be keyed to the action def sys_id
+                // (draft actions) or a snapshot sys_id (published actions). Check both.
+                {
+                    const candidateIds = new Set<string>([actionSysId])
+                    const snapshots = descendants
+                        .query('sys_hub_action_type_snapshot')
+                        .filter((s) => s.get('parent_action')?.asString()?.getValue() === actionSysId)
+                    for (const snap of snapshots) {
+                        candidateIds.add(snap.getId().getValue())
+                    }
+
+                    // Find element_mappings for action outputs keyed to any candidate id
+                    const outputElementMappings = descendants
+                        .query('sys_element_mapping')
+                        .filter(
+                            (m) =>
+                                candidateIds.has(m.get('id')?.asString()?.getValue() ?? '') &&
+                                (m.get('table')?.asString()?.getValue() ?? '').startsWith(ACTION_OUTPUT_TABLE_PREFIX)
+                        )
+
+                    // Build output element name lookup from all output records
+                    // (action-parented and snapshot-parented) for sys_variable_value resolution
+                    const varSysIdToElement = new Map<string, string>()
+                    const snapshotOutputs = descendants
+                        .query('sys_hub_action_output')
+                        .filter((r) => candidateIds.has(r.get('model')?.asString()?.getValue() ?? ''))
+                    for (const outputRec of [...snapshotOutputs, ...actionOutputs]) {
+                        const element = outputRec.get('element')?.asString()?.getValue()
+                        if (element) {
+                            varSysIdToElement.set(outputRec.getId().getValue(), element)
+                        }
+                    }
+
+                    // Gather sys_variable_value records for static output values
+                    const outputVarValues = descendants.query('sys_variable_value').filter((v) => {
+                        const docKey = v.get('document_key')?.asString()?.getValue() ?? ''
+                        return candidateIds.has(docKey)
+                    })
+
+                    if (outputElementMappings.length > 0 || outputVarValues.length > 0) {
+                        const valuesObj: Props = {}
+                        const sourceRecord = snapshots[0] ?? record
+
+                        // Static values from sys_variable_value
+                        for (const varValue of outputVarValues) {
+                            const variableSysId = varValue.get('variable')?.asString()?.getValue()
+                            const value = varValue.get('value')?.asString()?.getValue()
+                            const outputName = variableSysId ? varSysIdToElement.get(variableSysId) : undefined
+                            // Skip internal platform outputs and missing values (null/undefined)
+                            if (!outputName || outputName.startsWith('__') || value == null) {
+                                continue
+                            }
+                            // Skip FlowObject/FlowArray complex object schema serializations.
+                            // These sys_variable_value records store the output's type structure
+                            // (already declared via FlowObject/FlowArray in Fluent), not user-assigned values.
+                            if (value.includes('"complexObjectSchema"') || value.includes('"$COCollectionField"')) {
+                                continue
+                            }
+                            // sys_variable_value can contain pill strings (e.g. {{action.variable|string}})
+                            // Strip type suffix (|string, |reference) before pill parsing
+                            const pillStripped = value.replace(/\|[a-z_]+\}\}/g, '}}')
+                            valuesObj[outputName] = pillStripped
+                        }
+
+                        // Datapill values from sys_element_mapping (overrides var values when both exist)
+                        for (const mapping of outputElementMappings) {
+                            const outputName = mapping.get('field')?.asString()?.getValue()
+                            const pillValue = mapping.get('value')?.asString()?.getValue()
+                            // Skip internal outputs, missing values, and empty pill strings.
+                            // An empty pill value means "no datapill assignment" — the static value
+                            // from sys_variable_value (if any) should be preserved.
+                            if (!outputName || !pillValue || outputName.startsWith('__')) {
+                                continue
+                            }
+                            valuesObj[outputName] = pillValue
+                        }
+
+                        // Two-pass pill resolution (same approach as step inputs):
+                        // Pass 1: Convert action pills ({{action.xxx}}) → dataPill shapes
+                        convertActionPillsInInputs(valuesObj, sourceRecord, diagnostics, labelCacheMap)
+
+                        // Pass 2: Convert step pills ({{step[UUID].xxx}}) → dataPill shapes
+                        convertStepPillsInInputs(valuesObj, sourceRecord, cidToIdentifierMap, labelCacheMap)
+
+                        if (Object.keys(valuesObj).length > 0) {
+                            // Use params.outputs reference instead of duplicating the full schema
+                            const outputsRef = new PropertyAccessShape({
+                                source: sourceRecord,
+                                elements: [
+                                    new IdentifierShape({
+                                        source: sourceRecord,
+                                        name: ACTION_PILL_PARAM_NAME,
+                                    }),
+                                    'outputs',
+                                ],
+                            })
+                            stepShapes.push(
+                                new CallExpressionShape({
+                                    source: sourceRecord,
+                                    callee: ASSIGN_ACTION_OUTPUTS_CALLEE,
+                                    args: [
+                                        outputsRef,
+                                        new ObjectShape({
+                                            source: sourceRecord,
+                                            properties: valuesObj,
+                                        }),
+                                    ],
+                                })
+                            )
+                        }
+                    }
+                }
+
                 // Build args: config + optional body with step instances
                 const actionConfig = record.transform(({ $ }) => ({
                     $id: $.val(NowIdShape.from(record)),
@@ -1603,7 +2154,7 @@ export const ActionDefinitionPlugin = Plugin.create({
                     description: $.def(''),
                     access: $.def('public'),
                     category: $.def(''),
-                    protection: $.from('sys_policy').def(''),
+                    protectionPolicy: $.from('sys_policy').def(''),
                     inputs: $.val(inputs),
                     outputs: $.val(outputs),
                 }))
@@ -1665,6 +2216,9 @@ export const ActionDefinitionPlugin = Plugin.create({
         sys_hub_status_condition: {
             coalesce: ['action_status_metadata_id', 'order'],
         },
+        sys_element_mapping: {
+            coalesce: ['id', 'table', 'field'],
+        },
     },
     shapes: [
         {
@@ -1686,12 +2240,11 @@ export const ActionDefinitionPlugin = Plugin.create({
                     explicitId: actionConfiguration.get('$id'),
                     properties: actionConfiguration.transform(({ $ }) => ({
                         name: $,
-                        internal_name: $.from('name').map((n) => slugifyString(n.getValue())),
                         annotation: $.def(''),
                         description: $.def(''),
                         access: $.def('public'),
                         category: $.def(''),
-                        sys_policy: $.from('protection').def(''),
+                        sys_policy: $.from('protectionPolicy').def(''),
                         active: $.val(true),
                         state: $.val('draft'),
                         system_level: $.val(false),
@@ -1738,11 +2291,34 @@ export const ActionDefinitionPlugin = Plugin.create({
                 const pillTypeMap = new Map<string, string>()
 
                 const stepInfos: StepInfo[] = []
+                let assignActionOutputsShape: CallExpressionShape | undefined
+                let errorEvaluationShape: CallExpressionShape | undefined
                 let order = 1
                 for (const [, v] of (allInstances ?? []).entries()) {
                     const isVarStatement = v instanceof VariableStatementShape
                     const innerShape = isVarStatement ? v.getInitializer() : v
 
+                    if (
+                        innerShape instanceof CallExpressionShape &&
+                        innerShape.getCallee() === ASSIGN_ACTION_OUTPUTS_CALLEE
+                    ) {
+                        assignActionOutputsShape = innerShape
+                        continue
+                    }
+
+                    if (
+                        innerShape instanceof CallExpressionShape &&
+                        innerShape.getCallee() === ERROR_EVALUATION_CALLEE
+                    ) {
+                        errorEvaluationShape = innerShape
+                        if (assignActionOutputsShape) {
+                            diagnostics.error(
+                                innerShape,
+                                `wfa.errorEvaluation() must appear before wfa.assignActionOutputs() in the action body.`
+                            )
+                        }
+                        continue
+                    }
                     if (innerShape.getSource() instanceof StepInstanceShape) {
                         const stepShape = innerShape.getSource() as StepInstanceShape
                         stepShape.setCidMap(cidMap)
@@ -1793,6 +2369,162 @@ export const ActionDefinitionPlugin = Plugin.create({
                 )
                 relatedRecords.push(...resolvedStepPillRecords)
 
+                // Create sys_element_mapping records for assignActionOutputs values.
+                // For draft actions, element_mappings reference the action definition sys_id directly.
+                if (assignActionOutputsShape) {
+                    const actionDefId = actionDefinitionRecord.getId().getValue()
+                    const valuesArg = assignActionOutputsShape.getArgument(1)?.asObject()
+
+                    // Validate that assigned output names match declared outputs
+                    if (valuesArg && !outputsConfig) {
+                        diagnostics.error(
+                            assignActionOutputsShape,
+                            'assignActionOutputs is used but no outputs are declared in the action config'
+                        )
+                    }
+                    if (valuesArg && outputsConfig) {
+                        const declaredOutputNames = new Set(outputsConfig.keys())
+                        const assignedOutputNames = new Set<string>()
+                        for (const [outputName] of valuesArg.entries({ resolve: false })) {
+                            assignedOutputNames.add(outputName)
+                            if (!declaredOutputNames.has(outputName)) {
+                                diagnostics.error(
+                                    valuesArg.get(outputName),
+                                    `Unknown output '${outputName}'. Available outputs: ${[...declaredOutputNames].join(', ') || '(none)'}`
+                                )
+                            }
+                        }
+                        for (const declaredName of declaredOutputNames) {
+                            if (!assignedOutputNames.has(declaredName)) {
+                                diagnostics.error(
+                                    assignActionOutputsShape,
+                                    `Output '${declaredName}' is declared but not assigned in assignActionOutputs. All declared outputs must be assigned a value.`
+                                )
+                            }
+                        }
+                    }
+
+                    if (valuesArg) {
+                        const entries = valuesArg.entries({ resolve: false })
+                        for (const [outputName, valueShape] of entries) {
+                            const shape = valueShape as Shape
+
+                            // Validate that the output value is not an empty string
+                            if (shape.isString() && shape.getValue() === '') {
+                                diagnostics.error(
+                                    valuesArg.get(outputName),
+                                    `Output '${outputName}' is assigned an empty string. All action outputs must be assigned a non-empty value.`
+                                )
+                            }
+
+                            const pillValue = resolveToString(shape, cidMap, pillTypeMap)
+
+                            const elementMapping = await factory.createRecord({
+                                source: assignActionOutputsShape,
+                                table: 'sys_element_mapping',
+                                properties: {
+                                    field: outputName,
+                                    id: actionDefId,
+                                    table: `${ACTION_OUTPUT_TABLE_PREFIX}${actionDefId}`,
+                                    value: pillValue,
+                                },
+                            })
+                            relatedRecords.push(elementMapping)
+                        }
+                    }
+                }
+
+                // ── Error Evaluation ─────────────────────────────────────────────
+                // wfa.errorEvaluation([...]) → sys_hub_action_status_metadata + sys_hub_status_condition records
+                if (errorEvaluationShape) {
+                    const actionDefId = actionDefinitionRecord.getId().getValue()
+
+                    // Create the single sys_hub_action_status_metadata record for this action
+                    const statusMetadataRecord = await factory.createRecord({
+                        source: errorEvaluationShape,
+                        table: 'sys_hub_action_status_metadata',
+                        properties: {
+                            action_type_id: actionDefId,
+                        },
+                    })
+                    relatedRecords.push(statusMetadataRecord)
+                    const metadataId = statusMetadataRecord.getId().getValue()
+
+                    // Parse the array of conditions (arg 0)
+                    const conditionsArg = errorEvaluationShape.getArgument(0)
+                    if (conditionsArg?.isArray()) {
+                        const elements = conditionsArg.asArray().getElements(false)
+                        let condOrder = 1
+
+                        for (const condElement of elements) {
+                            if (!condElement.isObject()) {
+                                continue
+                            }
+                            const condObj = condElement.asObject()
+
+                            // Extract fields from { label, condition, status, dontTreatAsError }
+                            const labelShape = condObj.get('label')
+                            const conditionShape = condObj.get('condition')
+                            const statusShape = condObj.get('status')?.ifObject()?.asObject()
+                            const dontTreatShape = condObj.get('dontTreatAsError')
+
+                            const label = labelShape?.ifString()?.getValue() ?? ''
+                            const condition = conditionShape ? resolveToString(conditionShape, cidMap, pillTypeMap) : ''
+                            const dontTreatRaw = dontTreatShape?.getValue?.()
+                            const dontTreatAsError = dontTreatRaw === true || dontTreatRaw === 'true'
+
+                            // Resolve status code and message (may contain datapills).
+                            // Use entries({ resolve: false }) to get raw shapes — without this,
+                            // PillShape values get auto-resolved and lose their pill reference.
+                            let codeValue = ''
+                            let messageValue = ''
+                            if (statusShape) {
+                                for (const [field, fieldShape] of statusShape.entries({ resolve: false })) {
+                                    const shape = fieldShape as Shape
+                                    if (field === 'code') {
+                                        codeValue = resolveToString(shape, cidMap, pillTypeMap)
+                                    } else if (field === 'message') {
+                                        messageValue = resolveToString(shape, cidMap, pillTypeMap)
+                                    }
+                                }
+                            }
+
+                            const statusJson = buildStatusConditionJson(codeValue, messageValue)
+
+                            const conditionRecord = await factory.createRecord({
+                                source: errorEvaluationShape,
+                                table: 'sys_hub_status_condition',
+                                properties: {
+                                    action_status_metadata_id: metadataId,
+                                    condition,
+                                    dont_treat_as_error: dontTreatAsError,
+                                    label,
+                                    order: condOrder,
+                                    status: statusJson,
+                                },
+                            })
+                            relatedRecords.push(conditionRecord)
+                            condOrder++
+                        }
+                    }
+
+                    // Create the __action_status__ element_mapping record.
+                    // The platform requires this to connect error evaluation status
+                    // conditions to the action's output. Its value is the base
+                    // FDACTIONSTATUS JSON with empty code/message mapped fields.
+                    const actionStatusMapping = await factory.createRecord({
+                        source: errorEvaluationShape,
+                        table: 'sys_element_mapping',
+                        properties: {
+                            field: '__action_status__',
+                            id: actionDefId,
+                            table: `${ACTION_OUTPUT_TABLE_PREFIX}${actionDefId}`,
+                            value: buildStatusConditionJson('', ''),
+                        },
+                    })
+                    relatedRecords.push(actionStatusMapping)
+                }
+
                 const collectedStepPills = extractStepPillsFromRecords(relatedRecords, cidToLabelMap, pillTypeMap)
                 const dotWalkPills = extractActionDotWalkPills(relatedRecords, pillTypeMap)