@servicenow/sdk-build-plugins 4.6.1 → 4.7.0

package/dist/flow/plugins/flow-action-definition-plugin.js

@@ -3,19 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionDefinitionPlugin = void 0;
 const sdk_build_core_1 = require("@servicenow/sdk-build-core");
 const flow_io_to_record_1 = require("../utils/flow-io-to-record");
+const built_in_complex_objects_1 = require("../utils/built-in-complex-objects");
 const flow_to_xml_1 = require("../utils/flow-to-xml");
 const flow_constants_1 = require("../utils/flow-constants");
+const flow_pill_utils_1 = require("../utils/flow-pill-utils");
 const column_helper_1 = require("../../column/column-helper");
 const schema_to_flow_object_1 = require("../utils/schema-to-flow-object");
 const flow_instance_plugin_1 = require("./flow-instance-plugin");
+const flow_shapes_1 = require("../utils/flow-shapes");
 const arrow_function_plugin_1 = require("../../arrow-function-plugin");
-const utils_1 = require("../../utils");
 const inline_script_plugin_1 = require("./inline-script-plugin");
 const step_instance_plugin_1 = require("./step-instance-plugin");
 const now_id_plugin_1 = require("../../now-id-plugin");
 const now_include_plugin_1 = require("../../now-include-plugin");
-const utils_2 = require("../utils/utils");
+const utils_1 = require("../utils/utils");
 const pill_string_parser_1 = require("../utils/pill-string-parser");
+const data_pill_shapes_1 = require("../utils/data-pill-shapes");
 const label_cache_parser_1 = require("../utils/label-cache-parser");
 const column_helper_2 = require("../../column/column-helper");
 const pill_shape_helpers_1 = require("../utils/pill-shape-helpers");
