@servicenow/sdk-build-plugins 4.5.0 → 4.6.0

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

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