@@ -127,70 +130,52 @@ function resolveAnyPillFromShape(fieldShape, cidMap) {
     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) {
-    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, pillTypeMap) {
-    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(factory, source, field, id, stepDefinitionSysId, value) {
+function createElementMapping(factory, source, field, id, mappingTable, value) {
     return factory.createRecord({
         source,
         table: 'sys_element_mapping',
         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(templateShape, cidMap, pillTypeMap) {
+function resolveAllPillsInTemplate(templateShape, cidMap, pillTypeMap) {
     let result = templateShape.getLiteralText();
-    let hasStepPills = false;
     for (const span of templateShape.getSpans()) {
         const expr = span.getExpression();
-        const resolved = resolveAnyPillFromShape(expr, cidMap);
-        if (resolved) {
-            if (resolved.isStep) {
-                if (pillTypeMap) {
-                    collectStepPillType(resolved.pill, pillTypeMap);
-                }
-                hasStepPills = true;
+        if (expr instanceof data_pill_shapes_1.PillShape) {
+            const raw = expr.getValue();
+            if (pillTypeMap) {
+                (0, flow_pill_utils_1.collectPillTypes)(raw, pillTypeMap);
             }
-            result += stripPillTypeSuffix(resolved.pill);
+            result += (0, flow_pill_utils_1.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, cidMap);
+            if (resolved) {
+                if (resolved.isStep && pillTypeMap) {
+                    (0, flow_pill_utils_1.collectPillTypes)(resolved.pill, pillTypeMap);
+                }
+                result += (0, flow_pill_utils_1.stripPillType)(resolved.pill);
+            }
+            else {
+                const val = String(expr.getValue?.() ?? '');
+                result += val.startsWith('{{') ? (0, flow_pill_utils_1.stripPillType)(val) : val;
+            }
         }
         result += span.getLiteralText();
     }
-    if (!hasStepPills) {
-        return undefined;
-    }
-    return { result, hasStepPills };
+    return result;
 }
 async function resolveUnresolvedStepPills(steps, cidMap, pillTypeMap, factory) {
     if (cidMap.size === 0 || steps.length === 0) {
@@ -203,6 +188,33 @@ async function resolveUnresolvedStepPills(steps, cidMap, pillTypeMap, factory) {
             continue;
         }
         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 = `${flow_constants_1.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) {
+                    (0, flow_pill_utils_1.collectPillTypes)(resolved.pill, pillTypeMap);
+                    newRecords.push(await createElementMapping(factory, stepShape, varName, stepInstanceSysId, extInputTableName, (0, flow_pill_utils_1.stripPillType)(resolved.pill)));
+                }
+                else if (varValueShape.is(sdk_build_core_1.TemplateExpressionShape)) {
+                    const resolvedText = resolveAllPillsInTemplate(varValueShape, cidMap, pillTypeMap);
+                    if (resolvedText.includes('{{step[')) {
+                        newRecords.push(await createElementMapping(factory, stepShape, varName, stepInstanceSysId, extInputTableName, resolvedText));
+                    }
+                }
+            }
+        }
+        const stepDefTableName = `${flow_constants_1.STEP_DEF_INPUT_TABLE_PREFIX}${stepDefinitionSysId}`;
         for (const [key, valueShape] of Object.entries(valuesProperties)) {
             if (key === 'inputVariables' || key === 'outputVariables' || key === 'errorHandlingType') {
                 continue;
@@ -210,15 +222,17 @@ async function resolveUnresolvedStepPills(steps, cidMap, pillTypeMap, factory) {
             // 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)));
+                (0, flow_pill_utils_1.collectPillTypes)(resolved.pill, pillTypeMap);
+                newRecords.push(await createElementMapping(factory, stepShape, key, stepInstanceSysId, stepDefTableName, (0, flow_pill_utils_1.stripPillType)(resolved.pill)));
                 continue;
             }
             // Case 2: TemplateExpressionShape with step pills
             if (valueShape.is(sdk_build_core_1.TemplateExpressionShape)) {
-                const templateResolved = resolveStepPillsInTemplate(valueShape, cidMap, pillTypeMap);
-                if (templateResolved) {
-                    newRecords.push(await createElementMapping(factory, stepShape, key, stepInstanceSysId, stepDefinitionSysId, templateResolved.result));
+                const resolvedText = resolveAllPillsInTemplate(valueShape, cidMap, pillTypeMap);
+                // 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, stepDefTableName, resolvedText));
                 }
                 continue;
             }
@@ -230,28 +244,109 @@ async function resolveUnresolvedStepPills(steps, cidMap, pillTypeMap, factory) {
                 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)}`);
+                        (0, flow_pill_utils_1.collectPillTypes)(fieldResolved.pill, pillTypeMap);
+                        entries.push(`${field}=${(0, flow_pill_utils_1.stripPillType)(fieldResolved.pill)}`);
                         hasStepPills = true;
                     }
                     else if (fieldShape.is(sdk_build_core_1.TemplateExpressionShape)) {
-                        const resolved = resolveStepPillsInTemplate(fieldShape, cidMap, pillTypeMap);
-                        if (resolved) {
-                            entries.push(`${field}=${resolved.result}`);
+                        const resolvedText = resolveAllPillsInTemplate(fieldShape, cidMap, pillTypeMap);
+                        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('{{') ? (0, flow_pill_utils_1.stripPillType)(val) : val}`);
                     }
                 }
                 if (hasStepPills) {
-                    newRecords.push(await createElementMapping(factory, stepShape, key, stepInstanceSysId, stepDefinitionSysId, entries.join('^')));
+                    newRecords.push(await createElementMapping(factory, stepShape, key, stepInstanceSysId, 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(flow_shapes_1.ApprovalDueDateShape)) {
+                const dueDateShape = valueShape;
+                const dateFieldShape = dueDateShape.get('date', false);
+                const dateResolved = resolveAnyPillFromShape(dateFieldShape, cidMap);
+                if (dateResolved?.isStep) {
+                    (0, flow_pill_utils_1.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 flow_shapes_1.ApprovalDueDateShape({
+                        source: dueDateShape.getSource(),
+                        value: { ...dueDate, date: (0, flow_pill_utils_1.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(flow_shapes_1.ApprovalRulesShape)) {
+                const rulesShape = valueShape;
+                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) {
+                                    (0, flow_pill_utils_1.collectPillTypes)(resolved.pill, pillTypeMap);
+                                    condition.users[uIdx] = (0, flow_pill_utils_1.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) {
+                                    (0, flow_pill_utils_1.collectPillTypes)(resolved.pill, pillTypeMap);
+                                    condition.groups[gIdx] = (0, flow_pill_utils_1.stripPillType)(resolved.pill);
+                                    hasStepPills = true;
+                                }
+                            });
+                        });
+                    });
+                });
+                if (hasStepPills) {
+                    const correctedShape = new flow_shapes_1.ApprovalRulesShape({
+                        source: rulesShape.getSource(),
+                        value: rules,
+                    });
+                    const jsonValue = correctedShape.toString().getValue();
+                    newRecords.push(await createElementMapping(factory, stepShape, key, stepInstanceSysId, stepDefTableName, jsonValue));
                 }
             }
         }
@@ -259,51 +354,68 @@ async function resolveUnresolvedStepPills(steps, cidMap, pillTypeMap, factory) {
     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.
+ * Collects all pill-bearing text strings from records.
+ * Scans sys_element_mapping.value, sys_hub_status_condition.condition and .status fields.
  */
-function extractStepPillsFromRecords(records, cidToLabelMap, pillTypeMap) {
-    const pills = [];
-    const seen = new Set();
+function collectPillTextsFromRecords(records) {
+    const texts = [];
     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 table = rec.getTable();
+            if (table === 'sys_element_mapping') {
+                const value = rec.get('value')?.asString()?.getValue() ?? '';
+                if (value) {
+                    texts.push(value);
+                }
             }
-            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;
+            else if (table === 'sys_hub_status_condition') {
+                const condition = rec.get('condition')?.asString()?.getValue() ?? '';
+                if (condition) {
+                    texts.push(condition);
                 }
-                const key = `${cid}::${pillPath}`;
-                if (seen.has(key)) {
-                    continue;
+                const status = rec.get('status')?.asString()?.getValue() ?? '';
+                if (status) {
+                    texts.push(status);
                 }
-                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 texts;
+}
+function extractStepPillsFromRecords(records, cidToLabelMap, pillTypeMap) {
+    const pills = [];
+    const seen = new Set();
+    for (const text of collectPillTextsFromRecords(records)) {
+        const matches = text.matchAll(flow_pill_utils_1.STEP_PILL_TYPE_REGEX);
+        for (const match of matches) {
+            const [, cid, pillPath, dataType] = match;
+            if (!cid || !pillPath) {
+                continue;
+            }
+            // 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.
  */
@@ -311,34 +423,28 @@ function extractActionDotWalkPills(records, pillTypeMap) {
     const pills = [];
     const seen = new Set();
     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;
@@ -574,6 +680,66 @@ function convertActionPillsInInputs(inputsObj, source, diagnostics, labelCacheMa
         }
     }
 }
+/**
+ * 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, source, diagnostics, labelCacheMap) {
+    for (const [key, val] of Object.entries(inputsObj)) {
+        if (val instanceof flow_shapes_1.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 ((0, pill_string_parser_1.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 ((0, pill_string_parser_1.detectPillPattern)(s) !== 'none') {
+                            const shape = convertActionPillToShape(s, source, diagnostics, labelCacheMap);
+                            if (shape) {
+                                changed = true;
+                                return shape;
+                            }
+                        }
+                        return group;
+                    }),
+                }))),
+            }));
+            if (changed && newRuleSets) {
+                inputsObj[key] = new flow_shapes_1.ApprovalRulesShape({
+                    source,
+                    value: { ...rules, ruleSets: newRuleSets },
+                });
+            }
+        }
+        else if (val instanceof flow_shapes_1.ApprovalDueDateShape) {
+            const dueDate = val.getApprovalDueDate();
+            if (dueDate.date && (0, pill_string_parser_1.detectPillPattern)(dueDate.date) !== 'none') {
+                const shape = convertActionPillToShape(dueDate.date, source, diagnostics, labelCacheMap);
+                if (shape) {
+                    inputsObj[key] = new flow_shapes_1.ApprovalDueDateShape({
+                        source,
+                        value: { ...dueDate, date: shape },
+                    });
+                }
+            }
+        }
+    }
+}
 /** 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;
 /**
@@ -622,6 +788,84 @@ function convertStepPillsInInputs(inputsObj, source, cidToIdentifierMap, labelCa
                 inputsObj[key] = new sdk_build_core_1.TemplateValueShape({ source, value: newTemplateValue });
             }
         }
+        else if (val instanceof flow_shapes_1.ApprovalDueDateShape) {
+            const dueDate = val.getApprovalDueDate();
+            if (dueDate.date && typeof dueDate.date === 'string' && (0, pill_string_parser_1.detectPillPattern)(dueDate.date) !== 'none') {
+                const shape = convertStepPillString(dueDate.date, source, cidToIdentifierMap, labelCacheMap);
+                if (shape) {
+                    inputsObj[key] = new flow_shapes_1.ApprovalDueDateShape({
+                        source,
+                        value: { ...dueDate, date: shape },
+                    });
+                }
+            }
+        }
+        else if (val instanceof flow_shapes_1.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 ((0, pill_string_parser_1.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 ((0, pill_string_parser_1.detectPillPattern)(s) !== 'none') {
+                            const shape = convertStepPillString(s, source, cidToIdentifierMap, labelCacheMap);
+                            if (shape) {
+                                changed = true;
+                                return shape;
+                            }
+                        }
+                        return group;
+                    }),
+                }))),
+            }));
+            if (changed && newRuleSets) {
+                inputsObj[key] = new flow_shapes_1.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;
+            for (const nestedVal of Object.values(nestedObj)) {
+                if (nestedVal &&
+                    typeof nestedVal === 'object' &&
+                    !Array.isArray(nestedVal) &&
+                    !isShapeInstance(nestedVal)) {
+                    const innerObj = nestedVal;
+                    const innerValue = innerObj['value'];
+                    if (typeof innerValue === 'string') {
+                        const converted = convertStepPillString(innerValue, source, cidToIdentifierMap, labelCacheMap);
+                        if (converted) {
+                            innerObj['value'] = converted;
+                        }
+                    }
+                    else if (innerValue instanceof sdk_build_core_1.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;
+                        }
+                    }
+                }
+            }
+        }
     }
 }
 /**
@@ -632,9 +876,12 @@ function resolveStepPillMatch(uuid, property, source, cidToIdentifierMap, labelC
     if (!identifier) {
         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 sdk_build_core_1.PropertyAccessShape({
         source,
-        elements: [identifier, property],
+        elements: [identifier, ...pathParts],
     });
     const pillName = `step[${uuid}].${property}`;
     const dataType = labelCacheMap?.get(pillName) || 'string';
@@ -889,9 +1136,118 @@ const actionDefRelationships = {
         descendant: true,
     },
 };
+/**
+ * Resolves any shape (string literal, number, template expression, dataPill call)
+ * to its final string representation with pill references resolved.
+ */
+function resolveToString(shape, cidMap, pillTypeMap) {
+    if (shape instanceof sdk_build_core_1.TemplateExpressionShape) {
+        return resolveAllPillsInTemplate(shape, cidMap, pillTypeMap);
+    }
+    if (shape instanceof data_pill_shapes_1.PillShape) {
+        const raw = shape.getValue();
+        (0, flow_pill_utils_1.collectPillTypes)(raw, pillTypeMap);
+        return (0, flow_pill_utils_1.stripPillType)(raw);
+    }
+    const resolved = resolveAnyPillFromShape(shape, cidMap);
+    if (resolved) {
+        if (resolved.isStep) {
+            (0, flow_pill_utils_1.collectPillTypes)(resolved.pill, pillTypeMap);
+        }
+        return (0, flow_pill_utils_1.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, messageValue) {
+    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 = built_in_complex_objects_1.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],
+    ]) {
+        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, logger) {
+    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: '' };
+    }
+}
 exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
     name: 'ActionDefinitionPlugin',
-    docs: [(0, utils_1.createSdkDocEntry)('Action', ['sys_hub_action_type_definition'])],
     records: {
         sys_hub_action_type_definition: {
             relationships: {
@@ -901,6 +1257,10 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
                     descendant: true,
                     relationships: {
                         ...actionDefRelationships,
+                        sys_variable_value: {
+                            via: 'document_key',
+                            descendant: true,
+                        },
                         sys_element_mapping: {
                             via: 'id',
                             descendant: true,
@@ -934,85 +1294,31 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.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
+                    .filter((r) => r.get('action_type_id')?.asString()?.getValue() === actionSysId);
+                const actionStatusMetadataIds = actionStatusMetadata.map((r) => r.getId().getValue());
+                const statusConditions = 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((r) => actionStatusMetadataIds.includes(r.get('action_status_metadata_id')?.asString()?.getValue() ?? ''));
                 // 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, b) => 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);
+                    .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 flow_constants_1.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();
-                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);
-                            }
-                        }
-                    }
-                }
+                    .filter((r) => r.get('model')?.asString()?.getValue() === actionSysId)
+                    .sort(sortByOrder);
                 const inputs = (0, flow_io_to_record_1.buildVariableShapes)(actionInputs, descendants);
-                const outputs = (0, flow_io_to_record_1.buildVariableShapes)(actionOutputs, descendants, undefined, snapshotOutputValues);
+                const outputs = (0, flow_io_to_record_1.buildVariableShapes)(actionOutputs, descendants);
                 // Extract label_cache from action definition for datapill type info
                 let labelCacheMap;
                 try {
@@ -1095,7 +1401,7 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.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(flow_constants_1.EXT_INPUT_TABLE_PREFIX)) {
                                 extInputMappingValues[rawFieldName] = value;
                                 continue;
                             }
@@ -1156,8 +1462,8 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
                                 // 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 value = extInputMappingValues[elementName] ??
+                                    varValueRecord?.get('value')?.asString()?.getValue() ??
                                     '';
                                 const inputEntry = { label };
                                 if (value) {
@@ -1181,17 +1487,17 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.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 = (0, schema_to_flow_object_1.getAttributeValue)(attributes, 'uiType') ?? internalType;
                                 const columnApiName = column_helper_1.COLUMN_TYPE_TO_API[uiType] ?? 'StringColumn';
                                 const columnProps = { 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);
                                 }
@@ -1203,12 +1509,12 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.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;
                                 }
@@ -1227,6 +1533,9 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.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);
@@ -1238,7 +1547,7 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
                             configProperties['label'] = label;
                         }
                         // Built-in/OOB step: emit actionStep.xxx reference
-                        const stepIdentifier = (0, utils_2.getBuiltInStepIdentifier)(stepTypeSysId);
+                        const stepIdentifier = (0, utils_1.getBuiltInStepIdentifier)(stepTypeSysId);
                         // Built-in/OOB step: emit actionStep.xxx identifier reference
                         const stepDefShape = stepIdentifier
                             ? new sdk_build_core_1.IdentifierShape({ source: stepInstance, name: stepIdentifier })
@@ -1272,6 +1581,150 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.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 = [];
+                    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 = {};
+                        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 = { condition };
+                        convertActionPillsInInputs(conditionProps, cond, diagnostics, labelCacheMap);
+                        convertStepPillsInInputs(conditionProps, cond, cidToIdentifierMap, labelCacheMap);
+                        const condProps = {
+                            label,
+                            condition: conditionProps['condition'],
+                            status: new sdk_build_core_1.ObjectShape({ source: cond, properties: statusProps }),
+                        };
+                        if (dontTreatAsError) {
+                            condProps['dontTreatAsError'] = true;
+                        }
+                        conditionShapes.push(new sdk_build_core_1.ObjectShape({ source: cond, properties: condProps }));
+                    }
+                    const statusSource = actionStatusMetadata[0] ?? record;
+                    stepShapes.push(new sdk_build_core_1.CallExpressionShape({
+                        source: statusSource,
+                        callee: flow_constants_1.ERROR_EVALUATION_CALLEE,
+                        args: [
+                            new sdk_build_core_1.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([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(flow_constants_1.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();
+                    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 = {};
+                        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 sdk_build_core_1.PropertyAccessShape({
+                                source: sourceRecord,
+                                elements: [
+                                    new sdk_build_core_1.IdentifierShape({
+                                        source: sourceRecord,
+                                        name: ACTION_PILL_PARAM_NAME,
+                                    }),
+                                    'outputs',
+                                ],
+                            });
+                            stepShapes.push(new sdk_build_core_1.CallExpressionShape({
+                                source: sourceRecord,
+                                callee: flow_constants_1.ASSIGN_ACTION_OUTPUTS_CALLEE,
+                                args: [
+                                    outputsRef,
+                                    new sdk_build_core_1.ObjectShape({
+                                        source: sourceRecord,
+                                        properties: valuesObj,
+                                    }),
+                                ],
+                            }));
+                        }
+                    }
+                }
                 // Build args: config + optional body with step instances
                 const actionConfig = record.transform(({ $ }) => ({
                     $id: $.val(now_id_plugin_1.NowIdShape.from(record)),
@@ -1280,7 +1733,7 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.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),
                 }));
@@ -1298,7 +1751,7 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
                     args,
                 });
                 // Try to get the existing identifier from the record source, fallback to slugified name
-                const actionName = (0, utils_2.getIdentifierFromRecord)(record) ??
+                const actionName = (0, utils_1.getIdentifierFromRecord)(record) ??
                     (0, flow_constants_1.slugifyString)(String(record.get('internal_name')?.getValue() || record.get('name')?.getValue()));
                 return {
                     success: true,
@@ -1335,6 +1788,9 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
         sys_hub_status_condition: {
             coalesce: ['action_status_metadata_id', 'order'],
         },
+        sys_element_mapping: {
+            coalesce: ['id', 'table', 'field'],
+        },
     },
     shapes: [
         {
@@ -1354,12 +1810,11 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
                     explicitId: actionConfiguration.get('$id'),
                     properties: actionConfiguration.transform(({ $ }) => ({
                         name: $,
-                        internal_name: $.from('name').map((n) => (0, flow_constants_1.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),
@@ -1397,10 +1852,25 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
                 const cidToLabelMap = new Map();
                 const pillTypeMap = new Map();
                 const stepInfos = [];
+                let assignActionOutputsShape;
+                let errorEvaluationShape;
                 let order = 1;
                 for (const [, v] of (allInstances ?? []).entries()) {
                     const isVarStatement = v instanceof sdk_build_core_1.VariableStatementShape;
                     const innerShape = isVarStatement ? v.getInitializer() : v;
+                    if (innerShape instanceof sdk_build_core_1.CallExpressionShape &&
+                        innerShape.getCallee() === flow_constants_1.ASSIGN_ACTION_OUTPUTS_CALLEE) {
+                        assignActionOutputsShape = innerShape;
+                        continue;
+                    }
+                    if (innerShape instanceof sdk_build_core_1.CallExpressionShape &&
+                        innerShape.getCallee() === flow_constants_1.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 step_instance_plugin_1.StepInstanceShape) {
                         const stepShape = innerShape.getSource();
                         stepShape.setCidMap(cidMap);
@@ -1440,6 +1910,135 @@ exports.ActionDefinitionPlugin = sdk_build_core_1.Plugin.create({
                 // inputs directly and create correct sys_element_mapping records.
                 const resolvedStepPillRecords = await resolveUnresolvedStepPills(stepInfos, cidMap, pillTypeMap, factory);
                 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();
+                        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;
+                            // 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: `${flow_constants_1.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;
+                                    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: `${flow_constants_1.ACTION_OUTPUT_TABLE_PREFIX}${actionDefId}`,
+                            value: buildStatusConditionJson('', ''),
+                        },
+                    });
+                    relatedRecords.push(actionStatusMapping);
+                }
                 const collectedStepPills = extractStepPillsFromRecords(relatedRecords, cidToLabelMap, pillTypeMap);
                 const dotWalkPills = extractActionDotWalkPills(relatedRecords, pillTypeMap);
                 if (inputsConfig) {